ltt-sessiond/trace.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
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version 2
   7  * of the License, or (at your option) any later version.
   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
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  17  */
  18
  19 #define _GNU_SOURCE
  20 #include <errno.h>
  21 #include <limits.h>
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <urcu/list.h>
  26 #include <ust/ustctl.h>
  27
  28 #include "liblttsessiondcomm.h"
  29 #include "lttngerr.h"
  30 #include "trace.h"
  31 #include "session.h"
  32 #include "ltt-sessiond.h"
  33
  34 static struct ltt_ust_trace *find_session_ust_trace_by_pid(
  35                 struct ltt_session *session, pid_t pid);
  36
  37 /*
  38  *  find_session_ust_trace_by_pid
  39  *
  40  *  Iterate over the session ust_traces and
  41  *  return a pointer or NULL if not found.
  42  */
  43 static struct ltt_ust_trace *find_session_ust_trace_by_pid(
  44                 struct ltt_session *session, pid_t pid)
  45 {
  46         struct ltt_ust_trace *iter;
  47
  48         cds_list_for_each_entry(iter, &session->ust_traces, list) {
  49                 if (iter->pid == pid) {
  50                         /* Found */
  51                         return iter;
  52                 }
  53         }
  54
  55         return NULL;
  56 }
  57
  58 /*
  59  *  get_trace_count_per_session
  60  *
  61  *  Return the total count of traces (ust and kernel)
  62  *  for the specified session.
  63  */
  64 int get_trace_count_per_session(struct ltt_session *session)
  65 {
  66         return session->ust_trace_count + session->kern_session_count;
  67 }
  68
  69 /*
  70  *  get_traces_per_session
  71  *
  72  *  Fill the lttng_trace array of all the
  73  *  available trace of the session.
  74  */
  75 void get_traces_per_session(struct ltt_session *session, struct lttng_trace *traces)
  76 {
  77         int i = 0;
  78         struct ltt_ust_trace *ust_iter;
  79         struct lttng_trace trace;
  80
  81         DBG("Getting userspace traces for session %s", session->name);
  82
  83         /* Getting userspace traces */
  84         cds_list_for_each_entry(ust_iter, &session->ust_traces, list) {
  85                 trace.type = USERSPACE;
  86                 trace.pid = ust_iter->pid;
  87                 strncpy(trace.name, ust_iter->name, sizeof(trace.name));
  88                 trace.name[sizeof(trace.name) - 1] = '\0';
  89                 memcpy(&traces[i], &trace, sizeof(trace));
  90                 memset(&trace, 0, sizeof(trace));
  91                 i++;
  92         }
  93
  94         DBG("Getting kernel traces for session %s", session->name);
  95
  96         /* Getting kernel traces */
  97         if (session->kern_session_count > 0) {
  98                 trace.type = KERNEL;
  99                 strncpy(trace.name, "kernel", 6);
 100                 memcpy(&traces[i], &trace, sizeof(trace));
 101         }
 102 }
 103
 104 /*
 105  *  ust_create_trace
 106  *
 107  *  Create an userspace trace using pid.
 108  *  This trace is then appended to the current session
 109  *  ust trace list.
 110  */
 111 int ust_create_trace(struct command_ctx *cmd_ctx)
 112 {
 113         int ret;
 114         struct ltt_ust_trace *trace;
 115
 116         DBG("Creating trace for pid %d", cmd_ctx->lsm->pid);
 117
 118         trace = malloc(sizeof(struct ltt_ust_trace));
 119         if (trace == NULL) {
 120                 perror("malloc");
 121                 ret = -1;
 122                 goto error;
 123         }
 124
 125         /* Init */
 126         trace->pid = cmd_ctx->lsm->pid;
 127         trace->shmid = 0;
 128         /* NOTE: to be removed. Trace name will no longer be
 129          * required for LTTng userspace tracer. For now, we set it
 130          * to 'auto' for API compliance.
 131          */
 132         snprintf(trace->name, 5, "auto");
 133
 134         ret = ustctl_create_trace(cmd_ctx->ust_sock, trace->name);
 135         if (ret < 0) {
 136                 ret = LTTCOMM_CREATE_FAIL;
 137                 goto error_create;
 138         }
 139
 140         /* Check if current session is valid */
 141         if (cmd_ctx->session) {
 142                 cds_list_add(&trace->list, &cmd_ctx->session->ust_traces);
 143                 cmd_ctx->session->ust_trace_count++;
 144         }
 145
 146         return LTTCOMM_OK;
 147
 148 error_create:
 149         free(trace);
 150 error:
 151         return ret;
 152 }
 153
 154 /*
 155  *  ust_start_trace
 156  *
 157  *  Start a trace. This trace, identified by the pid, must be
 158  *  in the current session ust_traces list.
 159  */
 160 int ust_start_trace(struct command_ctx *cmd_ctx)
 161 {
 162         int ret;
 163         struct ltt_ust_trace *trace;
 164
 165         DBG("Starting trace for pid %d", cmd_ctx->lsm->pid);
 166
 167         trace = find_session_ust_trace_by_pid(cmd_ctx->session, cmd_ctx->lsm->pid);
 168         if (trace == NULL) {
 169                 ret = LTTCOMM_NO_TRACE;
 170                 goto error;
 171         }
 172
 173         ret = ustctl_start_trace(cmd_ctx->ust_sock, "auto");
 174         if (ret < 0) {
 175                 ret = LTTCOMM_START_FAIL;
 176                 goto error;
 177         }
 178
 179         ret = LTTCOMM_OK;
 180
 181 error:
 182         return ret;
 183 }
 184
 185 /*
 186  *  ust_stop_trace
 187  *
 188  *  Stop a trace. This trace, identified by the pid, must be
 189  *  in the current session ust_traces list.
 190  */
 191 int ust_stop_trace(struct command_ctx *cmd_ctx)
 192 {
 193         int ret;
 194         struct ltt_ust_trace *trace;
 195
 196         DBG("Stopping trace for pid %d", cmd_ctx->lsm->pid);
 197
 198         trace = find_session_ust_trace_by_pid(cmd_ctx->session, cmd_ctx->lsm->pid);
 199         if (trace == NULL) {
 200                 ret = LTTCOMM_NO_TRACE;
 201                 goto error;
 202         }
 203
 204         ret = ustctl_stop_trace(cmd_ctx->ust_sock, trace->name);
 205         if (ret < 0) {
 206                 ret = LTTCOMM_STOP_FAIL;
 207                 goto error;
 208         }
 209
 210         ret = LTTCOMM_OK;
 211
 212 error:
 213         return ret;
 214 }
 215