src/bin/lttng-sessiond/context.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 #define _GNU_SOURCE
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <string.h>
  22 #include <unistd.h>
  23 #include <urcu/list.h>
  24
  25 #include <common/error.h>
  26 #include <common/sessiond-comm/sessiond-comm.h>
  27
  28 #include "context.h"
  29 #include "kernel.h"
  30 #include "ust-app.h"
  31 #include "trace-ust.h"
  32
  33 /*
  34  * Add kernel context to an event of a specific channel.
  35  */
  36 static int add_kctx_to_event(struct lttng_kernel_context *kctx,
  37                 struct ltt_kernel_channel *kchan, char *event_name)
  38 {
  39         int ret, found = 0;
  40         struct ltt_kernel_event *kevent;
  41
  42         DBG("Add kernel context to event %s", event_name);
  43
  44         kevent = trace_kernel_get_event_by_name(event_name, kchan);
  45         if (kevent != NULL) {
  46                 ret = kernel_add_event_context(kevent, kctx);
  47                 if (ret < 0) {
  48                         goto error;
  49                 }
  50                 found = 1;
  51         }
  52
  53         ret = found;
  54
  55 error:
  56         return ret;
  57 }
  58
  59 /*
  60  * Add kernel context to all channel.
  61  *
  62  * If event_name is specified, add context to event instead.
  63  */
  64 static int add_kctx_all_channels(struct ltt_kernel_session *ksession,
  65                 struct lttng_kernel_context *kctx, char *event_name)
  66 {
  67         int ret, no_event = 0, found = 0;
  68         struct ltt_kernel_channel *kchan;
  69
  70         if (strlen(event_name) == 0) {
  71                 no_event = 1;
  72         }
  73
  74         DBG("Adding kernel context to all channels (event: %s)", event_name);
  75
  76         /* Go over all channels */
  77         cds_list_for_each_entry(kchan, &ksession->channel_list.head, list) {
  78                 if (no_event) {
  79                         ret = kernel_add_channel_context(kchan, kctx);
  80                         if (ret < 0) {
  81                                 ret = LTTCOMM_KERN_CONTEXT_FAIL;
  82                                 goto error;
  83                         }
  84                 } else {
  85                         ret = add_kctx_to_event(kctx, kchan, event_name);
  86                         if (ret < 0) {
  87                                 ret = LTTCOMM_KERN_CONTEXT_FAIL;
  88                                 goto error;
  89                         } else if (ret == 1) {
  90                                 /* Event found and context added */
  91                                 found = 1;
  92                                 break;
  93                         }
  94                 }
  95         }
  96
  97         if (!found && !no_event) {
  98                 ret = LTTCOMM_NO_EVENT;
  99                 goto error;
 100         }
 101
 102         ret = LTTCOMM_OK;
 103
 104 error:
 105         return ret;
 106 }
 107
 108 /*
 109  * Add kernel context to a specific channel.
 110  *
 111  * If event_name is specified, add context to that event.
 112  */
 113 static int add_kctx_to_channel(struct lttng_kernel_context *kctx,
 114                 struct ltt_kernel_channel *kchan, char *event_name)
 115 {
 116         int ret, no_event = 0, found = 0;
 117
 118         if (strlen(event_name) == 0) {
 119                 no_event = 1;
 120         }
 121
 122         DBG("Add kernel context to channel '%s', event '%s'",
 123                         kchan->channel->name, event_name);
 124
 125         if (no_event) {
 126                 ret = kernel_add_channel_context(kchan, kctx);
 127                 if (ret < 0) {
 128                         ret = LTTCOMM_KERN_CONTEXT_FAIL;
 129                         goto error;
 130                 }
 131         } else {
 132                 ret = add_kctx_to_event(kctx, kchan, event_name);
 133                 if (ret < 0) {
 134                         ret = LTTCOMM_KERN_CONTEXT_FAIL;
 135                         goto error;
 136                 } else if (ret == 1) {
 137                         /* Event found and context added */
 138                         found = 1;
 139                 }
 140         }
 141
 142         if (!found && !no_event) {
 143                 ret = LTTCOMM_NO_EVENT;
 144                 goto error;
 145         }
 146
 147         ret = LTTCOMM_OK;
 148
 149 error:
 150         return ret;
 151 }
 152
 153 /*
 154  * Add UST context to channel.
 155  */
 156 static int add_uctx_to_channel(struct ltt_ust_session *usess, int domain,
 157                 struct ltt_ust_channel *uchan, struct lttng_event_context *ctx)
 158 {
 159         int ret;
 160         struct ltt_ust_context *uctx;
 161
 162         /* Create ltt UST context */
 163         uctx = trace_ust_create_context(ctx);
 164         if (uctx == NULL) {
 165                 ret = LTTCOMM_FATAL;
 166                 goto error;
 167         }
 168
 169         switch (domain) {
 170         case LTTNG_DOMAIN_UST:
 171                 ret = ust_app_add_ctx_channel_glb(usess, uchan, uctx);
 172                 if (ret < 0) {
 173                         goto error;
 174                 }
 175                 break;
 176         default:
 177                 ret = LTTCOMM_NOT_IMPLEMENTED;
 178                 goto error;
 179         }
 180
 181         /* Add ltt UST context node to ltt UST channel */
 182         lttng_ht_add_unique_ulong(uchan->ctx, &uctx->node);
 183
 184         return LTTCOMM_OK;
 185
 186 error:
 187         free(uctx);
 188         return ret;
 189 }
 190
 191 /*
 192  * Add UST context to event.
 193  */
 194 static int add_uctx_to_event(struct ltt_ust_session *usess, int domain,
 195                 struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent,
 196                 struct lttng_event_context *ctx)
 197 {
 198         int ret;
 199         struct ltt_ust_context *uctx;
 200
 201         /* Create ltt UST context */
 202         uctx = trace_ust_create_context(ctx);
 203         if (uctx == NULL) {
 204                 ret = LTTCOMM_FATAL;
 205                 goto error;
 206         }
 207
 208         switch (domain) {
 209         case LTTNG_DOMAIN_UST:
 210                 ret = ust_app_add_ctx_event_glb(usess, uchan, uevent, uctx);
 211                 if (ret < 0) {
 212                         goto error;
 213                 }
 214                 break;
 215         default:
 216                 ret = LTTCOMM_NOT_IMPLEMENTED;
 217                 goto error;
 218         }
 219
 220         /* Add ltt UST context node to ltt UST event */
 221         lttng_ht_add_unique_ulong(uevent->ctx, &uctx->node);
 222
 223         return LTTCOMM_OK;
 224
 225 error:
 226         free(uctx);
 227         return ret;
 228 }
 229
 230 /*
 231  * Add kernel context to tracer.
 232  */
 233 int context_kernel_add(struct ltt_kernel_session *ksession,
 234                 struct lttng_event_context *ctx, char *event_name,
 235                 char *channel_name)
 236 {
 237         int ret;
 238         struct ltt_kernel_channel *kchan;
 239         struct lttng_kernel_context kctx;
 240
 241         /* Setup kernel context structure */
 242         kctx.ctx = ctx->ctx;
 243         kctx.u.perf_counter.type = ctx->u.perf_counter.type;
 244         kctx.u.perf_counter.config = ctx->u.perf_counter.config;
 245         strncpy(kctx.u.perf_counter.name, ctx->u.perf_counter.name,
 246                         LTTNG_SYMBOL_NAME_LEN);
 247         kctx.u.perf_counter.name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0';
 248
 249         if (strlen(channel_name) == 0) {
 250                 ret = add_kctx_all_channels(ksession, &kctx, event_name);
 251                 if (ret != LTTCOMM_OK) {
 252                         goto error;
 253                 }
 254         } else {
 255                 /* Get kernel channel */
 256                 kchan = trace_kernel_get_channel_by_name(channel_name, ksession);
 257                 if (kchan == NULL) {
 258                         ret = LTTCOMM_KERN_CHAN_NOT_FOUND;
 259                         goto error;
 260                 }
 261
 262                 ret = add_kctx_to_channel(&kctx, kchan, event_name);
 263                 if (ret != LTTCOMM_OK) {
 264                         goto error;
 265                 }
 266         }
 267
 268         ret = LTTCOMM_OK;
 269
 270 error:
 271         return ret;
 272 }
 273
 274 /*
 275  * Add UST context to tracer.
 276  */
 277 int context_ust_add(struct ltt_ust_session *usess, int domain,
 278                 struct lttng_event_context *ctx, char *event_name,
 279                 char *channel_name)
 280 {
 281         int ret = LTTCOMM_OK, have_event = 0;
 282         struct lttng_ht_iter iter, uiter;
 283         struct lttng_ht *chan_ht;
 284         struct ltt_ust_channel *uchan = NULL;
 285         struct ltt_ust_event *uevent = NULL;
 286
 287         /*
 288          * Define which channel's hashtable to use from the domain or quit if
 289          * unknown domain.
 290          */
 291         switch (domain) {
 292         case LTTNG_DOMAIN_UST:
 293                 chan_ht = usess->domain_global.channels;
 294                 break;
 295 #if 0
 296         case LTTNG_DOMAIN_UST_EXEC_NAME:
 297         case LTTNG_DOMAIN_UST_PID:
 298         case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN:
 299 #endif
 300         default:
 301                 ret = LTTCOMM_NOT_IMPLEMENTED;
 302                 goto error;
 303         }
 304
 305         /* Do we have an event name */
 306         if (strlen(event_name) != 0) {
 307                 have_event = 1;
 308         }
 309
 310         /* Get UST channel if defined */
 311         if (strlen(channel_name) != 0) {
 312                 uchan = trace_ust_find_channel_by_name(chan_ht, channel_name);
 313                 if (uchan == NULL) {
 314                         ret = LTTCOMM_UST_CHAN_NOT_FOUND;
 315                         goto error;
 316                 }
 317         }
 318
 319         /* If UST channel specified and event name, get UST event ref */
 320         if (uchan && have_event) {
 321                 uevent = trace_ust_find_event_by_name(uchan->events, event_name);
 322                 if (uevent == NULL) {
 323                         ret = LTTCOMM_UST_EVENT_NOT_FOUND;
 324                         goto error;
 325                 }
 326         }
 327
 328         /* At this point, we have 4 possibilities */
 329
 330         if (uchan && uevent) {                          /* Add ctx to event in channel */
 331                 ret = add_uctx_to_event(usess, domain, uchan, uevent, ctx);
 332         } else if (uchan && !have_event) {      /* Add ctx to channel */
 333                 ret = add_uctx_to_channel(usess, domain, uchan, ctx);
 334         } else if (!uchan && have_event) {      /* Add ctx to event */
 335                 /* Add context to event without having the channel name */
 336                 cds_lfht_for_each_entry(chan_ht->ht, &iter.iter, uchan, node.node) {
 337                         uevent = trace_ust_find_event_by_name(uchan->events, event_name);
 338                         if (uevent != NULL) {
 339                                 ret = add_uctx_to_event(usess, domain, uchan, uevent, ctx);
 340                                 /*
 341                                  * LTTng UST does not allowed the same event to be registered
 342                                  * multiple time in different or the same channel. So, if we
 343                                  * found our event, we stop.
 344                                  */
 345                                 goto end;
 346                         }
 347                 }
 348                 ret = LTTCOMM_UST_EVENT_NOT_FOUND;
 349                 goto error;
 350         } else if (!uchan && !have_event) {     /* Add ctx all events, all channels */
 351                 /* For all channels */
 352                 cds_lfht_for_each_entry(chan_ht->ht, &iter.iter, uchan, node.node) {
 353                         ret = add_uctx_to_channel(usess, domain, uchan, ctx);
 354                         if (ret < 0) {
 355                                 ERR("Context added to channel %s failed", uchan->name);
 356                                 continue;
 357                         }
 358
 359                         /* For all events in channel */
 360                         cds_lfht_for_each_entry(uchan->events->ht, &uiter.iter, uevent,
 361                                         node.node) {
 362                                 ret = add_uctx_to_event(usess, domain, uchan, uevent, ctx);
 363                                 if (ret < 0) {
 364                                         ERR("Context add to event %s in channel %s failed",
 365                                                         uevent->attr.name, uchan->name);
 366                                         continue;
 367                                 }
 368                         }
 369                 }
 370         }
 371
 372 end:
 373         switch (ret) {
 374         case -EEXIST:
 375                 ret = LTTCOMM_UST_CONTEXT_EXIST;
 376                 goto error;
 377         case -ENOMEM:
 378                 ret = LTTCOMM_FATAL;
 379                 goto error;
 380         }
 381
 382         return LTTCOMM_OK;
 383
 384 error:
 385         return ret;
 386 }