Fix: Remove undocumented session daemon short options
[lttng-tools.git] / src / bin / lttng-sessiond / agent.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
6c1c0768 19#define _LGPL_SOURCE
0475c50c 20#include <assert.h>
f20baf8e 21#include <urcu/uatomic.h>
0475c50c
DG
22
23#include <common/common.h>
022d91ba 24#include <common/sessiond-comm/agent.h>
0475c50c 25
f263b7fd
JD
26#include <common/compat/endian.h>
27
022d91ba 28#include "agent.h"
f20baf8e 29#include "ust-app.h"
0475c50c
DG
30#include "utils.h"
31
4a4ab2c3
DG
32/*
33 * Match function for the events hash table lookup by name.
34 */
35static int ht_match_event_by_name(struct cds_lfht_node *node,
36 const void *_key)
37{
022d91ba
DG
38 struct agent_event *event;
39 const struct agent_ht_key *key;
4a4ab2c3
DG
40
41 assert(node);
42 assert(_key);
43
022d91ba 44 event = caa_container_of(node, struct agent_event, node.node);
4a4ab2c3
DG
45 key = _key;
46
47 /* Match 1 elements of the key: name. */
48
49 /* Event name */
50 if (strncmp(event->name, key->name, sizeof(event->name)) != 0) {
51 goto no_match;
52 }
53 /* Match. */
54 return 1;
55
56no_match:
57 return 0;
58}
59
60/*
61 * Match function for the events hash table lookup by name and loglevel.
62 */
63static int ht_match_event(struct cds_lfht_node *node,
64 const void *_key)
65{
022d91ba
DG
66 struct agent_event *event;
67 const struct agent_ht_key *key;
4a4ab2c3
DG
68
69 assert(node);
70 assert(_key);
71
022d91ba 72 event = caa_container_of(node, struct agent_event, node.node);
4a4ab2c3
DG
73 key = _key;
74
75 /* Match 2 elements of the key: name and loglevel. */
76
77 /* Event name */
78 if (strncmp(event->name, key->name, sizeof(event->name)) != 0) {
79 goto no_match;
80 }
81
82 if (event->loglevel != key->loglevel) {
83 if (event->loglevel_type == LTTNG_EVENT_LOGLEVEL_ALL &&
84 key->loglevel == 0 && event->loglevel == -1) {
85 goto match;
86 }
87 goto no_match;
88 }
89match:
90 return 1;
91
92no_match:
93 return 0;
94}
95
96/*
022d91ba 97 * Add unique agent event based on the event name and loglevel.
4a4ab2c3 98 */
022d91ba
DG
99static void add_unique_agent_event(struct lttng_ht *ht,
100 struct agent_event *event)
4a4ab2c3
DG
101{
102 struct cds_lfht_node *node_ptr;
022d91ba 103 struct agent_ht_key key;
4a4ab2c3
DG
104
105 assert(ht);
106 assert(ht->ht);
107 assert(event);
108
109 key.name = event->name;
110 key.loglevel = event->loglevel;
111
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);
116}
117
0475c50c 118/*
022d91ba 119 * URCU delayed agent event reclaim.
0475c50c 120 */
022d91ba 121static void destroy_event_agent_rcu(struct rcu_head *head)
0475c50c
DG
122{
123 struct lttng_ht_node_str *node =
124 caa_container_of(head, struct lttng_ht_node_str, head);
022d91ba
DG
125 struct agent_event *event =
126 caa_container_of(node, struct agent_event, node);
0475c50c
DG
127
128 free(event);
129}
130
f20baf8e 131/*
022d91ba 132 * URCU delayed agent app reclaim.
f20baf8e 133 */
022d91ba 134static void destroy_app_agent_rcu(struct rcu_head *head)
f20baf8e
DG
135{
136 struct lttng_ht_node_ulong *node =
137 caa_container_of(head, struct lttng_ht_node_ulong, head);
022d91ba
DG
138 struct agent_app *app =
139 caa_container_of(node, struct agent_app, node);
f20baf8e
DG
140
141 free(app);
142}
143
144/*
022d91ba
DG
145 * Communication with the agent. Send the message header to the given socket in
146 * big endian.
f20baf8e
DG
147 *
148 * Return 0 on success or else a negative errno message of sendmsg() op.
149 */
150static int send_header(struct lttcomm_sock *sock, uint64_t data_size,
151 uint32_t cmd, uint32_t cmd_version)
152{
153 int ret;
154 ssize_t size;
022d91ba 155 struct lttcomm_agent_hdr msg;
f20baf8e
DG
156
157 assert(sock);
158
53efb85a 159 memset(&msg, 0, sizeof(msg));
f20baf8e
DG
160 msg.data_size = htobe64(data_size);
161 msg.cmd = htobe32(cmd);
162 msg.cmd_version = htobe32(cmd_version);
163
164 size = sock->ops->sendmsg(sock, &msg, sizeof(msg), 0);
165 if (size < sizeof(msg)) {
166 ret = -errno;
167 goto error;
168 }
169 ret = 0;
170
171error:
172 return ret;
173}
174
175/*
022d91ba
DG
176 * Communication call with the agent. Send the payload to the given socket. The
177 * header MUST be sent prior to this call.
f20baf8e
DG
178 *
179 * Return 0 on success or else a negative errno value of sendmsg() op.
180 */
181static int send_payload(struct lttcomm_sock *sock, void *data,
182 size_t size)
183{
184 int ret;
185 ssize_t len;
186
187 assert(sock);
188 assert(data);
189
190 len = sock->ops->sendmsg(sock, data, size, 0);
191 if (len < size) {
192 ret = -errno;
193 goto error;
194 }
195 ret = 0;
196
197error:
198 return ret;
199}
200
201/*
022d91ba
DG
202 * Communication call with the agent. Receive reply from the agent using the
203 * given socket.
f20baf8e
DG
204 *
205 * Return 0 on success or else a negative errno value from recvmsg() op.
206 */
207static int recv_reply(struct lttcomm_sock *sock, void *buf, size_t size)
208{
209 int ret;
210 ssize_t len;
211
212 assert(sock);
213 assert(buf);
214
215 len = sock->ops->recvmsg(sock, buf, size, 0);
216 if (len < size) {
217 ret = -errno;
218 goto error;
219 }
220 ret = 0;
221
222error:
223 return ret;
224}
225
3c6a091f 226/*
428de77a 227 * Internal event listing for a given app. Populate events.
3c6a091f
DG
228 *
229 * Return number of element in the list or else a negative LTTNG_ERR* code.
428de77a
MD
230 * On success, the caller is responsible for freeing the memory
231 * allocated for "events".
3c6a091f 232 */
022d91ba 233static ssize_t list_events(struct agent_app *app, struct lttng_event **events)
3c6a091f
DG
234{
235 int ret, i, len = 0, offset = 0;
236 uint32_t nb_event;
237 size_t data_size;
238 struct lttng_event *tmp_events = NULL;
022d91ba
DG
239 struct lttcomm_agent_list_reply *reply = NULL;
240 struct lttcomm_agent_list_reply_hdr reply_hdr;
3c6a091f
DG
241
242 assert(app);
243 assert(app->sock);
244 assert(events);
245
022d91ba 246 DBG2("Agent listing events for app pid: %d and socket %d", app->pid,
3c6a091f
DG
247 app->sock->fd);
248
022d91ba 249 ret = send_header(app->sock, 0, AGENT_CMD_LIST, 0);
3c6a091f
DG
250 if (ret < 0) {
251 goto error_io;
252 }
253
254 /* Get list header so we know how much we'll receive. */
255 ret = recv_reply(app->sock, &reply_hdr, sizeof(reply_hdr));
256 if (ret < 0) {
257 goto error_io;
258 }
259
260 switch (be32toh(reply_hdr.ret_code)) {
022d91ba 261 case AGENT_RET_CODE_SUCCESS:
3c6a091f
DG
262 data_size = be32toh(reply_hdr.data_size) + sizeof(*reply);
263 break;
264 default:
022d91ba 265 ERR("Agent returned an unknown code: %" PRIu32,
3c6a091f
DG
266 be32toh(reply_hdr.ret_code));
267 ret = LTTNG_ERR_FATAL;
268 goto error;
269 }
270
271 reply = zmalloc(data_size);
272 if (!reply) {
273 ret = LTTNG_ERR_NOMEM;
274 goto error;
275 }
276
277 /* Get the list with the appropriate data size. */
278 ret = recv_reply(app->sock, reply, data_size);
279 if (ret < 0) {
280 goto error_io;
281 }
282
283 nb_event = be32toh(reply->nb_event);
284 tmp_events = zmalloc(sizeof(*tmp_events) * nb_event);
285 if (!tmp_events) {
286 ret = LTTNG_ERR_NOMEM;
287 goto error;
288 }
289
290 for (i = 0; i < nb_event; i++) {
291 offset += len;
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;
297 }
298
299 *events = tmp_events;
300
301 free(reply);
302 return nb_event;
303
304error_io:
305 ret = LTTNG_ERR_UST_LIST_FAIL;
306error:
307 free(reply);
308 free(tmp_events);
309 return -ret;
310
311}
312
f20baf8e 313/*
022d91ba
DG
314 * Internal enable agent event on a agent application. This function
315 * communicates with the agent to enable a given event.
f20baf8e
DG
316 *
317 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
318 */
022d91ba 319static int enable_event(struct agent_app *app, struct agent_event *event)
f20baf8e
DG
320{
321 int ret;
322 uint64_t data_size;
022d91ba
DG
323 struct lttcomm_agent_enable msg;
324 struct lttcomm_agent_generic_reply reply;
f20baf8e
DG
325
326 assert(app);
327 assert(app->sock);
328 assert(event);
329
022d91ba 330 DBG2("Agent enabling event %s for app pid: %d and socket %d", event->name,
f20baf8e
DG
331 app->pid, app->sock->fd);
332
333 data_size = sizeof(msg);
334
022d91ba 335 ret = send_header(app->sock, data_size, AGENT_CMD_ENABLE, 0);
f20baf8e
DG
336 if (ret < 0) {
337 goto error_io;
338 }
339
53efb85a 340 memset(&msg, 0, sizeof(msg));
b2064f54
DG
341 msg.loglevel = event->loglevel;
342 msg.loglevel_type = event->loglevel_type;
f20baf8e
DG
343 strncpy(msg.name, event->name, sizeof(msg.name));
344 ret = send_payload(app->sock, &msg, sizeof(msg));
345 if (ret < 0) {
346 goto error_io;
347 }
348
349 ret = recv_reply(app->sock, &reply, sizeof(reply));
350 if (ret < 0) {
351 goto error_io;
352 }
353
354 switch (be32toh(reply.ret_code)) {
022d91ba 355 case AGENT_RET_CODE_SUCCESS:
f20baf8e 356 break;
022d91ba 357 case AGENT_RET_CODE_UNKNOWN_NAME:
f20baf8e
DG
358 ret = LTTNG_ERR_UST_EVENT_NOT_FOUND;
359 goto error;
360 default:
022d91ba 361 ERR("Agent returned an unknown code: %" PRIu32,
f20baf8e
DG
362 be32toh(reply.ret_code));
363 ret = LTTNG_ERR_FATAL;
364 goto error;
365 }
366
367 return LTTNG_OK;
368
369error_io:
370 ret = LTTNG_ERR_UST_ENABLE_FAIL;
371error:
372 return ret;
373}
374
375/*
022d91ba
DG
376 * Internal disable agent event call on a agent application. This function
377 * communicates with the agent to disable a given event.
f20baf8e
DG
378 *
379 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
380 */
022d91ba 381static int disable_event(struct agent_app *app, struct agent_event *event)
f20baf8e
DG
382{
383 int ret;
384 uint64_t data_size;
022d91ba
DG
385 struct lttcomm_agent_disable msg;
386 struct lttcomm_agent_generic_reply reply;
f20baf8e
DG
387
388 assert(app);
389 assert(app->sock);
390 assert(event);
391
022d91ba 392 DBG2("Agent disabling event %s for app pid: %d and socket %d", event->name,
f20baf8e
DG
393 app->pid, app->sock->fd);
394
395 data_size = sizeof(msg);
396
022d91ba 397 ret = send_header(app->sock, data_size, AGENT_CMD_DISABLE, 0);
f20baf8e
DG
398 if (ret < 0) {
399 goto error_io;
400 }
401
53efb85a 402 memset(&msg, 0, sizeof(msg));
f20baf8e
DG
403 strncpy(msg.name, event->name, sizeof(msg.name));
404 ret = send_payload(app->sock, &msg, sizeof(msg));
405 if (ret < 0) {
406 goto error_io;
407 }
408
409 ret = recv_reply(app->sock, &reply, sizeof(reply));
410 if (ret < 0) {
411 goto error_io;
412 }
413
414 switch (be32toh(reply.ret_code)) {
022d91ba
DG
415 case AGENT_RET_CODE_SUCCESS:
416 break;
417 case AGENT_RET_CODE_UNKNOWN_NAME:
418 ret = LTTNG_ERR_UST_EVENT_NOT_FOUND;
419 goto error;
420 default:
421 ERR("Agent returned an unknown code: %" PRIu32,
422 be32toh(reply.ret_code));
423 ret = LTTNG_ERR_FATAL;
424 goto error;
f20baf8e
DG
425 }
426
427 return LTTNG_OK;
428
429error_io:
430 ret = LTTNG_ERR_UST_DISABLE_FAIL;
431error:
432 return ret;
433}
434
1b500e7a 435/*
022d91ba 436 * Send back the registration DONE command to a given agent application.
1b500e7a
DG
437 *
438 * Return 0 on success or else a negative value.
439 */
022d91ba 440int agent_send_registration_done(struct agent_app *app)
1b500e7a
DG
441{
442 assert(app);
443 assert(app->sock);
444
022d91ba 445 DBG("Agent sending registration done to app socket %d", app->sock->fd);
1b500e7a 446
022d91ba 447 return send_header(app->sock, 0, AGENT_CMD_REG_DONE, 0);
1b500e7a
DG
448}
449
f20baf8e 450/*
022d91ba 451 * Enable agent event on every agent applications registered with the session
f20baf8e
DG
452 * daemon.
453 *
454 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
455 */
fefd409b
DG
456int agent_enable_event(struct agent_event *event,
457 enum lttng_domain_type domain)
f20baf8e
DG
458{
459 int ret;
022d91ba 460 struct agent_app *app;
f20baf8e
DG
461 struct lttng_ht_iter iter;
462
463 assert(event);
464
465 rcu_read_lock();
466
022d91ba 467 cds_lfht_for_each_entry(agent_apps_ht_by_sock->ht, &iter.iter, app,
f20baf8e 468 node.node) {
fefd409b
DG
469 if (app->domain != domain) {
470 continue;
471 }
472
022d91ba 473 /* Enable event on agent application through TCP socket. */
f20baf8e
DG
474 ret = enable_event(app, event);
475 if (ret != LTTNG_OK) {
476 goto error;
477 }
f20baf8e
DG
478 }
479
3c6a091f 480 event->enabled = 1;
f20baf8e
DG
481 ret = LTTNG_OK;
482
483error:
484 rcu_read_unlock();
485 return ret;
486}
487
488/*
022d91ba 489 * Disable agent event on every agent applications registered with the session
f20baf8e
DG
490 * daemon.
491 *
492 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
493 */
fefd409b
DG
494int agent_disable_event(struct agent_event *event,
495 enum lttng_domain_type domain)
f20baf8e
DG
496{
497 int ret;
022d91ba 498 struct agent_app *app;
f20baf8e
DG
499 struct lttng_ht_iter iter;
500
501 assert(event);
502
503 rcu_read_lock();
504
022d91ba 505 cds_lfht_for_each_entry(agent_apps_ht_by_sock->ht, &iter.iter, app,
f20baf8e 506 node.node) {
fefd409b
DG
507 if (app->domain != domain) {
508 continue;
509 }
510
022d91ba 511 /* Enable event on agent application through TCP socket. */
f20baf8e
DG
512 ret = disable_event(app, event);
513 if (ret != LTTNG_OK) {
514 goto error;
515 }
f20baf8e
DG
516 }
517
3c6a091f 518 event->enabled = 0;
f20baf8e
DG
519 ret = LTTNG_OK;
520
521error:
522 rcu_read_unlock();
523 return ret;
524}
525
526/*
022d91ba
DG
527 * Ask every agent for the list of possible event. Events is allocated with the
528 * events of every agent application.
f20baf8e
DG
529 *
530 * Return the number of events or else a negative value.
531 */
f60140a1
DG
532int agent_list_events(struct lttng_event **events,
533 enum lttng_domain_type domain)
f20baf8e
DG
534{
535 int ret;
536 size_t nbmem, count = 0;
022d91ba 537 struct agent_app *app;
aae6255e 538 struct lttng_event *tmp_events = NULL;
f20baf8e
DG
539 struct lttng_ht_iter iter;
540
541 assert(events);
542
0e115563
DG
543 DBG2("Agent listing events for domain %d", domain);
544
f20baf8e
DG
545 nbmem = UST_APP_EVENT_LIST_SIZE;
546 tmp_events = zmalloc(nbmem * sizeof(*tmp_events));
547 if (!tmp_events) {
022d91ba 548 PERROR("zmalloc agent list events");
f20baf8e
DG
549 ret = -ENOMEM;
550 goto error;
551 }
552
553 rcu_read_lock();
022d91ba 554 cds_lfht_for_each_entry(agent_apps_ht_by_sock->ht, &iter.iter, app,
f20baf8e
DG
555 node.node) {
556 ssize_t nb_ev;
022d91ba 557 struct lttng_event *agent_events;
f20baf8e 558
f60140a1
DG
559 /* Skip domain not asked by the list. */
560 if (app->domain != domain) {
561 continue;
562 }
563
022d91ba 564 nb_ev = list_events(app, &agent_events);
f20baf8e
DG
565 if (nb_ev < 0) {
566 ret = nb_ev;
428de77a 567 goto error_unlock;
f20baf8e
DG
568 }
569
53efb85a 570 if (count + nb_ev > nbmem) {
f20baf8e 571 /* In case the realloc fails, we free the memory */
53efb85a
MD
572 struct lttng_event *new_tmp_events;
573 size_t new_nbmem;
574
575 new_nbmem = max_t(size_t, count + nb_ev, nbmem << 1);
022d91ba 576 DBG2("Reallocating agent event list from %zu to %zu entries",
53efb85a
MD
577 nbmem, new_nbmem);
578 new_tmp_events = realloc(tmp_events,
579 new_nbmem * sizeof(*new_tmp_events));
580 if (!new_tmp_events) {
022d91ba 581 PERROR("realloc agent events");
f20baf8e 582 ret = -ENOMEM;
022d91ba 583 free(agent_events);
428de77a 584 goto error_unlock;
f20baf8e 585 }
53efb85a
MD
586 /* Zero the new memory */
587 memset(new_tmp_events + nbmem, 0,
588 (new_nbmem - nbmem) * sizeof(*new_tmp_events));
589 nbmem = new_nbmem;
590 tmp_events = new_tmp_events;
f20baf8e 591 }
022d91ba 592 memcpy(tmp_events + count, agent_events,
53efb85a 593 nb_ev * sizeof(*tmp_events));
022d91ba 594 free(agent_events);
f20baf8e
DG
595 count += nb_ev;
596 }
597 rcu_read_unlock();
598
599 ret = count;
600 *events = tmp_events;
aae6255e 601 return ret;
f20baf8e 602
428de77a
MD
603error_unlock:
604 rcu_read_unlock();
f20baf8e 605error:
aae6255e 606 free(tmp_events);
f20baf8e
DG
607 return ret;
608}
609
610/*
022d91ba 611 * Create a agent app object using the given PID.
f20baf8e
DG
612 *
613 * Return newly allocated object or else NULL on error.
614 */
fefd409b
DG
615struct agent_app *agent_create_app(pid_t pid, enum lttng_domain_type domain,
616 struct lttcomm_sock *sock)
f20baf8e 617{
022d91ba 618 struct agent_app *app;
f20baf8e
DG
619
620 assert(sock);
621
622 app = zmalloc(sizeof(*app));
623 if (!app) {
022d91ba 624 PERROR("zmalloc agent create");
f20baf8e
DG
625 goto error;
626 }
627
628 app->pid = pid;
fefd409b 629 app->domain = domain;
f20baf8e 630 app->sock = sock;
f20baf8e
DG
631 lttng_ht_node_init_ulong(&app->node, (unsigned long) app->sock->fd);
632
633error:
634 return app;
635}
636
637/*
022d91ba 638 * Lookup agent app by socket in the global hash table.
f20baf8e
DG
639 *
640 * RCU read side lock MUST be acquired.
641 *
642 * Return object if found else NULL.
643 */
022d91ba 644struct agent_app *agent_find_app_by_sock(int sock)
f20baf8e
DG
645{
646 struct lttng_ht_node_ulong *node;
647 struct lttng_ht_iter iter;
022d91ba 648 struct agent_app *app;
f20baf8e
DG
649
650 assert(sock >= 0);
651
022d91ba 652 lttng_ht_lookup(agent_apps_ht_by_sock, (void *)((unsigned long) sock), &iter);
f20baf8e
DG
653 node = lttng_ht_iter_get_node_ulong(&iter);
654 if (node == NULL) {
655 goto error;
656 }
022d91ba 657 app = caa_container_of(node, struct agent_app, node);
f20baf8e 658
022d91ba 659 DBG3("Agent app pid %d found by sock %d.", app->pid, sock);
f20baf8e
DG
660 return app;
661
662error:
022d91ba 663 DBG3("Agent app NOT found by sock %d.", sock);
f20baf8e
DG
664 return NULL;
665}
666
667/*
022d91ba 668 * Add agent application object to the global hash table.
f20baf8e 669 */
022d91ba 670void agent_add_app(struct agent_app *app)
f20baf8e
DG
671{
672 assert(app);
673
022d91ba 674 DBG3("Agent adding app sock: %d and pid: %d to ht", app->sock->fd, app->pid);
f20baf8e
DG
675
676 rcu_read_lock();
022d91ba 677 lttng_ht_add_unique_ulong(agent_apps_ht_by_sock, &app->node);
f20baf8e
DG
678 rcu_read_unlock();
679}
680
f20baf8e 681/*
022d91ba 682 * Delete agent application from the global hash table.
d558f236
JG
683 *
684 * rcu_read_lock() must be held by the caller.
f20baf8e 685 */
022d91ba 686void agent_delete_app(struct agent_app *app)
f20baf8e
DG
687{
688 int ret;
689 struct lttng_ht_iter iter;
690
691 assert(app);
692
022d91ba 693 DBG3("Agent deleting app pid: %d and sock: %d", app->pid, app->sock->fd);
f20baf8e
DG
694
695 iter.iter.node = &app->node.node;
022d91ba 696 ret = lttng_ht_del(agent_apps_ht_by_sock, &iter);
f20baf8e
DG
697 assert(!ret);
698}
699
700/*
e785906c 701 * Destroy an agent application object by detaching it from its corresponding
022d91ba 702 * UST app if one is connected by closing the socket. Finally, perform a
428de77a 703 * delayed memory reclaim.
f20baf8e 704 */
022d91ba 705void agent_destroy_app(struct agent_app *app)
f20baf8e
DG
706{
707 assert(app);
708
709 if (app->sock) {
710 app->sock->ops->close(app->sock);
711 lttcomm_destroy_sock(app->sock);
712 }
713
022d91ba 714 call_rcu(&app->node.head, destroy_app_agent_rcu);
f20baf8e
DG
715}
716
0475c50c 717/*
022d91ba 718 * Initialize an already allocated agent object.
0475c50c
DG
719 *
720 * Return 0 on success or else a negative errno value.
721 */
022d91ba 722int agent_init(struct agent *agt)
0475c50c
DG
723{
724 int ret;
725
022d91ba 726 assert(agt);
0475c50c 727
022d91ba
DG
728 agt->events = lttng_ht_new(0, LTTNG_HT_TYPE_STRING);
729 if (!agt->events) {
0475c50c
DG
730 ret = -ENOMEM;
731 goto error;
732 }
fefd409b 733 lttng_ht_node_init_u64(&agt->node, agt->domain);
0475c50c
DG
734
735 return 0;
736
737error:
738 return ret;
739}
740
fefd409b
DG
741/*
742 * Add agent object to the given hash table.
743 */
744void agent_add(struct agent *agt, struct lttng_ht *ht)
745{
746 assert(agt);
747 assert(ht);
748
749 DBG3("Agent adding from domain %d", agt->domain);
750
751 rcu_read_lock();
752 lttng_ht_add_unique_u64(ht, &agt->node);
753 rcu_read_unlock();
754}
755
756/*
757 * Create an agent object for the given domain.
758 *
759 * Return the allocated agent or NULL on error.
760 */
761struct agent *agent_create(enum lttng_domain_type domain)
762{
763 int ret;
764 struct agent *agt;
765
766 agt = zmalloc(sizeof(*agt));
767 if (!agt) {
768 goto error;
769 }
770 agt->domain = domain;
771
772 ret = agent_init(agt);
773 if (ret < 0) {
774 free(agt);
988ae332 775 agt = NULL;
fefd409b
DG
776 goto error;
777 }
778
779error:
780 return agt;
781}
782
0475c50c 783/*
022d91ba 784 * Create a newly allocated agent event data structure. If name is valid, it's
0475c50c
DG
785 * copied into the created event.
786 *
787 * Return a new object else NULL on error.
788 */
022d91ba 789struct agent_event *agent_create_event(const char *name,
be6a6276 790 struct lttng_filter_bytecode *filter)
0475c50c 791{
022d91ba 792 struct agent_event *event;
0475c50c 793
022d91ba 794 DBG3("Agent create new event with name %s", name);
0475c50c
DG
795
796 event = zmalloc(sizeof(*event));
797 if (!event) {
798 goto error;
799 }
800
801 if (name) {
802 strncpy(event->name, name, sizeof(event->name));
803 event->name[sizeof(event->name) - 1] = '\0';
f20baf8e 804 lttng_ht_node_init_str(&event->node, event->name);
0475c50c
DG
805 }
806
be6a6276
DG
807 if (filter) {
808 event->filter = filter;
809 }
810
0475c50c
DG
811error:
812 return event;
813}
814
815/*
022d91ba 816 * Unique add of a agent event to an agent object.
0475c50c 817 */
022d91ba 818void agent_add_event(struct agent_event *event, struct agent *agt)
0475c50c
DG
819{
820 assert(event);
022d91ba
DG
821 assert(agt);
822 assert(agt->events);
0475c50c 823
022d91ba 824 DBG3("Agent adding event %s", event->name);
0475c50c 825
f20baf8e 826 rcu_read_lock();
022d91ba 827 add_unique_agent_event(agt->events, event);
f20baf8e 828 rcu_read_unlock();
022d91ba 829 agt->being_used = 1;
0475c50c
DG
830}
831
832/*
022d91ba 833 * Find a agent event in the given agent using name.
4a4ab2c3
DG
834 *
835 * RCU read side lock MUST be acquired.
836 *
837 * Return object if found else NULL.
838 */
022d91ba
DG
839struct agent_event *agent_find_event_by_name(const char *name,
840 struct agent *agt)
4a4ab2c3
DG
841{
842 struct lttng_ht_node_str *node;
843 struct lttng_ht_iter iter;
844 struct lttng_ht *ht;
022d91ba 845 struct agent_ht_key key;
4a4ab2c3
DG
846
847 assert(name);
022d91ba
DG
848 assert(agt);
849 assert(agt->events);
4a4ab2c3 850
022d91ba 851 ht = agt->events;
4a4ab2c3
DG
852 key.name = name;
853
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);
857 if (node == NULL) {
858 goto error;
859 }
860
022d91ba
DG
861 DBG3("Agent event found %s by name.", name);
862 return caa_container_of(node, struct agent_event, node);
4a4ab2c3
DG
863
864error:
022d91ba 865 DBG3("Agent NOT found by name %s.", name);
4a4ab2c3
DG
866 return NULL;
867}
868
869/*
022d91ba 870 * Find a agent event in the given agent using name and loglevel.
0475c50c
DG
871 *
872 * RCU read side lock MUST be acquired.
873 *
874 * Return object if found else NULL.
875 */
022d91ba
DG
876struct agent_event *agent_find_event(const char *name, int loglevel,
877 struct agent *agt)
0475c50c
DG
878{
879 struct lttng_ht_node_str *node;
880 struct lttng_ht_iter iter;
4a4ab2c3 881 struct lttng_ht *ht;
022d91ba 882 struct agent_ht_key key;
0475c50c
DG
883
884 assert(name);
022d91ba
DG
885 assert(agt);
886 assert(agt->events);
0475c50c 887
022d91ba 888 ht = agt->events;
4a4ab2c3
DG
889 key.name = name;
890 key.loglevel = loglevel;
891
892 cds_lfht_lookup(ht->ht, ht->hash_fct((void *) name, lttng_ht_seed),
893 ht_match_event, &key, &iter.iter);
0475c50c
DG
894 node = lttng_ht_iter_get_node_str(&iter);
895 if (node == NULL) {
896 goto error;
897 }
898
022d91ba
DG
899 DBG3("Agent event found %s.", name);
900 return caa_container_of(node, struct agent_event, node);
0475c50c
DG
901
902error:
a51e817b 903 DBG3("Agent event NOT found %s.", name);
0475c50c
DG
904 return NULL;
905}
906
0475c50c 907/*
022d91ba
DG
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.
0475c50c 911 */
022d91ba 912void agent_destroy_event(struct agent_event *event)
0475c50c
DG
913{
914 assert(event);
915
971da06a 916 free(event->filter);
0475c50c
DG
917 free(event);
918}
919
920/*
022d91ba 921 * Destroy an agent completely. Note that the given pointer is NOT freed
428de77a 922 * thus a reference to static or stack data can be passed to this function.
0475c50c 923 */
022d91ba 924void agent_destroy(struct agent *agt)
0475c50c
DG
925{
926 struct lttng_ht_node_str *node;
927 struct lttng_ht_iter iter;
928
022d91ba 929 assert(agt);
0475c50c 930
022d91ba 931 DBG3("Agent destroy");
0475c50c
DG
932
933 /*
934 * Just ignore if no events hash table exists. This is possible if for
022d91ba 935 * instance an agent object was allocated but not initialized.
0475c50c 936 */
022d91ba 937 if (!agt->events) {
0475c50c
DG
938 return;
939 }
940
941 rcu_read_lock();
022d91ba 942 cds_lfht_for_each_entry(agt->events->ht, &iter.iter, node, node) {
0475c50c 943 int ret;
022d91ba 944 struct agent_event *event;
29c0fd4d
DG
945
946 /*
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.
950 */
022d91ba
DG
951 event = caa_container_of(node, struct agent_event, node);
952 (void) agent_disable_event(event, agt->domain);
0475c50c 953
022d91ba 954 ret = lttng_ht_del(agt->events, &iter);
0475c50c 955 assert(!ret);
022d91ba 956 call_rcu(&node->head, destroy_event_agent_rcu);
0475c50c
DG
957 }
958 rcu_read_unlock();
959
f8be902b 960 ht_cleanup_push(agt->events);
f20baf8e
DG
961}
962
963/*
022d91ba 964 * Initialize agent subsystem.
f20baf8e 965 */
022d91ba 966int agent_setup(void)
f20baf8e 967{
022d91ba
DG
968 agent_apps_ht_by_sock = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
969 if (!agent_apps_ht_by_sock) {
f20baf8e
DG
970 return -1;
971 }
972
973 return 0;
974}
975
976/*
022d91ba 977 * Update a agent application (given socket) using the given agent.
f20baf8e
DG
978 *
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).
981 */
022d91ba 982void agent_update(struct agent *agt, int sock)
f20baf8e
DG
983{
984 int ret;
022d91ba
DG
985 struct agent_app *app;
986 struct agent_event *event;
f20baf8e
DG
987 struct lttng_ht_iter iter;
988
022d91ba 989 assert(agt);
f20baf8e
DG
990 assert(sock >= 0);
991
022d91ba 992 DBG("Agent updating app socket %d", sock);
f20baf8e
DG
993
994 rcu_read_lock();
022d91ba 995 cds_lfht_for_each_entry(agt->events->ht, &iter.iter, event, node.node) {
f20baf8e
DG
996 /* Skip event if disabled. */
997 if (!event->enabled) {
998 continue;
999 }
1000
022d91ba 1001 app = agent_find_app_by_sock(sock);
f20baf8e
DG
1002 /*
1003 * We are in the registration path thus if the application is gone,
1004 * there is a serious code flow error.
1005 */
1006 assert(app);
1007
1008 ret = enable_event(app, event);
1009 if (ret != LTTNG_OK) {
022d91ba 1010 DBG2("Agent update unable to enable event %s on app pid: %d sock %d",
f20baf8e
DG
1011 event->name, app->pid, app->sock->fd);
1012 /* Let's try the others here and don't assume the app is dead. */
1013 continue;
1014 }
1015 }
1016 rcu_read_unlock();
0475c50c 1017}
This page took 0.131375 seconds and 5 git commands to generate.