Add disable kernel channel support
[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
5b97ec60 27#include <lttng/lttng.h>
fac6795d
DG
28
29#include "liblttsessiondcomm.h"
30#include "lttngerr.h"
f3ed775e 31#include "lttng-share.h"
fac6795d
DG
32
33/* Socket to session daemon for communication */
34static int sessiond_socket;
35static char sessiond_sock_path[PATH_MAX];
36
37/* Communication structure to ltt-sessiond */
fac6795d 38static struct lttcomm_session_msg lsm;
5461b305 39static struct lttcomm_lttng_msg llm;
fac6795d 40
fac6795d
DG
41/* Variables */
42static char *tracing_group;
43static int connected;
44
45/*
ca95a216 46 * send_data_sessiond
fac6795d 47 *
e065084a 48 * Send lttcomm_session_msg to the session daemon.
fac6795d
DG
49 *
50 * On success, return 0
51 * On error, return error code
52 */
ca95a216 53static int send_data_sessiond(void)
fac6795d
DG
54{
55 int ret;
56
57 if (!connected) {
e065084a
DG
58 ret = -ENOTCONN;
59 goto end;
fac6795d
DG
60 }
61
62 ret = lttcomm_send_unix_sock(sessiond_socket, &lsm, sizeof(lsm));
e065084a
DG
63
64end:
65 return ret;
66}
67
68/*
ca95a216 69 * recv_data_sessiond
e065084a
DG
70 *
71 * Receive data from the sessiond socket.
72 *
73 * On success, return 0
74 * On error, return recv() error code
75 */
ca95a216 76static int recv_data_sessiond(void *buf, size_t len)
e065084a
DG
77{
78 int ret;
79
80 if (!connected) {
81 ret = -ENOTCONN;
82 goto end;
fac6795d
DG
83 }
84
ca95a216 85 ret = lttcomm_recv_unix_sock(sessiond_socket, buf, len);
fac6795d 86
e065084a 87end:
fac6795d
DG
88 return ret;
89}
90
91/*
ca95a216 92 * ask_sessiond
fac6795d 93 *
947308c4 94 * Ask the session daemon a specific command and put the data into buf.
ca95a216
DG
95 *
96 * Return size of data (only payload, not header).
fac6795d 97 */
6abb15de 98static int ask_sessiond(enum lttcomm_sessiond_command lct, void **buf)
fac6795d 99{
ca95a216
DG
100 int ret;
101 size_t size;
102 void *data = NULL;
ca95a216 103
7442b2ba
DG
104 ret = lttng_connect_sessiond();
105 if (ret < 0) {
106 goto end;
107 }
108
ca95a216
DG
109 lsm.cmd_type = lct;
110
111 /* Send command to session daemon */
112 ret = send_data_sessiond();
113 if (ret < 0) {
114 goto end;
fac6795d
DG
115 }
116
ca95a216 117 /* Get header from data transmission */
5461b305 118 ret = recv_data_sessiond(&llm, sizeof(llm));
ca95a216
DG
119 if (ret < 0) {
120 goto end;
121 }
fac6795d 122
ca95a216 123 /* Check error code if OK */
5461b305
DG
124 if (llm.ret_code != LTTCOMM_OK) {
125 ret = -llm.ret_code;
ca95a216
DG
126 goto end;
127 }
fac6795d 128
f3ed775e 129 size = llm.data_size;
ca95a216
DG
130 if (size == 0) {
131 goto end;
fac6795d
DG
132 }
133
ca95a216
DG
134 data = (void*) malloc(size);
135
136 /* Get payload data */
137 ret = recv_data_sessiond(data, size);
fac6795d 138 if (ret < 0) {
947308c4 139 free(data);
fac6795d
DG
140 goto end;
141 }
142
ca95a216
DG
143 *buf = data;
144 ret = size;
fac6795d
DG
145
146end:
7442b2ba 147 lttng_disconnect_sessiond();
fac6795d
DG
148 return ret;
149}
150
947308c4
DG
151/*
152 * check_tracing_group
153 *
154 * Check if the specified group name exist.
155 * If yes, 0, else -1
156 */
157static int check_tracing_group(const char *grp_name)
158{
159 struct group *grp_tracing; /* no free(). See getgrnam(3) */
160 gid_t *grp_list;
161 int grp_list_size, grp_id, i;
162 int ret = -1;
163
164 /* Get GID of group 'tracing' */
165 grp_tracing = getgrnam(grp_name);
166 if (grp_tracing == NULL) {
167 /* NULL means not found also. getgrnam(3) */
168 if (errno != 0) {
169 perror("getgrnam");
170 }
171 goto end;
172 }
173
174 /* Get number of supplementary group IDs */
175 grp_list_size = getgroups(0, NULL);
176 if (grp_list_size < 0) {
177 perror("getgroups");
178 goto end;
179 }
180
181 /* Alloc group list of the right size */
182 grp_list = malloc(grp_list_size * sizeof(gid_t));
183 grp_id = getgroups(grp_list_size, grp_list);
184 if (grp_id < -1) {
185 perror("getgroups");
186 goto free_list;
187 }
188
189 for (i = 0; i < grp_list_size; i++) {
190 if (grp_list[i] == grp_tracing->gr_gid) {
191 ret = 0;
192 break;
193 }
194 }
195
196free_list:
197 free(grp_list);
198
199end:
200 return ret;
201}
202
203/*
204 * set_session_daemon_path
205 *
206 * Set sessiond socket path by putting it in
207 * the global sessiond_sock_path variable.
208 */
209static int set_session_daemon_path(void)
210{
211 int ret;
212
213 /* Are we in the tracing group ? */
214 ret = check_tracing_group(tracing_group);
215 if (ret < 0 && getuid() != 0) {
216 if (sprintf(sessiond_sock_path, DEFAULT_HOME_CLIENT_UNIX_SOCK,
217 getenv("HOME")) < 0) {
218 return -ENOMEM;
219 }
220 } else {
221 strncpy(sessiond_sock_path, DEFAULT_GLOBAL_CLIENT_UNIX_SOCK,
222 sizeof(DEFAULT_GLOBAL_CLIENT_UNIX_SOCK));
223 }
224
225 return 0;
226}
227
1df4dedd 228/*
f3ed775e
DG
229 * lttng_start_tracing
230 *
231 * Start tracing for all trace of the session.
1df4dedd 232 */
f3ed775e
DG
233int lttng_start_tracing(char *session_name)
234{
235 strncpy(lsm.session_name, session_name, NAME_MAX);
236 return ask_sessiond(LTTNG_START_TRACE, NULL);
237}
1df4dedd
DG
238
239/*
f3ed775e 240 * lttng_stop_tracing
1df4dedd 241 *
f3ed775e
DG
242 * Stop tracing for all trace of the session.
243 */
244int lttng_stop_tracing(char *session_name)
245{
246 strncpy(lsm.session_name, session_name, NAME_MAX);
247 return ask_sessiond(LTTNG_STOP_TRACE, NULL);
248}
249
250/*
251 * BEGIN Kernel control API
1df4dedd 252 */
f3ed775e
DG
253
254/*
255 * lttng_kernel_enable_event
256 */
257int lttng_kernel_enable_event(struct lttng_event *ev, char *channel_name)
1df4dedd 258{
33a2b854
DG
259 int ret;
260
f3ed775e
DG
261 if (strlen(channel_name) == 0) {
262 strncpy(lsm.u.enable.channel_name, DEFAULT_CHANNEL_NAME, NAME_MAX);
33a2b854 263 } else {
f3ed775e
DG
264 strncpy(lsm.u.enable.channel_name, channel_name, NAME_MAX);
265 }
266
267 if (ev == NULL) {
268 ret = ask_sessiond(LTTNG_KERNEL_ENABLE_ALL_EVENT, NULL);
269 } else {
270 memcpy(&lsm.u.enable.event, ev, sizeof(struct lttng_event));
271 ret = ask_sessiond(LTTNG_KERNEL_ENABLE_EVENT, NULL);
33a2b854
DG
272 }
273
274 return ret;
1df4dedd
DG
275}
276
277/*
278 * lttng_kernel_disable_event
279 *
280 * Disable an event in the kernel tracer.
281 */
f3ed775e 282int lttng_kernel_disable_event(char *name, char *channel_name)
1df4dedd 283{
f3ed775e 284 int ret;
1df4dedd 285
f3ed775e
DG
286 if (strlen(channel_name) == 0) {
287 strncpy(lsm.u.disable.channel_name, DEFAULT_CHANNEL_NAME, NAME_MAX);
288 } else {
289 strncpy(lsm.u.disable.channel_name, channel_name, NAME_MAX);
290 }
291
292 if (name == NULL) {
293 ret = ask_sessiond(LTTNG_KERNEL_DISABLE_ALL_EVENT, NULL);
294 } else {
295 strncpy(lsm.u.disable.name, name, NAME_MAX);
296 ret = ask_sessiond(LTTNG_KERNEL_DISABLE_EVENT, NULL);
297 }
298
299 return ret;
1df4dedd
DG
300}
301
302/*
f3ed775e 303 * lttng_kernel_enable_channel
1df4dedd 304 *
f3ed775e 305 * Enable recording for a channel for the kernel tracer.
1df4dedd 306 */
f3ed775e 307int lttng_kernel_enable_channel(char *name)
1df4dedd 308{
d36b8583 309 strncpy(lsm.u.enable.channel_name, name, NAME_MAX);
f3ed775e 310 return ask_sessiond(LTTNG_KERNEL_ENABLE_CHANNEL, NULL);
1df4dedd 311}
a5c5a2bd
DG
312
313/*
f3ed775e 314 * lttng_kernel_disable_channel
a5c5a2bd 315 *
f3ed775e 316 * Disable recording for the channel for the kernel tracer.
a5c5a2bd 317 */
f3ed775e 318int lttng_kernel_disable_channel(char *name)
a5c5a2bd 319{
26cc6b4e 320 strncpy(lsm.u.disable.channel_name, name, NAME_MAX);
f3ed775e 321 return ask_sessiond(LTTNG_KERNEL_DISABLE_CHANNEL, NULL);
a5c5a2bd 322}
8c0faa1d
DG
323
324/*
f3ed775e 325 * lttng_kernel_create_channel
8c0faa1d 326 *
f3ed775e 327 * Create a channel in the kernel tracer.
8c0faa1d 328 */
f3ed775e 329int lttng_kernel_create_channel(struct lttng_channel *chan)
8c0faa1d 330{
f3ed775e
DG
331 memcpy(&lsm.u.channel.chan, chan, sizeof(struct lttng_channel));
332 return ask_sessiond(LTTNG_KERNEL_CREATE_CHANNEL, NULL);
8c0faa1d 333}
1df4dedd 334
2ef84c95 335/*
f3ed775e 336 * lttng_list_events
2ef84c95
DG
337 *
338 * List all available events in the kernel.
339 *
340 * Return the size (bytes) of the list and set the event_list array.
341 * On error, return negative value.
342 */
343int lttng_kernel_list_events(char **event_list)
344{
f3ed775e 345 return ask_sessiond(LTTNG_KERNEL_LIST_EVENTS, (void **) event_list);
2ef84c95
DG
346}
347
1df4dedd 348/*
f3ed775e 349 * END Kernel control API
1df4dedd
DG
350 */
351
ca95a216
DG
352/*
353 * lttng_get_readable_code
354 *
355 * Return a human readable string of code
356 */
357const char *lttng_get_readable_code(int code)
358{
359 if (code > -LTTCOMM_OK) {
360 return "Ended with errors";
361 }
362
363 return lttcomm_get_readable_code(code);
364}
365
fac6795d
DG
366/*
367 * lttng_ust_list_apps
368 *
947308c4 369 * Ask the session daemon for all UST traceable applications.
fac6795d 370 *
ca95a216
DG
371 * Return the number of pids.
372 * On error, return negative value.
fac6795d 373 */
f3ed775e 374int lttng_ust_list_traceable_apps(pid_t **pids)
fac6795d 375{
ca95a216 376 int ret;
fac6795d 377
f3ed775e 378 ret = ask_sessiond(LTTNG_LIST_TRACEABLE_APPS, (void**) pids);
fac6795d 379 if (ret < 0) {
ca95a216 380 return ret;
fac6795d
DG
381 }
382
ca95a216 383 return ret / sizeof(pid_t);
fac6795d
DG
384}
385
1657e9bb
DG
386/*
387 * lttng_list_traces
388 *
947308c4 389 * Ask the session daemon for all traces (kernel and ust) for the session
f3ed775e 390 * identified by name.
1657e9bb
DG
391 *
392 * Return the number of traces.
947308c4 393 * On error, return negative value.
1657e9bb 394 */
f3ed775e
DG
395/*
396int lttng_list_traces(char *session_name, struct lttng_trace **traces)
1657e9bb
DG
397{
398 int ret;
399
f3ed775e 400 strncpy(lsm.session_name, session_name, NAME_MAX);
1657e9bb
DG
401
402 ret = ask_sessiond(LTTNG_LIST_TRACES, (void **) traces);
403 if (ret < 0) {
404 return ret;
405 }
406
407 return ret / sizeof(struct lttng_trace);
408}
f3ed775e 409*/
1657e9bb 410
aaf97519
DG
411/*
412 * lttng_create_session
413 *
894be886 414 * Create a brand new session using name.
aaf97519 415 */
f3ed775e 416int lttng_create_session(char *name, char *path)
aaf97519 417{
947308c4 418 strncpy(lsm.session_name, name, NAME_MAX);
f3ed775e 419 strncpy(lsm.path, path, PATH_MAX);
947308c4 420 return ask_sessiond(LTTNG_CREATE_SESSION, NULL);
8028d920
DG
421}
422
423/*
424 * lttng_destroy_session
425 *
426 * Destroy session using name.
427 */
f3ed775e 428int lttng_destroy_session(char *name)
8028d920 429{
f3ed775e 430 strncpy(lsm.session_name, name, NAME_MAX);
947308c4 431 return ask_sessiond(LTTNG_DESTROY_SESSION, NULL);
aaf97519
DG
432}
433
57167058
DG
434/*
435 * lttng_list_sessions
436 *
437 * Ask the session daemon for all available sessions.
438 *
ca95a216
DG
439 * Return number of session.
440 * On error, return negative value.
57167058 441 */
ca95a216 442int lttng_list_sessions(struct lttng_session **sessions)
57167058 443{
ca95a216 444 int ret;
57167058 445
ca95a216 446 ret = ask_sessiond(LTTNG_LIST_SESSIONS, (void**) sessions);
57167058 447 if (ret < 0) {
ca95a216 448 return ret;
57167058
DG
449 }
450
ca95a216 451 return ret / sizeof(struct lttng_session);
57167058
DG
452}
453
fac6795d
DG
454/*
455 * lttng_connect_sessiond
456 *
457 * Connect to the LTTng session daemon.
458 * On success, return 0
459 * On error, return a negative value
460 */
461int lttng_connect_sessiond(void)
462{
463 int ret;
464
465 ret = set_session_daemon_path();
466 if (ret < 0) {
467 return ret;
468 }
469
470 /* Connect to the sesssion daemon */
471 ret = lttcomm_connect_unix_sock(sessiond_sock_path);
472 if (ret < 0) {
473 return ret;
474 }
475
476 sessiond_socket = ret;
477 connected = 1;
478
479 return 0;
480}
481
87378cf5
DG
482/*
483 * lttng_disconnect_sessiond
484 *
485 * Clean disconnect the session daemon.
486 */
487int lttng_disconnect_sessiond(void)
488{
489 int ret = 0;
490
491 if (connected) {
492 ret = lttcomm_close_unix_sock(sessiond_socket);
493 sessiond_socket = 0;
494 connected = 0;
495 }
496
497 return ret;
498}
499
f3ed775e 500void lttng_set_session_name(char *name)
e8be5f4f 501{
f3ed775e 502 strncpy(lsm.session_name, name, NAME_MAX);
e8be5f4f
DG
503}
504
fac6795d
DG
505/*
506 * lttng_set_tracing_group
507 *
508 * Set tracing group variable with name. This function
509 * allocate memory pointed by tracing_group.
510 */
511int lttng_set_tracing_group(const char *name)
512{
513 if (asprintf(&tracing_group, "%s", name) < 0) {
514 return -ENOMEM;
515 }
516
517 return 0;
518}
519
520/*
521 * lttng_check_session_daemon
522 *
947308c4
DG
523 * Yes, return 1
524 * No, return 0
525 * Error, return negative value
fac6795d 526 */
947308c4 527int lttng_session_daemon_alive(void)
fac6795d
DG
528{
529 int ret;
530
531 ret = set_session_daemon_path();
532 if (ret < 0) {
947308c4 533 /* Error */
fac6795d
DG
534 return ret;
535 }
536
537 /* If socket exist, we consider the daemon started */
538 ret = access(sessiond_sock_path, F_OK);
539 if (ret < 0) {
947308c4
DG
540 /* Not alive */
541 return 0;
fac6795d
DG
542 }
543
947308c4
DG
544 /* Is alive */
545 return 1;
fac6795d
DG
546}
547
548/*
549 * lib constructor
550 */
551static void __attribute__((constructor)) init()
552{
553 /* Set default session group */
64a23ac4 554 lttng_set_tracing_group(LTTNG_DEFAULT_TRACING_GROUP);
fac6795d 555}
This page took 0.075865 seconds and 4 git commands to generate.