projects / lttng-tools.git / blob
? search:


a117575b74c45ae067ed9ac31fccc6952a3e9fd0
[lttng-tools.git] / src / bin / lttng-sessiond / kernel.c
1 /*
2 * Copyright (C) 2011 David Goulet <david.goulet@polymtl.ca>
3 *
4 * SPDX-License-Identifier: GPL-2.0-only
5 *
6 */
7
8 #include "bin/lttng-sessiond/tracker.h"
9 #include "common/tracker.h"
10 #include "common/utils.h"
11 #include "lttng/event.h"
12 #include "lttng/lttng-error.h"
13 #include "lttng/tracker.h"
14 #define _LGPL_SOURCE
15 #include <fcntl.h>
16 #include <stdlib.h>
17 #include <stdio.h>
18 #include <string.h>
19 #include <unistd.h>
20 #include <inttypes.h>
21 #include <sys/types.h>
22
23 #include <common/common.h>
24 #include <common/trace-chunk.h>
25 #include <common/kernel-ctl/kernel-ctl.h>
26 #include <common/kernel-ctl/kernel-ioctl.h>
27 #include <common/sessiond-comm/sessiond-comm.h>
28
29 #include "lttng-sessiond.h"
30 #include "lttng-syscall.h"
31 #include "consumer.h"
32 #include "kernel.h"
33 #include "kernel-consumer.h"
34 #include "kern-modules.h"
35 #include "utils.h"
36 #include "rotate.h"
37 #include "modprobe.h"
38
39 /*
40 * Key used to reference a channel between the sessiond and the consumer. This
41 * is only read and updated with the session_list lock held.
42 */
43 static uint64_t next_kernel_channel_key;
44
45 static const char *module_proc_lttng = "/proc/lttng";
46
47 static int kernel_tracer_fd = -1;
48
49 #include <lttng/userspace-probe.h>
50 #include <lttng/userspace-probe-internal.h>
51 /*
52 * Add context on a kernel channel.
53 *
54 * Assumes the ownership of ctx.
55 */
56 int kernel_add_channel_context(struct ltt_kernel_channel *chan,
57 struct ltt_kernel_context *ctx)
58 {
59 int ret;
60
61 assert(chan);
62 assert(ctx);
63
64 DBG("Adding context to channel %s", chan->channel->name);
65 ret = kernctl_add_context(chan->fd, &ctx->ctx);
66 if (ret < 0) {
67 switch (-ret) {
68 case ENOSYS:
69 /* Exists but not available for this kernel */
70 ret = LTTNG_ERR_KERN_CONTEXT_UNAVAILABLE;
71 goto error;
72 case EEXIST:
73 /* If EEXIST, we just ignore the error */
74 ret = 0;
75 goto end;
76 default:
77 PERROR("add context ioctl");
78 ret = LTTNG_ERR_KERN_CONTEXT_FAIL;
79 goto error;
80 }
81 }
82 ret = 0;
83
84 end:
85 cds_list_add_tail(&ctx->list, &chan->ctx_list);
86 ctx->in_list = true;
87 ctx = NULL;
88 error:
89 if (ctx) {
90 trace_kernel_destroy_context(ctx);
91 }
92 return ret;
93 }
94
95 /*
96 * Create a new kernel session, register it to the kernel tracer and add it to
97 * the session daemon session.
98 */
99 int kernel_create_session(struct ltt_session *session)
100 {
101 int ret;
102 struct ltt_kernel_session *lks;
103
104 assert(session);
105
106 /* Allocate data structure */
107 lks = trace_kernel_create_session();
108 if (lks == NULL) {
109 ret = -1;
110 goto error;
111 }
112
113 /* Kernel tracer session creation */
114 ret = kernctl_create_session(kernel_tracer_fd);
115 if (ret < 0) {
116 PERROR("ioctl kernel create session");
117 goto error;
118 }
119
120 lks->fd = ret;
121 /* Prevent fd duplication after execlp() */
122 ret = fcntl(lks->fd, F_SETFD, FD_CLOEXEC);
123 if (ret < 0) {
124 PERROR("fcntl session fd");
125 }
126
127 lks->id = session->id;
128 lks->consumer_fds_sent = 0;
129 session->kernel_session = lks;
130
131 DBG("Kernel session created (fd: %d)", lks->fd);
132
133 /*
134 * This is necessary since the creation time is present in the session
135 * name when it is generated.
136 */
137 if (session->has_auto_generated_name) {
138 ret = kernctl_session_set_name(lks->fd, DEFAULT_SESSION_NAME);
139 } else {
140 ret = kernctl_session_set_name(lks->fd, session->name);
141 }
142 if (ret) {
143 WARN("Could not set kernel session name for session %" PRIu64 " name: %s",
144 session->id, session->name);
145 }
146
147 ret = kernctl_session_set_creation_time(lks->fd, session->creation_time);
148 if (ret) {
149 WARN("Could not set kernel session creation time for session %" PRIu64 " name: %s",
150 session->id, session->name);
151 }
152
153 return 0;
154
155 error:
156 if (lks) {
157 trace_kernel_destroy_session(lks);
158 trace_kernel_free_session(lks);
159 }
160 return ret;
161 }
162
163 /*
164 * Create a kernel channel, register it to the kernel tracer and add it to the
165 * kernel session.
166 */
167 int kernel_create_channel(struct ltt_kernel_session *session,
168 struct lttng_channel *chan)
169 {
170 int ret;
171 struct ltt_kernel_channel *lkc;
172
173 assert(session);
174 assert(chan);
175
176 /* Allocate kernel channel */
177 lkc = trace_kernel_create_channel(chan);
178 if (lkc == NULL) {
179 goto error;
180 }
181
182 DBG3("Kernel create channel %s with attr: %d, %" PRIu64 ", %" PRIu64 ", %u, %u, %d, %d",
183 chan->name, lkc->channel->attr.overwrite,
184 lkc->channel->attr.subbuf_size, lkc->channel->attr.num_subbuf,
185 lkc->channel->attr.switch_timer_interval, lkc->channel->attr.read_timer_interval,
186 lkc->channel->attr.live_timer_interval, lkc->channel->attr.output);
187
188 /* Kernel tracer channel creation */
189 ret = kernctl_create_channel(session->fd, &lkc->channel->attr);
190 if (ret < 0) {
191 PERROR("ioctl kernel create channel");
192 goto error;
193 }
194
195 /* Setup the channel fd */
196 lkc->fd = ret;
197 /* Prevent fd duplication after execlp() */
198 ret = fcntl(lkc->fd, F_SETFD, FD_CLOEXEC);
199 if (ret < 0) {
200 PERROR("fcntl session fd");
201 }
202
203 /* Add channel to session */
204 cds_list_add(&lkc->list, &session->channel_list.head);
205 session->channel_count++;
206 lkc->session = session;
207 lkc->key = ++next_kernel_channel_key;
208
209 DBG("Kernel channel %s created (fd: %d, key: %" PRIu64 ")",
210 lkc->channel->name, lkc->fd, lkc->key);
211
212 return 0;
213
214 error:
215 if (lkc) {
216 free(lkc->channel);
217 free(lkc);
218 }
219 return -1;
220 }
221
222 /*
223 * Compute the offset of the instrumentation byte in the binary based on the
224 * function probe location using the ELF lookup method.
225 *
226 * Returns 0 on success and set the offset out parameter to the offset of the
227 * elf symbol
228 * Returns -1 on error
229 */
230 static
231 int extract_userspace_probe_offset_function_elf(
232 const struct lttng_userspace_probe_location *probe_location,
233 struct ltt_kernel_session *session, uint64_t *offset)
234 {
235 int fd;
236 int ret = 0;
237 const char *symbol = NULL;
238 const struct lttng_userspace_probe_location_lookup_method *lookup = NULL;
239 enum lttng_userspace_probe_location_lookup_method_type lookup_method_type;
240
241 assert(lttng_userspace_probe_location_get_type(probe_location) ==
242 LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION);
243
244 lookup = lttng_userspace_probe_location_get_lookup_method(
245 probe_location);
246 if (!lookup) {
247 ret = -1;
248 goto end;
249 }
250
251 lookup_method_type =
252 lttng_userspace_probe_location_lookup_method_get_type(lookup);
253
254 assert(lookup_method_type ==
255 LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_ELF);
256
257 symbol = lttng_userspace_probe_location_function_get_function_name(
258 probe_location);
259 if (!symbol) {
260 ret = -1;
261 goto end;
262 }
263
264 fd = lttng_userspace_probe_location_function_get_binary_fd(probe_location);
265 if (fd < 0) {
266 ret = -1;
267 goto end;
268 }
269
270 ret = run_as_extract_elf_symbol_offset(fd, symbol, session->uid,
271 session->gid, offset);
272 if (ret < 0) {
273 DBG("userspace probe offset calculation failed for "
274 "function %s", symbol);
275 goto end;
276 }
277
278 DBG("userspace probe elf offset for %s is 0x%jd", symbol, (intmax_t)(*offset));
279 end:
280 return ret;
281 }
282
283 /*
284 * Compute the offsets of the instrumentation bytes in the binary based on the
285 * tracepoint probe location using the SDT lookup method. This function
286 * allocates the offsets buffer, the caller must free it.
287 *
288 * Returns 0 on success and set the offset out parameter to the offsets of the
289 * SDT tracepoint.
290 * Returns -1 on error.
291 */
292 static
293 int extract_userspace_probe_offset_tracepoint_sdt(
294 const struct lttng_userspace_probe_location *probe_location,
295 struct ltt_kernel_session *session, uint64_t **offsets,
296 uint32_t *offsets_count)
297 {
298 enum lttng_userspace_probe_location_lookup_method_type lookup_method_type;
299 const struct lttng_userspace_probe_location_lookup_method *lookup = NULL;
300 const char *probe_name = NULL, *provider_name = NULL;
301 int ret = 0;
302 int fd, i;
303
304 assert(lttng_userspace_probe_location_get_type(probe_location) ==
305 LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT);
306
307 lookup = lttng_userspace_probe_location_get_lookup_method(probe_location);
308 if (!lookup) {
309 ret = -1;
310 goto end;
311 }
312
313 lookup_method_type =
314 lttng_userspace_probe_location_lookup_method_get_type(lookup);
315
316 assert(lookup_method_type ==
317 LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_TRACEPOINT_SDT);
318
319
320 probe_name = lttng_userspace_probe_location_tracepoint_get_probe_name(
321 probe_location);
322 if (!probe_name) {
323 ret = -1;
324 goto end;
325 }
326
327 provider_name = lttng_userspace_probe_location_tracepoint_get_provider_name(
328 probe_location);
329 if (!provider_name) {
330 ret = -1;
331 goto end;
332 }
333
334 fd = lttng_userspace_probe_location_tracepoint_get_binary_fd(probe_location);
335 if (fd < 0) {
336 ret = -1;
337 goto end;
338 }
339
340 ret = run_as_extract_sdt_probe_offsets(fd, provider_name, probe_name,
341 session->uid, session->gid, offsets, offsets_count);
342 if (ret < 0) {
343 DBG("userspace probe offset calculation failed for sdt "
344 "probe %s:%s", provider_name, probe_name);
345 goto end;
346 }
347
348 if (*offsets_count == 0) {
349 DBG("no userspace probe offset found");
350 goto end;
351 }
352
353 DBG("%u userspace probe SDT offsets found for %s:%s at:",
354 *offsets_count, provider_name, probe_name);
355 for (i = 0; i < *offsets_count; i++) {
356 DBG("\t0x%jd", (intmax_t)((*offsets)[i]));
357 }
358 end:
359 return ret;
360 }
361
362 /*
363 * Extract the offsets of the instrumentation point for the different lookup
364 * methods.
365 */
366 static
367 int userspace_probe_add_callsites(struct lttng_event *ev,
368 struct ltt_kernel_session *session, int fd)
369 {
370 const struct lttng_userspace_probe_location_lookup_method *lookup_method = NULL;
371 enum lttng_userspace_probe_location_lookup_method_type type;
372 const struct lttng_userspace_probe_location *location = NULL;
373 int ret;
374
375 assert(ev);
376 assert(ev->type == LTTNG_EVENT_USERSPACE_PROBE);
377
378 location = lttng_event_get_userspace_probe_location(ev);
379 if (!location) {
380 ret = -1;
381 goto end;
382 }
383 lookup_method =
384 lttng_userspace_probe_location_get_lookup_method(location);
385 if (!lookup_method) {
386 ret = -1;
387 goto end;
388 }
389
390 type = lttng_userspace_probe_location_lookup_method_get_type(lookup_method);
391 switch (type) {
392 case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_ELF:
393 {
394 struct lttng_kernel_event_callsite callsite;
395 uint64_t offset;
396
397 ret = extract_userspace_probe_offset_function_elf(location, session, &offset);
398 if (ret) {
399 ret = LTTNG_ERR_PROBE_LOCATION_INVAL;
400 goto end;
401 }
402
403 callsite.u.uprobe.offset = offset;
404 ret = kernctl_add_callsite(fd, &callsite);
405 if (ret) {
406 WARN("Adding callsite to userspace probe "
407 "event %s failed.", ev->name);
408 ret = LTTNG_ERR_KERN_ENABLE_FAIL;
409 goto end;
410 }
411 break;
412 }
413 case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_TRACEPOINT_SDT:
414 {
415 int i;
416 uint64_t *offsets = NULL;
417 uint32_t offsets_count;
418 struct lttng_kernel_event_callsite callsite;
419
420 /*
421 * This call allocates the offsets buffer. This buffer must be freed
422 * by the caller
423 */
424 ret = extract_userspace_probe_offset_tracepoint_sdt(location, session,
425 &offsets, &offsets_count);
426 if (ret) {
427 ret = LTTNG_ERR_PROBE_LOCATION_INVAL;
428 goto end;
429 }
430 for (i = 0; i < offsets_count; i++) {
431 callsite.u.uprobe.offset = offsets[i];
432 ret = kernctl_add_callsite(fd, &callsite);
433 if (ret) {
434 WARN("Adding callsite to userspace probe "
435 "event %s failed.", ev->name);
436 ret = LTTNG_ERR_KERN_ENABLE_FAIL;
437 free(offsets);
438 goto end;
439 }
440 }
441 free(offsets);
442 break;
443 }
444 default:
445 ret = LTTNG_ERR_PROBE_LOCATION_INVAL;
446 goto end;
447 }
448 end:
449 return ret;
450 }
451
452 /*
453 * Create a kernel event, enable it to the kernel tracer and add it to the
454 * channel event list of the kernel session.
455 * We own filter_expression and filter.
456 */
457 int kernel_create_event(struct lttng_event *ev,
458 struct ltt_kernel_channel *channel,
459 char *filter_expression,
460 struct lttng_filter_bytecode *filter)
461 {
462 int err, fd;
463 enum lttng_error_code ret;
464 struct ltt_kernel_event *event;
465
466 assert(ev);
467 assert(channel);
468
469 /* We pass ownership of filter_expression and filter */
470 ret = trace_kernel_create_event(ev, filter_expression,
471 filter, &event);
472 if (ret != LTTNG_OK) {
473 goto error;
474 }
475
476 fd = kernctl_create_event(channel->fd, event->event);
477 if (fd < 0) {
478 switch (-fd) {
479 case EEXIST:
480 ret = LTTNG_ERR_KERN_EVENT_EXIST;
481 break;
482 case ENOSYS:
483 WARN("Event type not implemented");
484 ret = LTTNG_ERR_KERN_EVENT_ENOSYS;
485 break;
486 case ENOENT:
487 WARN("Event %s not found!", ev->name);
488 ret = LTTNG_ERR_KERN_ENABLE_FAIL;
489 break;
490 default:
491 ret = LTTNG_ERR_KERN_ENABLE_FAIL;
492 PERROR("create event ioctl");
493 }
494 goto free_event;
495 }
496
497 event->type = ev->type;
498 event->fd = fd;
499 /* Prevent fd duplication after execlp() */
500 err = fcntl(event->fd, F_SETFD, FD_CLOEXEC);
501 if (err < 0) {
502 PERROR("fcntl session fd");
503 }
504
505 if (filter) {
506 err = kernctl_filter(event->fd, filter);
507 if (err < 0) {
508 switch (-err) {
509 case ENOMEM:
510 ret = LTTNG_ERR_FILTER_NOMEM;
511 break;
512 default:
513 ret = LTTNG_ERR_FILTER_INVAL;
514 break;
515 }
516 goto filter_error;
517 }
518 }
519
520 if (ev->type == LTTNG_EVENT_USERSPACE_PROBE) {
521 ret = userspace_probe_add_callsites(ev, channel->session, event->fd);
522 if (ret) {
523 goto add_callsite_error;
524 }
525 }
526
527 err = kernctl_enable(event->fd);
528 if (err < 0) {
529 switch (-err) {
530 case EEXIST:
531 ret = LTTNG_ERR_KERN_EVENT_EXIST;
532 break;
533 default:
534 PERROR("enable kernel event");
535 ret = LTTNG_ERR_KERN_ENABLE_FAIL;
536 break;
537 }
538 goto enable_error;
539 }
540
541 /* Add event to event list */
542 cds_list_add(&event->list, &channel->events_list.head);
543 channel->event_count++;
544
545 DBG("Event %s created (fd: %d)", ev->name, event->fd);
546
547 return 0;
548
549 add_callsite_error:
550 enable_error:
551 filter_error:
552 {
553 int closeret;
554
555 closeret = close(event->fd);
556 if (closeret) {
557 PERROR("close event fd");
558 }
559 }
560 free_event:
561 free(event);
562 error:
563 return ret;
564 }
565
566 /*
567 * Disable a kernel channel.
568 */
569 int kernel_disable_channel(struct ltt_kernel_channel *chan)
570 {
571 int ret;
572
573 assert(chan);
574
575 ret = kernctl_disable(chan->fd);
576 if (ret < 0) {
577 PERROR("disable chan ioctl");
578 goto error;
579 }
580
581 chan->enabled = 0;
582 DBG("Kernel channel %s disabled (fd: %d, key: %" PRIu64 ")",
583 chan->channel->name, chan->fd, chan->key);
584
585 return 0;
586
587 error:
588 return ret;
589 }
590
591 /*
592 * Enable a kernel channel.
593 */
594 int kernel_enable_channel(struct ltt_kernel_channel *chan)
595 {
596 int ret;
597
598 assert(chan);
599
600 ret = kernctl_enable(chan->fd);
601 if (ret < 0 && ret != -EEXIST) {
602 PERROR("Enable kernel chan");
603 goto error;
604 }
605
606 chan->enabled = 1;
607 DBG("Kernel channel %s enabled (fd: %d, key: %" PRIu64 ")",
608 chan->channel->name, chan->fd, chan->key);
609
610 return 0;
611
612 error:
613 return ret;
614 }
615
616 /*
617 * Enable a kernel event.
618 */
619 int kernel_enable_event(struct ltt_kernel_event *event)
620 {
621 int ret;
622
623 assert(event);
624
625 ret = kernctl_enable(event->fd);
626 if (ret < 0) {
627 switch (-ret) {
628 case EEXIST:
629 ret = LTTNG_ERR_KERN_EVENT_EXIST;
630 break;
631 default:
632 PERROR("enable kernel event");
633 break;
634 }
635 goto error;
636 }
637
638 event->enabled = 1;
639 DBG("Kernel event %s enabled (fd: %d)", event->event->name, event->fd);
640
641 return 0;
642
643 error:
644 return ret;
645 }
646
647 /*
648 * Disable a kernel event.
649 */
650 int kernel_disable_event(struct ltt_kernel_event *event)
651 {
652 int ret;
653
654 assert(event);
655
656 ret = kernctl_disable(event->fd);
657 if (ret < 0) {
658 switch (-ret) {
659 case EEXIST:
660 ret = LTTNG_ERR_KERN_EVENT_EXIST;
661 break;
662 default:
663 PERROR("disable kernel event");
664 break;
665 }
666 goto error;
667 }
668
669 event->enabled = 0;
670 DBG("Kernel event %s disabled (fd: %d)", event->event->name, event->fd);
671
672 return 0;
673
674 error:
675 return ret;
676 }
677
678 static
679 struct process_attr_tracker *_kernel_get_process_attr_tracker(
680 struct ltt_kernel_session *session,
681 enum lttng_process_attr process_attr)
682 {
683 switch (process_attr) {
684 case LTTNG_PROCESS_ATTR_PROCESS_ID:
685 return session->tracker_pid;
686 case LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID:
687 return session->tracker_vpid;
688 case LTTNG_PROCESS_ATTR_USER_ID:
689 return session->tracker_uid;
690 case LTTNG_PROCESS_ATTR_VIRTUAL_USER_ID:
691 return session->tracker_vuid;
692 case LTTNG_PROCESS_ATTR_GROUP_ID:
693 return session->tracker_gid;
694 case LTTNG_PROCESS_ATTR_VIRTUAL_GROUP_ID:
695 return session->tracker_vgid;
696 default:
697 return NULL;
698 }
699 }
700
701 const struct process_attr_tracker *kernel_get_process_attr_tracker(
702 struct ltt_kernel_session *session,
703 enum lttng_process_attr process_attr)
704 {
705 return (const struct process_attr_tracker *)
706 _kernel_get_process_attr_tracker(session, process_attr);
707 }
708
709 enum lttng_error_code kernel_process_attr_tracker_set_tracking_policy(
710 struct ltt_kernel_session *session,
711 enum lttng_process_attr process_attr,
712 enum lttng_tracking_policy policy)
713 {
714 int ret;
715 enum lttng_error_code ret_code = LTTNG_OK;
716 struct process_attr_tracker *tracker =
717 _kernel_get_process_attr_tracker(session, process_attr);
718 enum lttng_tracking_policy previous_policy;
719
720 if (!tracker) {
721 ret_code = LTTNG_ERR_INVALID;
722 goto end;
723 }
724
725 previous_policy = process_attr_tracker_get_tracking_policy(tracker);
726 ret = process_attr_tracker_set_tracking_policy(tracker, policy);
727 if (ret) {
728 ret_code = LTTNG_ERR_UNK;
729 goto end;
730 }
731
732 if (previous_policy == policy) {
733 goto end;
734 }
735
736 switch (policy) {
737 case LTTNG_TRACKING_POLICY_INCLUDE_ALL:
738 if (process_attr == LTTNG_PROCESS_ATTR_PROCESS_ID) {
739 /*
740 * Maintain a special case for the process ID process
741 * attribute tracker as it was the only supported
742 * attribute prior to 2.12.
743 */
744 ret = kernctl_track_pid(session->fd, -1);
745 } else {
746 ret = kernctl_track_id(session->fd, process_attr, -1);
747 }
748 break;
749 case LTTNG_TRACKING_POLICY_EXCLUDE_ALL:
750 case LTTNG_TRACKING_POLICY_INCLUDE_SET:
751 /* fall-through. */
752 if (process_attr == LTTNG_PROCESS_ATTR_PROCESS_ID) {
753 /*
754 * Maintain a special case for the process ID process
755 * attribute tracker as it was the only supported
756 * attribute prior to 2.12.
757 */
758 ret = kernctl_untrack_pid(session->fd, -1);
759 } else {
760 ret = kernctl_untrack_id(session->fd, process_attr, -1);
761 }
762 break;
763 default:
764 abort();
765 }
766 /* kern-ctl error handling */
767 switch (-ret) {
768 case 0:
769 ret_code = LTTNG_OK;
770 break;
771 case EINVAL:
772 ret_code = LTTNG_ERR_INVALID;
773 break;
774 case ENOMEM:
775 ret_code = LTTNG_ERR_NOMEM;
776 break;
777 case EEXIST:
778 ret_code = LTTNG_ERR_PROCESS_ATTR_EXISTS;
779 break;
780 default:
781 ret_code = LTTNG_ERR_UNK;
782 break;
783 }
784 end:
785 return ret_code;
786 }
787
788 enum lttng_error_code kernel_process_attr_tracker_inclusion_set_add_value(
789 struct ltt_kernel_session *session,
790 enum lttng_process_attr process_attr,
791 const struct process_attr_value *value)
792 {
793 int ret, integral_value;
794 enum lttng_error_code ret_code;
795 struct process_attr_tracker *tracker;
796 enum process_attr_tracker_status status;
797
798 /*
799 * Convert process attribute tracker value to the integral
800 * representation required by the kern-ctl API.
801 */
802 switch (process_attr) {
803 case LTTNG_PROCESS_ATTR_PROCESS_ID:
804 case LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID:
805 integral_value = (int) value->value.pid;
806 break;
807 case LTTNG_PROCESS_ATTR_USER_ID:
808 case LTTNG_PROCESS_ATTR_VIRTUAL_USER_ID:
809 if (value->type == LTTNG_PROCESS_ATTR_VALUE_TYPE_USER_NAME) {
810 uid_t uid;
811
812 ret_code = utils_user_id_from_name(
813 value->value.user_name, &uid);
814 if (ret_code != LTTNG_OK) {
815 goto end;
816 }
817 integral_value = (int) uid;
818 } else {
819 integral_value = (int) value->value.uid;
820 }
821 break;
822 case LTTNG_PROCESS_ATTR_GROUP_ID:
823 case LTTNG_PROCESS_ATTR_VIRTUAL_GROUP_ID:
824 if (value->type == LTTNG_PROCESS_ATTR_VALUE_TYPE_GROUP_NAME) {
825 gid_t gid;
826
827 ret_code = utils_group_id_from_name(
828 value->value.group_name, &gid);
829 if (ret_code != LTTNG_OK) {
830 goto end;
831 }
832 integral_value = (int) gid;
833 } else {
834 integral_value = (int) value->value.gid;
835 }
836 break;
837 default:
838 ret_code = LTTNG_ERR_INVALID;
839 goto end;
840 }
841
842 tracker = _kernel_get_process_attr_tracker(session, process_attr);
843 if (!tracker) {
844 ret_code = LTTNG_ERR_INVALID;
845 goto end;
846 }
847
848 status = process_attr_tracker_inclusion_set_add_value(tracker, value);
849 if (status != PROCESS_ATTR_TRACKER_STATUS_OK) {
850 switch (status) {
851 case PROCESS_ATTR_TRACKER_STATUS_EXISTS:
852 ret_code = LTTNG_ERR_PROCESS_ATTR_EXISTS;
853 break;
854 case PROCESS_ATTR_TRACKER_STATUS_INVALID_TRACKING_POLICY:
855 ret_code = LTTNG_ERR_PROCESS_ATTR_TRACKER_INVALID_TRACKING_POLICY;
856 break;
857 case PROCESS_ATTR_TRACKER_STATUS_ERROR:
858 default:
859 ret_code = LTTNG_ERR_UNK;
860 break;
861 }
862 goto end;
863 }
864
865 DBG("Kernel track %s %d for session id %" PRIu64,
866 lttng_process_attr_to_string(process_attr),
867 integral_value, session->id);
868 if (process_attr == LTTNG_PROCESS_ATTR_PROCESS_ID) {
869 /*
870 * Maintain a special case for the process ID process attribute
871 * tracker as it was the only supported attribute prior to 2.12.
872 */
873 ret = kernctl_track_pid(session->fd, integral_value);
874 } else {
875 ret = kernctl_track_id(
876 session->fd, process_attr, integral_value);
877 }
878 if (ret == 0) {
879 ret_code = LTTNG_OK;
880 goto end;
881 }
882
883 kernel_wait_quiescent();
884
885 /* kern-ctl error handling */
886 switch (-ret) {
887 case 0:
888 ret_code = LTTNG_OK;
889 break;
890 case EINVAL:
891 ret_code = LTTNG_ERR_INVALID;
892 break;
893 case ENOMEM:
894 ret_code = LTTNG_ERR_NOMEM;
895 break;
896 case EEXIST:
897 ret_code = LTTNG_ERR_PROCESS_ATTR_EXISTS;
898 break;
899 default:
900 ret_code = LTTNG_ERR_UNK;
901 break;
902 }
903
904 /* Attempt to remove the value from the tracker. */
905 status = process_attr_tracker_inclusion_set_remove_value(
906 tracker, value);
907 if (status != PROCESS_ATTR_TRACKER_STATUS_OK) {
908 ERR("Failed to roll-back the tracking of kernel %s process attribute %d while handling a kern-ctl error",
909 lttng_process_attr_to_string(process_attr),
910 integral_value);
911 }
912 end:
913 return ret_code;
914 }
915
916 enum lttng_error_code kernel_process_attr_tracker_inclusion_set_remove_value(
917 struct ltt_kernel_session *session,
918 enum lttng_process_attr process_attr,
919 const struct process_attr_value *value)
920 {
921 int ret, integral_value;
922 enum lttng_error_code ret_code;
923 struct process_attr_tracker *tracker;
924 enum process_attr_tracker_status status;
925
926 /*
927 * Convert process attribute tracker value to the integral
928 * representation required by the kern-ctl API.
929 */
930 switch (process_attr) {
931 case LTTNG_PROCESS_ATTR_PROCESS_ID:
932 case LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID:
933 integral_value = (int) value->value.pid;
934 break;
935 case LTTNG_PROCESS_ATTR_USER_ID:
936 case LTTNG_PROCESS_ATTR_VIRTUAL_USER_ID:
937 if (value->type == LTTNG_PROCESS_ATTR_VALUE_TYPE_USER_NAME) {
938 uid_t uid;
939
940 ret_code = utils_user_id_from_name(
941 value->value.user_name, &uid);
942 if (ret_code != LTTNG_OK) {
943 goto end;
944 }
945 integral_value = (int) uid;
946 } else {
947 integral_value = (int) value->value.uid;
948 }
949 break;
950 case LTTNG_PROCESS_ATTR_GROUP_ID:
951 case LTTNG_PROCESS_ATTR_VIRTUAL_GROUP_ID:
952 if (value->type == LTTNG_PROCESS_ATTR_VALUE_TYPE_GROUP_NAME) {
953 gid_t gid;
954
955 ret_code = utils_group_id_from_name(
956 value->value.group_name, &gid);
957 if (ret_code != LTTNG_OK) {
958 goto end;
959 }
960 integral_value = (int) gid;
961 } else {
962 integral_value = (int) value->value.gid;
963 }
964 break;
965 default:
966 ret_code = LTTNG_ERR_INVALID;
967 goto end;
968 }
969
970 tracker = _kernel_get_process_attr_tracker(session, process_attr);
971 if (!tracker) {
972 ret_code = LTTNG_ERR_INVALID;
973 goto end;
974 }
975
976 status = process_attr_tracker_inclusion_set_remove_value(
977 tracker, value);
978 if (status != PROCESS_ATTR_TRACKER_STATUS_OK) {
979 switch (status) {
980 case PROCESS_ATTR_TRACKER_STATUS_MISSING:
981 ret_code = LTTNG_ERR_PROCESS_ATTR_MISSING;
982 break;
983 case PROCESS_ATTR_TRACKER_STATUS_INVALID_TRACKING_POLICY:
984 ret_code = LTTNG_ERR_PROCESS_ATTR_TRACKER_INVALID_TRACKING_POLICY;
985 break;
986 case PROCESS_ATTR_TRACKER_STATUS_ERROR:
987 default:
988 ret_code = LTTNG_ERR_UNK;
989 break;
990 }
991 goto end;
992 }
993
994 DBG("Kernel track %s %d for session id %" PRIu64,
995 lttng_process_attr_to_string(process_attr),
996 integral_value, session->id);
997 if (process_attr == LTTNG_PROCESS_ATTR_PROCESS_ID) {
998 /*
999 * Maintain a special case for the process ID process attribute
1000 * tracker as it was the only supported attribute prior to 2.12.
1001 */
1002 ret = kernctl_untrack_pid(session->fd, integral_value);
1003 } else {
1004 ret = kernctl_untrack_id(
1005 session->fd, process_attr, integral_value);
1006 }
1007 if (ret == 0) {
1008 ret_code = LTTNG_OK;
1009 goto end;
1010 }
1011 kernel_wait_quiescent();
1012
1013 /* kern-ctl error handling */
1014 switch (-ret) {
1015 case 0:
1016 ret_code = LTTNG_OK;
1017 break;
1018 case EINVAL:
1019 ret_code = LTTNG_ERR_INVALID;
1020 break;
1021 case ENOMEM:
1022 ret_code = LTTNG_ERR_NOMEM;
1023 break;
1024 case ENOENT:
1025 ret_code = LTTNG_ERR_PROCESS_ATTR_MISSING;
1026 break;
1027 default:
1028 ret_code = LTTNG_ERR_UNK;
1029 break;
1030 }
1031
1032 /* Attempt to add the value to the tracker. */
1033 status = process_attr_tracker_inclusion_set_add_value(
1034 tracker, value);
1035 if (status != PROCESS_ATTR_TRACKER_STATUS_OK) {
1036 ERR("Failed to roll-back the tracking of kernel %s process attribute %d while handling a kern-ctl error",
1037 lttng_process_attr_to_string(process_attr),
1038 integral_value);
1039 }
1040 end:
1041 return ret_code;
1042 }
1043
1044 /*
1045 * Create kernel metadata, open from the kernel tracer and add it to the
1046 * kernel session.
1047 */
1048 int kernel_open_metadata(struct ltt_kernel_session *session)
1049 {
1050 int ret;
1051 struct ltt_kernel_metadata *lkm = NULL;
1052
1053 assert(session);
1054
1055 /* Allocate kernel metadata */
1056 lkm = trace_kernel_create_metadata();
1057 if (lkm == NULL) {
1058 goto error;
1059 }
1060
1061 /* Kernel tracer metadata creation */
1062 ret = kernctl_open_metadata(session->fd, &lkm->conf->attr);
1063 if (ret < 0) {
1064 goto error_open;
1065 }
1066
1067 lkm->fd = ret;
1068 lkm->key = ++next_kernel_channel_key;
1069 /* Prevent fd duplication after execlp() */
1070 ret = fcntl(lkm->fd, F_SETFD, FD_CLOEXEC);
1071 if (ret < 0) {
1072 PERROR("fcntl session fd");
1073 }
1074
1075 session->metadata = lkm;
1076
1077 DBG("Kernel metadata opened (fd: %d)", lkm->fd);
1078
1079 return 0;
1080
1081 error_open:
1082 trace_kernel_destroy_metadata(lkm);
1083 error:
1084 return -1;
1085 }
1086
1087 /*
1088 * Start tracing session.
1089 */
1090 int kernel_start_session(struct ltt_kernel_session *session)
1091 {
1092 int ret;
1093
1094 assert(session);
1095
1096 ret = kernctl_start_session(session->fd);
1097 if (ret < 0) {
1098 PERROR("ioctl start session");
1099 goto error;
1100 }
1101
1102 DBG("Kernel session started");
1103
1104 return 0;
1105
1106 error:
1107 return ret;
1108 }
1109
1110 /*
1111 * Make a kernel wait to make sure in-flight probe have completed.
1112 */
1113 void kernel_wait_quiescent(void)
1114 {
1115 int ret;
1116 int fd = kernel_tracer_fd;
1117
1118 DBG("Kernel quiescent wait on %d", fd);
1119
1120 ret = kernctl_wait_quiescent(fd);
1121 if (ret < 0) {
1122 PERROR("wait quiescent ioctl");
1123 ERR("Kernel quiescent wait failed");
1124 }
1125 }
1126
1127 /*
1128 * Force flush buffer of metadata.
1129 */
1130 int kernel_metadata_flush_buffer(int fd)
1131 {
1132 int ret;
1133
1134 DBG("Kernel flushing metadata buffer on fd %d", fd);
1135
1136 ret = kernctl_buffer_flush(fd);
1137 if (ret < 0) {
1138 ERR("Fail to flush metadata buffers %d (ret: %d)", fd, ret);
1139 }
1140
1141 return 0;
1142 }
1143
1144 /*
1145 * Force flush buffer for channel.
1146 */
1147 int kernel_flush_buffer(struct ltt_kernel_channel *channel)
1148 {
1149 int ret;
1150 struct ltt_kernel_stream *stream;
1151
1152 assert(channel);
1153
1154 DBG("Flush buffer for channel %s", channel->channel->name);
1155
1156 cds_list_for_each_entry(stream, &channel->stream_list.head, list) {
1157 DBG("Flushing channel stream %d", stream->fd);
1158 ret = kernctl_buffer_flush(stream->fd);
1159 if (ret < 0) {
1160 PERROR("ioctl");
1161 ERR("Fail to flush buffer for stream %d (ret: %d)",
1162 stream->fd, ret);
1163 }
1164 }
1165
1166 return 0;
1167 }
1168
1169 /*
1170 * Stop tracing session.
1171 */
1172 int kernel_stop_session(struct ltt_kernel_session *session)
1173 {
1174 int ret;
1175
1176 assert(session);
1177
1178 ret = kernctl_stop_session(session->fd);
1179 if (ret < 0) {
1180 goto error;
1181 }
1182
1183 DBG("Kernel session stopped");
1184
1185 return 0;
1186
1187 error:
1188 return ret;
1189 }
1190
1191 /*
1192 * Open stream of channel, register it to the kernel tracer and add it
1193 * to the stream list of the channel.
1194 *
1195 * Note: given that the streams may appear in random order wrt CPU
1196 * number (e.g. cpu hotplug), the index value of the stream number in
1197 * the stream name is not necessarily linked to the CPU number.
1198 *
1199 * Return the number of created stream. Else, a negative value.
1200 */
1201 int kernel_open_channel_stream(struct ltt_kernel_channel *channel)
1202 {
1203 int ret;
1204 struct ltt_kernel_stream *lks;
1205
1206 assert(channel);
1207
1208 while ((ret = kernctl_create_stream(channel->fd)) >= 0) {
1209 lks = trace_kernel_create_stream(channel->channel->name,
1210 channel->stream_count);
1211 if (lks == NULL) {
1212 ret = close(ret);
1213 if (ret) {
1214 PERROR("close");
1215 }
1216 goto error;
1217 }
1218
1219 lks->fd = ret;
1220 /* Prevent fd duplication after execlp() */
1221 ret = fcntl(lks->fd, F_SETFD, FD_CLOEXEC);
1222 if (ret < 0) {
1223 PERROR("fcntl session fd");
1224 }
1225
1226 lks->tracefile_size = channel->channel->attr.tracefile_size;
1227 lks->tracefile_count = channel->channel->attr.tracefile_count;
1228
1229 /* Add stream to channel stream list */
1230 cds_list_add(&lks->list, &channel->stream_list.head);
1231 channel->stream_count++;
1232
1233 DBG("Kernel stream %s created (fd: %d, state: %d)", lks->name, lks->fd,
1234 lks->state);
1235 }
1236
1237 return channel->stream_count;
1238
1239 error:
1240 return -1;
1241 }
1242
1243 /*
1244 * Open the metadata stream and set it to the kernel session.
1245 */
1246 int kernel_open_metadata_stream(struct ltt_kernel_session *session)
1247 {
1248 int ret;
1249
1250 assert(session);
1251
1252 ret = kernctl_create_stream(session->metadata->fd);
1253 if (ret < 0) {
1254 PERROR("kernel create metadata stream");
1255 goto error;
1256 }
1257
1258 DBG("Kernel metadata stream created (fd: %d)", ret);
1259 session->metadata_stream_fd = ret;
1260 /* Prevent fd duplication after execlp() */
1261 ret = fcntl(session->metadata_stream_fd, F_SETFD, FD_CLOEXEC);
1262 if (ret < 0) {
1263 PERROR("fcntl session fd");
1264 }
1265
1266 return 0;
1267
1268 error:
1269 return -1;
1270 }
1271
1272 /*
1273 * Get the event list from the kernel tracer and return the number of elements.
1274 */
1275 ssize_t kernel_list_events(struct lttng_event **events)
1276 {
1277 int fd, ret;
1278 char *event;
1279 size_t nbmem, count = 0;
1280 FILE *fp;
1281 struct lttng_event *elist;
1282
1283 assert(events);
1284
1285 fd = kernctl_tracepoint_list(kernel_tracer_fd);
1286 if (fd < 0) {
1287 PERROR("kernel tracepoint list");
1288 goto error;
1289 }
1290
1291 fp = fdopen(fd, "r");
1292 if (fp == NULL) {
1293 PERROR("kernel tracepoint list fdopen");
1294 goto error_fp;
1295 }
1296
1297 /*
1298 * Init memory size counter
1299 * See kernel-ctl.h for explanation of this value
1300 */
1301 nbmem = KERNEL_EVENT_INIT_LIST_SIZE;
1302 elist = zmalloc(sizeof(struct lttng_event) * nbmem);
1303 if (elist == NULL) {
1304 PERROR("alloc list events");
1305 count = -ENOMEM;
1306 goto end;
1307 }
1308
1309 while (fscanf(fp, "event { name = %m[^;]; };\n", &event) == 1) {
1310 if (count >= nbmem) {
1311 struct lttng_event *new_elist;
1312 size_t new_nbmem;
1313
1314 new_nbmem = nbmem << 1;
1315 DBG("Reallocating event list from %zu to %zu bytes",
1316 nbmem, new_nbmem);
1317 new_elist = realloc(elist, new_nbmem * sizeof(struct lttng_event));
1318 if (new_elist == NULL) {
1319 PERROR("realloc list events");
1320 free(event);
1321 free(elist);
1322 count = -ENOMEM;
1323 goto end;
1324 }
1325 /* Zero the new memory */
1326 memset(new_elist + nbmem, 0,
1327 (new_nbmem - nbmem) * sizeof(struct lttng_event));
1328 nbmem = new_nbmem;
1329 elist = new_elist;
1330 }
1331 strncpy(elist[count].name, event, LTTNG_SYMBOL_NAME_LEN);
1332 elist[count].name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0';
1333 elist[count].enabled = -1;
1334 count++;
1335 free(event);
1336 }
1337
1338 *events = elist;
1339 DBG("Kernel list events done (%zu events)", count);
1340 end:
1341 ret = fclose(fp); /* closes both fp and fd */
1342 if (ret) {
1343 PERROR("fclose");
1344 }
1345 return count;
1346
1347 error_fp:
1348 ret = close(fd);
1349 if (ret) {
1350 PERROR("close");
1351 }
1352 error:
1353 return -1;
1354 }
1355
1356 /*
1357 * Get kernel version and validate it.
1358 */
1359 int kernel_validate_version(struct lttng_kernel_tracer_version *version,
1360 struct lttng_kernel_tracer_abi_version *abi_version)
1361 {
1362 int ret;
1363
1364 ret = kernctl_tracer_version(kernel_tracer_fd, version);
1365 if (ret < 0) {
1366 ERR("Failed to retrieve the lttng-modules version");
1367 goto error;
1368 }
1369
1370 /* Validate version */
1371 if (version->major != VERSION_MAJOR) {
1372 ERR("Kernel tracer major version (%d) is not compatible with lttng-tools major version (%d)",
1373 version->major, VERSION_MAJOR);
1374 goto error_version;
1375 }
1376 ret = kernctl_tracer_abi_version(kernel_tracer_fd, abi_version);
1377 if (ret < 0) {
1378 ERR("Failed to retrieve lttng-modules ABI version");
1379 goto error;
1380 }
1381 if (abi_version->major != LTTNG_MODULES_ABI_MAJOR_VERSION) {
1382 ERR("Kernel tracer ABI version (%d.%d) does not match the expected ABI major version (%d.*)",
1383 abi_version->major, abi_version->minor,
1384 LTTNG_MODULES_ABI_MAJOR_VERSION);
1385 goto error;
1386 }
1387 DBG2("Kernel tracer version validated (%d.%d, ABI %d.%d)",
1388 version->major, version->minor,
1389 abi_version->major, abi_version->minor);
1390 return 0;
1391
1392 error_version:
1393 ret = -1;
1394
1395 error:
1396 ERR("Kernel tracer version check failed; kernel tracing will not be available");
1397 return ret;
1398 }
1399
1400 /*
1401 * Kernel work-arounds called at the start of sessiond main().
1402 */
1403 int init_kernel_workarounds(void)
1404 {
1405 int ret;
1406 FILE *fp;
1407
1408 /*
1409 * boot_id needs to be read once before being used concurrently
1410 * to deal with a Linux kernel race. A fix is proposed for
1411 * upstream, but the work-around is needed for older kernels.
1412 */
1413 fp = fopen("/proc/sys/kernel/random/boot_id", "r");
1414 if (!fp) {
1415 goto end_boot_id;
1416 }
1417 while (!feof(fp)) {
1418 char buf[37] = "";
1419
1420 ret = fread(buf, 1, sizeof(buf), fp);
1421 if (ret < 0) {
1422 /* Ignore error, we don't really care */
1423 }
1424 }
1425 ret = fclose(fp);
1426 if (ret) {
1427 PERROR("fclose");
1428 }
1429 end_boot_id:
1430 return 0;
1431 }
1432
1433 /*
1434 * Teardown of a kernel session, keeping data required by destroy notifiers.
1435 */
1436 void kernel_destroy_session(struct ltt_kernel_session *ksess)
1437 {
1438 struct lttng_trace_chunk *trace_chunk;
1439
1440 if (ksess == NULL) {
1441 DBG3("No kernel session when tearing down session");
1442 return;
1443 }
1444
1445 DBG("Tearing down kernel session");
1446 trace_chunk = ksess->current_trace_chunk;
1447
1448 /*
1449 * Destroy channels on the consumer if at least one FD has been sent and we
1450 * are in no output mode because the streams are in *no* monitor mode so we
1451 * have to send a command to clean them up or else they leaked.
1452 */
1453 if (!ksess->output_traces && ksess->consumer_fds_sent) {
1454 int ret;
1455 struct consumer_socket *socket;
1456 struct lttng_ht_iter iter;
1457
1458 /* For each consumer socket. */
1459 rcu_read_lock();
1460 cds_lfht_for_each_entry(ksess->consumer->socks->ht, &iter.iter,
1461 socket, node.node) {
1462 struct ltt_kernel_channel *chan;
1463
1464 /* For each channel, ask the consumer to destroy it. */
1465 cds_list_for_each_entry(chan, &ksess->channel_list.head, list) {
1466 ret = kernel_consumer_destroy_channel(socket, chan);
1467 if (ret < 0) {
1468 /* Consumer is probably dead. Use next socket. */
1469 continue;
1470 }
1471 }
1472 }
1473 rcu_read_unlock();
1474 }
1475
1476 /* Close any relayd session */
1477 consumer_output_send_destroy_relayd(ksess->consumer);
1478
1479 trace_kernel_destroy_session(ksess);
1480 lttng_trace_chunk_put(trace_chunk);
1481 }
1482
1483 /* Teardown of data required by destroy notifiers. */
1484 void kernel_free_session(struct ltt_kernel_session *ksess)
1485 {
1486 if (ksess == NULL) {
1487 return;
1488 }
1489 trace_kernel_free_session(ksess);
1490 }
1491
1492 /*
1493 * Destroy a kernel channel object. It does not do anything on the tracer side.
1494 */
1495 void kernel_destroy_channel(struct ltt_kernel_channel *kchan)
1496 {
1497 struct ltt_kernel_session *ksess = NULL;
1498
1499 assert(kchan);
1500 assert(kchan->channel);
1501
1502 DBG3("Kernel destroy channel %s", kchan->channel->name);
1503
1504 /* Update channel count of associated session. */
1505 if (kchan->session) {
1506 /* Keep pointer reference so we can update it after the destroy. */
1507 ksess = kchan->session;
1508 }
1509
1510 trace_kernel_destroy_channel(kchan);
1511
1512 /*
1513 * At this point the kernel channel is not visible anymore. This is safe
1514 * since in order to work on a visible kernel session, the tracing session
1515 * lock (ltt_session.lock) MUST be acquired.
1516 */
1517 if (ksess) {
1518 ksess->channel_count--;
1519 }
1520 }
1521
1522 /*
1523 * Take a snapshot for a given kernel session.
1524 *
1525 * Return LTTNG_OK on success or else return a LTTNG_ERR code.
1526 */
1527 enum lttng_error_code kernel_snapshot_record(
1528 struct ltt_kernel_session *ksess,
1529 const struct consumer_output *output, int wait,
1530 uint64_t nb_packets_per_stream)
1531 {
1532 int err, ret, saved_metadata_fd;
1533 enum lttng_error_code status = LTTNG_OK;
1534 struct consumer_socket *socket;
1535 struct lttng_ht_iter iter;
1536 struct ltt_kernel_metadata *saved_metadata;
1537 char *trace_path = NULL;
1538 size_t consumer_path_offset = 0;
1539
1540 assert(ksess);
1541 assert(ksess->consumer);
1542 assert(output);
1543
1544 DBG("Kernel snapshot record started");
1545
1546 /* Save current metadata since the following calls will change it. */
1547 saved_metadata = ksess->metadata;
1548 saved_metadata_fd = ksess->metadata_stream_fd;
1549
1550 rcu_read_lock();
1551
1552 ret = kernel_open_metadata(ksess);
1553 if (ret < 0) {
1554 status = LTTNG_ERR_KERN_META_FAIL;
1555 goto error;
1556 }
1557
1558 ret = kernel_open_metadata_stream(ksess);
1559 if (ret < 0) {
1560 status = LTTNG_ERR_KERN_META_FAIL;
1561 goto error_open_stream;
1562 }
1563
1564 trace_path = setup_channel_trace_path(ksess->consumer,
1565 DEFAULT_KERNEL_TRACE_DIR, &consumer_path_offset);
1566 if (!trace_path) {
1567 status = LTTNG_ERR_INVALID;
1568 goto error;
1569 }
1570 /* Send metadata to consumer and snapshot everything. */
1571 cds_lfht_for_each_entry(output->socks->ht, &iter.iter,
1572 socket, node.node) {
1573 struct ltt_kernel_channel *chan;
1574
1575 pthread_mutex_lock(socket->lock);
1576 /* This stream must not be monitored by the consumer. */
1577 ret = kernel_consumer_add_metadata(socket, ksess, 0);
1578 pthread_mutex_unlock(socket->lock);
1579 if (ret < 0) {
1580 status = LTTNG_ERR_KERN_META_FAIL;
1581 goto error_consumer;
1582 }
1583
1584 /* For each channel, ask the consumer to snapshot it. */
1585 cds_list_for_each_entry(chan, &ksess->channel_list.head, list) {
1586 status = consumer_snapshot_channel(socket, chan->key, output, 0,
1587 ksess->uid, ksess->gid,
1588 &trace_path[consumer_path_offset], wait,
1589 nb_packets_per_stream);
1590 if (status != LTTNG_OK) {
1591 (void) kernel_consumer_destroy_metadata(socket,
1592 ksess->metadata);
1593 goto error_consumer;
1594 }
1595 }
1596
1597 /* Snapshot metadata, */
1598 status = consumer_snapshot_channel(socket, ksess->metadata->key, output,
1599 1, ksess->uid, ksess->gid, &trace_path[consumer_path_offset],
1600 wait, 0);
1601 if (status != LTTNG_OK) {
1602 goto error_consumer;
1603 }
1604
1605 /*
1606 * The metadata snapshot is done, ask the consumer to destroy it since
1607 * it's not monitored on the consumer side.
1608 */
1609 (void) kernel_consumer_destroy_metadata(socket, ksess->metadata);
1610 }
1611
1612 error_consumer:
1613 /* Close newly opened metadata stream. It's now on the consumer side. */
1614 err = close(ksess->metadata_stream_fd);
1615 if (err < 0) {
1616 PERROR("close snapshot kernel");
1617 }
1618
1619 error_open_stream:
1620 trace_kernel_destroy_metadata(ksess->metadata);
1621 error:
1622 /* Restore metadata state.*/
1623 ksess->metadata = saved_metadata;
1624 ksess->metadata_stream_fd = saved_metadata_fd;
1625 rcu_read_unlock();
1626 free(trace_path);
1627 return status;
1628 }
1629
1630 /*
1631 * Get the syscall mask array from the kernel tracer.
1632 *
1633 * Return 0 on success else a negative value. In both case, syscall_mask should
1634 * be freed.
1635 */
1636 int kernel_syscall_mask(int chan_fd, char **syscall_mask, uint32_t *nr_bits)
1637 {
1638 assert(syscall_mask);
1639 assert(nr_bits);
1640
1641 return kernctl_syscall_mask(chan_fd, syscall_mask, nr_bits);
1642 }
1643
1644 /*
1645 * Check for the support of the RING_BUFFER_SNAPSHOT_SAMPLE_POSITIONS via abi
1646 * version number.
1647 *
1648 * Return 1 on success, 0 when feature is not supported, negative value in case
1649 * of errors.
1650 */
1651 int kernel_supports_ring_buffer_snapshot_sample_positions(void)
1652 {
1653 int ret = 0; // Not supported by default
1654 struct lttng_kernel_tracer_abi_version abi;
1655
1656 ret = kernctl_tracer_abi_version(kernel_tracer_fd, &abi);
1657 if (ret < 0) {
1658 ERR("Failed to retrieve lttng-modules ABI version");
1659 goto error;
1660 }
1661
1662 /*
1663 * RING_BUFFER_SNAPSHOT_SAMPLE_POSITIONS was introduced in 2.3
1664 */
1665 if (abi.major >= 2 && abi.minor >= 3) {
1666 /* Supported */
1667 ret = 1;
1668 } else {
1669 /* Not supported */
1670 ret = 0;
1671 }
1672 error:
1673 return ret;
1674 }
1675
1676 /*
1677 * Check for the support of the packet sequence number via abi version number.
1678 *
1679 * Return 1 on success, 0 when feature is not supported, negative value in case
1680 * of errors.
1681 */
1682 int kernel_supports_ring_buffer_packet_sequence_number(void)
1683 {
1684 int ret = 0; // Not supported by default
1685 struct lttng_kernel_tracer_abi_version abi;
1686
1687 ret = kernctl_tracer_abi_version(kernel_tracer_fd, &abi);
1688 if (ret < 0) {
1689 ERR("Failed to retrieve lttng-modules ABI version");
1690 goto error;
1691 }
1692
1693 /*
1694 * Packet sequence number was introduced in LTTng 2.8,
1695 * lttng-modules ABI 2.1.
1696 */
1697 if (abi.major >= 2 && abi.minor >= 1) {
1698 /* Supported */
1699 ret = 1;
1700 } else {
1701 /* Not supported */
1702 ret = 0;
1703 }
1704 error:
1705 return ret;
1706 }
1707
1708 /*
1709 * Rotate a kernel session.
1710 *
1711 * Return LTTNG_OK on success or else an LTTng error code.
1712 */
1713 enum lttng_error_code kernel_rotate_session(struct ltt_session *session)
1714 {
1715 int ret;
1716 enum lttng_error_code status = LTTNG_OK;
1717 struct consumer_socket *socket;
1718 struct lttng_ht_iter iter;
1719 struct ltt_kernel_session *ksess = session->kernel_session;
1720
1721 assert(ksess);
1722 assert(ksess->consumer);
1723
1724 DBG("Rotate kernel session %s started (session %" PRIu64 ")",
1725 session->name, session->id);
1726
1727 rcu_read_lock();
1728
1729 /*
1730 * Note that this loop will end after one iteration given that there is
1731 * only one kernel consumer.
1732 */
1733 cds_lfht_for_each_entry(ksess->consumer->socks->ht, &iter.iter,
1734 socket, node.node) {
1735 struct ltt_kernel_channel *chan;
1736
1737 /* For each channel, ask the consumer to rotate it. */
1738 cds_list_for_each_entry(chan, &ksess->channel_list.head, list) {
1739 DBG("Rotate kernel channel %" PRIu64 ", session %s",
1740 chan->key, session->name);
1741 ret = consumer_rotate_channel(socket, chan->key,
1742 ksess->uid, ksess->gid, ksess->consumer,
1743 /* is_metadata_channel */ false);
1744 if (ret < 0) {
1745 status = LTTNG_ERR_ROTATION_FAIL_CONSUMER;
1746 goto error;
1747 }
1748 }
1749
1750 /*
1751 * Rotate the metadata channel.
1752 */
1753 ret = consumer_rotate_channel(socket, ksess->metadata->key,
1754 ksess->uid, ksess->gid, ksess->consumer,
1755 /* is_metadata_channel */ true);
1756 if (ret < 0) {
1757 status = LTTNG_ERR_ROTATION_FAIL_CONSUMER;
1758 goto error;
1759 }
1760 }
1761
1762 error:
1763 rcu_read_unlock();
1764 return status;
1765 }
1766
1767 enum lttng_error_code kernel_create_channel_subdirectories(
1768 const struct ltt_kernel_session *ksess)
1769 {
1770 enum lttng_error_code ret = LTTNG_OK;
1771 enum lttng_trace_chunk_status chunk_status;
1772
1773 rcu_read_lock();
1774 assert(ksess->current_trace_chunk);
1775
1776 /*
1777 * Create the index subdirectory which will take care
1778 * of implicitly creating the channel's path.
1779 */
1780 chunk_status = lttng_trace_chunk_create_subdirectory(
1781 ksess->current_trace_chunk,
1782 DEFAULT_KERNEL_TRACE_DIR "/" DEFAULT_INDEX_DIR);
1783 if (chunk_status != LTTNG_TRACE_CHUNK_STATUS_OK) {
1784 ret = LTTNG_ERR_CREATE_DIR_FAIL;
1785 goto error;
1786 }
1787 error:
1788 rcu_read_unlock();
1789 return ret;
1790 }
1791
1792 /*
1793 * Setup necessary data for kernel tracer action.
1794 */
1795 LTTNG_HIDDEN
1796 int init_kernel_tracer(void)
1797 {
1798 int ret;
1799 bool is_root = !getuid();
1800
1801 /* Modprobe lttng kernel modules */
1802 ret = modprobe_lttng_control();
1803 if (ret < 0) {
1804 goto error;
1805 }
1806
1807 /* Open debugfs lttng */
1808 kernel_tracer_fd = open(module_proc_lttng, O_RDWR);
1809 if (kernel_tracer_fd < 0) {
1810 DBG("Failed to open %s", module_proc_lttng);
1811 goto error_open;
1812 }
1813
1814 /* Validate kernel version */
1815 ret = kernel_validate_version(&kernel_tracer_version,
1816 &kernel_tracer_abi_version);
1817 if (ret < 0) {
1818 goto error_version;
1819 }
1820
1821 ret = modprobe_lttng_data();
1822 if (ret < 0) {
1823 goto error_modules;
1824 }
1825
1826 ret = kernel_supports_ring_buffer_snapshot_sample_positions();
1827 if (ret < 0) {
1828 goto error_modules;
1829 }
1830
1831 if (ret < 1) {
1832 WARN("Kernel tracer does not support buffer monitoring. "
1833 "The monitoring timer of channels in the kernel domain "
1834 "will be set to 0 (disabled).");
1835 }
1836
1837 DBG("Kernel tracer fd %d", kernel_tracer_fd);
1838
1839 ret = syscall_init_table(kernel_tracer_fd);
1840 if (ret < 0) {
1841 ERR("Unable to populate syscall table. Syscall tracing won't "
1842 "work for this session daemon.");
1843 }
1844 return 0;
1845
1846 error_version:
1847 modprobe_remove_lttng_control();
1848 ret = close(kernel_tracer_fd);
1849 if (ret) {
1850 PERROR("close");
1851 }
1852 kernel_tracer_fd = -1;
1853 return LTTNG_ERR_KERN_VERSION;
1854
1855 error_modules:
1856 ret = close(kernel_tracer_fd);
1857 if (ret) {
1858 PERROR("close");
1859 }
1860
1861 error_open:
1862 modprobe_remove_lttng_control();
1863
1864 error:
1865 WARN("No kernel tracer available");
1866 kernel_tracer_fd = -1;
1867 if (!is_root) {
1868 return LTTNG_ERR_NEED_ROOT_SESSIOND;
1869 } else {
1870 return LTTNG_ERR_KERN_NA;
1871 }
1872 }
1873
1874 LTTNG_HIDDEN
1875 void cleanup_kernel_tracer(void)
1876 {
1877 int ret;
1878
1879 DBG2("Closing kernel fd");
1880 if (kernel_tracer_fd >= 0) {
1881 ret = close(kernel_tracer_fd);
1882 if (ret) {
1883 PERROR("close");
1884 }
1885 kernel_tracer_fd = -1;
1886 }
1887 DBG("Unloading kernel modules");
1888 modprobe_remove_lttng_all();
1889 free(syscall_table);
1890 }
1891
1892 LTTNG_HIDDEN
1893 bool kernel_tracer_is_initialized(void)
1894 {
1895 return kernel_tracer_fd >= 0;
1896 }
1897
1898 /*
1899 * Clear a kernel session.
1900 *
1901 * Return LTTNG_OK on success or else an LTTng error code.
1902 */
1903 enum lttng_error_code kernel_clear_session(struct ltt_session *session)
1904 {
1905 int ret;
1906 enum lttng_error_code status = LTTNG_OK;
1907 struct consumer_socket *socket;
1908 struct lttng_ht_iter iter;
1909 struct ltt_kernel_session *ksess = session->kernel_session;
1910
1911 assert(ksess);
1912 assert(ksess->consumer);
1913
1914 DBG("Clear kernel session %s (session %" PRIu64 ")",
1915 session->name, session->id);
1916
1917 rcu_read_lock();
1918
1919 if (ksess->active) {
1920 ERR("Expecting inactive session %s (%" PRIu64 ")", session->name, session->id);
1921 status = LTTNG_ERR_FATAL;
1922 goto end;
1923 }
1924
1925 /*
1926 * Note that this loop will end after one iteration given that there is
1927 * only one kernel consumer.
1928 */
1929 cds_lfht_for_each_entry(ksess->consumer->socks->ht, &iter.iter,
1930 socket, node.node) {
1931 struct ltt_kernel_channel *chan;
1932
1933 /* For each channel, ask the consumer to clear it. */
1934 cds_list_for_each_entry(chan, &ksess->channel_list.head, list) {
1935 DBG("Clear kernel channel %" PRIu64 ", session %s",
1936 chan->key, session->name);
1937 ret = consumer_clear_channel(socket, chan->key);
1938 if (ret < 0) {
1939 goto error;
1940 }
1941 }
1942
1943 if (!ksess->metadata) {
1944 /*
1945 * Nothing to do for the metadata.
1946 * This is a snapshot session.
1947 * The metadata is genererated on the fly.
1948 */
1949 continue;
1950 }
1951
1952 /*
1953 * Clear the metadata channel.
1954 * Metadata channel is not cleared per se but we still need to
1955 * perform a rotation operation on it behind the scene.
1956 */
1957 ret = consumer_clear_channel(socket, ksess->metadata->key);
1958 if (ret < 0) {
1959 goto error;
1960 }
1961 }
1962
1963 goto end;
1964 error:
1965 switch (-ret) {
1966 case LTTCOMM_CONSUMERD_RELAYD_CLEAR_DISALLOWED:
1967 status = LTTNG_ERR_CLEAR_RELAY_DISALLOWED;
1968 break;
1969 default:
1970 status = LTTNG_ERR_CLEAR_FAIL_CONSUMER;
1971 break;
1972 }
1973 end:
1974 rcu_read_unlock();
1975 return status;
1976 }
LTTng 2.0 tools and control repository
This page took 0.099348 seconds and 4 git commands to generate.