Cleanup: jul.h include guards
[lttng-tools.git] / src / bin / lttng-sessiond / jul.c
CommitLineData
0475c50c
DG
1/*
2 * Copyright (C) 2013 - David Goulet <dgoulet@efficios.com>
3 *
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.
7 *
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
11 * more details.
12 *
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.
16 */
17
18#define _GNU_SOURCE
19#include <assert.h>
f20baf8e 20#include <urcu/uatomic.h>
0475c50c
DG
21
22#include <common/common.h>
f20baf8e 23#include <common/sessiond-comm/jul.h>
0475c50c
DG
24
25#include "jul.h"
f20baf8e 26#include "ust-app.h"
0475c50c
DG
27#include "utils.h"
28
29/*
30 * URCU intermediate call to complete destroy a JUL event.
31 */
32static void destroy_event_jul_rcu(struct rcu_head *head)
33{
34 struct lttng_ht_node_str *node =
35 caa_container_of(head, struct lttng_ht_node_str, head);
36 struct jul_event *event =
37 caa_container_of(node, struct jul_event, node);
38
39 free(event);
40}
41
f20baf8e
DG
42/*
43 * URCU intermediate call to complete destroy a JUL event.
44 */
45static void destroy_app_jul_rcu(struct rcu_head *head)
46{
47 struct lttng_ht_node_ulong *node =
48 caa_container_of(head, struct lttng_ht_node_ulong, head);
49 struct jul_app *app =
50 caa_container_of(node, struct jul_app, node);
51
52 free(app);
53}
54
55/*
56 * Communication with Java agent call. Send the message header to the given
57 * socket all in big endian.
58 *
59 * Return 0 on success or else a negative errno message of sendmsg() op.
60 */
61static int send_header(struct lttcomm_sock *sock, uint64_t data_size,
62 uint32_t cmd, uint32_t cmd_version)
63{
64 int ret;
65 ssize_t size;
66 struct lttcomm_jul_hdr msg;
67
68 assert(sock);
69
70 msg.data_size = htobe64(data_size);
71 msg.cmd = htobe32(cmd);
72 msg.cmd_version = htobe32(cmd_version);
73
74 size = sock->ops->sendmsg(sock, &msg, sizeof(msg), 0);
75 if (size < sizeof(msg)) {
76 ret = -errno;
77 goto error;
78 }
79 ret = 0;
80
81error:
82 return ret;
83}
84
85/*
86 * Communication call with the Java agent. Send the payload to the given
87 * socket. The header MUST be sent prior to this call.
88 *
89 * Return 0 on success or else a negative errno value of sendmsg() op.
90 */
91static int send_payload(struct lttcomm_sock *sock, void *data,
92 size_t size)
93{
94 int ret;
95 ssize_t len;
96
97 assert(sock);
98 assert(data);
99
100 len = sock->ops->sendmsg(sock, data, size, 0);
101 if (len < size) {
102 ret = -errno;
103 goto error;
104 }
105 ret = 0;
106
107error:
108 return ret;
109}
110
111/*
112 * Communication call with the Java agent. Receive reply from the agent using
113 * the given socket.
114 *
115 * Return 0 on success or else a negative errno value from recvmsg() op.
116 */
117static int recv_reply(struct lttcomm_sock *sock, void *buf, size_t size)
118{
119 int ret;
120 ssize_t len;
121
122 assert(sock);
123 assert(buf);
124
125 len = sock->ops->recvmsg(sock, buf, size, 0);
126 if (len < size) {
127 ret = -errno;
128 goto error;
129 }
130 ret = 0;
131
132error:
133 return ret;
134}
135
3c6a091f
DG
136
137/*
138 * Internal call to list events on a given app. Populate events.
139 *
140 * Return number of element in the list or else a negative LTTNG_ERR* code.
141 */
142static ssize_t list_events(struct jul_app *app, struct lttng_event **events)
143{
144 int ret, i, len = 0, offset = 0;
145 uint32_t nb_event;
146 size_t data_size;
147 struct lttng_event *tmp_events = NULL;
148 struct lttcomm_jul_list_reply *reply = NULL;
149 struct lttcomm_jul_list_reply_hdr reply_hdr;
150
151 assert(app);
152 assert(app->sock);
153 assert(events);
154
155 DBG2("JUL listing events for app pid: %d and socket %d", app->pid,
156 app->sock->fd);
157
158 ret = send_header(app->sock, 0, JUL_CMD_LIST, 0);
159 if (ret < 0) {
160 goto error_io;
161 }
162
163 /* Get list header so we know how much we'll receive. */
164 ret = recv_reply(app->sock, &reply_hdr, sizeof(reply_hdr));
165 if (ret < 0) {
166 goto error_io;
167 }
168
169 switch (be32toh(reply_hdr.ret_code)) {
170 case JUL_RET_CODE_SUCCESS:
171 data_size = be32toh(reply_hdr.data_size) + sizeof(*reply);
172 break;
173 default:
174 ERR("Java agent returned an unknown code: %" PRIu32,
175 be32toh(reply_hdr.ret_code));
176 ret = LTTNG_ERR_FATAL;
177 goto error;
178 }
179
180 reply = zmalloc(data_size);
181 if (!reply) {
182 ret = LTTNG_ERR_NOMEM;
183 goto error;
184 }
185
186 /* Get the list with the appropriate data size. */
187 ret = recv_reply(app->sock, reply, data_size);
188 if (ret < 0) {
189 goto error_io;
190 }
191
192 nb_event = be32toh(reply->nb_event);
193 tmp_events = zmalloc(sizeof(*tmp_events) * nb_event);
194 if (!tmp_events) {
195 ret = LTTNG_ERR_NOMEM;
196 goto error;
197 }
198
199 for (i = 0; i < nb_event; i++) {
200 offset += len;
201 strncpy(tmp_events[i].name, reply->payload + offset,
202 sizeof(tmp_events[i].name));
203 tmp_events[i].pid = app->pid;
204 tmp_events[i].enabled = -1;
205 len = strlen(reply->payload + offset) + 1;
206 }
207
208 *events = tmp_events;
209
210 free(reply);
211 return nb_event;
212
213error_io:
214 ret = LTTNG_ERR_UST_LIST_FAIL;
215error:
216 free(reply);
217 free(tmp_events);
218 return -ret;
219
220}
221
f20baf8e
DG
222/*
223 * Internal enable JUL event call on a JUL application. This function
224 * communicates with the Java agent to enable a given event (Logger name).
225 *
226 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
227 */
228static int enable_event(struct jul_app *app, struct jul_event *event)
229{
230 int ret;
231 uint64_t data_size;
232 struct lttcomm_jul_enable msg;
233 struct lttcomm_jul_generic_reply reply;
234
235 assert(app);
236 assert(app->sock);
237 assert(event);
238
239 DBG2("JUL enabling event %s for app pid: %d and socket %d", event->name,
240 app->pid, app->sock->fd);
241
242 data_size = sizeof(msg);
243
244 ret = send_header(app->sock, data_size, JUL_CMD_ENABLE, 0);
245 if (ret < 0) {
246 goto error_io;
247 }
248
249 strncpy(msg.name, event->name, sizeof(msg.name));
250 ret = send_payload(app->sock, &msg, sizeof(msg));
251 if (ret < 0) {
252 goto error_io;
253 }
254
255 ret = recv_reply(app->sock, &reply, sizeof(reply));
256 if (ret < 0) {
257 goto error_io;
258 }
259
260 switch (be32toh(reply.ret_code)) {
261 case JUL_RET_CODE_SUCCESS:
262 break;
263 case JUL_RET_CODE_UNKNOWN_NAME:
264 ret = LTTNG_ERR_UST_EVENT_NOT_FOUND;
265 goto error;
266 default:
267 ERR("Java agent returned an unknown code: %" PRIu32,
268 be32toh(reply.ret_code));
269 ret = LTTNG_ERR_FATAL;
270 goto error;
271 }
272
273 return LTTNG_OK;
274
275error_io:
276 ret = LTTNG_ERR_UST_ENABLE_FAIL;
277error:
278 return ret;
279}
280
281/*
282 * Internal disable JUL event call on a JUL application. This function
283 * communicates with the Java agent to disable a given event (Logger name).
284 *
285 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
286 */
287static int disable_event(struct jul_app *app, struct jul_event *event)
288{
289 int ret;
290 uint64_t data_size;
291 struct lttcomm_jul_disable msg;
292 struct lttcomm_jul_generic_reply reply;
293
294 assert(app);
295 assert(app->sock);
296 assert(event);
297
298 DBG2("JUL disabling event %s for app pid: %d and socket %d", event->name,
299 app->pid, app->sock->fd);
300
301 data_size = sizeof(msg);
302
303 ret = send_header(app->sock, data_size, JUL_CMD_DISABLE, 0);
304 if (ret < 0) {
305 goto error_io;
306 }
307
308 strncpy(msg.name, event->name, sizeof(msg.name));
309 ret = send_payload(app->sock, &msg, sizeof(msg));
310 if (ret < 0) {
311 goto error_io;
312 }
313
314 ret = recv_reply(app->sock, &reply, sizeof(reply));
315 if (ret < 0) {
316 goto error_io;
317 }
318
319 switch (be32toh(reply.ret_code)) {
320 case JUL_RET_CODE_SUCCESS:
321 break;
322 case JUL_RET_CODE_UNKNOWN_NAME:
323 ret = LTTNG_ERR_UST_EVENT_NOT_FOUND;
324 goto error;
325 default:
326 ERR("Java agent returned an unknown code: %" PRIu32,
327 be32toh(reply.ret_code));
328 ret = LTTNG_ERR_FATAL;
329 goto error;
330 }
331
332 return LTTNG_OK;
333
334error_io:
335 ret = LTTNG_ERR_UST_DISABLE_FAIL;
336error:
337 return ret;
338}
339
340/*
341 * Enable JUL event on every JUL applications registered with the session
342 * daemon.
343 *
344 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
345 */
346int jul_enable_event(struct jul_event *event)
347{
348 int ret;
349 struct jul_app *app;
350 struct lttng_ht_iter iter;
351
352 assert(event);
353
354 rcu_read_lock();
355
356 cds_lfht_for_each_entry(jul_apps_ht_by_sock->ht, &iter.iter, app,
357 node.node) {
358 /* Enable event on JUL application through TCP socket. */
359 ret = enable_event(app, event);
360 if (ret != LTTNG_OK) {
361 goto error;
362 }
f20baf8e
DG
363 }
364
3c6a091f 365 event->enabled = 1;
f20baf8e
DG
366 ret = LTTNG_OK;
367
368error:
369 rcu_read_unlock();
370 return ret;
371}
372
373/*
374 * Disable JUL event on every JUL applications registered with the session
375 * daemon.
376 *
377 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
378 */
379int jul_disable_event(struct jul_event *event)
380{
381 int ret;
382 struct jul_app *app;
383 struct lttng_ht_iter iter;
384
385 assert(event);
386
387 rcu_read_lock();
388
389 cds_lfht_for_each_entry(jul_apps_ht_by_sock->ht, &iter.iter, app,
390 node.node) {
391 /* Enable event on JUL application through TCP socket. */
392 ret = disable_event(app, event);
393 if (ret != LTTNG_OK) {
394 goto error;
395 }
f20baf8e
DG
396 }
397
3c6a091f 398 event->enabled = 0;
f20baf8e
DG
399 ret = LTTNG_OK;
400
401error:
402 rcu_read_unlock();
403 return ret;
404}
405
406/*
407 * Ask every java agent for the list of possible event (logger name). Events is
408 * allocated with the events of every JUL application.
409 *
410 * Return the number of events or else a negative value.
411 */
412int jul_list_events(struct lttng_event **events)
413{
414 int ret;
415 size_t nbmem, count = 0;
416 struct jul_app *app;
aae6255e 417 struct lttng_event *tmp_events = NULL;
f20baf8e
DG
418 struct lttng_ht_iter iter;
419
420 assert(events);
421
422 nbmem = UST_APP_EVENT_LIST_SIZE;
423 tmp_events = zmalloc(nbmem * sizeof(*tmp_events));
424 if (!tmp_events) {
425 PERROR("zmalloc jul list events");
426 ret = -ENOMEM;
427 goto error;
428 }
429
430 rcu_read_lock();
431 cds_lfht_for_each_entry(jul_apps_ht_by_sock->ht, &iter.iter, app,
432 node.node) {
433 ssize_t nb_ev;
434 struct lttng_event *jul_events;
435
436 nb_ev = list_events(app, &jul_events);
437 if (nb_ev < 0) {
438 ret = nb_ev;
439 rcu_read_unlock();
440 goto error;
441 }
442
443 if (count >= nbmem) {
444 /* In case the realloc fails, we free the memory */
445 void *ptr;
446
447 DBG2("Reallocating JUL event list from %zu to %zu entries", nbmem,
448 2 * nbmem);
449 nbmem *= 2;
450 ptr = realloc(tmp_events, nbmem * sizeof(*tmp_events));
451 if (!ptr) {
452 PERROR("realloc JUL events");
f20baf8e
DG
453 ret = -ENOMEM;
454 rcu_read_unlock();
c36441a9 455 free(jul_events);
f20baf8e
DG
456 goto error;
457 }
458 tmp_events = ptr;
459 }
460 memcpy(tmp_events + (count * sizeof(*tmp_events)), jul_events,
461 nb_ev * sizeof(*tmp_events));
462 free(jul_events);
463 count += nb_ev;
464 }
465 rcu_read_unlock();
466
467 ret = count;
468 *events = tmp_events;
aae6255e 469 return ret;
f20baf8e
DG
470
471error:
aae6255e 472 free(tmp_events);
f20baf8e
DG
473 return ret;
474}
475
476/*
477 * Create a JUL app object using the given PID.
478 *
479 * Return newly allocated object or else NULL on error.
480 */
481struct jul_app *jul_create_app(pid_t pid, struct lttcomm_sock *sock)
482{
483 struct jul_app *app;
484
485 assert(sock);
486
487 app = zmalloc(sizeof(*app));
488 if (!app) {
489 PERROR("zmalloc JUL create");
490 goto error;
491 }
492
493 app->pid = pid;
494 app->sock = sock;
495 /* Flag it invalid until assignation. */
496 app->ust_app_sock = -1;
497 lttng_ht_node_init_ulong(&app->node, (unsigned long) app->sock->fd);
498
499error:
500 return app;
501}
502
503/*
504 * Lookup JUL app by socket in the global hash table.
505 *
506 * RCU read side lock MUST be acquired.
507 *
508 * Return object if found else NULL.
509 */
510struct jul_app *jul_find_app_by_sock(int sock)
511{
512 struct lttng_ht_node_ulong *node;
513 struct lttng_ht_iter iter;
514 struct jul_app *app;
515
516 assert(sock >= 0);
517
518 lttng_ht_lookup(jul_apps_ht_by_sock, (void *)((unsigned long) sock), &iter);
519 node = lttng_ht_iter_get_node_ulong(&iter);
520 if (node == NULL) {
521 goto error;
522 }
523 app = caa_container_of(node, struct jul_app, node);
524
525 DBG3("JUL app pid %d found by sock %d.", app->pid, sock);
526 return app;
527
528error:
529 DBG3("JUL app NOT found by sock %d.", sock);
530 return NULL;
531}
532
533/*
534 * Add JUL application object to a given hash table.
535 */
536void jul_add_app(struct jul_app *app)
537{
538 assert(app);
539
540 DBG3("JUL adding app sock: %d and pid: %d to ht", app->sock->fd, app->pid);
541
542 rcu_read_lock();
543 lttng_ht_add_unique_ulong(jul_apps_ht_by_sock, &app->node);
544 rcu_read_unlock();
545}
546
547/*
548 * Attach a given JUL application to an UST app object. This is done by copying
549 * the socket fd value into the ust app obj. atomically.
550 */
551void jul_attach_app(struct jul_app *japp)
552{
553 struct ust_app *uapp;
554
555 assert(japp);
556
557 rcu_read_lock();
558 uapp = ust_app_find_by_pid(japp->pid);
559 if (!uapp) {
560 goto end;
561 }
562
563 uatomic_set(&uapp->jul_app_sock, japp->sock->fd);
564
565 DBG3("JUL app pid: %d, sock: %d attached to UST app.", japp->pid,
566 japp->sock->fd);
567
568end:
569 rcu_read_unlock();
570 return;
571}
572
573/*
574 * Remove JUL app. reference from an UST app object and set it to NULL.
575 */
576void jul_detach_app(struct jul_app *japp)
577{
578 struct ust_app *uapp;
579
580 assert(japp);
581
582 rcu_read_lock();
583
584 if (japp->ust_app_sock < 0) {
585 goto end;
586 }
587
588 uapp = ust_app_find_by_sock(japp->ust_app_sock);
589 if (!uapp) {
590 goto end;
591 }
592
593 uapp->jul_app_sock = -1;
594
595end:
596 rcu_read_unlock();
597 return;
598}
599
600/*
601 * Delete JUL application from the global hash table.
602 */
603void jul_delete_app(struct jul_app *app)
604{
605 int ret;
606 struct lttng_ht_iter iter;
607
608 assert(app);
609
610 DBG3("JUL deleting app pid: %d and sock: %d", app->pid, app->sock->fd);
611
612 iter.iter.node = &app->node.node;
613 rcu_read_lock();
614 ret = lttng_ht_del(jul_apps_ht_by_sock, &iter);
615 rcu_read_unlock();
616 assert(!ret);
617}
618
619/*
620 * Destroy a JUL application object by detaching it from its corresponding UST
621 * app if one, closing the socket and freeing the memory.
622 */
623void jul_destroy_app(struct jul_app *app)
624{
625 assert(app);
626
627 if (app->sock) {
628 app->sock->ops->close(app->sock);
629 lttcomm_destroy_sock(app->sock);
630 }
631
632 call_rcu(&app->node.head, destroy_app_jul_rcu);
633}
634
0475c50c
DG
635/*
636 * Initialize an already allocated JUL domain object.
637 *
638 * Return 0 on success or else a negative errno value.
639 */
640int jul_init_domain(struct jul_domain *dom)
641{
642 int ret;
643
644 assert(dom);
645
646 dom->events = lttng_ht_new(0, LTTNG_HT_TYPE_STRING);
647 if (!dom->events) {
648 ret = -ENOMEM;
649 goto error;
650 }
651
652 return 0;
653
654error:
655 return ret;
656}
657
658/*
659 * Create a newly allocated JUL event data structure. If name is valid, it's
660 * copied into the created event.
661 *
662 * Return a new object else NULL on error.
663 */
664struct jul_event *jul_create_event(const char *name)
665{
666 struct jul_event *event;
667
668 DBG3("JUL create new event with name %s", name);
669
670 event = zmalloc(sizeof(*event));
671 if (!event) {
672 goto error;
673 }
674
675 if (name) {
676 strncpy(event->name, name, sizeof(event->name));
677 event->name[sizeof(event->name) - 1] = '\0';
f20baf8e 678 lttng_ht_node_init_str(&event->node, event->name);
0475c50c
DG
679 }
680
681error:
682 return event;
683}
684
685/*
686 * Unique add of a JUL event to a given domain.
687 */
688void jul_add_event(struct jul_event *event, struct jul_domain *dom)
689{
690 assert(event);
691 assert(dom);
692 assert(dom->events);
693
694 DBG3("JUL adding event %s to domain", event->name);
695
f20baf8e 696 rcu_read_lock();
0475c50c 697 lttng_ht_add_unique_str(dom->events, &event->node);
f20baf8e 698 rcu_read_unlock();
3c6a091f 699 dom->being_used = 1;
0475c50c
DG
700}
701
702/*
703 * Find a JUL event in the given domain using name.
704 *
705 * RCU read side lock MUST be acquired.
706 *
707 * Return object if found else NULL.
708 */
709struct jul_event *jul_find_by_name(const char *name, struct jul_domain *dom)
710{
711 struct lttng_ht_node_str *node;
712 struct lttng_ht_iter iter;
713
714 assert(name);
715 assert(dom);
716 assert(dom->events);
717
718 lttng_ht_lookup(dom->events, (void *)name, &iter);
719 node = lttng_ht_iter_get_node_str(&iter);
720 if (node == NULL) {
721 goto error;
722 }
723
724 DBG3("JUL found by name %s in domain.", name);
725 return caa_container_of(node, struct jul_event, node);
726
727error:
728 DBG3("JUL NOT found by name %s in domain.", name);
729 return NULL;
730}
731
732/*
733 * Delete JUL event from given domain. Events hash table MUST be initialized.
734 */
735void jul_delete_event(struct jul_event *event, struct jul_domain *dom)
736{
737 int ret;
738 struct lttng_ht_iter iter;
739
740 assert(event);
741 assert(dom);
742 assert(dom->events);
743
744 DBG3("JUL deleting event %s from domain", event->name);
745
746 iter.iter.node = &event->node.node;
747 rcu_read_lock();
748 ret = lttng_ht_del(dom->events, &iter);
749 rcu_read_unlock();
750 assert(!ret);
751}
752
753/*
754 * Free given JUl event. After this call, the pointer is not usable anymore.
755 */
756void jul_destroy_event(struct jul_event *event)
757{
758 assert(event);
759
760 free(event);
761}
762
763/*
764 * Destroy a JUL domain completely. Note that the given pointer is NOT freed
765 * thus a reference can be passed to this function.
766 */
767void jul_destroy_domain(struct jul_domain *dom)
768{
769 struct lttng_ht_node_str *node;
770 struct lttng_ht_iter iter;
771
772 assert(dom);
773
774 DBG3("JUL destroy domain");
775
776 /*
777 * Just ignore if no events hash table exists. This is possible if for
778 * instance a JUL domain object was allocated but not initialized.
779 */
780 if (!dom->events) {
781 return;
782 }
783
784 rcu_read_lock();
785 cds_lfht_for_each_entry(dom->events->ht, &iter.iter, node, node) {
786 int ret;
787
788 ret = lttng_ht_del(dom->events, &iter);
789 assert(!ret);
790 call_rcu(&node->head, destroy_event_jul_rcu);
791 }
792 rcu_read_unlock();
793
f20baf8e
DG
794 lttng_ht_destroy(dom->events);
795}
796
797/*
798 * Initialize JUL subsystem.
799 */
800int jul_init(void)
801{
802 jul_apps_ht_by_sock = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
803 if (!jul_apps_ht_by_sock) {
804 return -1;
805 }
806
807 return 0;
808}
809
810/*
811 * Update a JUL application (given socket) using the given domain.
812 *
813 * Note that this function is most likely to be used with a tracing session
814 * thus the caller should make sure to hold the appropriate lock(s).
815 */
816void jul_update(struct jul_domain *domain, int sock)
817{
818 int ret;
819 struct jul_app *app;
820 struct jul_event *event;
821 struct lttng_ht_iter iter;
822
823 assert(domain);
824 assert(sock >= 0);
825
826 DBG("JUL updating app socket %d", sock);
827
828 rcu_read_lock();
829 cds_lfht_for_each_entry(domain->events->ht, &iter.iter, event, node.node) {
830 /* Skip event if disabled. */
831 if (!event->enabled) {
832 continue;
833 }
834
835 app = jul_find_app_by_sock(sock);
836 /*
837 * We are in the registration path thus if the application is gone,
838 * there is a serious code flow error.
839 */
840 assert(app);
841
842 ret = enable_event(app, event);
843 if (ret != LTTNG_OK) {
844 DBG2("JUL update unable to enable event %s on app pid: %d sock %d",
845 event->name, app->pid, app->sock->fd);
846 /* Let's try the others here and don't assume the app is dead. */
847 continue;
848 }
849 }
850 rcu_read_unlock();
0475c50c 851}
This page took 0.089587 seconds and 5 git commands to generate.