ltt-sessiond/event.c

   1 /*
   2  * Copyright (C) 2011 - David Goulet <david.goulet@polymtl.ca>
   3  *
   4  * This program is free software; you can redistribute it and/or modify it
   5  * under the terms of the GNU General Public License as published by the Free
   6  * Software Foundation; only version 2 of the License.
   7  *
   8  * This program is distributed in the hope that it will be useful, but WITHOUT
   9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  10  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  11  * more details.
  12  *
  13  * You should have received a copy of the GNU General Public License along with
  14  * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
  15  * Place - Suite 330, Boston, MA  02111-1307, USA.
  16  */
  17
  18 #include <errno.h>
  19 #include <urcu/list.h>
  20 #include <string.h>
  21
  22 #include <lttng/lttng.h>
  23 #include <lttng-sessiond-comm.h>
  24 #include <lttngerr.h>
  25
  26 #ifdef CONFIG_LTTNG_TOOLS_HAVE_UST
  27 #include <ust/lttng-ust-ctl.h>
  28 #else
  29 #include "lttng-ust-ctl.h"
  30 #endif
  31
  32 #include "channel.h"
  33 #include "event.h"
  34 #include "kernel-ctl.h"
  35
  36 /*
  37  * Setup a lttng_event used to enable *all* syscall tracing.
  38  */
  39 static void init_syscalls_kernel_event(struct lttng_event *event)
  40 {
  41         event->name[0] = '\0';
  42         /*
  43          * We use LTTNG_EVENT* here since the trace kernel creation will make the
  44          * right changes for the kernel.
  45          */
  46         event->type = LTTNG_EVENT_SYSCALL;
  47 }
  48
  49 /*
  50  * Disable kernel tracepoint event for a channel from the kernel session.
  51  */
  52 int event_kernel_disable_tracepoint(struct ltt_kernel_session *ksession,
  53                 struct ltt_kernel_channel *kchan, char *event_name)
  54 {
  55         int ret;
  56         struct ltt_kernel_event *kevent;
  57
  58         kevent = trace_kernel_get_event_by_name(event_name, kchan);
  59         if (kevent == NULL) {
  60                 ret = LTTCOMM_NO_EVENT;
  61                 goto error;
  62         }
  63
  64         ret = kernel_disable_event(kevent);
  65         if (ret < 0) {
  66                 ret = LTTCOMM_KERN_DISABLE_FAIL;
  67                 goto error;
  68         }
  69
  70         DBG("Kernel event %s disable for channel %s.",
  71                         kevent->event->name, kchan->channel->name);
  72
  73         ret = LTTCOMM_OK;
  74
  75 error:
  76         return ret;
  77 }
  78
  79 /*
  80  * Disable kernel tracepoint events for a channel from the kernel session.
  81  */
  82 int event_kernel_disable_all_tracepoints(struct ltt_kernel_session *ksession,
  83                 struct ltt_kernel_channel *kchan)
  84 {
  85         int ret;
  86         struct ltt_kernel_event *kevent;
  87
  88         /* For each event in the kernel session */
  89         cds_list_for_each_entry(kevent, &kchan->events_list.head, list) {
  90                 ret = kernel_disable_event(kevent);
  91                 if (ret < 0) {
  92                         /* We continue disabling the rest */
  93                         continue;
  94                 }
  95         }
  96         ret = LTTCOMM_OK;
  97         return ret;
  98 }
  99
 100 /*
 101  * Disable kernel syscall events for a channel from the kernel session.
 102  */
 103 int event_kernel_disable_all_syscalls(struct ltt_kernel_session *ksession,
 104                 struct ltt_kernel_channel *kchan)
 105 {
 106         ERR("Cannot disable syscall tracing for existing session. Please destroy session instead.");
 107         return LTTCOMM_OK;      /* Return OK so disable all succeeds */
 108 }
 109
 110 /*
 111  * Disable all kernel event for a channel from the kernel session.
 112  */
 113 int event_kernel_disable_all(struct ltt_kernel_session *ksession,
 114                 struct ltt_kernel_channel *kchan)
 115 {
 116         int ret;
 117
 118         ret = event_kernel_disable_all_tracepoints(ksession, kchan);
 119         if (ret != LTTCOMM_OK)
 120                 return ret;
 121         ret = event_kernel_disable_all_syscalls(ksession, kchan);
 122         return ret;
 123 }
 124
 125 /*
 126  * Enable kernel tracepoint event for a channel from the kernel session.
 127  */
 128 int event_kernel_enable_tracepoint(struct ltt_kernel_session *ksession,
 129                 struct ltt_kernel_channel *kchan, struct lttng_event *event)
 130 {
 131         int ret;
 132         struct ltt_kernel_event *kevent;
 133
 134         kevent = trace_kernel_get_event_by_name(event->name, kchan);
 135         if (kevent == NULL) {
 136                 ret = kernel_create_event(event, kchan);
 137                 if (ret < 0) {
 138                         if (ret == -EEXIST) {
 139                                 ret = LTTCOMM_KERN_EVENT_EXIST;
 140                         } else {
 141                                 ret = LTTCOMM_KERN_ENABLE_FAIL;
 142                         }
 143                         goto end;
 144                 }
 145         } else if (kevent->enabled == 0) {
 146                 ret = kernel_enable_event(kevent);
 147                 if (ret < 0) {
 148                         ret = LTTCOMM_KERN_ENABLE_FAIL;
 149                         goto end;
 150                 }
 151         }
 152         ret = LTTCOMM_OK;
 153 end:
 154         return ret;
 155 }
 156
 157 /*
 158  * Enable all kernel tracepoint events of a channel of the kernel session.
 159  */
 160 int event_kernel_enable_all_tracepoints(struct ltt_kernel_session *ksession,
 161                 struct ltt_kernel_channel *kchan, int kernel_tracer_fd)
 162 {
 163         int size, i, ret;
 164         struct ltt_kernel_event *kevent;
 165         struct lttng_event *event_list;
 166
 167         /* For each event in the kernel session */
 168         cds_list_for_each_entry(kevent, &kchan->events_list.head, list) {
 169                 ret = kernel_enable_event(kevent);
 170                 if (ret < 0) {
 171                         /* Enable failed but still continue */
 172                         continue;
 173                 }
 174         }
 175
 176         size = kernel_list_events(kernel_tracer_fd, &event_list);
 177         if (size < 0) {
 178                 ret = LTTCOMM_KERN_LIST_FAIL;
 179                 goto end;
 180         }
 181
 182         for (i = 0; i < size; i++) {
 183                 kevent = trace_kernel_get_event_by_name(event_list[i].name, kchan);
 184                 if (kevent == NULL) {
 185                         /* Default event type for enable all */
 186                         event_list[i].type = LTTNG_EVENT_TRACEPOINT;
 187                         /* Enable each single tracepoint event */
 188                         ret = kernel_create_event(&event_list[i], kchan);
 189                         if (ret < 0) {
 190                                 /* Ignore error here and continue */
 191                         }
 192                 }
 193         }
 194         free(event_list);
 195         ret = LTTCOMM_OK;
 196 end:
 197         return ret;
 198
 199 }
 200
 201 /*
 202  * Enable all kernel tracepoint events of a channel of the kernel session.
 203  */
 204 int event_kernel_enable_all_syscalls(struct ltt_kernel_session *ksession,
 205                 struct ltt_kernel_channel *kchan, int kernel_tracer_fd)
 206 {
 207         int ret;
 208         struct lttng_event event;
 209
 210         init_syscalls_kernel_event(&event);
 211
 212         DBG("Enabling all syscall tracing");
 213
 214         ret = kernel_create_event(&event, kchan);
 215         if (ret < 0) {
 216                 goto end;
 217         }
 218         ret = LTTCOMM_OK;
 219 end:
 220         return ret;
 221 }
 222
 223 /*
 224  * Enable all kernel events of a channel of the kernel session.
 225  */
 226 int event_kernel_enable_all(struct ltt_kernel_session *ksession,
 227                 struct ltt_kernel_channel *kchan, int kernel_tracer_fd)
 228 {
 229         int ret;
 230
 231         ret = event_kernel_enable_all_tracepoints(ksession, kchan, kernel_tracer_fd);
 232         if (ret != LTTCOMM_OK) {
 233                 goto end;
 234         }
 235         ret = event_kernel_enable_all_syscalls(ksession, kchan, kernel_tracer_fd);
 236 end:
 237         return ret;
 238 }
 239
 240 /*
 241  * Enable UST tracepoint event for a channel from a UST session.
 242  */
 243 int event_ust_enable_tracepoint(struct ltt_ust_session *ustsession,
 244                 struct ltt_ust_channel *ustchan, struct lttng_event *event)
 245 {
 246         int ret;
 247         struct ltt_ust_event *ustevent;
 248         struct lttng_ust_event lttngustevent;
 249         struct object_data *object_event;
 250
 251         ustevent = trace_ust_get_event_by_name(event->name, ustchan);
 252         if (ustevent == NULL) {
 253                 ustevent = trace_ust_create_event(event);
 254                 if (ustevent == NULL) {
 255                         ret = -1;
 256                         goto end;
 257                 }
 258                 strncpy(lttngustevent.name, event->name,
 259                         LTTNG_UST_SYM_NAME_LEN);
 260                 lttngustevent.name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
 261                 /* TODO: adjust to other instrumentation types */
 262                 lttngustevent.instrumentation = LTTNG_UST_TRACEPOINT;
 263                 ret = ustctl_create_event(ustsession->sock, &lttngustevent,
 264                         ustchan->obj, &object_event);
 265                 if (ret < 0) {
 266                         if (ret == -EEXIST) {
 267                                 ret = LTTCOMM_KERN_EVENT_EXIST;
 268                         } else {
 269                                 ret = LTTCOMM_KERN_ENABLE_FAIL;
 270                         }
 271                         goto end;
 272                 }
 273                 ustevent->obj = object_event;
 274                 ustevent->handle = object_event->handle;
 275                 ustevent->enabled = 1;
 276                 /* Add event to event list */
 277                 cds_list_add(&ustevent->list, &ustchan->events.head);
 278                 ustchan->events.count++;
 279         } else if (ustevent->enabled == 0) {
 280                 ret = ustctl_enable(ustsession->sock, ustevent->obj);
 281                 if (ret < 0) {
 282                         ret = LTTCOMM_KERN_ENABLE_FAIL;
 283                         goto end;
 284                 }
 285                 ustevent->enabled = 1;
 286         }
 287         ret = LTTCOMM_OK;
 288 end:
 289         return ret;
 290 }
 291
 292 int event_ust_disable_tracepoint(struct ltt_ust_session *ustsession,
 293                 struct ltt_ust_channel *ustchan, char *event_name)
 294 {
 295         int ret;
 296         struct ltt_ust_event *ustevent;
 297
 298         ustevent = trace_ust_get_event_by_name(event_name, ustchan);
 299         if (ustevent == NULL) {
 300                 ret = LTTCOMM_NO_EVENT;
 301                 goto end;
 302         }
 303         ret = ustctl_disable(ustsession->sock, ustevent->obj);
 304         if (ret < 0) {
 305                 ret = LTTCOMM_UST_ENABLE_FAIL;
 306                 goto end;
 307         }
 308         ustevent->enabled = 0;
 309         ret = LTTCOMM_OK;
 310 end:
 311         return ret;
 312 }