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