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