projects / lttng-ust.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Fix: event notifier create protocol order issue
[lttng-ust.git] / liblttng-ust-ctl / ustctl.c
1 /*
2 * Copyright (C) 2011 - Julien Desfossez <julien.desfossez@polymtl.ca>
3 * Copyright (C) 2011-2013 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; version 2 of the License only.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License along
15 * with this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
17 */
18
19 #include <stdint.h>
20 #include <string.h>
21 #include <sys/mman.h>
22 #include <unistd.h>
23
24 #include <lttng/ust-config.h>
25 #include <lttng/ust-ctl.h>
26 #include <lttng/ust-abi.h>
27 #include <lttng/ust-events.h>
28 #include <lttng/ust-endian.h>
29 #include <usterr-signal-safe.h>
30 #include <ust-comm.h>
31 #include <helper.h>
32
33 #include "../libringbuffer/backend.h"
34 #include "../libringbuffer/frontend.h"
35 #include "../liblttng-ust/wait.h"
36 #include "../liblttng-ust/lttng-rb-clients.h"
37 #include "../liblttng-ust/clock.h"
38 #include "../liblttng-ust/getenv.h"
39
40 #include "../libcounter/shm.h"
41 #include "../libcounter/smp.h"
42 #include "../libcounter/counter.h"
43
44 /*
45 * Number of milliseconds to retry before failing metadata writes on
46 * buffer full condition. (10 seconds)
47 */
48 #define LTTNG_METADATA_TIMEOUT_MSEC 10000
49
50 /*
51 * Channel representation within consumer.
52 */
53 struct ustctl_consumer_channel {
54 struct lttng_channel *chan; /* lttng channel buffers */
55
56 /* initial attributes */
57 struct ustctl_consumer_channel_attr attr;
58 int wait_fd; /* monitor close() */
59 int wakeup_fd; /* monitor close() */
60 };
61
62 /*
63 * Stream representation within consumer.
64 */
65 struct ustctl_consumer_stream {
66 struct lttng_ust_shm_handle *handle; /* shared-memory handle */
67 struct lttng_ust_lib_ring_buffer *buf;
68 struct ustctl_consumer_channel *chan;
69 int shm_fd, wait_fd, wakeup_fd;
70 int cpu;
71 uint64_t memory_map_size;
72 };
73
74 #define USTCTL_COUNTER_ATTR_DIMENSION_MAX 8
75 struct ustctl_counter_attr {
76 enum ustctl_counter_arithmetic arithmetic;
77 enum ustctl_counter_bitness bitness;
78 uint32_t nr_dimensions;
79 int64_t global_sum_step;
80 struct ustctl_counter_dimension dimensions[USTCTL_COUNTER_ATTR_DIMENSION_MAX];
81 };
82
83 /*
84 * Counter representation within daemon.
85 */
86 struct ustctl_daemon_counter {
87 struct lib_counter *counter;
88 const struct lttng_counter_ops *ops;
89 struct ustctl_counter_attr *attr; /* initial attributes */
90 };
91
92 extern void lttng_ring_buffer_client_overwrite_init(void);
93 extern void lttng_ring_buffer_client_overwrite_rt_init(void);
94 extern void lttng_ring_buffer_client_discard_init(void);
95 extern void lttng_ring_buffer_client_discard_rt_init(void);
96 extern void lttng_ring_buffer_metadata_client_init(void);
97 extern void lttng_ring_buffer_client_overwrite_exit(void);
98 extern void lttng_ring_buffer_client_overwrite_rt_exit(void);
99 extern void lttng_ring_buffer_client_discard_exit(void);
100 extern void lttng_ring_buffer_client_discard_rt_exit(void);
101 extern void lttng_ring_buffer_metadata_client_exit(void);
102 extern void lttng_counter_client_percpu_32_modular_init(void);
103 extern void lttng_counter_client_percpu_32_modular_exit(void);
104 extern void lttng_counter_client_percpu_64_modular_init(void);
105 extern void lttng_counter_client_percpu_64_modular_exit(void);
106
107 int ustctl_release_handle(int sock, int handle)
108 {
109 struct ustcomm_ust_msg lum;
110 struct ustcomm_ust_reply lur;
111
112 if (sock < 0 || handle < 0)
113 return 0;
114 memset(&lum, 0, sizeof(lum));
115 lum.handle = handle;
116 lum.cmd = LTTNG_UST_RELEASE;
117 return ustcomm_send_app_cmd(sock, &lum, &lur);
118 }
119
120 /*
121 * If sock is negative, it means we don't have to notify the other side
122 * (e.g. application has already vanished).
123 */
124 int ustctl_release_object(int sock, struct lttng_ust_object_data *data)
125 {
126 int ret;
127
128 if (!data)
129 return -EINVAL;
130
131 switch (data->type) {
132 case LTTNG_UST_OBJECT_TYPE_CHANNEL:
133 if (data->u.channel.wakeup_fd >= 0) {
134 ret = close(data->u.channel.wakeup_fd);
135 if (ret < 0) {
136 ret = -errno;
137 return ret;
138 }
139 data->u.channel.wakeup_fd = -1;
140 }
141 free(data->u.channel.data);
142 data->u.channel.data = NULL;
143 break;
144 case LTTNG_UST_OBJECT_TYPE_STREAM:
145 if (data->u.stream.shm_fd >= 0) {
146 ret = close(data->u.stream.shm_fd);
147 if (ret < 0) {
148 ret = -errno;
149 return ret;
150 }
151 data->u.stream.shm_fd = -1;
152 }
153 if (data->u.stream.wakeup_fd >= 0) {
154 ret = close(data->u.stream.wakeup_fd);
155 if (ret < 0) {
156 ret = -errno;
157 return ret;
158 }
159 data->u.stream.wakeup_fd = -1;
160 }
161 break;
162 case LTTNG_UST_OBJECT_TYPE_EVENT:
163 case LTTNG_UST_OBJECT_TYPE_CONTEXT:
164 case LTTNG_UST_OBJECT_TYPE_EVENT_NOTIFIER_GROUP:
165 case LTTNG_UST_OBJECT_TYPE_EVENT_NOTIFIER:
166 break;
167 case LTTNG_UST_OBJECT_TYPE_COUNTER:
168 free(data->u.counter.data);
169 data->u.counter.data = NULL;
170 break;
171 case LTTNG_UST_OBJECT_TYPE_COUNTER_GLOBAL:
172 if (data->u.counter_global.shm_fd >= 0) {
173 ret = close(data->u.counter_global.shm_fd);
174 if (ret < 0) {
175 ret = -errno;
176 return ret;
177 }
178 data->u.counter_global.shm_fd = -1;
179 }
180 break;
181 case LTTNG_UST_OBJECT_TYPE_COUNTER_CPU:
182 if (data->u.counter_cpu.shm_fd >= 0) {
183 ret = close(data->u.counter_cpu.shm_fd);
184 if (ret < 0) {
185 ret = -errno;
186 return ret;
187 }
188 data->u.counter_cpu.shm_fd = -1;
189 }
190 break;
191 default:
192 assert(0);
193 }
194 return ustctl_release_handle(sock, data->handle);
195 }
196
197 /*
198 * Send registration done packet to the application.
199 */
200 int ustctl_register_done(int sock)
201 {
202 struct ustcomm_ust_msg lum;
203 struct ustcomm_ust_reply lur;
204 int ret;
205
206 DBG("Sending register done command to %d", sock);
207 memset(&lum, 0, sizeof(lum));
208 lum.handle = LTTNG_UST_ROOT_HANDLE;
209 lum.cmd = LTTNG_UST_REGISTER_DONE;
210 ret = ustcomm_send_app_cmd(sock, &lum, &lur);
211 if (ret)
212 return ret;
213 return 0;
214 }
215
216 /*
217 * returns session handle.
218 */
219 int ustctl_create_session(int sock)
220 {
221 struct ustcomm_ust_msg lum;
222 struct ustcomm_ust_reply lur;
223 int ret, session_handle;
224
225 /* Create session */
226 memset(&lum, 0, sizeof(lum));
227 lum.handle = LTTNG_UST_ROOT_HANDLE;
228 lum.cmd = LTTNG_UST_SESSION;
229 ret = ustcomm_send_app_cmd(sock, &lum, &lur);
230 if (ret)
231 return ret;
232 session_handle = lur.ret_val;
233 DBG("received session handle %u", session_handle);
234 return session_handle;
235 }
236
237 int ustctl_create_event(int sock, struct lttng_ust_event *ev,
238 struct lttng_ust_object_data *channel_data,
239 struct lttng_ust_object_data **_event_data)
240 {
241 struct ustcomm_ust_msg lum;
242 struct ustcomm_ust_reply lur;
243 struct lttng_ust_object_data *event_data;
244 int ret;
245
246 if (!channel_data || !_event_data)
247 return -EINVAL;
248
249 event_data = zmalloc(sizeof(*event_data));
250 if (!event_data)
251 return -ENOMEM;
252 event_data->type = LTTNG_UST_OBJECT_TYPE_EVENT;
253 memset(&lum, 0, sizeof(lum));
254 lum.handle = channel_data->handle;
255 lum.cmd = LTTNG_UST_EVENT;
256 strncpy(lum.u.event.name, ev->name,
257 LTTNG_UST_SYM_NAME_LEN);
258 lum.u.event.instrumentation = ev->instrumentation;
259 lum.u.event.loglevel_type = ev->loglevel_type;
260 lum.u.event.loglevel = ev->loglevel;
261 ret = ustcomm_send_app_cmd(sock, &lum, &lur);
262 if (ret) {
263 free(event_data);
264 return ret;
265 }
266 event_data->handle = lur.ret_val;
267 DBG("received event handle %u", event_data->handle);
268 *_event_data = event_data;
269 return 0;
270 }
271
272 int ustctl_add_context(int sock, struct lttng_ust_context_attr *ctx,
273 struct lttng_ust_object_data *obj_data,
274 struct lttng_ust_object_data **_context_data)
275 {
276 struct ustcomm_ust_msg lum;
277 struct ustcomm_ust_reply lur;
278 struct lttng_ust_object_data *context_data = NULL;
279 char *buf = NULL;
280 size_t len;
281 int ret;
282
283 if (!obj_data || !_context_data) {
284 ret = -EINVAL;
285 goto end;
286 }
287
288 context_data = zmalloc(sizeof(*context_data));
289 if (!context_data) {
290 ret = -ENOMEM;
291 goto end;
292 }
293 context_data->type = LTTNG_UST_OBJECT_TYPE_CONTEXT;
294 memset(&lum, 0, sizeof(lum));
295 lum.handle = obj_data->handle;
296 lum.cmd = LTTNG_UST_CONTEXT;
297
298 lum.u.context.ctx = ctx->ctx;
299 switch (ctx->ctx) {
300 case LTTNG_UST_CONTEXT_PERF_THREAD_COUNTER:
301 lum.u.context.u.perf_counter = ctx->u.perf_counter;
302 break;
303 case LTTNG_UST_CONTEXT_APP_CONTEXT:
304 {
305 size_t provider_name_len = strlen(
306 ctx->u.app_ctx.provider_name) + 1;
307 size_t ctx_name_len = strlen(ctx->u.app_ctx.ctx_name) + 1;
308
309 lum.u.context.u.app_ctx.provider_name_len = provider_name_len;
310 lum.u.context.u.app_ctx.ctx_name_len = ctx_name_len;
311
312 len = provider_name_len + ctx_name_len;
313 buf = zmalloc(len);
314 if (!buf) {
315 ret = -ENOMEM;
316 goto end;
317 }
318 memcpy(buf, ctx->u.app_ctx.provider_name,
319 provider_name_len);
320 memcpy(buf + provider_name_len, ctx->u.app_ctx.ctx_name,
321 ctx_name_len);
322 break;
323 }
324 default:
325 break;
326 }
327 ret = ustcomm_send_app_msg(sock, &lum);
328 if (ret)
329 goto end;
330 if (buf) {
331 /* send var len ctx_name */
332 ret = ustcomm_send_unix_sock(sock, buf, len);
333 if (ret < 0) {
334 goto end;
335 }
336 if (ret != len) {
337 ret = -EINVAL;
338 goto end;
339 }
340 }
341 ret = ustcomm_recv_app_reply(sock, &lur, lum.handle, lum.cmd);
342 if (ret < 0) {
343 goto end;
344 }
345 context_data->handle = -1;
346 DBG("Context created successfully");
347 *_context_data = context_data;
348 context_data = NULL;
349 end:
350 free(context_data);
351 free(buf);
352 return ret;
353 }
354
355 int ustctl_set_filter(int sock, struct lttng_ust_filter_bytecode *bytecode,
356 struct lttng_ust_object_data *obj_data)
357 {
358 struct ustcomm_ust_msg lum;
359 struct ustcomm_ust_reply lur;
360 int ret;
361
362 if (!obj_data)
363 return -EINVAL;
364
365 memset(&lum, 0, sizeof(lum));
366 lum.handle = obj_data->handle;
367 lum.cmd = LTTNG_UST_FILTER;
368 lum.u.filter.data_size = bytecode->len;
369 lum.u.filter.reloc_offset = bytecode->reloc_offset;
370 lum.u.filter.seqnum = bytecode->seqnum;
371
372 ret = ustcomm_send_app_msg(sock, &lum);
373 if (ret)
374 return ret;
375 /* send var len bytecode */
376 ret = ustcomm_send_unix_sock(sock, bytecode->data,
377 bytecode->len);
378 if (ret < 0) {
379 return ret;
380 }
381 if (ret != bytecode->len)
382 return -EINVAL;
383 return ustcomm_recv_app_reply(sock, &lur, lum.handle, lum.cmd);
384 }
385
386 int ustctl_set_capture(int sock, struct lttng_ust_capture_bytecode *bytecode,
387 struct lttng_ust_object_data *obj_data)
388 {
389 struct ustcomm_ust_msg lum;
390 struct ustcomm_ust_reply lur;
391 int ret;
392
393 if (!obj_data)
394 return -EINVAL;
395
396 memset(&lum, 0, sizeof(lum));
397 lum.handle = obj_data->handle;
398 lum.cmd = LTTNG_UST_CAPTURE;
399 lum.u.capture.data_size = bytecode->len;
400 lum.u.capture.reloc_offset = bytecode->reloc_offset;
401 lum.u.capture.seqnum = bytecode->seqnum;
402
403 ret = ustcomm_send_app_msg(sock, &lum);
404 if (ret)
405 return ret;
406 /* send var len bytecode */
407 ret = ustcomm_send_unix_sock(sock, bytecode->data,
408 bytecode->len);
409 if (ret < 0) {
410 return ret;
411 }
412 if (ret != bytecode->len)
413 return -EINVAL;
414 return ustcomm_recv_app_reply(sock, &lur, lum.handle, lum.cmd);
415 }
416
417 int ustctl_set_exclusion(int sock, struct lttng_ust_event_exclusion *exclusion,
418 struct lttng_ust_object_data *obj_data)
419 {
420 struct ustcomm_ust_msg lum;
421 struct ustcomm_ust_reply lur;
422 int ret;
423
424 if (!obj_data) {
425 return -EINVAL;
426 }
427
428 memset(&lum, 0, sizeof(lum));
429 lum.handle = obj_data->handle;
430 lum.cmd = LTTNG_UST_EXCLUSION;
431 lum.u.exclusion.count = exclusion->count;
432
433 ret = ustcomm_send_app_msg(sock, &lum);
434 if (ret) {
435 return ret;
436 }
437
438 /* send var len exclusion names */
439 ret = ustcomm_send_unix_sock(sock,
440 exclusion->names,
441 exclusion->count * LTTNG_UST_SYM_NAME_LEN);
442 if (ret < 0) {
443 return ret;
444 }
445 if (ret != exclusion->count * LTTNG_UST_SYM_NAME_LEN) {
446 return -EINVAL;
447 }
448 return ustcomm_recv_app_reply(sock, &lur, lum.handle, lum.cmd);
449 }
450
451 /* Enable event, channel and session ioctl */
452 int ustctl_enable(int sock, struct lttng_ust_object_data *object)
453 {
454 struct ustcomm_ust_msg lum;
455 struct ustcomm_ust_reply lur;
456 int ret;
457
458 if (!object)
459 return -EINVAL;
460
461 memset(&lum, 0, sizeof(lum));
462 lum.handle = object->handle;
463 lum.cmd = LTTNG_UST_ENABLE;
464 ret = ustcomm_send_app_cmd(sock, &lum, &lur);
465 if (ret)
466 return ret;
467 DBG("enabled handle %u", object->handle);
468 return 0;
469 }
470
471 /* Disable event, channel and session ioctl */
472 int ustctl_disable(int sock, struct lttng_ust_object_data *object)
473 {
474 struct ustcomm_ust_msg lum;
475 struct ustcomm_ust_reply lur;
476 int ret;
477
478 if (!object)
479 return -EINVAL;
480
481 memset(&lum, 0, sizeof(lum));
482 lum.handle = object->handle;
483 lum.cmd = LTTNG_UST_DISABLE;
484 ret = ustcomm_send_app_cmd(sock, &lum, &lur);
485 if (ret)
486 return ret;
487 DBG("disable handle %u", object->handle);
488 return 0;
489 }
490
491 int ustctl_start_session(int sock, int handle)
492 {
493 struct lttng_ust_object_data obj;
494
495 obj.handle = handle;
496 return ustctl_enable(sock, &obj);
497 }
498
499 int ustctl_stop_session(int sock, int handle)
500 {
501 struct lttng_ust_object_data obj;
502
503 obj.handle = handle;
504 return ustctl_disable(sock, &obj);
505 }
506
507 int ustctl_create_event_notifier_group(int sock, int pipe_fd,
508 struct lttng_ust_object_data **_event_notifier_group_data)
509 {
510 struct lttng_ust_object_data *event_notifier_group_data;
511 struct ustcomm_ust_msg lum;
512 struct ustcomm_ust_reply lur;
513 ssize_t len;
514 int ret;
515
516 if (!_event_notifier_group_data)
517 return -EINVAL;
518
519 event_notifier_group_data = zmalloc(sizeof(*event_notifier_group_data));
520 if (!event_notifier_group_data)
521 return -ENOMEM;
522
523 event_notifier_group_data->type = LTTNG_UST_OBJECT_TYPE_EVENT_NOTIFIER_GROUP;
524
525 memset(&lum, 0, sizeof(lum));
526 lum.handle = LTTNG_UST_ROOT_HANDLE;
527 lum.cmd = LTTNG_UST_EVENT_NOTIFIER_GROUP_CREATE;
528
529 ret = ustcomm_send_app_msg(sock, &lum);
530 if (ret)
531 goto error;
532
533 /* Send event_notifier notification pipe. */
534 len = ustcomm_send_fds_unix_sock(sock, &pipe_fd, 1);
535 if (len <= 0) {
536 ret = len;
537 goto error;
538 }
539
540 ret = ustcomm_recv_app_reply(sock, &lur, lum.handle, lum.cmd);
541 if (ret)
542 goto error;
543
544 event_notifier_group_data->handle = lur.ret_val;
545 DBG("received event_notifier group handle %d", event_notifier_group_data->handle);
546
547 *_event_notifier_group_data = event_notifier_group_data;
548
549 ret = 0;
550 goto end;
551 error:
552 free(event_notifier_group_data);
553
554 end:
555 return ret;
556 }
557
558 int ustctl_create_event_notifier(int sock, struct lttng_ust_event_notifier *event_notifier,
559 struct lttng_ust_object_data *event_notifier_group,
560 struct lttng_ust_object_data **_event_notifier_data)
561 {
562 struct ustcomm_ust_msg lum;
563 struct ustcomm_ust_reply lur;
564 struct lttng_ust_object_data *event_notifier_data;
565 ssize_t len;
566 int ret;
567
568 if (!event_notifier_group || !_event_notifier_data)
569 return -EINVAL;
570
571 event_notifier_data = zmalloc(sizeof(*event_notifier_data));
572 if (!event_notifier_data)
573 return -ENOMEM;
574
575 event_notifier_data->type = LTTNG_UST_OBJECT_TYPE_EVENT_NOTIFIER;
576
577 memset(&lum, 0, sizeof(lum));
578 lum.handle = event_notifier_group->handle;
579 lum.cmd = LTTNG_UST_EVENT_NOTIFIER_CREATE;
580 lum.u.event_notifier.len = sizeof(*event_notifier);
581
582 ret = ustcomm_send_app_msg(sock, &lum);
583 if (ret) {
584 free(event_notifier_data);
585 return ret;
586 }
587 /* Send struct lttng_ust_event_notifier */
588 len = ustcomm_send_unix_sock(sock, event_notifier, sizeof(*event_notifier));
589 if (len != sizeof(*event_notifier)) {
590 if (len < 0)
591 return len;
592 else
593 return -EIO;
594 }
595 ret = ustcomm_recv_app_reply(sock, &lur, lum.handle, lum.cmd);
596 if (ret) {
597 free(event_notifier_data);
598 return ret;
599 }
600 event_notifier_data->handle = lur.ret_val;
601 DBG("received event_notifier handle %u", event_notifier_data->handle);
602 *_event_notifier_data = event_notifier_data;
603
604 return ret;
605 }
606
607 int ustctl_tracepoint_list(int sock)
608 {
609 struct ustcomm_ust_msg lum;
610 struct ustcomm_ust_reply lur;
611 int ret, tp_list_handle;
612
613 memset(&lum, 0, sizeof(lum));
614 lum.handle = LTTNG_UST_ROOT_HANDLE;
615 lum.cmd = LTTNG_UST_TRACEPOINT_LIST;
616 ret = ustcomm_send_app_cmd(sock, &lum, &lur);
617 if (ret)
618 return ret;
619 tp_list_handle = lur.ret_val;
620 DBG("received tracepoint list handle %u", tp_list_handle);
621 return tp_list_handle;
622 }
623
624 int ustctl_tracepoint_list_get(int sock, int tp_list_handle,
625 struct lttng_ust_tracepoint_iter *iter)
626 {
627 struct ustcomm_ust_msg lum;
628 struct ustcomm_ust_reply lur;
629 int ret;
630
631 if (!iter)
632 return -EINVAL;
633
634 memset(&lum, 0, sizeof(lum));
635 lum.handle = tp_list_handle;
636 lum.cmd = LTTNG_UST_TRACEPOINT_LIST_GET;
637 ret = ustcomm_send_app_cmd(sock, &lum, &lur);
638 if (ret)
639 return ret;
640 DBG("received tracepoint list entry name %s loglevel %d",
641 lur.u.tracepoint.name,
642 lur.u.tracepoint.loglevel);
643 memcpy(iter, &lur.u.tracepoint, sizeof(*iter));
644 return 0;
645 }
646
647 int ustctl_tracepoint_field_list(int sock)
648 {
649 struct ustcomm_ust_msg lum;
650 struct ustcomm_ust_reply lur;
651 int ret, tp_field_list_handle;
652
653 memset(&lum, 0, sizeof(lum));
654 lum.handle = LTTNG_UST_ROOT_HANDLE;
655 lum.cmd = LTTNG_UST_TRACEPOINT_FIELD_LIST;
656 ret = ustcomm_send_app_cmd(sock, &lum, &lur);
657 if (ret)
658 return ret;
659 tp_field_list_handle = lur.ret_val;
660 DBG("received tracepoint field list handle %u", tp_field_list_handle);
661 return tp_field_list_handle;
662 }
663
664 int ustctl_tracepoint_field_list_get(int sock, int tp_field_list_handle,
665 struct lttng_ust_field_iter *iter)
666 {
667 struct ustcomm_ust_msg lum;
668 struct ustcomm_ust_reply lur;
669 int ret;
670 ssize_t len;
671
672 if (!iter)
673 return -EINVAL;
674
675 memset(&lum, 0, sizeof(lum));
676 lum.handle = tp_field_list_handle;
677 lum.cmd = LTTNG_UST_TRACEPOINT_FIELD_LIST_GET;
678 ret = ustcomm_send_app_cmd(sock, &lum, &lur);
679 if (ret)
680 return ret;
681 len = ustcomm_recv_unix_sock(sock, iter, sizeof(*iter));
682 if (len != sizeof(*iter)) {
683 return -EINVAL;
684 }
685 DBG("received tracepoint field list entry event_name %s event_loglevel %d field_name %s field_type %d",
686 iter->event_name,
687 iter->loglevel,
688 iter->field_name,
689 iter->type);
690 return 0;
691 }
692
693 int ustctl_tracer_version(int sock, struct lttng_ust_tracer_version *v)
694 {
695 struct ustcomm_ust_msg lum;
696 struct ustcomm_ust_reply lur;
697 int ret;
698
699 if (!v)
700 return -EINVAL;
701
702 memset(&lum, 0, sizeof(lum));
703 lum.handle = LTTNG_UST_ROOT_HANDLE;
704 lum.cmd = LTTNG_UST_TRACER_VERSION;
705 ret = ustcomm_send_app_cmd(sock, &lum, &lur);
706 if (ret)
707 return ret;
708 memcpy(v, &lur.u.version, sizeof(*v));
709 DBG("received tracer version");
710 return 0;
711 }
712
713 int ustctl_wait_quiescent(int sock)
714 {
715 struct ustcomm_ust_msg lum;
716 struct ustcomm_ust_reply lur;
717 int ret;
718
719 memset(&lum, 0, sizeof(lum));
720 lum.handle = LTTNG_UST_ROOT_HANDLE;
721 lum.cmd = LTTNG_UST_WAIT_QUIESCENT;
722 ret = ustcomm_send_app_cmd(sock, &lum, &lur);
723 if (ret)
724 return ret;
725 DBG("waited for quiescent state");
726 return 0;
727 }
728
729 int ustctl_calibrate(int sock, struct lttng_ust_calibrate *calibrate)
730 {
731 if (!calibrate)
732 return -EINVAL;
733
734 return -ENOSYS;
735 }
736
737 int ustctl_sock_flush_buffer(int sock, struct lttng_ust_object_data *object)
738 {
739 struct ustcomm_ust_msg lum;
740 struct ustcomm_ust_reply lur;
741 int ret;
742
743 if (!object)
744 return -EINVAL;
745
746 memset(&lum, 0, sizeof(lum));
747 lum.handle = object->handle;
748 lum.cmd = LTTNG_UST_FLUSH_BUFFER;
749 ret = ustcomm_send_app_cmd(sock, &lum, &lur);
750 if (ret)
751 return ret;
752 DBG("flushed buffer handle %u", object->handle);
753 return 0;
754 }
755
756 static
757 int ustctl_send_channel(int sock,
758 enum lttng_ust_chan_type type,
759 void *data,
760 uint64_t size,
761 int wakeup_fd,
762 int send_fd_only)
763 {
764 ssize_t len;
765
766 if (!send_fd_only) {
767 /* Send mmap size */
768 len = ustcomm_send_unix_sock(sock, &size, sizeof(size));
769 if (len != sizeof(size)) {
770 if (len < 0)
771 return len;
772 else
773 return -EIO;
774 }
775
776 /* Send channel type */
777 len = ustcomm_send_unix_sock(sock, &type, sizeof(type));
778 if (len != sizeof(type)) {
779 if (len < 0)
780 return len;
781 else
782 return -EIO;
783 }
784 }
785
786 /* Send channel data */
787 len = ustcomm_send_unix_sock(sock, data, size);
788 if (len != size) {
789 if (len < 0)
790 return len;
791 else
792 return -EIO;
793 }
794
795 /* Send wakeup fd */
796 len = ustcomm_send_fds_unix_sock(sock, &wakeup_fd, 1);
797 if (len <= 0) {
798 if (len < 0)
799 return len;
800 else
801 return -EIO;
802 }
803 return 0;
804 }
805
806 static
807 int ustctl_send_stream(int sock,
808 uint32_t stream_nr,
809 uint64_t memory_map_size,
810 int shm_fd, int wakeup_fd,
811 int send_fd_only)
812 {
813 ssize_t len;
814 int fds[2];
815
816 if (!send_fd_only) {
817 if (shm_fd < 0) {
818 /* finish iteration */
819 uint64_t v = -1;
820
821 len = ustcomm_send_unix_sock(sock, &v, sizeof(v));
822 if (len != sizeof(v)) {
823 if (len < 0)
824 return len;
825 else
826 return -EIO;
827 }
828 return 0;
829 }
830
831 /* Send mmap size */
832 len = ustcomm_send_unix_sock(sock, &memory_map_size,
833 sizeof(memory_map_size));
834 if (len != sizeof(memory_map_size)) {
835 if (len < 0)
836 return len;
837 else
838 return -EIO;
839 }
840
841 /* Send stream nr */
842 len = ustcomm_send_unix_sock(sock, &stream_nr,
843 sizeof(stream_nr));
844 if (len != sizeof(stream_nr)) {
845 if (len < 0)
846 return len;
847 else
848 return -EIO;
849 }
850 }
851
852 /* Send shm fd and wakeup fd */
853 fds[0] = shm_fd;
854 fds[1] = wakeup_fd;
855 len = ustcomm_send_fds_unix_sock(sock, fds, 2);
856 if (len <= 0) {
857 if (len < 0)
858 return len;
859 else
860 return -EIO;
861 }
862 return 0;
863 }
864
865 int ustctl_recv_channel_from_consumer(int sock,
866 struct lttng_ust_object_data **_channel_data)
867 {
868 struct lttng_ust_object_data *channel_data;
869 ssize_t len;
870 int wakeup_fd;
871 int ret;
872
873 channel_data = zmalloc(sizeof(*channel_data));
874 if (!channel_data) {
875 ret = -ENOMEM;
876 goto error_alloc;
877 }
878 channel_data->type = LTTNG_UST_OBJECT_TYPE_CHANNEL;
879 channel_data->handle = -1;
880
881 /* recv mmap size */
882 len = ustcomm_recv_unix_sock(sock, &channel_data->size,
883 sizeof(channel_data->size));
884 if (len != sizeof(channel_data->size)) {
885 if (len < 0)
886 ret = len;
887 else
888 ret = -EINVAL;
889 goto error;
890 }
891
892 /* recv channel type */
893 len = ustcomm_recv_unix_sock(sock, &channel_data->u.channel.type,
894 sizeof(channel_data->u.channel.type));
895 if (len != sizeof(channel_data->u.channel.type)) {
896 if (len < 0)
897 ret = len;
898 else
899 ret = -EINVAL;
900 goto error;
901 }
902
903 /* recv channel data */
904 channel_data->u.channel.data = zmalloc(channel_data->size);
905 if (!channel_data->u.channel.data) {
906 ret = -ENOMEM;
907 goto error;
908 }
909 len = ustcomm_recv_unix_sock(sock, channel_data->u.channel.data,
910 channel_data->size);
911 if (len != channel_data->size) {
912 if (len < 0)
913 ret = len;
914 else
915 ret = -EINVAL;
916 goto error_recv_data;
917 }
918 /* recv wakeup fd */
919 len = ustcomm_recv_fds_unix_sock(sock, &wakeup_fd, 1);
920 if (len <= 0) {
921 if (len < 0) {
922 ret = len;
923 goto error_recv_data;
924 } else {
925 ret = -EIO;
926 goto error_recv_data;
927 }
928 }
929 channel_data->u.channel.wakeup_fd = wakeup_fd;
930 *_channel_data = channel_data;
931 return 0;
932
933 error_recv_data:
934 free(channel_data->u.channel.data);
935 error:
936 free(channel_data);
937 error_alloc:
938 return ret;
939 }
940
941 int ustctl_recv_stream_from_consumer(int sock,
942 struct lttng_ust_object_data **_stream_data)
943 {
944 struct lttng_ust_object_data *stream_data;
945 ssize_t len;
946 int ret;
947 int fds[2];
948
949 stream_data = zmalloc(sizeof(*stream_data));
950 if (!stream_data) {
951 ret = -ENOMEM;
952 goto error_alloc;
953 }
954
955 stream_data->type = LTTNG_UST_OBJECT_TYPE_STREAM;
956 stream_data->handle = -1;
957
958 /* recv mmap size */
959 len = ustcomm_recv_unix_sock(sock, &stream_data->size,
960 sizeof(stream_data->size));
961 if (len != sizeof(stream_data->size)) {
962 if (len < 0)
963 ret = len;
964 else
965 ret = -EINVAL;
966 goto error;
967 }
968 if (stream_data->size == -1) {
969 ret = -LTTNG_UST_ERR_NOENT;
970 goto error;
971 }
972
973 /* recv stream nr */
974 len = ustcomm_recv_unix_sock(sock, &stream_data->u.stream.stream_nr,
975 sizeof(stream_data->u.stream.stream_nr));
976 if (len != sizeof(stream_data->u.stream.stream_nr)) {
977 if (len < 0)
978 ret = len;
979 else
980 ret = -EINVAL;
981 goto error;
982 }
983
984 /* recv shm fd and wakeup fd */
985 len = ustcomm_recv_fds_unix_sock(sock, fds, 2);
986 if (len <= 0) {
987 if (len < 0) {
988 ret = len;
989 goto error;
990 } else {
991 ret = -EIO;
992 goto error;
993 }
994 }
995 stream_data->u.stream.shm_fd = fds[0];
996 stream_data->u.stream.wakeup_fd = fds[1];
997 *_stream_data = stream_data;
998 return 0;
999
1000 error:
1001 free(stream_data);
1002 error_alloc:
1003 return ret;
1004 }
1005
1006 int ustctl_send_channel_to_ust(int sock, int session_handle,
1007 struct lttng_ust_object_data *channel_data)
1008 {
1009 struct ustcomm_ust_msg lum;
1010 struct ustcomm_ust_reply lur;
1011 int ret;
1012
1013 if (!channel_data)
1014 return -EINVAL;
1015
1016 memset(&lum, 0, sizeof(lum));
1017 lum.handle = session_handle;
1018 lum.cmd = LTTNG_UST_CHANNEL;
1019 lum.u.channel.len = channel_data->size;
1020 lum.u.channel.type = channel_data->u.channel.type;
1021 ret = ustcomm_send_app_msg(sock, &lum);
1022 if (ret)
1023 return ret;
1024
1025 ret = ustctl_send_channel(sock,
1026 channel_data->u.channel.type,
1027 channel_data->u.channel.data,
1028 channel_data->size,
1029 channel_data->u.channel.wakeup_fd,
1030 1);
1031 if (ret)
1032 return ret;
1033 ret = ustcomm_recv_app_reply(sock, &lur, lum.handle, lum.cmd);
1034 if (!ret) {
1035 channel_data->handle = lur.ret_val;
1036 }
1037 return ret;
1038 }
1039
1040 int ustctl_send_stream_to_ust(int sock,
1041 struct lttng_ust_object_data *channel_data,
1042 struct lttng_ust_object_data *stream_data)
1043 {
1044 struct ustcomm_ust_msg lum;
1045 struct ustcomm_ust_reply lur;
1046 int ret;
1047
1048 memset(&lum, 0, sizeof(lum));
1049 lum.handle = channel_data->handle;
1050 lum.cmd = LTTNG_UST_STREAM;
1051 lum.u.stream.len = stream_data->size;
1052 lum.u.stream.stream_nr = stream_data->u.stream.stream_nr;
1053 ret = ustcomm_send_app_msg(sock, &lum);
1054 if (ret)
1055 return ret;
1056
1057 assert(stream_data);
1058 assert(stream_data->type == LTTNG_UST_OBJECT_TYPE_STREAM);
1059
1060 ret = ustctl_send_stream(sock,
1061 stream_data->u.stream.stream_nr,
1062 stream_data->size,
1063 stream_data->u.stream.shm_fd,
1064 stream_data->u.stream.wakeup_fd, 1);
1065 if (ret)
1066 return ret;
1067 return ustcomm_recv_app_reply(sock, &lur, lum.handle, lum.cmd);
1068 }
1069
1070 int ustctl_duplicate_ust_object_data(struct lttng_ust_object_data **dest,
1071 struct lttng_ust_object_data *src)
1072 {
1073 struct lttng_ust_object_data *obj;
1074 int ret;
1075
1076 if (src->handle != -1) {
1077 ret = -EINVAL;
1078 goto error;
1079 }
1080
1081 obj = zmalloc(sizeof(*obj));
1082 if (!obj) {
1083 ret = -ENOMEM;
1084 goto error;
1085 }
1086
1087 obj->type = src->type;
1088 obj->handle = src->handle;
1089 obj->size = src->size;
1090
1091 switch (obj->type) {
1092 case LTTNG_UST_OBJECT_TYPE_CHANNEL:
1093 {
1094 obj->u.channel.type = src->u.channel.type;
1095 if (src->u.channel.wakeup_fd >= 0) {
1096 obj->u.channel.wakeup_fd =
1097 dup(src->u.channel.wakeup_fd);
1098 if (obj->u.channel.wakeup_fd < 0) {
1099 ret = errno;
1100 goto chan_error_wakeup_fd;
1101 }
1102 } else {
1103 obj->u.channel.wakeup_fd =
1104 src->u.channel.wakeup_fd;
1105 }
1106 obj->u.channel.data = zmalloc(obj->size);
1107 if (!obj->u.channel.data) {
1108 ret = -ENOMEM;
1109 goto chan_error_alloc;
1110 }
1111 memcpy(obj->u.channel.data, src->u.channel.data, obj->size);
1112 break;
1113
1114 chan_error_alloc:
1115 if (src->u.channel.wakeup_fd >= 0) {
1116 int closeret;
1117
1118 closeret = close(obj->u.channel.wakeup_fd);
1119 if (closeret) {
1120 PERROR("close");
1121 }
1122 }
1123 chan_error_wakeup_fd:
1124 goto error_type;
1125
1126 }
1127
1128 case LTTNG_UST_OBJECT_TYPE_STREAM:
1129 {
1130 obj->u.stream.stream_nr = src->u.stream.stream_nr;
1131 if (src->u.stream.wakeup_fd >= 0) {
1132 obj->u.stream.wakeup_fd =
1133 dup(src->u.stream.wakeup_fd);
1134 if (obj->u.stream.wakeup_fd < 0) {
1135 ret = errno;
1136 goto stream_error_wakeup_fd;
1137 }
1138 } else {
1139 obj->u.stream.wakeup_fd =
1140 src->u.stream.wakeup_fd;
1141 }
1142
1143 if (src->u.stream.shm_fd >= 0) {
1144 obj->u.stream.shm_fd =
1145 dup(src->u.stream.shm_fd);
1146 if (obj->u.stream.shm_fd < 0) {
1147 ret = errno;
1148 goto stream_error_shm_fd;
1149 }
1150 } else {
1151 obj->u.stream.shm_fd =
1152 src->u.stream.shm_fd;
1153 }
1154 break;
1155
1156 stream_error_shm_fd:
1157 if (src->u.stream.wakeup_fd >= 0) {
1158 int closeret;
1159
1160 closeret = close(obj->u.stream.wakeup_fd);
1161 if (closeret) {
1162 PERROR("close");
1163 }
1164 }
1165 stream_error_wakeup_fd:
1166 goto error_type;
1167 }
1168
1169 case LTTNG_UST_OBJECT_TYPE_COUNTER:
1170 {
1171 obj->u.counter.data = zmalloc(obj->size);
1172 if (!obj->u.counter.data) {
1173 ret = -ENOMEM;
1174 goto error_type;
1175 }
1176 memcpy(obj->u.counter.data, src->u.counter.data, obj->size);
1177 break;
1178 }
1179
1180 case LTTNG_UST_OBJECT_TYPE_COUNTER_GLOBAL:
1181 {
1182 if (src->u.counter_global.shm_fd >= 0) {
1183 obj->u.counter_global.shm_fd =
1184 dup(src->u.counter_global.shm_fd);
1185 if (obj->u.counter_global.shm_fd < 0) {
1186 ret = errno;
1187 goto error_type;
1188 }
1189 }
1190 break;
1191 }
1192
1193 case LTTNG_UST_OBJECT_TYPE_COUNTER_CPU:
1194 {
1195 obj->u.counter_cpu.cpu_nr = src->u.counter_cpu.cpu_nr;
1196 if (src->u.counter_cpu.shm_fd >= 0) {
1197 obj->u.counter_cpu.shm_fd =
1198 dup(src->u.counter_cpu.shm_fd);
1199 if (obj->u.counter_cpu.shm_fd < 0) {
1200 ret = errno;
1201 goto error_type;
1202 }
1203 }
1204 break;
1205 }
1206
1207 default:
1208 ret = -EINVAL;
1209 goto error_type;
1210 }
1211
1212 *dest = obj;
1213 return 0;
1214
1215 error_type:
1216 free(obj);
1217 error:
1218 return ret;
1219 }
1220
1221
1222 /* Buffer operations */
1223
1224 int ustctl_get_nr_stream_per_channel(void)
1225 {
1226 return num_possible_cpus();
1227 }
1228
1229 struct ustctl_consumer_channel *
1230 ustctl_create_channel(struct ustctl_consumer_channel_attr *attr,
1231 const int *stream_fds, int nr_stream_fds)
1232 {
1233 struct ustctl_consumer_channel *chan;
1234 const char *transport_name;
1235 struct lttng_transport *transport;
1236
1237 switch (attr->type) {
1238 case LTTNG_UST_CHAN_PER_CPU:
1239 if (attr->output == LTTNG_UST_MMAP) {
1240 if (attr->overwrite) {
1241 if (attr->read_timer_interval == 0) {
1242 transport_name = "relay-overwrite-mmap";
1243 } else {
1244 transport_name = "relay-overwrite-rt-mmap";
1245 }
1246 } else {
1247 if (attr->read_timer_interval == 0) {
1248 transport_name = "relay-discard-mmap";
1249 } else {
1250 transport_name = "relay-discard-rt-mmap";
1251 }
1252 }
1253 } else {
1254 return NULL;
1255 }
1256 break;
1257 case LTTNG_UST_CHAN_METADATA:
1258 if (attr->output == LTTNG_UST_MMAP)
1259 transport_name = "relay-metadata-mmap";
1260 else
1261 return NULL;
1262 break;
1263 default:
1264 transport_name = "<unknown>";
1265 return NULL;
1266 }
1267
1268 transport = lttng_transport_find(transport_name);
1269 if (!transport) {
1270 DBG("LTTng transport %s not found\n",
1271 transport_name);
1272 return NULL;
1273 }
1274
1275 chan = zmalloc(sizeof(*chan));
1276 if (!chan)
1277 return NULL;
1278
1279 chan->chan = transport->ops.channel_create(transport_name, NULL,
1280 attr->subbuf_size, attr->num_subbuf,
1281 attr->switch_timer_interval,
1282 attr->read_timer_interval,
1283 attr->uuid, attr->chan_id,
1284 stream_fds, nr_stream_fds,
1285 attr->blocking_timeout);
1286 if (!chan->chan) {
1287 goto chan_error;
1288 }
1289 chan->chan->ops = &transport->ops;
1290 memcpy(&chan->attr, attr, sizeof(chan->attr));
1291 chan->wait_fd = ustctl_channel_get_wait_fd(chan);
1292 chan->wakeup_fd = ustctl_channel_get_wakeup_fd(chan);
1293 return chan;
1294
1295 chan_error:
1296 free(chan);
1297 return NULL;
1298 }
1299
1300 void ustctl_destroy_channel(struct ustctl_consumer_channel *chan)
1301 {
1302 (void) ustctl_channel_close_wait_fd(chan);
1303 (void) ustctl_channel_close_wakeup_fd(chan);
1304 chan->chan->ops->channel_destroy(chan->chan);
1305 free(chan);
1306 }
1307
1308 int ustctl_send_channel_to_sessiond(int sock,
1309 struct ustctl_consumer_channel *channel)
1310 {
1311 struct shm_object_table *table;
1312
1313 table = channel->chan->handle->table;
1314 if (table->size <= 0)
1315 return -EINVAL;
1316 return ustctl_send_channel(sock,
1317 channel->attr.type,
1318 table->objects[0].memory_map,
1319 table->objects[0].memory_map_size,
1320 channel->wakeup_fd,
1321 0);
1322 }
1323
1324 int ustctl_send_stream_to_sessiond(int sock,
1325 struct ustctl_consumer_stream *stream)
1326 {
1327 if (!stream)
1328 return ustctl_send_stream(sock, -1U, -1U, -1, -1, 0);
1329
1330 return ustctl_send_stream(sock,
1331 stream->cpu,
1332 stream->memory_map_size,
1333 stream->shm_fd, stream->wakeup_fd,
1334 0);
1335 }
1336
1337 int ustctl_write_metadata_to_channel(
1338 struct ustctl_consumer_channel *channel,
1339 const char *metadata_str, /* NOT null-terminated */
1340 size_t len) /* metadata length */
1341 {
1342 struct lttng_ust_lib_ring_buffer_ctx ctx;
1343 struct lttng_channel *chan = channel->chan;
1344 const char *str = metadata_str;
1345 int ret = 0, waitret;
1346 size_t reserve_len, pos;
1347
1348 for (pos = 0; pos < len; pos += reserve_len) {
1349 reserve_len = min_t(size_t,
1350 chan->ops->packet_avail_size(chan->chan, chan->handle),
1351 len - pos);
1352 lib_ring_buffer_ctx_init(&ctx, chan->chan, NULL, reserve_len,
1353 sizeof(char), -1, chan->handle, NULL);
1354 /*
1355 * We don't care about metadata buffer's records lost
1356 * count, because we always retry here. Report error if
1357 * we need to bail out after timeout or being
1358 * interrupted.
1359 */
1360 waitret = wait_cond_interruptible_timeout(
1361 ({
1362 ret = chan->ops->event_reserve(&ctx, 0);
1363 ret != -ENOBUFS || !ret;
1364 }),
1365 LTTNG_METADATA_TIMEOUT_MSEC);
1366 if (waitret == -ETIMEDOUT || waitret == -EINTR || ret) {
1367 DBG("LTTng: Failure to write metadata to buffers (%s)\n",
1368 waitret == -EINTR ? "interrupted" :
1369 (ret == -ENOBUFS ? "timeout" : "I/O error"));
1370 if (waitret == -EINTR)
1371 ret = waitret;
1372 goto end;
1373 }
1374 chan->ops->event_write(&ctx, &str[pos], reserve_len);
1375 chan->ops->event_commit(&ctx);
1376 }
1377 end:
1378 return ret;
1379 }
1380
1381 /*
1382 * Write at most one packet in the channel.
1383 * Returns the number of bytes written on success, < 0 on error.
1384 */
1385 ssize_t ustctl_write_one_packet_to_channel(
1386 struct ustctl_consumer_channel *channel,
1387 const char *metadata_str, /* NOT null-terminated */
1388 size_t len) /* metadata length */
1389 {
1390 struct lttng_ust_lib_ring_buffer_ctx ctx;
1391 struct lttng_channel *chan = channel->chan;
1392 const char *str = metadata_str;
1393 ssize_t reserve_len;
1394 int ret;
1395
1396 reserve_len = min_t(ssize_t,
1397 chan->ops->packet_avail_size(chan->chan, chan->handle),
1398 len);
1399 lib_ring_buffer_ctx_init(&ctx, chan->chan, NULL, reserve_len,
1400 sizeof(char), -1, chan->handle, NULL);
1401 ret = chan->ops->event_reserve(&ctx, 0);
1402 if (ret != 0) {
1403 DBG("LTTng: event reservation failed");
1404 assert(ret < 0);
1405 reserve_len = ret;
1406 goto end;
1407 }
1408 chan->ops->event_write(&ctx, str, reserve_len);
1409 chan->ops->event_commit(&ctx);
1410
1411 end:
1412 return reserve_len;
1413 }
1414
1415 int ustctl_channel_close_wait_fd(struct ustctl_consumer_channel *consumer_chan)
1416 {
1417 struct channel *chan;
1418 int ret;
1419
1420 chan = consumer_chan->chan->chan;
1421 ret = ring_buffer_channel_close_wait_fd(&chan->backend.config,
1422 chan, chan->handle);
1423 if (!ret)
1424 consumer_chan->wait_fd = -1;
1425 return ret;
1426 }
1427
1428 int ustctl_channel_close_wakeup_fd(struct ustctl_consumer_channel *consumer_chan)
1429 {
1430 struct channel *chan;
1431 int ret;
1432
1433 chan = consumer_chan->chan->chan;
1434 ret = ring_buffer_channel_close_wakeup_fd(&chan->backend.config,
1435 chan, chan->handle);
1436 if (!ret)
1437 consumer_chan->wakeup_fd = -1;
1438 return ret;
1439 }
1440
1441 int ustctl_stream_close_wait_fd(struct ustctl_consumer_stream *stream)
1442 {
1443 struct channel *chan;
1444
1445 chan = stream->chan->chan->chan;
1446 return ring_buffer_stream_close_wait_fd(&chan->backend.config,
1447 chan, stream->handle, stream->cpu);
1448 }
1449
1450 int ustctl_stream_close_wakeup_fd(struct ustctl_consumer_stream *stream)
1451 {
1452 struct channel *chan;
1453
1454 chan = stream->chan->chan->chan;
1455 return ring_buffer_stream_close_wakeup_fd(&chan->backend.config,
1456 chan, stream->handle, stream->cpu);
1457 }
1458
1459 struct ustctl_consumer_stream *
1460 ustctl_create_stream(struct ustctl_consumer_channel *channel,
1461 int cpu)
1462 {
1463 struct ustctl_consumer_stream *stream;
1464 struct lttng_ust_shm_handle *handle;
1465 struct channel *chan;
1466 int shm_fd, wait_fd, wakeup_fd;
1467 uint64_t memory_map_size;
1468 struct lttng_ust_lib_ring_buffer *buf;
1469 int ret;
1470
1471 if (!channel)
1472 return NULL;
1473 handle = channel->chan->handle;
1474 if (!handle)
1475 return NULL;
1476
1477 chan = channel->chan->chan;
1478 buf = channel_get_ring_buffer(&chan->backend.config,
1479 chan, cpu, handle, &shm_fd, &wait_fd,
1480 &wakeup_fd, &memory_map_size);
1481 if (!buf)
1482 return NULL;
1483 ret = lib_ring_buffer_open_read(buf, handle);
1484 if (ret)
1485 return NULL;
1486
1487 stream = zmalloc(sizeof(*stream));
1488 if (!stream)
1489 goto alloc_error;
1490 stream->handle = handle;
1491 stream->buf = buf;
1492 stream->chan = channel;
1493 stream->shm_fd = shm_fd;
1494 stream->wait_fd = wait_fd;
1495 stream->wakeup_fd = wakeup_fd;
1496 stream->memory_map_size = memory_map_size;
1497 stream->cpu = cpu;
1498 return stream;
1499
1500 alloc_error:
1501 return NULL;
1502 }
1503
1504 void ustctl_destroy_stream(struct ustctl_consumer_stream *stream)
1505 {
1506 struct lttng_ust_lib_ring_buffer *buf;
1507 struct ustctl_consumer_channel *consumer_chan;
1508
1509 assert(stream);
1510 buf = stream->buf;
1511 consumer_chan = stream->chan;
1512 (void) ustctl_stream_close_wait_fd(stream);
1513 (void) ustctl_stream_close_wakeup_fd(stream);
1514 lib_ring_buffer_release_read(buf, consumer_chan->chan->handle);
1515 free(stream);
1516 }
1517
1518 int ustctl_channel_get_wait_fd(struct ustctl_consumer_channel *chan)
1519 {
1520 if (!chan)
1521 return -EINVAL;
1522 return shm_get_wait_fd(chan->chan->handle,
1523 &chan->chan->handle->chan._ref);
1524 }
1525
1526 int ustctl_channel_get_wakeup_fd(struct ustctl_consumer_channel *chan)
1527 {
1528 if (!chan)
1529 return -EINVAL;
1530 return shm_get_wakeup_fd(chan->chan->handle,
1531 &chan->chan->handle->chan._ref);
1532 }
1533
1534 int ustctl_stream_get_wait_fd(struct ustctl_consumer_stream *stream)
1535 {
1536 struct lttng_ust_lib_ring_buffer *buf;
1537 struct ustctl_consumer_channel *consumer_chan;
1538
1539 if (!stream)
1540 return -EINVAL;
1541 buf = stream->buf;
1542 consumer_chan = stream->chan;
1543 return shm_get_wait_fd(consumer_chan->chan->handle, &buf->self._ref);
1544 }
1545
1546 int ustctl_stream_get_wakeup_fd(struct ustctl_consumer_stream *stream)
1547 {
1548 struct lttng_ust_lib_ring_buffer *buf;
1549 struct ustctl_consumer_channel *consumer_chan;
1550
1551 if (!stream)
1552 return -EINVAL;
1553 buf = stream->buf;
1554 consumer_chan = stream->chan;
1555 return shm_get_wakeup_fd(consumer_chan->chan->handle, &buf->self._ref);
1556 }
1557
1558 /* For mmap mode, readable without "get" operation */
1559
1560 void *ustctl_get_mmap_base(struct ustctl_consumer_stream *stream)
1561 {
1562 struct lttng_ust_lib_ring_buffer *buf;
1563 struct ustctl_consumer_channel *consumer_chan;
1564
1565 if (!stream)
1566 return NULL;
1567 buf = stream->buf;
1568 consumer_chan = stream->chan;
1569 return shmp(consumer_chan->chan->handle, buf->backend.memory_map);
1570 }
1571
1572 /* returns the length to mmap. */
1573 int ustctl_get_mmap_len(struct ustctl_consumer_stream *stream,
1574 unsigned long *len)
1575 {
1576 struct ustctl_consumer_channel *consumer_chan;
1577 unsigned long mmap_buf_len;
1578 struct channel *chan;
1579
1580 if (!stream)
1581 return -EINVAL;
1582 consumer_chan = stream->chan;
1583 chan = consumer_chan->chan->chan;
1584 if (chan->backend.config.output != RING_BUFFER_MMAP)
1585 return -EINVAL;
1586 mmap_buf_len = chan->backend.buf_size;
1587 if (chan->backend.extra_reader_sb)
1588 mmap_buf_len += chan->backend.subbuf_size;
1589 if (mmap_buf_len > INT_MAX)
1590 return -EFBIG;
1591 *len = mmap_buf_len;
1592 return 0;
1593 }
1594
1595 /* returns the maximum size for sub-buffers. */
1596 int ustctl_get_max_subbuf_size(struct ustctl_consumer_stream *stream,
1597 unsigned long *len)
1598 {
1599 struct ustctl_consumer_channel *consumer_chan;
1600 struct channel *chan;
1601
1602 if (!stream)
1603 return -EINVAL;
1604 consumer_chan = stream->chan;
1605 chan = consumer_chan->chan->chan;
1606 *len = chan->backend.subbuf_size;
1607 return 0;
1608 }
1609
1610 /*
1611 * For mmap mode, operate on the current packet (between get/put or
1612 * get_next/put_next).
1613 */
1614
1615 /* returns the offset of the subbuffer belonging to the mmap reader. */
1616 int ustctl_get_mmap_read_offset(struct ustctl_consumer_stream *stream,
1617 unsigned long *off)
1618 {
1619 struct channel *chan;
1620 unsigned long sb_bindex;
1621 struct lttng_ust_lib_ring_buffer *buf;
1622 struct ustctl_consumer_channel *consumer_chan;
1623 struct lttng_ust_lib_ring_buffer_backend_pages_shmp *barray_idx;
1624 struct lttng_ust_lib_ring_buffer_backend_pages *pages;
1625
1626 if (!stream)
1627 return -EINVAL;
1628 buf = stream->buf;
1629 consumer_chan = stream->chan;
1630 chan = consumer_chan->chan->chan;
1631 if (chan->backend.config.output != RING_BUFFER_MMAP)
1632 return -EINVAL;
1633 sb_bindex = subbuffer_id_get_index(&chan->backend.config,
1634 buf->backend.buf_rsb.id);
1635 barray_idx = shmp_index(consumer_chan->chan->handle, buf->backend.array,
1636 sb_bindex);
1637 if (!barray_idx)
1638 return -EINVAL;
1639 pages = shmp(consumer_chan->chan->handle, barray_idx->shmp);
1640 if (!pages)
1641 return -EINVAL;
1642 *off = pages->mmap_offset;
1643 return 0;
1644 }
1645
1646 /* returns the size of the current sub-buffer, without padding (for mmap). */
1647 int ustctl_get_subbuf_size(struct ustctl_consumer_stream *stream,
1648 unsigned long *len)
1649 {
1650 struct ustctl_consumer_channel *consumer_chan;
1651 struct channel *chan;
1652 struct lttng_ust_lib_ring_buffer *buf;
1653
1654 if (!stream)
1655 return -EINVAL;
1656
1657 buf = stream->buf;
1658 consumer_chan = stream->chan;
1659 chan = consumer_chan->chan->chan;
1660 *len = lib_ring_buffer_get_read_data_size(&chan->backend.config, buf,
1661 consumer_chan->chan->handle);
1662 return 0;
1663 }
1664
1665 /* returns the size of the current sub-buffer, without padding (for mmap). */
1666 int ustctl_get_padded_subbuf_size(struct ustctl_consumer_stream *stream,
1667 unsigned long *len)
1668 {
1669 struct ustctl_consumer_channel *consumer_chan;
1670 struct channel *chan;
1671 struct lttng_ust_lib_ring_buffer *buf;
1672
1673 if (!stream)
1674 return -EINVAL;
1675 buf = stream->buf;
1676 consumer_chan = stream->chan;
1677 chan = consumer_chan->chan->chan;
1678 *len = lib_ring_buffer_get_read_data_size(&chan->backend.config, buf,
1679 consumer_chan->chan->handle);
1680 *len = LTTNG_UST_PAGE_ALIGN(*len);
1681 return 0;
1682 }
1683
1684 /* Get exclusive read access to the next sub-buffer that can be read. */
1685 int ustctl_get_next_subbuf(struct ustctl_consumer_stream *stream)
1686 {
1687 struct lttng_ust_lib_ring_buffer *buf;
1688 struct ustctl_consumer_channel *consumer_chan;
1689
1690 if (!stream)
1691 return -EINVAL;
1692 buf = stream->buf;
1693 consumer_chan = stream->chan;
1694 return lib_ring_buffer_get_next_subbuf(buf,
1695 consumer_chan->chan->handle);
1696 }
1697
1698
1699 /* Release exclusive sub-buffer access, move consumer forward. */
1700 int ustctl_put_next_subbuf(struct ustctl_consumer_stream *stream)
1701 {
1702 struct lttng_ust_lib_ring_buffer *buf;
1703 struct ustctl_consumer_channel *consumer_chan;
1704
1705 if (!stream)
1706 return -EINVAL;
1707 buf = stream->buf;
1708 consumer_chan = stream->chan;
1709 lib_ring_buffer_put_next_subbuf(buf, consumer_chan->chan->handle);
1710 return 0;
1711 }
1712
1713 /* snapshot */
1714
1715 /* Get a snapshot of the current ring buffer producer and consumer positions */
1716 int ustctl_snapshot(struct ustctl_consumer_stream *stream)
1717 {
1718 struct lttng_ust_lib_ring_buffer *buf;
1719 struct ustctl_consumer_channel *consumer_chan;
1720
1721 if (!stream)
1722 return -EINVAL;
1723 buf = stream->buf;
1724 consumer_chan = stream->chan;
1725 return lib_ring_buffer_snapshot(buf, &buf->cons_snapshot,
1726 &buf->prod_snapshot, consumer_chan->chan->handle);
1727 }
1728
1729 /*
1730 * Get a snapshot of the current ring buffer producer and consumer positions
1731 * even if the consumed and produced positions are contained within the same
1732 * subbuffer.
1733 */
1734 int ustctl_snapshot_sample_positions(struct ustctl_consumer_stream *stream)
1735 {
1736 struct lttng_ust_lib_ring_buffer *buf;
1737 struct ustctl_consumer_channel *consumer_chan;
1738
1739 if (!stream)
1740 return -EINVAL;
1741 buf = stream->buf;
1742 consumer_chan = stream->chan;
1743 return lib_ring_buffer_snapshot_sample_positions(buf,
1744 &buf->cons_snapshot, &buf->prod_snapshot,
1745 consumer_chan->chan->handle);
1746 }
1747
1748 /* Get the consumer position (iteration start) */
1749 int ustctl_snapshot_get_consumed(struct ustctl_consumer_stream *stream,
1750 unsigned long *pos)
1751 {
1752 struct lttng_ust_lib_ring_buffer *buf;
1753
1754 if (!stream)
1755 return -EINVAL;
1756 buf = stream->buf;
1757 *pos = buf->cons_snapshot;
1758 return 0;
1759 }
1760
1761 /* Get the producer position (iteration end) */
1762 int ustctl_snapshot_get_produced(struct ustctl_consumer_stream *stream,
1763 unsigned long *pos)
1764 {
1765 struct lttng_ust_lib_ring_buffer *buf;
1766
1767 if (!stream)
1768 return -EINVAL;
1769 buf = stream->buf;
1770 *pos = buf->prod_snapshot;
1771 return 0;
1772 }
1773
1774 /* Get exclusive read access to the specified sub-buffer position */
1775 int ustctl_get_subbuf(struct ustctl_consumer_stream *stream,
1776 unsigned long *pos)
1777 {
1778 struct lttng_ust_lib_ring_buffer *buf;
1779 struct ustctl_consumer_channel *consumer_chan;
1780
1781 if (!stream)
1782 return -EINVAL;
1783 buf = stream->buf;
1784 consumer_chan = stream->chan;
1785 return lib_ring_buffer_get_subbuf(buf, *pos,
1786 consumer_chan->chan->handle);
1787 }
1788
1789 /* Release exclusive sub-buffer access */
1790 int ustctl_put_subbuf(struct ustctl_consumer_stream *stream)
1791 {
1792 struct lttng_ust_lib_ring_buffer *buf;
1793 struct ustctl_consumer_channel *consumer_chan;
1794
1795 if (!stream)
1796 return -EINVAL;
1797 buf = stream->buf;
1798 consumer_chan = stream->chan;
1799 lib_ring_buffer_put_subbuf(buf, consumer_chan->chan->handle);
1800 return 0;
1801 }
1802
1803 void ustctl_flush_buffer(struct ustctl_consumer_stream *stream,
1804 int producer_active)
1805 {
1806 struct lttng_ust_lib_ring_buffer *buf;
1807 struct ustctl_consumer_channel *consumer_chan;
1808
1809 assert(stream);
1810 buf = stream->buf;
1811 consumer_chan = stream->chan;
1812 lib_ring_buffer_switch_slow(buf,
1813 producer_active ? SWITCH_ACTIVE : SWITCH_FLUSH,
1814 consumer_chan->chan->handle);
1815 }
1816
1817 void ustctl_clear_buffer(struct ustctl_consumer_stream *stream)
1818 {
1819 struct lttng_ust_lib_ring_buffer *buf;
1820 struct ustctl_consumer_channel *consumer_chan;
1821
1822 assert(stream);
1823 buf = stream->buf;
1824 consumer_chan = stream->chan;
1825 lib_ring_buffer_switch_slow(buf, SWITCH_ACTIVE,
1826 consumer_chan->chan->handle);
1827 lib_ring_buffer_clear_reader(buf, consumer_chan->chan->handle);
1828 }
1829
1830 static
1831 struct lttng_ust_client_lib_ring_buffer_client_cb *get_client_cb(
1832 struct lttng_ust_lib_ring_buffer *buf,
1833 struct lttng_ust_shm_handle *handle)
1834 {
1835 struct channel *chan;
1836 const struct lttng_ust_lib_ring_buffer_config *config;
1837 struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb;
1838
1839 chan = shmp(handle, buf->backend.chan);
1840 if (!chan)
1841 return NULL;
1842 config = &chan->backend.config;
1843 if (!config->cb_ptr)
1844 return NULL;
1845 client_cb = caa_container_of(config->cb_ptr,
1846 struct lttng_ust_client_lib_ring_buffer_client_cb,
1847 parent);
1848 return client_cb;
1849 }
1850
1851 int ustctl_get_timestamp_begin(struct ustctl_consumer_stream *stream,
1852 uint64_t *timestamp_begin)
1853 {
1854 struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb;
1855 struct lttng_ust_lib_ring_buffer *buf;
1856 struct lttng_ust_shm_handle *handle;
1857
1858 if (!stream || !timestamp_begin)
1859 return -EINVAL;
1860 buf = stream->buf;
1861 handle = stream->chan->chan->handle;
1862 client_cb = get_client_cb(buf, handle);
1863 if (!client_cb)
1864 return -ENOSYS;
1865 return client_cb->timestamp_begin(buf, handle, timestamp_begin);
1866 }
1867
1868 int ustctl_get_timestamp_end(struct ustctl_consumer_stream *stream,
1869 uint64_t *timestamp_end)
1870 {
1871 struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb;
1872 struct lttng_ust_lib_ring_buffer *buf;
1873 struct lttng_ust_shm_handle *handle;
1874
1875 if (!stream || !timestamp_end)
1876 return -EINVAL;
1877 buf = stream->buf;
1878 handle = stream->chan->chan->handle;
1879 client_cb = get_client_cb(buf, handle);
1880 if (!client_cb)
1881 return -ENOSYS;
1882 return client_cb->timestamp_end(buf, handle, timestamp_end);
1883 }
1884
1885 int ustctl_get_events_discarded(struct ustctl_consumer_stream *stream,
1886 uint64_t *events_discarded)
1887 {
1888 struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb;
1889 struct lttng_ust_lib_ring_buffer *buf;
1890 struct lttng_ust_shm_handle *handle;
1891
1892 if (!stream || !events_discarded)
1893 return -EINVAL;
1894 buf = stream->buf;
1895 handle = stream->chan->chan->handle;
1896 client_cb = get_client_cb(buf, handle);
1897 if (!client_cb)
1898 return -ENOSYS;
1899 return client_cb->events_discarded(buf, handle, events_discarded);
1900 }
1901
1902 int ustctl_get_content_size(struct ustctl_consumer_stream *stream,
1903 uint64_t *content_size)
1904 {
1905 struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb;
1906 struct lttng_ust_lib_ring_buffer *buf;
1907 struct lttng_ust_shm_handle *handle;
1908
1909 if (!stream || !content_size)
1910 return -EINVAL;
1911 buf = stream->buf;
1912 handle = stream->chan->chan->handle;
1913 client_cb = get_client_cb(buf, handle);
1914 if (!client_cb)
1915 return -ENOSYS;
1916 return client_cb->content_size(buf, handle, content_size);
1917 }
1918
1919 int ustctl_get_packet_size(struct ustctl_consumer_stream *stream,
1920 uint64_t *packet_size)
1921 {
1922 struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb;
1923 struct lttng_ust_lib_ring_buffer *buf;
1924 struct lttng_ust_shm_handle *handle;
1925
1926 if (!stream || !packet_size)
1927 return -EINVAL;
1928 buf = stream->buf;
1929 handle = stream->chan->chan->handle;
1930 client_cb = get_client_cb(buf, handle);
1931 if (!client_cb)
1932 return -ENOSYS;
1933 return client_cb->packet_size(buf, handle, packet_size);
1934 }
1935
1936 int ustctl_get_stream_id(struct ustctl_consumer_stream *stream,
1937 uint64_t *stream_id)
1938 {
1939 struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb;
1940 struct lttng_ust_lib_ring_buffer *buf;
1941 struct lttng_ust_shm_handle *handle;
1942
1943 if (!stream || !stream_id)
1944 return -EINVAL;
1945 buf = stream->buf;
1946 handle = stream->chan->chan->handle;
1947 client_cb = get_client_cb(buf, handle);
1948 if (!client_cb)
1949 return -ENOSYS;
1950 return client_cb->stream_id(buf, handle, stream_id);
1951 }
1952
1953 int ustctl_get_current_timestamp(struct ustctl_consumer_stream *stream,
1954 uint64_t *ts)
1955 {
1956 struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb;
1957 struct lttng_ust_lib_ring_buffer *buf;
1958 struct lttng_ust_shm_handle *handle;
1959
1960 if (!stream || !ts)
1961 return -EINVAL;
1962 buf = stream->buf;
1963 handle = stream->chan->chan->handle;
1964 client_cb = get_client_cb(buf, handle);
1965 if (!client_cb || !client_cb->current_timestamp)
1966 return -ENOSYS;
1967 return client_cb->current_timestamp(buf, handle, ts);
1968 }
1969
1970 int ustctl_get_sequence_number(struct ustctl_consumer_stream *stream,
1971 uint64_t *seq)
1972 {
1973 struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb;
1974 struct lttng_ust_lib_ring_buffer *buf;
1975 struct lttng_ust_shm_handle *handle;
1976
1977 if (!stream || !seq)
1978 return -EINVAL;
1979 buf = stream->buf;
1980 handle = stream->chan->chan->handle;
1981 client_cb = get_client_cb(buf, handle);
1982 if (!client_cb || !client_cb->sequence_number)
1983 return -ENOSYS;
1984 return client_cb->sequence_number(buf, handle, seq);
1985 }
1986
1987 int ustctl_get_instance_id(struct ustctl_consumer_stream *stream,
1988 uint64_t *id)
1989 {
1990 struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb;
1991 struct lttng_ust_lib_ring_buffer *buf;
1992 struct lttng_ust_shm_handle *handle;
1993
1994 if (!stream || !id)
1995 return -EINVAL;
1996 buf = stream->buf;
1997 handle = stream->chan->chan->handle;
1998 client_cb = get_client_cb(buf, handle);
1999 if (!client_cb)
2000 return -ENOSYS;
2001 return client_cb->instance_id(buf, handle, id);
2002 }
2003
2004 #ifdef LTTNG_UST_HAVE_PERF_EVENT
2005
2006 int ustctl_has_perf_counters(void)
2007 {
2008 return 1;
2009 }
2010
2011 #else
2012
2013 int ustctl_has_perf_counters(void)
2014 {
2015 return 0;
2016 }
2017
2018 #endif
2019
2020 /*
2021 * Returns 0 on success, negative error value on error.
2022 */
2023 int ustctl_recv_reg_msg(int sock,
2024 enum ustctl_socket_type *type,
2025 uint32_t *major,
2026 uint32_t *minor,
2027 uint32_t *pid,
2028 uint32_t *ppid,
2029 uint32_t *uid,
2030 uint32_t *gid,
2031 uint32_t *bits_per_long,
2032 uint32_t *uint8_t_alignment,
2033 uint32_t *uint16_t_alignment,
2034 uint32_t *uint32_t_alignment,
2035 uint32_t *uint64_t_alignment,
2036 uint32_t *long_alignment,
2037 int *byte_order,
2038 char *name)
2039 {
2040 ssize_t len;
2041 struct ustctl_reg_msg reg_msg;
2042
2043 len = ustcomm_recv_unix_sock(sock, &reg_msg, sizeof(reg_msg));
2044 if (len > 0 && len != sizeof(reg_msg))
2045 return -EIO;
2046 if (len == 0)
2047 return -EPIPE;
2048 if (len < 0)
2049 return len;
2050
2051 if (reg_msg.magic == LTTNG_UST_COMM_MAGIC) {
2052 *byte_order = BYTE_ORDER == BIG_ENDIAN ?
2053 BIG_ENDIAN : LITTLE_ENDIAN;
2054 } else if (reg_msg.magic == bswap_32(LTTNG_UST_COMM_MAGIC)) {
2055 *byte_order = BYTE_ORDER == BIG_ENDIAN ?
2056 LITTLE_ENDIAN : BIG_ENDIAN;
2057 } else {
2058 return -LTTNG_UST_ERR_INVAL_MAGIC;
2059 }
2060 switch (reg_msg.socket_type) {
2061 case 0: *type = USTCTL_SOCKET_CMD;
2062 break;
2063 case 1: *type = USTCTL_SOCKET_NOTIFY;
2064 break;
2065 default:
2066 return -LTTNG_UST_ERR_INVAL_SOCKET_TYPE;
2067 }
2068 *major = reg_msg.major;
2069 *minor = reg_msg.minor;
2070 *pid = reg_msg.pid;
2071 *ppid = reg_msg.ppid;
2072 *uid = reg_msg.uid;
2073 *gid = reg_msg.gid;
2074 *bits_per_long = reg_msg.bits_per_long;
2075 *uint8_t_alignment = reg_msg.uint8_t_alignment;
2076 *uint16_t_alignment = reg_msg.uint16_t_alignment;
2077 *uint32_t_alignment = reg_msg.uint32_t_alignment;
2078 *uint64_t_alignment = reg_msg.uint64_t_alignment;
2079 *long_alignment = reg_msg.long_alignment;
2080 memcpy(name, reg_msg.name, LTTNG_UST_ABI_PROCNAME_LEN);
2081 if (reg_msg.major < LTTNG_UST_ABI_MAJOR_VERSION_OLDEST_COMPATIBLE ||
2082 reg_msg.major > LTTNG_UST_ABI_MAJOR_VERSION) {
2083 return -LTTNG_UST_ERR_UNSUP_MAJOR;
2084 }
2085
2086 return 0;
2087 }
2088
2089 int ustctl_recv_notify(int sock, enum ustctl_notify_cmd *notify_cmd)
2090 {
2091 struct ustcomm_notify_hdr header;
2092 ssize_t len;
2093
2094 len = ustcomm_recv_unix_sock(sock, &header, sizeof(header));
2095 if (len > 0 && len != sizeof(header))
2096 return -EIO;
2097 if (len == 0)
2098 return -EPIPE;
2099 if (len < 0)
2100 return len;
2101 switch (header.notify_cmd) {
2102 case 0:
2103 *notify_cmd = USTCTL_NOTIFY_CMD_EVENT;
2104 break;
2105 case 1:
2106 *notify_cmd = USTCTL_NOTIFY_CMD_CHANNEL;
2107 break;
2108 case 2:
2109 *notify_cmd = USTCTL_NOTIFY_CMD_ENUM;
2110 break;
2111 default:
2112 return -EINVAL;
2113 }
2114 return 0;
2115 }
2116
2117 /*
2118 * Returns 0 on success, negative error value on error.
2119 */
2120 int ustctl_recv_register_event(int sock,
2121 int *session_objd,
2122 int *channel_objd,
2123 char *event_name,
2124 int *loglevel,
2125 char **signature,
2126 size_t *nr_fields,
2127 struct ustctl_field **fields,
2128 char **model_emf_uri)
2129 {
2130 ssize_t len;
2131 struct ustcomm_notify_event_msg msg;
2132 size_t signature_len, fields_len, model_emf_uri_len;
2133 char *a_sign = NULL, *a_model_emf_uri = NULL;
2134 struct ustctl_field *a_fields = NULL;
2135
2136 len = ustcomm_recv_unix_sock(sock, &msg, sizeof(msg));
2137 if (len > 0 && len != sizeof(msg))
2138 return -EIO;
2139 if (len == 0)
2140 return -EPIPE;
2141 if (len < 0)
2142 return len;
2143
2144 *session_objd = msg.session_objd;
2145 *channel_objd = msg.channel_objd;
2146 strncpy(event_name, msg.event_name, LTTNG_UST_SYM_NAME_LEN);
2147 event_name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
2148 *loglevel = msg.loglevel;
2149 signature_len = msg.signature_len;
2150 fields_len = msg.fields_len;
2151
2152 if (fields_len % sizeof(*a_fields) != 0) {
2153 return -EINVAL;
2154 }
2155
2156 model_emf_uri_len = msg.model_emf_uri_len;
2157
2158 /* recv signature. contains at least \0. */
2159 a_sign = zmalloc(signature_len);
2160 if (!a_sign)
2161 return -ENOMEM;
2162 len = ustcomm_recv_unix_sock(sock, a_sign, signature_len);
2163 if (len > 0 && len != signature_len) {
2164 len = -EIO;
2165 goto signature_error;
2166 }
2167 if (len == 0) {
2168 len = -EPIPE;
2169 goto signature_error;
2170 }
2171 if (len < 0) {
2172 goto signature_error;
2173 }
2174 /* Enforce end of string */
2175 a_sign[signature_len - 1] = '\0';
2176
2177 /* recv fields */
2178 if (fields_len) {
2179 a_fields = zmalloc(fields_len);
2180 if (!a_fields) {
2181 len = -ENOMEM;
2182 goto signature_error;
2183 }
2184 len = ustcomm_recv_unix_sock(sock, a_fields, fields_len);
2185 if (len > 0 && len != fields_len) {
2186 len = -EIO;
2187 goto fields_error;
2188 }
2189 if (len == 0) {
2190 len = -EPIPE;
2191 goto fields_error;
2192 }
2193 if (len < 0) {
2194 goto fields_error;
2195 }
2196 }
2197
2198 if (model_emf_uri_len) {
2199 /* recv model_emf_uri_len */
2200 a_model_emf_uri = zmalloc(model_emf_uri_len);
2201 if (!a_model_emf_uri) {
2202 len = -ENOMEM;
2203 goto fields_error;
2204 }
2205 len = ustcomm_recv_unix_sock(sock, a_model_emf_uri,
2206 model_emf_uri_len);
2207 if (len > 0 && len != model_emf_uri_len) {
2208 len = -EIO;
2209 goto model_error;
2210 }
2211 if (len == 0) {
2212 len = -EPIPE;
2213 goto model_error;
2214 }
2215 if (len < 0) {
2216 goto model_error;
2217 }
2218 /* Enforce end of string */
2219 a_model_emf_uri[model_emf_uri_len - 1] = '\0';
2220 }
2221
2222 *signature = a_sign;
2223 *nr_fields = fields_len / sizeof(*a_fields);
2224 *fields = a_fields;
2225 *model_emf_uri = a_model_emf_uri;
2226
2227 return 0;
2228
2229 model_error:
2230 free(a_model_emf_uri);
2231 fields_error:
2232 free(a_fields);
2233 signature_error:
2234 free(a_sign);
2235 return len;
2236 }
2237
2238 /*
2239 * Returns 0 on success, negative error value on error.
2240 */
2241 int ustctl_reply_register_event(int sock,
2242 uint32_t id,
2243 int ret_code)
2244 {
2245 ssize_t len;
2246 struct {
2247 struct ustcomm_notify_hdr header;
2248 struct ustcomm_notify_event_reply r;
2249 } reply;
2250
2251 memset(&reply, 0, sizeof(reply));
2252 reply.header.notify_cmd = USTCTL_NOTIFY_CMD_EVENT;
2253 reply.r.ret_code = ret_code;
2254 reply.r.event_id = id;
2255 len = ustcomm_send_unix_sock(sock, &reply, sizeof(reply));
2256 if (len > 0 && len != sizeof(reply))
2257 return -EIO;
2258 if (len < 0)
2259 return len;
2260 return 0;
2261 }
2262
2263 /*
2264 * Returns 0 on success, negative UST or system error value on error.
2265 */
2266 int ustctl_recv_register_enum(int sock,
2267 int *session_objd,
2268 char *enum_name,
2269 struct ustctl_enum_entry **entries,
2270 size_t *nr_entries)
2271 {
2272 ssize_t len;
2273 struct ustcomm_notify_enum_msg msg;
2274 size_t entries_len;
2275 struct ustctl_enum_entry *a_entries = NULL;
2276
2277 len = ustcomm_recv_unix_sock(sock, &msg, sizeof(msg));
2278 if (len > 0 && len != sizeof(msg))
2279 return -EIO;
2280 if (len == 0)
2281 return -EPIPE;
2282 if (len < 0)
2283 return len;
2284
2285 *session_objd = msg.session_objd;
2286 strncpy(enum_name, msg.enum_name, LTTNG_UST_SYM_NAME_LEN);
2287 enum_name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
2288 entries_len = msg.entries_len;
2289
2290 if (entries_len % sizeof(*a_entries) != 0) {
2291 return -EINVAL;
2292 }
2293
2294 /* recv entries */
2295 if (entries_len) {
2296 a_entries = zmalloc(entries_len);
2297 if (!a_entries)
2298 return -ENOMEM;
2299 len = ustcomm_recv_unix_sock(sock, a_entries, entries_len);
2300 if (len > 0 && len != entries_len) {
2301 len = -EIO;
2302 goto entries_error;
2303 }
2304 if (len == 0) {
2305 len = -EPIPE;
2306 goto entries_error;
2307 }
2308 if (len < 0) {
2309 goto entries_error;
2310 }
2311 }
2312 *nr_entries = entries_len / sizeof(*a_entries);
2313 *entries = a_entries;
2314
2315 return 0;
2316
2317 entries_error:
2318 free(a_entries);
2319 return len;
2320 }
2321
2322 /*
2323 * Returns 0 on success, negative error value on error.
2324 */
2325 int ustctl_reply_register_enum(int sock,
2326 uint64_t id,
2327 int ret_code)
2328 {
2329 ssize_t len;
2330 struct {
2331 struct ustcomm_notify_hdr header;
2332 struct ustcomm_notify_enum_reply r;
2333 } reply;
2334
2335 memset(&reply, 0, sizeof(reply));
2336 reply.header.notify_cmd = USTCTL_NOTIFY_CMD_ENUM;
2337 reply.r.ret_code = ret_code;
2338 reply.r.enum_id = id;
2339 len = ustcomm_send_unix_sock(sock, &reply, sizeof(reply));
2340 if (len > 0 && len != sizeof(reply))
2341 return -EIO;
2342 if (len < 0)
2343 return len;
2344 return 0;
2345 }
2346
2347 /*
2348 * Returns 0 on success, negative UST or system error value on error.
2349 */
2350 int ustctl_recv_register_channel(int sock,
2351 int *session_objd, /* session descriptor (output) */
2352 int *channel_objd, /* channel descriptor (output) */
2353 size_t *nr_fields,
2354 struct ustctl_field **fields)
2355 {
2356 ssize_t len;
2357 struct ustcomm_notify_channel_msg msg;
2358 size_t fields_len;
2359 struct ustctl_field *a_fields;
2360
2361 len = ustcomm_recv_unix_sock(sock, &msg, sizeof(msg));
2362 if (len > 0 && len != sizeof(msg))
2363 return -EIO;
2364 if (len == 0)
2365 return -EPIPE;
2366 if (len < 0)
2367 return len;
2368
2369 *session_objd = msg.session_objd;
2370 *channel_objd = msg.channel_objd;
2371 fields_len = msg.ctx_fields_len;
2372
2373 if (fields_len % sizeof(*a_fields) != 0) {
2374 return -EINVAL;
2375 }
2376
2377 /* recv fields */
2378 if (fields_len) {
2379 a_fields = zmalloc(fields_len);
2380 if (!a_fields) {
2381 len = -ENOMEM;
2382 goto alloc_error;
2383 }
2384 len = ustcomm_recv_unix_sock(sock, a_fields, fields_len);
2385 if (len > 0 && len != fields_len) {
2386 len = -EIO;
2387 goto fields_error;
2388 }
2389 if (len == 0) {
2390 len = -EPIPE;
2391 goto fields_error;
2392 }
2393 if (len < 0) {
2394 goto fields_error;
2395 }
2396 *fields = a_fields;
2397 } else {
2398 *fields = NULL;
2399 }
2400 *nr_fields = fields_len / sizeof(*a_fields);
2401 return 0;
2402
2403 fields_error:
2404 free(a_fields);
2405 alloc_error:
2406 return len;
2407 }
2408
2409 /*
2410 * Returns 0 on success, negative error value on error.
2411 */
2412 int ustctl_reply_register_channel(int sock,
2413 uint32_t chan_id,
2414 enum ustctl_channel_header header_type,
2415 int ret_code)
2416 {
2417 ssize_t len;
2418 struct {
2419 struct ustcomm_notify_hdr header;
2420 struct ustcomm_notify_channel_reply r;
2421 } reply;
2422
2423 memset(&reply, 0, sizeof(reply));
2424 reply.header.notify_cmd = USTCTL_NOTIFY_CMD_CHANNEL;
2425 reply.r.ret_code = ret_code;
2426 reply.r.chan_id = chan_id;
2427 switch (header_type) {
2428 case USTCTL_CHANNEL_HEADER_COMPACT:
2429 reply.r.header_type = 1;
2430 break;
2431 case USTCTL_CHANNEL_HEADER_LARGE:
2432 reply.r.header_type = 2;
2433 break;
2434 default:
2435 reply.r.header_type = 0;
2436 break;
2437 }
2438 len = ustcomm_send_unix_sock(sock, &reply, sizeof(reply));
2439 if (len > 0 && len != sizeof(reply))
2440 return -EIO;
2441 if (len < 0)
2442 return len;
2443 return 0;
2444 }
2445
2446 /* Regenerate the statedump. */
2447 int ustctl_regenerate_statedump(int sock, int handle)
2448 {
2449 struct ustcomm_ust_msg lum;
2450 struct ustcomm_ust_reply lur;
2451 int ret;
2452
2453 memset(&lum, 0, sizeof(lum));
2454 lum.handle = handle;
2455 lum.cmd = LTTNG_UST_SESSION_STATEDUMP;
2456 ret = ustcomm_send_app_cmd(sock, &lum, &lur);
2457 if (ret)
2458 return ret;
2459 DBG("Regenerated statedump for handle %u", handle);
2460 return 0;
2461 }
2462
2463 /* counter operations */
2464
2465 int ustctl_get_nr_cpu_per_counter(void)
2466 {
2467 return lttng_counter_num_possible_cpus();
2468 }
2469
2470 struct ustctl_daemon_counter *
2471 ustctl_create_counter(size_t nr_dimensions,
2472 const struct ustctl_counter_dimension *dimensions,
2473 int64_t global_sum_step,
2474 int global_counter_fd,
2475 int nr_counter_cpu_fds,
2476 const int *counter_cpu_fds,
2477 enum ustctl_counter_bitness bitness,
2478 enum ustctl_counter_arithmetic arithmetic,
2479 uint32_t alloc_flags)
2480 {
2481 const char *transport_name;
2482 struct ustctl_daemon_counter *counter;
2483 struct lttng_counter_transport *transport;
2484 struct lttng_counter_dimension ust_dim[LTTNG_COUNTER_DIMENSION_MAX];
2485 size_t i;
2486
2487 if (nr_dimensions > LTTNG_COUNTER_DIMENSION_MAX)
2488 return NULL;
2489 /* Currently, only per-cpu allocation is supported. */
2490 switch (alloc_flags) {
2491 case USTCTL_COUNTER_ALLOC_PER_CPU:
2492 break;
2493
2494 case USTCTL_COUNTER_ALLOC_PER_CPU | USTCTL_COUNTER_ALLOC_GLOBAL:
2495 case USTCTL_COUNTER_ALLOC_GLOBAL:
2496 default:
2497 return NULL;
2498 }
2499 switch (bitness) {
2500 case USTCTL_COUNTER_BITNESS_32:
2501 switch (arithmetic) {
2502 case USTCTL_COUNTER_ARITHMETIC_MODULAR:
2503 transport_name = "counter-per-cpu-32-modular";
2504 break;
2505 case USTCTL_COUNTER_ARITHMETIC_SATURATION:
2506 transport_name = "counter-per-cpu-32-saturation";
2507 break;
2508 default:
2509 return NULL;
2510 }
2511 break;
2512 case USTCTL_COUNTER_BITNESS_64:
2513 switch (arithmetic) {
2514 case USTCTL_COUNTER_ARITHMETIC_MODULAR:
2515 transport_name = "counter-per-cpu-64-modular";
2516 break;
2517 case USTCTL_COUNTER_ARITHMETIC_SATURATION:
2518 transport_name = "counter-per-cpu-64-saturation";
2519 break;
2520 default:
2521 return NULL;
2522 }
2523 break;
2524 default:
2525 return NULL;
2526 }
2527
2528 transport = lttng_counter_transport_find(transport_name);
2529 if (!transport) {
2530 DBG("LTTng transport %s not found\n",
2531 transport_name);
2532 return NULL;
2533 }
2534
2535 counter = zmalloc(sizeof(*counter));
2536 if (!counter)
2537 return NULL;
2538 counter->attr = zmalloc(sizeof(*counter->attr));
2539 if (!counter->attr)
2540 goto free_counter;
2541 counter->attr->bitness = bitness;
2542 counter->attr->arithmetic = arithmetic;
2543 counter->attr->nr_dimensions = nr_dimensions;
2544 counter->attr->global_sum_step = global_sum_step;
2545 for (i = 0; i < nr_dimensions; i++)
2546 counter->attr->dimensions[i] = dimensions[i];
2547
2548 for (i = 0; i < nr_dimensions; i++) {
2549 ust_dim[i].size = dimensions[i].size;
2550 ust_dim[i].underflow_index = dimensions[i].underflow_index;
2551 ust_dim[i].overflow_index = dimensions[i].overflow_index;
2552 ust_dim[i].has_underflow = dimensions[i].has_underflow;
2553 ust_dim[i].has_overflow = dimensions[i].has_overflow;
2554 }
2555 counter->counter = transport->ops.counter_create(nr_dimensions,
2556 ust_dim, global_sum_step, global_counter_fd,
2557 nr_counter_cpu_fds, counter_cpu_fds, true);
2558 if (!counter->counter)
2559 goto free_attr;
2560 counter->ops = &transport->ops;
2561 return counter;
2562
2563 free_attr:
2564 free(counter->attr);
2565 free_counter:
2566 free(counter);
2567 return NULL;
2568 }
2569
2570 int ustctl_create_counter_data(struct ustctl_daemon_counter *counter,
2571 struct lttng_ust_object_data **_counter_data)
2572 {
2573 struct lttng_ust_object_data *counter_data;
2574 struct lttng_ust_counter_conf counter_conf = {0};
2575 size_t i;
2576 int ret;
2577
2578 switch (counter->attr->arithmetic) {
2579 case USTCTL_COUNTER_ARITHMETIC_MODULAR:
2580 counter_conf.arithmetic = LTTNG_UST_COUNTER_ARITHMETIC_MODULAR;
2581 break;
2582 case USTCTL_COUNTER_ARITHMETIC_SATURATION:
2583 counter_conf.arithmetic = LTTNG_UST_COUNTER_ARITHMETIC_SATURATION;
2584 break;
2585 default:
2586 return -EINVAL;
2587 }
2588 switch (counter->attr->bitness) {
2589 case USTCTL_COUNTER_BITNESS_32:
2590 counter_conf.bitness = LTTNG_UST_COUNTER_BITNESS_32;
2591 break;
2592 case USTCTL_COUNTER_BITNESS_64:
2593 counter_conf.bitness = LTTNG_UST_COUNTER_BITNESS_64;
2594 break;
2595 default:
2596 return -EINVAL;
2597 }
2598 counter_conf.number_dimensions = counter->attr->nr_dimensions;
2599 counter_conf.global_sum_step = counter->attr->global_sum_step;
2600 for (i = 0; i < counter->attr->nr_dimensions; i++) {
2601 counter_conf.dimensions[i].size = counter->attr->dimensions[i].size;
2602 counter_conf.dimensions[i].underflow_index = counter->attr->dimensions[i].underflow_index;
2603 counter_conf.dimensions[i].overflow_index = counter->attr->dimensions[i].overflow_index;
2604 counter_conf.dimensions[i].has_underflow = counter->attr->dimensions[i].has_underflow;
2605 counter_conf.dimensions[i].has_overflow = counter->attr->dimensions[i].has_overflow;
2606 }
2607
2608 counter_data = zmalloc(sizeof(*counter_data));
2609 if (!counter_data) {
2610 ret = -ENOMEM;
2611 goto error_alloc;
2612 }
2613 counter_data->type = LTTNG_UST_OBJECT_TYPE_COUNTER;
2614 counter_data->handle = -1;
2615
2616 counter_data->size = sizeof(counter_conf);
2617 counter_data->u.counter.data = zmalloc(sizeof(counter_conf));
2618 if (!counter_data->u.counter.data) {
2619 ret = -ENOMEM;
2620 goto error_alloc_data;
2621 }
2622
2623 memcpy(counter_data->u.counter.data, &counter_conf, sizeof(counter_conf));
2624 *_counter_data = counter_data;
2625
2626 return 0;
2627
2628 error_alloc_data:
2629 free(counter_data);
2630 error_alloc:
2631 return ret;
2632 }
2633
2634 int ustctl_create_counter_global_data(struct ustctl_daemon_counter *counter,
2635 struct lttng_ust_object_data **_counter_global_data)
2636 {
2637 struct lttng_ust_object_data *counter_global_data;
2638 int ret, fd;
2639 size_t len;
2640
2641 if (lttng_counter_get_global_shm(counter->counter, &fd, &len))
2642 return -EINVAL;
2643 counter_global_data = zmalloc(sizeof(*counter_global_data));
2644 if (!counter_global_data) {
2645 ret = -ENOMEM;
2646 goto error_alloc;
2647 }
2648 counter_global_data->type = LTTNG_UST_OBJECT_TYPE_COUNTER_GLOBAL;
2649 counter_global_data->handle = -1;
2650 counter_global_data->size = len;
2651 counter_global_data->u.counter_global.shm_fd = fd;
2652 *_counter_global_data = counter_global_data;
2653 return 0;
2654
2655 error_alloc:
2656 return ret;
2657 }
2658
2659 int ustctl_create_counter_cpu_data(struct ustctl_daemon_counter *counter, int cpu,
2660 struct lttng_ust_object_data **_counter_cpu_data)
2661 {
2662 struct lttng_ust_object_data *counter_cpu_data;
2663 int ret, fd;
2664 size_t len;
2665
2666 if (lttng_counter_get_cpu_shm(counter->counter, cpu, &fd, &len))
2667 return -EINVAL;
2668 counter_cpu_data = zmalloc(sizeof(*counter_cpu_data));
2669 if (!counter_cpu_data) {
2670 ret = -ENOMEM;
2671 goto error_alloc;
2672 }
2673 counter_cpu_data->type = LTTNG_UST_OBJECT_TYPE_COUNTER_CPU;
2674 counter_cpu_data->handle = -1;
2675 counter_cpu_data->size = len;
2676 counter_cpu_data->u.counter_cpu.shm_fd = fd;
2677 counter_cpu_data->u.counter_cpu.cpu_nr = cpu;
2678 *_counter_cpu_data = counter_cpu_data;
2679 return 0;
2680
2681 error_alloc:
2682 return ret;
2683 }
2684
2685 void ustctl_destroy_counter(struct ustctl_daemon_counter *counter)
2686 {
2687 counter->ops->counter_destroy(counter->counter);
2688 free(counter->attr);
2689 free(counter);
2690 }
2691
2692 int ustctl_send_counter_data_to_ust(int sock, int parent_handle,
2693 struct lttng_ust_object_data *counter_data)
2694 {
2695 struct ustcomm_ust_msg lum;
2696 struct ustcomm_ust_reply lur;
2697 int ret;
2698 size_t size;
2699 ssize_t len;
2700
2701 if (!counter_data)
2702 return -EINVAL;
2703
2704 size = counter_data->size;
2705 memset(&lum, 0, sizeof(lum));
2706 lum.handle = parent_handle;
2707 lum.cmd = LTTNG_UST_COUNTER;
2708 lum.u.counter.len = size;
2709 ret = ustcomm_send_app_msg(sock, &lum);
2710 if (ret)
2711 return ret;
2712
2713 /* Send counter data */
2714 len = ustcomm_send_unix_sock(sock, counter_data->u.counter.data, size);
2715 if (len != size) {
2716 if (len < 0)
2717 return len;
2718 else
2719 return -EIO;
2720 }
2721
2722 ret = ustcomm_recv_app_reply(sock, &lur, lum.handle, lum.cmd);
2723 if (!ret) {
2724 counter_data->handle = lur.ret_val;
2725 }
2726 return ret;
2727 }
2728
2729 int ustctl_send_counter_global_data_to_ust(int sock,
2730 struct lttng_ust_object_data *counter_data,
2731 struct lttng_ust_object_data *counter_global_data)
2732 {
2733 struct ustcomm_ust_msg lum;
2734 struct ustcomm_ust_reply lur;
2735 int ret, shm_fd[1];
2736 size_t size;
2737 ssize_t len;
2738
2739 if (!counter_data || !counter_global_data)
2740 return -EINVAL;
2741
2742 size = counter_global_data->size;
2743 memset(&lum, 0, sizeof(lum));
2744 lum.handle = counter_data->handle; /* parent handle */
2745 lum.cmd = LTTNG_UST_COUNTER_GLOBAL;
2746 lum.u.counter_global.len = size;
2747 ret = ustcomm_send_app_msg(sock, &lum);
2748 if (ret)
2749 return ret;
2750
2751 shm_fd[0] = counter_global_data->u.counter_global.shm_fd;
2752 len = ustcomm_send_fds_unix_sock(sock, shm_fd, 1);
2753 if (len <= 0) {
2754 if (len < 0)
2755 return len;
2756 else
2757 return -EIO;
2758 }
2759
2760 ret = ustcomm_recv_app_reply(sock, &lur, lum.handle, lum.cmd);
2761 if (!ret) {
2762 counter_global_data->handle = lur.ret_val;
2763 }
2764 return ret;
2765 }
2766
2767 int ustctl_send_counter_cpu_data_to_ust(int sock,
2768 struct lttng_ust_object_data *counter_data,
2769 struct lttng_ust_object_data *counter_cpu_data)
2770 {
2771 struct ustcomm_ust_msg lum;
2772 struct ustcomm_ust_reply lur;
2773 int ret, shm_fd[1];
2774 size_t size;
2775 ssize_t len;
2776
2777 if (!counter_data || !counter_cpu_data)
2778 return -EINVAL;
2779
2780 size = counter_cpu_data->size;
2781 memset(&lum, 0, sizeof(lum));
2782 lum.handle = counter_data->handle; /* parent handle */
2783 lum.cmd = LTTNG_UST_COUNTER_CPU;
2784 lum.u.counter_cpu.len = size;
2785 lum.u.counter_cpu.cpu_nr = counter_cpu_data->u.counter_cpu.cpu_nr;
2786 ret = ustcomm_send_app_msg(sock, &lum);
2787 if (ret)
2788 return ret;
2789
2790 shm_fd[0] = counter_cpu_data->u.counter_global.shm_fd;
2791 len = ustcomm_send_fds_unix_sock(sock, shm_fd, 1);
2792 if (len <= 0) {
2793 if (len < 0)
2794 return len;
2795 else
2796 return -EIO;
2797 }
2798
2799 ret = ustcomm_recv_app_reply(sock, &lur, lum.handle, lum.cmd);
2800 if (!ret) {
2801 counter_cpu_data->handle = lur.ret_val;
2802 }
2803 return ret;
2804 }
2805
2806 int ustctl_counter_read(struct ustctl_daemon_counter *counter,
2807 const size_t *dimension_indexes,
2808 int cpu, int64_t *value,
2809 bool *overflow, bool *underflow)
2810 {
2811 return counter->ops->counter_read(counter->counter, dimension_indexes, cpu,
2812 value, overflow, underflow);
2813 }
2814
2815 int ustctl_counter_aggregate(struct ustctl_daemon_counter *counter,
2816 const size_t *dimension_indexes,
2817 int64_t *value,
2818 bool *overflow, bool *underflow)
2819 {
2820 return counter->ops->counter_aggregate(counter->counter, dimension_indexes,
2821 value, overflow, underflow);
2822 }
2823
2824 int ustctl_counter_clear(struct ustctl_daemon_counter *counter,
2825 const size_t *dimension_indexes)
2826 {
2827 return counter->ops->counter_clear(counter->counter, dimension_indexes);
2828 }
2829
2830 static __attribute__((constructor))
2831 void ustctl_init(void)
2832 {
2833 init_usterr();
2834 lttng_ust_getenv_init(); /* Needs init_usterr() to be completed. */
2835 lttng_ust_clock_init();
2836 lttng_ring_buffer_metadata_client_init();
2837 lttng_ring_buffer_client_overwrite_init();
2838 lttng_ring_buffer_client_overwrite_rt_init();
2839 lttng_ring_buffer_client_discard_init();
2840 lttng_ring_buffer_client_discard_rt_init();
2841 lttng_counter_client_percpu_32_modular_init();
2842 lttng_counter_client_percpu_64_modular_init();
2843 lib_ringbuffer_signal_init();
2844 }
2845
2846 static __attribute__((destructor))
2847 void ustctl_exit(void)
2848 {
2849 lttng_ring_buffer_client_discard_rt_exit();
2850 lttng_ring_buffer_client_discard_exit();
2851 lttng_ring_buffer_client_overwrite_rt_exit();
2852 lttng_ring_buffer_client_overwrite_exit();
2853 lttng_ring_buffer_metadata_client_exit();
2854 lttng_counter_client_percpu_32_modular_exit();
2855 lttng_counter_client_percpu_64_modular_exit();
2856 }
LTTng 2.0 Userspace Tracer
This page took 0.155379 seconds and 4 git commands to generate.