liblttngctl/liblttngctl.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 <grp.h>
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <unistd.h>
  26
  27 #include <lttng/liblttngctl.h>
  28
  29 #include "liblttsessiondcomm.h"
  30 #include "lttngerr.h"
  31
  32 /* Socket to session daemon for communication */
  33 static int sessiond_socket;
  34 static char sessiond_sock_path[PATH_MAX];
  35
  36 /* Communication structure to ltt-sessiond */
  37 static struct lttcomm_session_msg lsm;
  38 static struct lttcomm_lttng_msg llm;
  39
  40 /* Prototypes */
  41 static int check_tracing_group(const char *grp_name);
  42 static int ask_sessiond(enum lttcomm_command_type lct, void **buf);
  43 static int recv_data_sessiond(void *buf, size_t len);
  44 static int send_data_sessiond(void);
  45 static int set_session_daemon_path(void);
  46
  47 /* Variables */
  48 static char *tracing_group;
  49 static int connected;
  50
  51 /*
  52  *  send_data_sessiond
  53  *
  54  *  Send lttcomm_session_msg to the session daemon.
  55  *
  56  *  On success, return 0
  57  *  On error, return error code
  58  */
  59 static int send_data_sessiond(void)
  60 {
  61         int ret;
  62
  63         if (!connected) {
  64                 ret = -ENOTCONN;
  65                 goto end;
  66         }
  67
  68         ret = lttcomm_send_unix_sock(sessiond_socket, &lsm, sizeof(lsm));
  69
  70 end:
  71         return ret;
  72 }
  73
  74 /*
  75  *  recv_data_sessiond
  76  *
  77  *  Receive data from the sessiond socket.
  78  *
  79  *  On success, return 0
  80  *  On error, return recv() error code
  81  */
  82 static int recv_data_sessiond(void *buf, size_t len)
  83 {
  84         int ret;
  85
  86         if (!connected) {
  87                 ret = -ENOTCONN;
  88                 goto end;
  89         }
  90
  91         ret = lttcomm_recv_unix_sock(sessiond_socket, buf, len);
  92         if (ret < 0) {
  93                 goto end;
  94         }
  95
  96 end:
  97         return ret;
  98 }
  99
 100 /*
 101  *  ask_sessiond
 102  *
 103  *  Ask the session daemon a specific command
 104  *  and put the data into buf.
 105  *
 106  *  Return size of data (only payload, not header).
 107  */
 108 static int ask_sessiond(enum lttcomm_command_type lct, void **buf)
 109 {
 110         int ret;
 111         size_t size;
 112         void *data = NULL;
 113
 114         lsm.cmd_type = lct;
 115
 116         /* Send command to session daemon */
 117         ret = send_data_sessiond();
 118         if (ret < 0) {
 119                 goto end;
 120         }
 121
 122         /* Get header from data transmission */
 123         ret = recv_data_sessiond(&llm, sizeof(llm));
 124         if (ret < 0) {
 125                 goto end;
 126         }
 127
 128         /* Check error code if OK */
 129         if (llm.ret_code != LTTCOMM_OK) {
 130                 ret = -llm.ret_code;
 131                 goto end;
 132         }
 133
 134         size = llm.size_payload;
 135         if (size == 0) {
 136                 goto end;
 137         }
 138
 139         data = (void*) malloc(size);
 140
 141         /* Get payload data */
 142         ret = recv_data_sessiond(data, size);
 143         if (ret < 0) {
 144                 goto end;
 145         }
 146
 147         *buf = data;
 148         ret = size;
 149
 150 end:
 151         /* Reset lsm data struct */
 152         memset(&lsm, 0, sizeof(lsm));
 153         return ret;
 154 }
 155
 156 /*
 157  *  lttng_get_readable_code
 158  *
 159  *  Return a human readable string of code
 160  */
 161 const char *lttng_get_readable_code(int code)
 162 {
 163         if (code > -LTTCOMM_OK) {
 164                 return "Ended with errors";
 165         }
 166
 167         return lttcomm_get_readable_code(code);
 168 }
 169
 170 /*
 171  *  lttng_ust_list_apps
 172  *
 173  *  Ask the session daemon for all UST traceable
 174  *  applications.
 175  *
 176  *  Return the number of pids.
 177  *  On error, return negative value.
 178  */
 179 int lttng_ust_list_apps(pid_t **pids)
 180 {
 181         int ret;
 182
 183         ret = ask_sessiond(UST_LIST_APPS, (void**) pids);
 184         if (ret < 0) {
 185                 return ret;
 186         }
 187
 188         return ret / sizeof(pid_t);
 189 }
 190
 191 /*
 192  *  lttng_create_session
 193  *
 194  *  Create a brand new session using name. Allocate
 195  *  the session_id param pointing to the UUID.
 196  */
 197 int lttng_create_session(char *name, uuid_t *session_id)
 198 {
 199         int ret;
 200         char *uuid;
 201
 202         strncpy(lsm.session_name, name, sizeof(lsm.session_name));
 203         lsm.session_name[sizeof(lsm.session_name) - 1] = '\0';
 204
 205         ret = ask_sessiond(LTTNG_CREATE_SESSION, NULL);
 206         if (ret < 0) {
 207                 goto end;
 208         }
 209
 210         uuid_copy(*session_id, llm.session_id);
 211
 212 end:
 213         return ret;
 214 }
 215
 216 /*
 217  *  lttng_destroy_session
 218  *
 219  *  Destroy session using name.
 220  */
 221 int lttng_destroy_session(uuid_t *uuid)
 222 {
 223         int ret;
 224
 225         uuid_copy(lsm.session_id, *uuid);
 226
 227         ret = ask_sessiond(LTTNG_DESTROY_SESSION, NULL);
 228         if (ret < 0) {
 229                 goto end;
 230         }
 231
 232 end:
 233         return ret;
 234 }
 235
 236 /*
 237  *  lttng_list_sessions
 238  *
 239  *  Ask the session daemon for all available sessions.
 240  *
 241  *  Return number of session.
 242  *  On error, return negative value.
 243  */
 244 int lttng_list_sessions(struct lttng_session **sessions)
 245 {
 246         int ret;
 247
 248         ret = ask_sessiond(LTTNG_LIST_SESSIONS, (void**) sessions);
 249         if (ret < 0) {
 250                 return ret;
 251         }
 252
 253         return ret / sizeof(struct lttng_session);
 254 }
 255
 256 /*
 257  *  lttng_connect_sessiond
 258  *
 259  *  Connect to the LTTng session daemon.
 260  *  On success, return 0
 261  *  On error, return a negative value
 262  */
 263 int lttng_connect_sessiond(void)
 264 {
 265         int ret;
 266
 267         ret = set_session_daemon_path();
 268         if (ret < 0) {
 269                 return ret;
 270         }
 271
 272         /* Connect to the sesssion daemon */
 273         ret = lttcomm_connect_unix_sock(sessiond_sock_path);
 274         if (ret < 0) {
 275                 return ret;
 276         }
 277
 278         sessiond_socket = ret;
 279         connected = 1;
 280
 281         return 0;
 282 }
 283
 284 /*
 285  *  lttng_set_tracing_group
 286  *
 287  *  Set tracing group variable with name. This function
 288  *  allocate memory pointed by tracing_group.
 289  */
 290 int lttng_set_tracing_group(const char *name)
 291 {
 292         if (asprintf(&tracing_group, "%s", name) < 0) {
 293                 return -ENOMEM;
 294         }
 295
 296         return 0;
 297 }
 298
 299 /*
 300  *  lttng_check_session_daemon
 301  *
 302  *  Return 0 if a sesssion daemon is available
 303  *  else return -1
 304  */
 305 int lttng_check_session_daemon(void)
 306 {
 307         int ret;
 308
 309         ret = set_session_daemon_path();
 310         if (ret < 0) {
 311                 return ret;
 312         }
 313
 314         /* If socket exist, we consider the daemon started */
 315         ret = access(sessiond_sock_path, F_OK);
 316         if (ret < 0) {
 317                 return ret;
 318         }
 319
 320         return 0;
 321 }
 322
 323 /*
 324  *  set_session_daemon_path
 325  *
 326  *  Set sessiond socket path by putting it in
 327  *  the global sessiond_sock_path variable.
 328  */
 329 static int set_session_daemon_path(void)
 330 {
 331         int ret;
 332
 333         /* Are we in the tracing group ? */
 334         ret = check_tracing_group(tracing_group);
 335         if (ret < 0) {
 336                 if (sprintf(sessiond_sock_path, DEFAULT_HOME_CLIENT_UNIX_SOCK,
 337                                         getenv("HOME")) < 0) {
 338                         return -ENOMEM;
 339                 }
 340         } else {
 341                 strncpy(sessiond_sock_path, DEFAULT_GLOBAL_CLIENT_UNIX_SOCK,
 342                                 sizeof(DEFAULT_GLOBAL_CLIENT_UNIX_SOCK));
 343         }
 344
 345         return 0;
 346 }
 347
 348 /*
 349  *  check_tracing_group
 350  *
 351  *  Check if the specified group name exist.
 352  *  If yes, 0, else -1
 353  */
 354 static int check_tracing_group(const char *grp_name)
 355 {
 356         struct group *grp_tracing;      /* no free(). See getgrnam(3) */
 357         gid_t *grp_list;
 358         int grp_list_size, grp_id, i;
 359         int ret = -1;
 360
 361         /* Get GID of group 'tracing' */
 362         grp_tracing = getgrnam(grp_name);
 363         if (grp_tracing == NULL) {
 364                 /* NULL means not found also. getgrnam(3) */
 365                 if (errno != 0) {
 366                         perror("getgrnam");
 367                 }
 368                 goto end;
 369         }
 370
 371         /* Get number of supplementary group IDs */
 372         grp_list_size = getgroups(0, NULL);
 373         if (grp_list_size < 0) {
 374                 perror("getgroups");
 375                 goto end;
 376         }
 377
 378         /* Alloc group list of the right size */
 379         grp_list = malloc(grp_list_size * sizeof(gid_t));
 380         grp_id = getgroups(grp_list_size, grp_list);
 381         if (grp_id < -1) {
 382                 perror("getgroups");
 383                 goto free_list;
 384         }
 385
 386         for (i = 0; i < grp_list_size; i++) {
 387                 if (grp_list[i] == grp_tracing->gr_gid) {
 388                         ret = 0;
 389                         break;
 390                 }
 391         }
 392
 393 free_list:
 394         free(grp_list);
 395
 396 end:
 397         return ret;
 398 }
 399
 400 /*
 401  * lib constructor
 402  */
 403 static void __attribute__((constructor)) init()
 404 {
 405         /* Set default session group */
 406         lttng_set_tracing_group(DEFAULT_TRACING_GROUP);
 407 }