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 <urcu/uatomic.h>
23 #include <common/common.h>
24 #include <common/sessiond-comm/agent.h>
26 #include <common/compat/endian.h>
33 * Match function for the events hash table lookup by name.
35 static int ht_match_event_by_name(struct cds_lfht_node
*node
,
38 struct agent_event
*event
;
39 const struct agent_ht_key
*key
;
44 event
= caa_container_of(node
, struct agent_event
, node
.node
);
47 /* Match 1 elements of the key: name. */
50 if (strncmp(event
->name
, key
->name
, sizeof(event
->name
)) != 0) {
61 * Match function for the events hash table lookup by name and loglevel.
63 static int ht_match_event(struct cds_lfht_node
*node
,
66 struct agent_event
*event
;
67 const struct agent_ht_key
*key
;
72 event
= caa_container_of(node
, struct agent_event
, node
.node
);
75 /* Match 2 elements of the key: name and loglevel. */
78 if (strncmp(event
->name
, key
->name
, sizeof(event
->name
)) != 0) {
82 if (event
->loglevel
!= key
->loglevel
) {
83 if (event
->loglevel_type
== LTTNG_EVENT_LOGLEVEL_ALL
&&
84 key
->loglevel
== 0 && event
->loglevel
== -1) {
97 * Add unique agent event based on the event name and loglevel.
99 static void add_unique_agent_event(struct lttng_ht
*ht
,
100 struct agent_event
*event
)
102 struct cds_lfht_node
*node_ptr
;
103 struct agent_ht_key key
;
109 key
.name
= event
->name
;
110 key
.loglevel
= event
->loglevel
;
112 node_ptr
= cds_lfht_add_unique(ht
->ht
,
113 ht
->hash_fct(event
->node
.key
, lttng_ht_seed
),
114 ht_match_event
, &key
, &event
->node
.node
);
115 assert(node_ptr
== &event
->node
.node
);
119 * URCU delayed agent event reclaim.
121 static void destroy_event_agent_rcu(struct rcu_head
*head
)
123 struct lttng_ht_node_str
*node
=
124 caa_container_of(head
, struct lttng_ht_node_str
, head
);
125 struct agent_event
*event
=
126 caa_container_of(node
, struct agent_event
, node
);
132 * URCU delayed agent app reclaim.
134 static void destroy_app_agent_rcu(struct rcu_head
*head
)
136 struct lttng_ht_node_ulong
*node
=
137 caa_container_of(head
, struct lttng_ht_node_ulong
, head
);
138 struct agent_app
*app
=
139 caa_container_of(node
, struct agent_app
, node
);
145 * Communication with the agent. Send the message header to the given socket in
148 * Return 0 on success or else a negative errno message of sendmsg() op.
150 static int send_header(struct lttcomm_sock
*sock
, uint64_t data_size
,
151 uint32_t cmd
, uint32_t cmd_version
)
155 struct lttcomm_agent_hdr msg
;
159 memset(&msg
, 0, sizeof(msg
));
160 msg
.data_size
= htobe64(data_size
);
161 msg
.cmd
= htobe32(cmd
);
162 msg
.cmd_version
= htobe32(cmd_version
);
164 size
= sock
->ops
->sendmsg(sock
, &msg
, sizeof(msg
), 0);
165 if (size
< sizeof(msg
)) {
176 * Communication call with the agent. Send the payload to the given socket. The
177 * header MUST be sent prior to this call.
179 * Return 0 on success or else a negative errno value of sendmsg() op.
181 static int send_payload(struct lttcomm_sock
*sock
, void *data
,
190 len
= sock
->ops
->sendmsg(sock
, data
, size
, 0);
202 * Communication call with the agent. Receive reply from the agent using the
205 * Return 0 on success or else a negative errno value from recvmsg() op.
207 static int recv_reply(struct lttcomm_sock
*sock
, void *buf
, size_t size
)
215 len
= sock
->ops
->recvmsg(sock
, buf
, size
, 0);
227 * Internal event listing for a given app. Populate events.
229 * Return number of element in the list or else a negative LTTNG_ERR* code.
230 * On success, the caller is responsible for freeing the memory
231 * allocated for "events".
233 static ssize_t
list_events(struct agent_app
*app
, struct lttng_event
**events
)
235 int ret
, i
, len
= 0, offset
= 0;
238 struct lttng_event
*tmp_events
= NULL
;
239 struct lttcomm_agent_list_reply
*reply
= NULL
;
240 struct lttcomm_agent_list_reply_hdr reply_hdr
;
246 DBG2("Agent listing events for app pid: %d and socket %d", app
->pid
,
249 ret
= send_header(app
->sock
, 0, AGENT_CMD_LIST
, 0);
254 /* Get list header so we know how much we'll receive. */
255 ret
= recv_reply(app
->sock
, &reply_hdr
, sizeof(reply_hdr
));
260 switch (be32toh(reply_hdr
.ret_code
)) {
261 case AGENT_RET_CODE_SUCCESS
:
262 data_size
= be32toh(reply_hdr
.data_size
) + sizeof(*reply
);
265 ERR("Agent returned an unknown code: %" PRIu32
,
266 be32toh(reply_hdr
.ret_code
));
267 ret
= LTTNG_ERR_FATAL
;
271 reply
= zmalloc(data_size
);
273 ret
= LTTNG_ERR_NOMEM
;
277 /* Get the list with the appropriate data size. */
278 ret
= recv_reply(app
->sock
, reply
, data_size
);
283 nb_event
= be32toh(reply
->nb_event
);
284 tmp_events
= zmalloc(sizeof(*tmp_events
) * nb_event
);
286 ret
= LTTNG_ERR_NOMEM
;
290 for (i
= 0; i
< nb_event
; i
++) {
292 strncpy(tmp_events
[i
].name
, reply
->payload
+ offset
,
293 sizeof(tmp_events
[i
].name
));
294 tmp_events
[i
].pid
= app
->pid
;
295 tmp_events
[i
].enabled
= -1;
296 len
= strlen(reply
->payload
+ offset
) + 1;
299 *events
= tmp_events
;
305 ret
= LTTNG_ERR_UST_LIST_FAIL
;
314 * Internal enable agent event on a agent application. This function
315 * communicates with the agent to enable a given event.
317 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
319 static int enable_event(struct agent_app
*app
, struct agent_event
*event
)
323 struct lttcomm_agent_enable msg
;
324 struct lttcomm_agent_generic_reply reply
;
330 DBG2("Agent enabling event %s for app pid: %d and socket %d", event
->name
,
331 app
->pid
, app
->sock
->fd
);
333 data_size
= sizeof(msg
);
335 ret
= send_header(app
->sock
, data_size
, AGENT_CMD_ENABLE
, 0);
340 memset(&msg
, 0, sizeof(msg
));
341 msg
.loglevel
= event
->loglevel
;
342 msg
.loglevel_type
= event
->loglevel_type
;
343 strncpy(msg
.name
, event
->name
, sizeof(msg
.name
));
344 ret
= send_payload(app
->sock
, &msg
, sizeof(msg
));
349 ret
= recv_reply(app
->sock
, &reply
, sizeof(reply
));
354 switch (be32toh(reply
.ret_code
)) {
355 case AGENT_RET_CODE_SUCCESS
:
357 case AGENT_RET_CODE_UNKNOWN_NAME
:
358 ret
= LTTNG_ERR_UST_EVENT_NOT_FOUND
;
361 ERR("Agent returned an unknown code: %" PRIu32
,
362 be32toh(reply
.ret_code
));
363 ret
= LTTNG_ERR_FATAL
;
370 ret
= LTTNG_ERR_UST_ENABLE_FAIL
;
376 * Internal disable agent event call on a agent application. This function
377 * communicates with the agent to disable a given event.
379 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
381 static int disable_event(struct agent_app
*app
, struct agent_event
*event
)
385 struct lttcomm_agent_disable msg
;
386 struct lttcomm_agent_generic_reply reply
;
392 DBG2("Agent disabling event %s for app pid: %d and socket %d", event
->name
,
393 app
->pid
, app
->sock
->fd
);
395 data_size
= sizeof(msg
);
397 ret
= send_header(app
->sock
, data_size
, AGENT_CMD_DISABLE
, 0);
402 memset(&msg
, 0, sizeof(msg
));
403 strncpy(msg
.name
, event
->name
, sizeof(msg
.name
));
404 ret
= send_payload(app
->sock
, &msg
, sizeof(msg
));
409 ret
= recv_reply(app
->sock
, &reply
, sizeof(reply
));
414 switch (be32toh(reply
.ret_code
)) {
415 case AGENT_RET_CODE_SUCCESS
:
417 case AGENT_RET_CODE_UNKNOWN_NAME
:
418 ret
= LTTNG_ERR_UST_EVENT_NOT_FOUND
;
421 ERR("Agent returned an unknown code: %" PRIu32
,
422 be32toh(reply
.ret_code
));
423 ret
= LTTNG_ERR_FATAL
;
430 ret
= LTTNG_ERR_UST_DISABLE_FAIL
;
436 * Send back the registration DONE command to a given agent application.
438 * Return 0 on success or else a negative value.
440 int agent_send_registration_done(struct agent_app
*app
)
445 DBG("Agent sending registration done to app socket %d", app
->sock
->fd
);
447 return send_header(app
->sock
, 0, AGENT_CMD_REG_DONE
, 0);
451 * Enable agent event on every agent applications registered with the session
454 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
456 int agent_enable_event(struct agent_event
*event
,
457 enum lttng_domain_type domain
)
460 struct agent_app
*app
;
461 struct lttng_ht_iter iter
;
467 cds_lfht_for_each_entry(agent_apps_ht_by_sock
->ht
, &iter
.iter
, app
,
469 if (app
->domain
!= domain
) {
473 /* Enable event on agent application through TCP socket. */
474 ret
= enable_event(app
, event
);
475 if (ret
!= LTTNG_OK
) {
489 * Disable agent event on every agent applications registered with the session
492 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
494 int agent_disable_event(struct agent_event
*event
,
495 enum lttng_domain_type domain
)
498 struct agent_app
*app
;
499 struct lttng_ht_iter iter
;
505 cds_lfht_for_each_entry(agent_apps_ht_by_sock
->ht
, &iter
.iter
, app
,
507 if (app
->domain
!= domain
) {
511 /* Enable event on agent application through TCP socket. */
512 ret
= disable_event(app
, event
);
513 if (ret
!= LTTNG_OK
) {
527 * Ask every agent for the list of possible event. Events is allocated with the
528 * events of every agent application.
530 * Return the number of events or else a negative value.
532 int agent_list_events(struct lttng_event
**events
,
533 enum lttng_domain_type domain
)
536 size_t nbmem
, count
= 0;
537 struct agent_app
*app
;
538 struct lttng_event
*tmp_events
= NULL
;
539 struct lttng_ht_iter iter
;
543 DBG2("Agent listing events for domain %d", domain
);
545 nbmem
= UST_APP_EVENT_LIST_SIZE
;
546 tmp_events
= zmalloc(nbmem
* sizeof(*tmp_events
));
548 PERROR("zmalloc agent list events");
554 cds_lfht_for_each_entry(agent_apps_ht_by_sock
->ht
, &iter
.iter
, app
,
557 struct lttng_event
*agent_events
;
559 /* Skip domain not asked by the list. */
560 if (app
->domain
!= domain
) {
564 nb_ev
= list_events(app
, &agent_events
);
570 if (count
+ nb_ev
> nbmem
) {
571 /* In case the realloc fails, we free the memory */
572 struct lttng_event
*new_tmp_events
;
575 new_nbmem
= max_t(size_t, count
+ nb_ev
, nbmem
<< 1);
576 DBG2("Reallocating agent event list from %zu to %zu entries",
578 new_tmp_events
= realloc(tmp_events
,
579 new_nbmem
* sizeof(*new_tmp_events
));
580 if (!new_tmp_events
) {
581 PERROR("realloc agent events");
586 /* Zero the new memory */
587 memset(new_tmp_events
+ nbmem
, 0,
588 (new_nbmem
- nbmem
) * sizeof(*new_tmp_events
));
590 tmp_events
= new_tmp_events
;
592 memcpy(tmp_events
+ count
, agent_events
,
593 nb_ev
* sizeof(*tmp_events
));
600 *events
= tmp_events
;
611 * Create a agent app object using the given PID.
613 * Return newly allocated object or else NULL on error.
615 struct agent_app
*agent_create_app(pid_t pid
, enum lttng_domain_type domain
,
616 struct lttcomm_sock
*sock
)
618 struct agent_app
*app
;
622 app
= zmalloc(sizeof(*app
));
624 PERROR("zmalloc agent create");
629 app
->domain
= domain
;
631 lttng_ht_node_init_ulong(&app
->node
, (unsigned long) app
->sock
->fd
);
638 * Lookup agent app by socket in the global hash table.
640 * RCU read side lock MUST be acquired.
642 * Return object if found else NULL.
644 struct agent_app
*agent_find_app_by_sock(int sock
)
646 struct lttng_ht_node_ulong
*node
;
647 struct lttng_ht_iter iter
;
648 struct agent_app
*app
;
652 lttng_ht_lookup(agent_apps_ht_by_sock
, (void *)((unsigned long) sock
), &iter
);
653 node
= lttng_ht_iter_get_node_ulong(&iter
);
657 app
= caa_container_of(node
, struct agent_app
, node
);
659 DBG3("Agent app pid %d found by sock %d.", app
->pid
, sock
);
663 DBG3("Agent app NOT found by sock %d.", sock
);
668 * Add agent application object to the global hash table.
670 void agent_add_app(struct agent_app
*app
)
674 DBG3("Agent adding app sock: %d and pid: %d to ht", app
->sock
->fd
, app
->pid
);
677 lttng_ht_add_unique_ulong(agent_apps_ht_by_sock
, &app
->node
);
682 * Delete agent application from the global hash table.
684 void agent_delete_app(struct agent_app
*app
)
687 struct lttng_ht_iter iter
;
691 DBG3("Agent deleting app pid: %d and sock: %d", app
->pid
, app
->sock
->fd
);
693 iter
.iter
.node
= &app
->node
.node
;
695 ret
= lttng_ht_del(agent_apps_ht_by_sock
, &iter
);
701 * Destroy a agent application object by detaching it from its corresponding
702 * UST app if one is connected by closing the socket. Finally, perform a
703 * delayed memory reclaim.
705 void agent_destroy_app(struct agent_app
*app
)
710 app
->sock
->ops
->close(app
->sock
);
711 lttcomm_destroy_sock(app
->sock
);
714 call_rcu(&app
->node
.head
, destroy_app_agent_rcu
);
718 * Initialize an already allocated agent object.
720 * Return 0 on success or else a negative errno value.
722 int agent_init(struct agent
*agt
)
728 agt
->events
= lttng_ht_new(0, LTTNG_HT_TYPE_STRING
);
733 lttng_ht_node_init_u64(&agt
->node
, agt
->domain
);
742 * Add agent object to the given hash table.
744 void agent_add(struct agent
*agt
, struct lttng_ht
*ht
)
749 DBG3("Agent adding from domain %d", agt
->domain
);
752 lttng_ht_add_unique_u64(ht
, &agt
->node
);
757 * Create an agent object for the given domain.
759 * Return the allocated agent or NULL on error.
761 struct agent
*agent_create(enum lttng_domain_type domain
)
766 agt
= zmalloc(sizeof(*agt
));
770 agt
->domain
= domain
;
772 ret
= agent_init(agt
);
784 * Create a newly allocated agent event data structure. If name is valid, it's
785 * copied into the created event.
787 * Return a new object else NULL on error.
789 struct agent_event
*agent_create_event(const char *name
,
790 struct lttng_filter_bytecode
*filter
)
792 struct agent_event
*event
;
794 DBG3("Agent create new event with name %s", name
);
796 event
= zmalloc(sizeof(*event
));
802 strncpy(event
->name
, name
, sizeof(event
->name
));
803 event
->name
[sizeof(event
->name
) - 1] = '\0';
804 lttng_ht_node_init_str(&event
->node
, event
->name
);
808 event
->filter
= filter
;
816 * Unique add of a agent event to an agent object.
818 void agent_add_event(struct agent_event
*event
, struct agent
*agt
)
824 DBG3("Agent adding event %s", event
->name
);
827 add_unique_agent_event(agt
->events
, event
);
833 * Find a agent event in the given agent using name.
835 * RCU read side lock MUST be acquired.
837 * Return object if found else NULL.
839 struct agent_event
*agent_find_event_by_name(const char *name
,
842 struct lttng_ht_node_str
*node
;
843 struct lttng_ht_iter iter
;
845 struct agent_ht_key key
;
854 cds_lfht_lookup(ht
->ht
, ht
->hash_fct((void *) name
, lttng_ht_seed
),
855 ht_match_event_by_name
, &key
, &iter
.iter
);
856 node
= lttng_ht_iter_get_node_str(&iter
);
861 DBG3("Agent event found %s by name.", name
);
862 return caa_container_of(node
, struct agent_event
, node
);
865 DBG3("Agent NOT found by name %s.", name
);
870 * Find a agent event in the given agent using name and loglevel.
872 * RCU read side lock MUST be acquired.
874 * Return object if found else NULL.
876 struct agent_event
*agent_find_event(const char *name
, int loglevel
,
879 struct lttng_ht_node_str
*node
;
880 struct lttng_ht_iter iter
;
882 struct agent_ht_key key
;
890 key
.loglevel
= loglevel
;
892 cds_lfht_lookup(ht
->ht
, ht
->hash_fct((void *) name
, lttng_ht_seed
),
893 ht_match_event
, &key
, &iter
.iter
);
894 node
= lttng_ht_iter_get_node_str(&iter
);
899 DBG3("Agent event found %s.", name
);
900 return caa_container_of(node
, struct agent_event
, node
);
903 DBG3("Agent NOT found %s.", name
);
908 * Free given agent event. This event must not be globally visible at this
909 * point (only expected to be used on failure just after event creation). After
910 * this call, the pointer is not usable anymore.
912 void agent_destroy_event(struct agent_event
*event
)
921 * Destroy an agent completely. Note that the given pointer is NOT freed
922 * thus a reference to static or stack data can be passed to this function.
924 void agent_destroy(struct agent
*agt
)
926 struct lttng_ht_node_str
*node
;
927 struct lttng_ht_iter iter
;
931 DBG3("Agent destroy");
934 * Just ignore if no events hash table exists. This is possible if for
935 * instance an agent object was allocated but not initialized.
942 cds_lfht_for_each_entry(agt
->events
->ht
, &iter
.iter
, node
, node
) {
944 struct agent_event
*event
;
947 * When destroying an event, we have to try to disable it on the agent
948 * side so the event stops generating data. The return value is not
949 * important since we have to continue anyway destroying the object.
951 event
= caa_container_of(node
, struct agent_event
, node
);
952 (void) agent_disable_event(event
, agt
->domain
);
954 ret
= lttng_ht_del(agt
->events
, &iter
);
956 call_rcu(&node
->head
, destroy_event_agent_rcu
);
960 ht_cleanup_push(agt
->events
);
964 * Initialize agent subsystem.
966 int agent_setup(void)
968 agent_apps_ht_by_sock
= lttng_ht_new(0, LTTNG_HT_TYPE_ULONG
);
969 if (!agent_apps_ht_by_sock
) {
977 * Update a agent application (given socket) using the given agent.
979 * Note that this function is most likely to be used with a tracing session
980 * thus the caller should make sure to hold the appropriate lock(s).
982 void agent_update(struct agent
*agt
, int sock
)
985 struct agent_app
*app
;
986 struct agent_event
*event
;
987 struct lttng_ht_iter iter
;
992 DBG("Agent updating app socket %d", sock
);
995 cds_lfht_for_each_entry(agt
->events
->ht
, &iter
.iter
, event
, node
.node
) {
996 /* Skip event if disabled. */
997 if (!event
->enabled
) {
1001 app
= agent_find_app_by_sock(sock
);
1003 * We are in the registration path thus if the application is gone,
1004 * there is a serious code flow error.
1008 ret
= enable_event(app
, event
);
1009 if (ret
!= LTTNG_OK
) {
1010 DBG2("Agent update unable to enable event %s on app pid: %d sock %d",
1011 event
->name
, app
->pid
, app
->sock
->fd
);
1012 /* Let's try the others here and don't assume the app is dead. */