[ust.git] / libustcmd / ustcmd.c

/* Copyright (C) 2009  Pierre-Marc Fournier, Philippe Proulx-Barrette
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
 */

#define _GNU_SOURCE
#include <stdio.h>
#include <unistd.h>
#include <getopt.h>
#include <stdlib.h>
#include <fcntl.h>
#include <string.h>
#include <dirent.h>

#include "ustcomm.h"
#include "ust/ustcmd.h"
#include "usterr.h"

pid_t *ustcmd_get_online_pids(void)
{
	struct dirent *dirent;
	DIR *dir;
	unsigned int ret_size = 1 * sizeof(pid_t), i = 0;

	dir = opendir(SOCK_DIR);
	if (!dir) {
		return NULL;
	}

	pid_t *ret = (pid_t *) malloc(ret_size);

	while ((dirent = readdir(dir))) {
		if (!strcmp(dirent->d_name, ".") ||
			!strcmp(dirent->d_name, "..")) {

			continue;
		}

		if (dirent->d_type != DT_DIR &&
			!!strcmp(dirent->d_name, "ustd")) {

			sscanf(dirent->d_name, "%u", (unsigned int *) &ret[i]);
			if (pid_is_online(ret[i])) {
				ret_size += sizeof(pid_t);
				ret = (pid_t *) realloc(ret, ret_size);
				++i;
			}
		}
	}

	ret[i] = 0; /* Array end */

	if (ret[0] == 0) {
		 /* No PID at all */
		free(ret);
		return NULL;
	}

	closedir(dir);
	return ret;
}

/**
 * Sets marker state (USTCMD_MS_ON or USTCMD_MS_OFF).
 *
 * @param mn	Marker name
 * @param state	Marker's new state
 * @param pid	Traced process ID
 * @return	0 if successful, or errors {USTCMD_ERR_GEN, USTCMD_ERR_ARG}
 */
int ustcmd_set_marker_state(const char *mn, int state, pid_t pid)
{
	char *cmd_str [] = {"disable_marker", "enable_marker"};
	char *cmd;
	int result;

	if (mn == NULL) {
		return USTCMD_ERR_ARG;
	}

	if (asprintf(&cmd, "%s %s", cmd_str[state], mn) < 0) {
		ERR("ustcmd_set_marker_state : asprintf failed (%s %s)",
		    cmd_str[state], mn);
		return USTCMD_ERR_GEN;
	}

	result = ustcmd_send_cmd(cmd, pid, NULL);
	if (result != 1) {
		free(cmd);
		return USTCMD_ERR_GEN;
	}

	free(cmd);
	return 0;
}

/**
 * Set subbuffer size.
 *
 * @param channel_size	Channel name and size
 * @param pid		Traced process ID
 * @return		0 if successful, or error
 */
int ustcmd_set_subbuf_size(const char *channel_size, pid_t pid)
{
	char *cmd;
	int result;

	if (asprintf(&cmd, "%s %s", "set_subbuf_size", channel_size) < 0) {
		ERR("ustcmd_set_subbuf_size : asprintf failed (set_subbuf_size %s)",
		    channel_size);
		return -1;
	}

	result = ustcmd_send_cmd(cmd, pid, NULL);
	if (result != 1) {
		free(cmd);
		return 1;
	}

	free(cmd);
	return 0;
}

/**
 * Set subbuffer num.
 *
 * @param channel_num	Channel name and num
 * @param pid		Traced process ID
 * @return		0 if successful, or error
 */
int ustcmd_set_subbuf_num(const char *channel_size, pid_t pid)
{
	char *cmd;
	int result;

	if (asprintf(&cmd, "%s %s", "set_subbuf_num", channel_size) < 0) {
		ERR("ustcmd_set_subbuf_num : asprintf failed (set_subbuf_num %s",
		    channel_size);
		return -1;
	}

	result = ustcmd_send_cmd(cmd, pid, NULL);
	if (result != 1) {
		free(cmd);
		return 1;
	}

	free(cmd);
	return 0;
}

/**
 * Get subbuffer size.
 *
 * @param channel	Channel name
 * @param pid		Traced process ID
 * @return		subbuf size if successful, or error
 */
int ustcmd_get_subbuf_size(const char *channel, pid_t pid)
{
	char *cmd, *reply;
	int result;

	/* format: channel_cpu */
	if (asprintf(&cmd, "%s %s_0", "get_subbuf_size", channel) < 0) {
		ERR("ustcmd_get_subbuf_size : asprintf failed (get_subbuf_size, %s_0",
		    channel);
		return -1;
	}

	result = ustcmd_send_cmd(cmd, pid, &reply);
	if (result != 1) {
		free(cmd);
		return -1;
	}

	result = atoi(reply);
	free(cmd);
	free(reply);
	return result;
}

/**
 * Get subbuffer num.
 *
 * @param channel	Channel name
 * @param pid		Traced process ID
 * @return		subbuf cnf if successful, or error
 */
int ustcmd_get_subbuf_num(const char *channel, pid_t pid)
{
	char *cmd, *reply;
	int result;

	/* format: channel_cpu */
	if (asprintf(&cmd, "%s %s_0", "get_n_subbufs", channel) < 0) {
		ERR("ustcmd_get_subbuf_num : asprintf failed (get_n_subbufs, %s_0",
		    channel);
		return -1;
	}

	result = ustcmd_send_cmd(cmd, pid, &reply);
	if (result != 1) {
		free(cmd);
		return -1;
	}

	result = atoi(reply);
	free(cmd);
	free(reply);
	return result;
}

/**
 * Destroys an UST trace according to a PID.
 *
 * @param pid	Traced process ID
 * @return	0 if successful, or error USTCMD_ERR_GEN
 */
int ustcmd_destroy_trace(pid_t pid)
{
	int result;

	result = ustcmd_send_cmd("trace_destroy", pid, NULL);
	if (result != 1) {
		return USTCMD_ERR_GEN;
	}

	return 0;
}

/**
 * Starts an UST trace (and setups it) according to a PID.
 *
 * @param pid	Traced process ID
 * @return	0 if successful, or error USTCMD_ERR_GEN
 */
int ustcmd_setup_and_start(pid_t pid)
{
	int result;

	result = ustcmd_send_cmd("start", pid, NULL);
	if (result != 1) {
		return USTCMD_ERR_GEN;
	}

	return 0;
}

/**
 * Creates an UST trace according to a PID.
 *
 * @param pid	Traced process ID
 * @return	0 if successful, or error USTCMD_ERR_GEN
 */
int ustcmd_create_trace(pid_t pid)
{
	int result;

	result = ustcmd_send_cmd("trace_create", pid, NULL);
	if (result != 1) {
		return USTCMD_ERR_GEN;
	}

	return 0;
}

/**
 * Starts an UST trace according to a PID.
 *
 * @param pid	Traced process ID
 * @return	0 if successful, or error USTCMD_ERR_GEN
 */
int ustcmd_start_trace(pid_t pid)
{
	int result;

	result = ustcmd_send_cmd("trace_start", pid, NULL);
	if (result != 1) {
		return USTCMD_ERR_GEN;
	}

	return 0;
}

/**
 * Alloc an UST trace according to a PID.
 *
 * @param pid	Traced process ID
 * @return	0 if successful, or error USTCMD_ERR_GEN
 */
int ustcmd_alloc_trace(pid_t pid)
{
	int result;

	result = ustcmd_send_cmd("trace_alloc", pid, NULL);
	if (result != 1) {
		return USTCMD_ERR_GEN;
	}

	return 0;
}

/**
 * Stops an UST trace according to a PID.
 *
 * @param pid	Traced process ID
 * @return	0 if successful, or error USTCMD_ERR_GEN
 */
int ustcmd_stop_trace(pid_t pid)
{
	int result;

	result = ustcmd_send_cmd("trace_stop", pid, NULL);
	if (result != 1) {
		return USTCMD_ERR_GEN;
	}

	return 0;
}

/**
 * Counts newlines ('\n') in a string.
 *
 * @param str	String to search in
 * @return	Total newlines count
 */
unsigned int ustcmd_count_nl(const char *str)
{
	unsigned int i = 0, tot = 0;

	while (str[i] != '\0') {
		if (str[i] == '\n') {
			++tot;
		}
		++i;
	}

	return tot;
}

/**
 * Frees a CMSF array.
 *
 * @param cmsf	CMSF array to free
 * @return	0 if successful, or error USTCMD_ERR_ARG
 */
int ustcmd_free_cmsf(struct marker_status *cmsf)
{
	if (cmsf == NULL) {
		return USTCMD_ERR_ARG;
	}

	unsigned int i = 0;
	while (cmsf[i].channel != NULL) {
		free(cmsf[i].channel);
		free(cmsf[i].marker);
		free(cmsf[i].fs);
		++i;
	}
	free(cmsf);

	return 0;
}

/**
 * Gets channel/marker/state/format string for a given PID.
 *
 * @param cmsf	Pointer to CMSF array to be filled (callee allocates, caller
 *		frees with `ustcmd_free_cmsf')
 * @param pid	Targeted PID
 * @return	0 if successful, or -1 on error
 */
int ustcmd_get_cmsf(struct marker_status **cmsf, const pid_t pid)
{
	char *big_str = NULL;
	int result;
	struct marker_status *tmp_cmsf = NULL;
	unsigned int i = 0, cmsf_ind = 0;

	if (cmsf == NULL) {
		return -1;
	}
	result = ustcmd_send_cmd("list_markers", pid, &big_str);
	if (result != 1) {
		return -1;
	}

	if (result != 1) {
		ERR("error while getting markers list");
		return -1;
	}

	tmp_cmsf = (struct marker_status *) malloc(sizeof(struct marker_status) *
		(ustcmd_count_nl(big_str) + 1));
	if (tmp_cmsf == NULL) {
		return -1;
	}

	/* Parse received reply string (format: "[chan]/[mark] [st] [fs]"): */
	while (big_str[i] != '\0') {
		char state;

		sscanf(big_str + i, "marker: %a[^/]/%a[^ ] %c %a[^\n]",
			&tmp_cmsf[cmsf_ind].channel,
			&tmp_cmsf[cmsf_ind].marker,
			&state,
			&tmp_cmsf[cmsf_ind].fs);
		tmp_cmsf[cmsf_ind].state = (state == USTCMD_MS_CHR_ON ?
			USTCMD_MS_ON : USTCMD_MS_OFF); /* Marker state */

		while (big_str[i] != '\n') {
			++i; /* Go to next '\n' */
		}
		++i; /* Skip current pointed '\n' */
		++cmsf_ind;
	}
	tmp_cmsf[cmsf_ind].channel = NULL;
	tmp_cmsf[cmsf_ind].marker = NULL;
	tmp_cmsf[cmsf_ind].fs = NULL;

	*cmsf = tmp_cmsf;

	free(big_str);
	return 0;
}


/**
 * Frees a TES array.
 *
 * @param tes	TES array to free
 * @return	0 if successful, or error USTCMD_ERR_ARG
 */
int ustcmd_free_tes(struct trace_event_status *tes)
{
	if (tes == NULL) {
		return USTCMD_ERR_ARG;
	}

	unsigned int i = 0;
	while (tes[i].name != NULL) {
		free(tes[i].name);
		++i;
	}
	free(tes);

	return 0;
}

/**
 * Gets trace_events string for a given PID.
 *
 * @param tes	Pointer to TES array to be filled (callee allocates, caller
 *		frees with `ustcmd_free_tes')
 * @param pid	Targeted PID
 * @return	0 if successful, or -1 on error
 */
int ustcmd_get_tes(struct trace_event_status **tes,
			    const pid_t pid)
{
	char *big_str = NULL;
	int result;
	struct trace_event_status *tmp_tes = NULL;
	unsigned int i = 0, tes_ind = 0;

	if (tes == NULL) {
		return -1;
	}

	result = ustcmd_send_cmd("list_trace_events", pid, &big_str);
	if (result != 1) {
		ERR("error while getting trace_event list");
		return -1;
	}

	tmp_tes = (struct trace_event_status *)
		zmalloc(sizeof(struct trace_event_status) *
			(ustcmd_count_nl(big_str) + 1));
	if (tmp_tes == NULL) {
		ERR("Failed to allocate TES array");
		return -1;
	}

	/* Parse received reply string (format: "[name]"): */
	while (big_str[i] != '\0') {
		char state;

		sscanf(big_str + i, "trace_event: %a[^\n]",
			&tmp_tes[tes_ind].name);
		while (big_str[i] != '\n') {
			++i; /* Go to next '\n' */
		}
		++i; /* Skip current pointed '\n' */
		++tes_ind;
	}
	tmp_tes[tes_ind].name = NULL;

	*tes = tmp_tes;

	free(big_str);
	return 0;
}

/**
 * Set socket path
 *
 * @param sock_path	Socket path
 * @param pid		Traced process ID
 * @return		0 if successful, or error
 */
int ustcmd_set_sock_path(const char *sock_path, pid_t pid)
{
	char *cmd;
	int result;

	if (asprintf(&cmd, "%s %s", "set_sock_path", sock_path) < 0) {
		ERR("ustcmd_set_sock_path : asprintf failed (set_sock_path, %s",
		    sock_path);
		return -1;
	}

	result = ustcmd_send_cmd(cmd, pid, NULL);
	if (result != 1) {
		free(cmd);
		return USTCMD_ERR_GEN;
	}

	free(cmd);
	return 0;
}

/**
 * Get socket path
 *
 * @param sock_path	Pointer to where the socket path will be returned
 * @param pid		Traced process ID
 * @return		0 if successful, or error
 */
int ustcmd_get_sock_path(char **sock_path, pid_t pid)
{
	char *cmd, *reply;
	int result;

	if (asprintf(&cmd, "%s", "get_sock_path") < 0) {
		ERR("ustcmd_get_sock_path : asprintf failed");
		return USTCMD_ERR_GEN;
	}

	result = ustcmd_send_cmd(cmd, pid, &reply);
	if (result != 1) {
		free(cmd);
		return USTCMD_ERR_GEN;
	}

	free(cmd);
	*sock_path = reply;
	return 0;
}

int ustcmd_force_switch(pid_t pid)
{
	int result;

	result = ustcmd_send_cmd("force_switch", pid, NULL);
	if (result != 1) {
		return USTCMD_ERR_GEN;
	}

	return 0;
}

/**
 * Sends a given command to a traceable process
 *
 * @param cmd	Null-terminated command to send
 * @param pid	Targeted PID
 * @param reply	Pointer to string to be filled with a reply string (must
 *		be NULL if no reply is needed for the given command).
 * @return	-1 if not successful, 0 on EOT, 1 on success
 */

int ustcmd_send_cmd(const char *cmd, const pid_t pid, char **reply)
{
	struct ustcomm_connection conn;
	int retval;

	if (ustcomm_connect_app(pid, &conn)) {
		ERR("could not connect to PID %u", (unsigned int) pid);
		return -1;
	}

	retval = ustcomm_send_request(&conn, cmd, reply);

	ustcomm_close_app(&conn);

	return retval;
}
Commit	Line	Data
ab33e65c PP	1	/* Copyright (C) 2009 Pierre-Marc Fournier, Philippe Proulx-Barrette
	2	*
	3	* This library is free software; you can redistribute it and/or
	4	* modify it under the terms of the GNU Lesser General Public
	5	* License as published by the Free Software Foundation; either
	6	* version 2.1 of the License, or (at your option) any later version.
	7	*
	8	* This library is distributed in the hope that it will be useful,
	9	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	10	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	11	* Lesser General Public License for more details.
	12	*
	13	* You should have received a copy of the GNU Lesser General Public
	14	* License along with this library; if not, write to the Free Software
	15	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	16	*/
	17
ef290fca	18	#define _GNU_SOURCE
ab33e65c PP	19	#include <stdio.h>
	20	#include <unistd.h>
	21	#include <getopt.h>
	22	#include <stdlib.h>
	23	#include <fcntl.h>
	24	#include <string.h>
	25	#include <dirent.h>
ab33e65c PP	26
ab33e65c PP	27	#include "ustcomm.h"
d6c9f207	28	#include "ust/ustcmd.h"
2a79ceeb	29	#include "usterr.h"
ab33e65c	30
08230db7	31	pid_t *ustcmd_get_online_pids(void)
772030fe	32	{
08230db7 PMF	33	struct dirent *dirent;
08230db7 PMF	34	DIR *dir;
ef290fca	35	unsigned int ret_size = 1 * sizeof(pid_t), i = 0;
ab33e65c PP	36
	37	dir = opendir(SOCK_DIR);
	38	if (!dir) {
	39	return NULL;
	40	}
	41
08230db7	42	pid_t ret = (pid_t ) malloc(ret_size);
ab33e65c	43
772030fe	44	while ((dirent = readdir(dir))) {
ab33e65c PP	45	if (!strcmp(dirent->d_name, ".") \|\|
	46	!strcmp(dirent->d_name, "..")) {
	47
	48	continue;
	49	}
	50
	51	if (dirent->d_type != DT_DIR &&
	52	!!strcmp(dirent->d_name, "ustd")) {
	53
08230db7	54	sscanf(dirent->d_name, "%u", (unsigned int *) &ret[i]);
ab33e65c PP	55	if (pid_is_online(ret[i])) {
ab33e65c PP	56	ret_size += sizeof(pid_t);
08230db7	57	ret = (pid_t *) realloc(ret, ret_size);
ab33e65c PP	58	++i;
	59	}
	60	}
	61	}
	62
77957c95	63	ret[i] = 0; /* Array end */
ab33e65c	64
08230db7 PMF	65	if (ret[0] == 0) {
08230db7 PMF	66	/* No PID at all */
ab33e65c PP	67	free(ret);
	68	return NULL;
	69	}
	70
	71	closedir(dir);
	72	return ret;
	73	}
	74
	75	/**
	76	* Sets marker state (USTCMD_MS_ON or USTCMD_MS_OFF).
	77	*
	78	* @param mn Marker name
	79	* @param state Marker's new state
	80	* @param pid Traced process ID
	81	* @return 0 if successful, or errors {USTCMD_ERR_GEN, USTCMD_ERR_ARG}
	82	*/
08230db7	83	int ustcmd_set_marker_state(const char *mn, int state, pid_t pid)
ef290fca	84	{
08230db7 PMF	85	char *cmd_str [] = {"disable_marker", "enable_marker"};
08230db7 PMF	86	char *cmd;
ef290fca PMF	87	int result;
ef290fca PMF	88
ab33e65c PP	89	if (mn == NULL) {
	90	return USTCMD_ERR_ARG;
	91	}
	92
08b8805e DG	93	if (asprintf(&cmd, "%s %s", cmd_str[state], mn) < 0) {
	94	ERR("ustcmd_set_marker_state : asprintf failed (%s %s)",
	95	cmd_str[state], mn);
	96	return USTCMD_ERR_GEN;
	97	}
ab33e65c	98
08230db7	99	result = ustcmd_send_cmd(cmd, pid, NULL);
9d20cbf2	100	if (result != 1) {
ab33e65c PP	101	free(cmd);
	102	return USTCMD_ERR_GEN;
	103	}
	104
	105	free(cmd);
	106	return 0;
	107	}
	108
763f41e5 DS	109	/**
	110	* Set subbuffer size.
	111	*
	112	* @param channel_size Channel name and size
	113	* @param pid Traced process ID
	114	* @return 0 if successful, or error
	115	*/
	116	int ustcmd_set_subbuf_size(const char *channel_size, pid_t pid)
	117	{
	118	char *cmd;
	119	int result;
	120
08b8805e DG	121	if (asprintf(&cmd, "%s %s", "set_subbuf_size", channel_size) < 0) {
	122	ERR("ustcmd_set_subbuf_size : asprintf failed (set_subbuf_size %s)",
	123	channel_size);
	124	return -1;
	125	}
763f41e5 DS	126
763f41e5 DS	127	result = ustcmd_send_cmd(cmd, pid, NULL);
2a79ceeb	128	if (result != 1) {
763f41e5 DS	129	free(cmd);
	130	return 1;
	131	}
	132
	133	free(cmd);
	134	return 0;
	135	}
	136
	137	/**
	138	* Set subbuffer num.
	139	*
	140	* @param channel_num Channel name and num
	141	* @param pid Traced process ID
	142	* @return 0 if successful, or error
	143	*/
	144	int ustcmd_set_subbuf_num(const char *channel_size, pid_t pid)
	145	{
	146	char *cmd;
	147	int result;
	148
08b8805e DG	149	if (asprintf(&cmd, "%s %s", "set_subbuf_num", channel_size) < 0) {
	150	ERR("ustcmd_set_subbuf_num : asprintf failed (set_subbuf_num %s",
	151	channel_size);
	152	return -1;
	153	}
763f41e5 DS	154
763f41e5 DS	155	result = ustcmd_send_cmd(cmd, pid, NULL);
2a79ceeb	156	if (result != 1) {
763f41e5 DS	157	free(cmd);
	158	return 1;
	159	}
	160
	161	free(cmd);
	162	return 0;
	163	}
	164
e77b8e8e DS	165	/**
	166	* Get subbuffer size.
	167	*
	168	* @param channel Channel name
	169	* @param pid Traced process ID
	170	* @return subbuf size if successful, or error
	171	*/
	172	int ustcmd_get_subbuf_size(const char *channel, pid_t pid)
	173	{
	174	char cmd, reply;
	175	int result;
	176
	177	/* format: channel_cpu */
08b8805e DG	178	if (asprintf(&cmd, "%s %s_0", "get_subbuf_size", channel) < 0) {
	179	ERR("ustcmd_get_subbuf_size : asprintf failed (get_subbuf_size, %s_0",
	180	channel);
	181	return -1;
	182	}
e77b8e8e DS	183
e77b8e8e DS	184	result = ustcmd_send_cmd(cmd, pid, &reply);
9d20cbf2	185	if (result != 1) {
e77b8e8e	186	free(cmd);
e77b8e8e DS	187	return -1;
	188	}
	189
	190	result = atoi(reply);
	191	free(cmd);
	192	free(reply);
	193	return result;
	194	}
	195
	196	/**
	197	* Get subbuffer num.
	198	*
	199	* @param channel Channel name
	200	* @param pid Traced process ID
	201	* @return subbuf cnf if successful, or error
	202	*/
	203	int ustcmd_get_subbuf_num(const char *channel, pid_t pid)
	204	{
	205	char cmd, reply;
	206	int result;
	207
	208	/* format: channel_cpu */
08b8805e DG	209	if (asprintf(&cmd, "%s %s_0", "get_n_subbufs", channel) < 0) {
	210	ERR("ustcmd_get_subbuf_num : asprintf failed (get_n_subbufs, %s_0",
	211	channel);
	212	return -1;
	213	}
e77b8e8e DS	214
e77b8e8e DS	215	result = ustcmd_send_cmd(cmd, pid, &reply);
9d20cbf2	216	if (result != 1) {
e77b8e8e	217	free(cmd);
e77b8e8e DS	218	return -1;
	219	}
	220
	221	result = atoi(reply);
	222	free(cmd);
	223	free(reply);
	224	return result;
	225	}
763f41e5	226
ab33e65c PP	227	/**
	228	* Destroys an UST trace according to a PID.
	229	*
	230	* @param pid Traced process ID
	231	* @return 0 if successful, or error USTCMD_ERR_GEN
	232	*/
772030fe PMF	233	int ustcmd_destroy_trace(pid_t pid)
	234	{
	235	int result;
ab33e65c	236
b5b073e2	237	result = ustcmd_send_cmd("trace_destroy", pid, NULL);
2a79ceeb	238	if (result != 1) {
ab33e65c PP	239	return USTCMD_ERR_GEN;
	240	}
	241
	242	return 0;
	243	}
	244
	245	/**
	246	* Starts an UST trace (and setups it) according to a PID.
	247	*
	248	* @param pid Traced process ID
	249	* @return 0 if successful, or error USTCMD_ERR_GEN
	250	*/
772030fe PMF	251	int ustcmd_setup_and_start(pid_t pid)
	252	{
	253	int result;
ab33e65c	254
08230db7	255	result = ustcmd_send_cmd("start", pid, NULL);
2a79ceeb	256	if (result != 1) {
ab33e65c PP	257	return USTCMD_ERR_GEN;
	258	}
	259
	260	return 0;
	261	}
	262
62ec620f PMF	263	/**
	264	* Creates an UST trace according to a PID.
	265	*
	266	* @param pid Traced process ID
	267	* @return 0 if successful, or error USTCMD_ERR_GEN
	268	*/
	269	int ustcmd_create_trace(pid_t pid)
	270	{
	271	int result;
	272
	273	result = ustcmd_send_cmd("trace_create", pid, NULL);
2a79ceeb	274	if (result != 1) {
62ec620f PMF	275	return USTCMD_ERR_GEN;
	276	}
	277
	278	return 0;
	279	}
	280
ab33e65c PP	281	/**
	282	* Starts an UST trace according to a PID.
	283	*
	284	* @param pid Traced process ID
	285	* @return 0 if successful, or error USTCMD_ERR_GEN
	286	*/
772030fe PMF	287	int ustcmd_start_trace(pid_t pid)
	288	{
	289	int result;
ab33e65c	290
08230db7	291	result = ustcmd_send_cmd("trace_start", pid, NULL);
2a79ceeb	292	if (result != 1) {
ab33e65c PP	293	return USTCMD_ERR_GEN;
	294	}
	295
	296	return 0;
	297	}
	298
763f41e5 DS	299	/**
	300	* Alloc an UST trace according to a PID.
	301	*
	302	* @param pid Traced process ID
	303	* @return 0 if successful, or error USTCMD_ERR_GEN
	304	*/
	305	int ustcmd_alloc_trace(pid_t pid)
	306	{
	307	int result;
	308
	309	result = ustcmd_send_cmd("trace_alloc", pid, NULL);
2a79ceeb	310	if (result != 1) {
763f41e5 DS	311	return USTCMD_ERR_GEN;
	312	}
	313
	314	return 0;
	315	}
	316
ab33e65c PP	317	/**
	318	* Stops an UST trace according to a PID.
	319	*
	320	* @param pid Traced process ID
	321	* @return 0 if successful, or error USTCMD_ERR_GEN
	322	*/
772030fe PMF	323	int ustcmd_stop_trace(pid_t pid)
	324	{
	325	int result;
ab33e65c	326
08230db7	327	result = ustcmd_send_cmd("trace_stop", pid, NULL);
2a79ceeb	328	if (result != 1) {
ab33e65c PP	329	return USTCMD_ERR_GEN;
	330	}
	331
	332	return 0;
	333	}
	334
	335	/**
	336	* Counts newlines ('\n') in a string.
	337	*
	338	* @param str String to search in
	339	* @return Total newlines count
	340	*/
08230db7	341	unsigned int ustcmd_count_nl(const char *str)
772030fe	342	{
ab33e65c PP	343	unsigned int i = 0, tot = 0;
	344
	345	while (str[i] != '\0') {
	346	if (str[i] == '\n') {
	347	++tot;
	348	}
	349	++i;
	350	}
	351
	352	return tot;
	353	}
	354
	355	/**
	356	* Frees a CMSF array.
	357	*
	358	* @param cmsf CMSF array to free
	359	* @return 0 if successful, or error USTCMD_ERR_ARG
	360	*/
08230db7	361	int ustcmd_free_cmsf(struct marker_status *cmsf)
772030fe	362	{
ab33e65c PP	363	if (cmsf == NULL) {
	364	return USTCMD_ERR_ARG;
	365	}
	366
	367	unsigned int i = 0;
	368	while (cmsf[i].channel != NULL) {
	369	free(cmsf[i].channel);
	370	free(cmsf[i].marker);
	371	free(cmsf[i].fs);
	372	++i;
	373	}
	374	free(cmsf);
	375
	376	return 0;
	377	}
	378
	379	/**
	380	* Gets channel/marker/state/format string for a given PID.
	381	*
	382	* @param cmsf Pointer to CMSF array to be filled (callee allocates, caller
	383	* frees with `ustcmd_free_cmsf')
	384	* @param pid Targeted PID
2a79ceeb	385	* @return 0 if successful, or -1 on error
ab33e65c	386	*/
08230db7	387	int ustcmd_get_cmsf(struct marker_status **cmsf, const pid_t pid)
772030fe	388	{
08230db7	389	char *big_str = NULL;
ef290fca	390	int result;
08230db7	391	struct marker_status *tmp_cmsf = NULL;
ef290fca PMF	392	unsigned int i = 0, cmsf_ind = 0;
ef290fca PMF	393
ab33e65c	394	if (cmsf == NULL) {
2a79ceeb	395	return -1;
ab33e65c	396	}
08230db7	397	result = ustcmd_send_cmd("list_markers", pid, &big_str);
2a79ceeb PMF	398	if (result != 1) {
2a79ceeb PMF	399	return -1;
ab33e65c PP	400	}
ab33e65c PP	401
2a79ceeb PMF	402	if (result != 1) {
	403	ERR("error while getting markers list");
	404	return -1;
ab33e65c PP	405	}
ab33e65c PP	406
08230db7	407	tmp_cmsf = (struct marker_status ) malloc(sizeof(struct marker_status)
ab33e65c PP	408	(ustcmd_count_nl(big_str) + 1));
ab33e65c PP	409	if (tmp_cmsf == NULL) {
2a79ceeb	410	return -1;
ab33e65c PP	411	}
ab33e65c PP	412
77957c95	413	/* Parse received reply string (format: "[chan]/[mark] [st] [fs]"): */
ab33e65c	414	while (big_str[i] != '\0') {
ab33e65c	415	char state;
ef290fca	416
264f6231	417	sscanf(big_str + i, "marker: %a[^/]/%a[^ ] %c %a[^\n]",
ab33e65c PP	418	&tmp_cmsf[cmsf_ind].channel,
	419	&tmp_cmsf[cmsf_ind].marker,
	420	&state,
	421	&tmp_cmsf[cmsf_ind].fs);
	422	tmp_cmsf[cmsf_ind].state = (state == USTCMD_MS_CHR_ON ?
77957c95	423	USTCMD_MS_ON : USTCMD_MS_OFF); /* Marker state */
ab33e65c PP	424
ab33e65c PP	425	while (big_str[i] != '\n') {
77957c95	426	++i; /* Go to next '\n' */
ab33e65c	427	}
77957c95	428	++i; /* Skip current pointed '\n' */
ab33e65c PP	429	++cmsf_ind;
	430	}
	431	tmp_cmsf[cmsf_ind].channel = NULL;
	432	tmp_cmsf[cmsf_ind].marker = NULL;
	433	tmp_cmsf[cmsf_ind].fs = NULL;
	434
	435	*cmsf = tmp_cmsf;
	436
	437	free(big_str);
	438	return 0;
	439	}
	440
a3adfb05 NC	441
	442	/**
	443	* Frees a TES array.
	444	*
	445	* @param tes TES array to free
	446	* @return 0 if successful, or error USTCMD_ERR_ARG
	447	*/
	448	int ustcmd_free_tes(struct trace_event_status *tes)
	449	{
	450	if (tes == NULL) {
	451	return USTCMD_ERR_ARG;
	452	}
	453
	454	unsigned int i = 0;
	455	while (tes[i].name != NULL) {
	456	free(tes[i].name);
	457	++i;
	458	}
	459	free(tes);
	460
	461	return 0;
	462	}
	463
	464	/**
	465	* Gets trace_events string for a given PID.
	466	*
	467	* @param tes Pointer to TES array to be filled (callee allocates, caller
	468	* frees with `ustcmd_free_tes')
	469	* @param pid Targeted PID
	470	* @return 0 if successful, or -1 on error
	471	*/
	472	int ustcmd_get_tes(struct trace_event_status **tes,
	473	const pid_t pid)
	474	{
	475	char *big_str = NULL;
	476	int result;
	477	struct trace_event_status *tmp_tes = NULL;
	478	unsigned int i = 0, tes_ind = 0;
	479
	480	if (tes == NULL) {
	481	return -1;
	482	}
	483
	484	result = ustcmd_send_cmd("list_trace_events", pid, &big_str);
	485	if (result != 1) {
	486	ERR("error while getting trace_event list");
	487	return -1;
	488	}
	489
	490	tmp_tes = (struct trace_event_status *)
	491	zmalloc(sizeof(struct trace_event_status) *
	492	(ustcmd_count_nl(big_str) + 1));
	493	if (tmp_tes == NULL) {
	494	ERR("Failed to allocate TES array");
	495	return -1;
	496	}
	497
	498	/* Parse received reply string (format: "[name]"): */
	499	while (big_str[i] != '\0') {
	500	char state;
	501
	502	sscanf(big_str + i, "trace_event: %a[^\n]",
	503	&tmp_tes[tes_ind].name);
	504	while (big_str[i] != '\n') {
505	++i; /* Go to next '\n' */
506	}
507	++i; /* Skip current pointed '\n' */
508	++tes_ind;
509	}
510	tmp_tes[tes_ind].name = NULL;
511
512	*tes = tmp_tes;
513
514	free(big_str);
515	return 0;
516	}
517
b2fb2f91 AH	518	/**
	519	* Set socket path
	520	*
	521	* @param sock_path Socket path
	522	* @param pid Traced process ID
	523	* @return 0 if successful, or error
	524	*/
	525	int ustcmd_set_sock_path(const char *sock_path, pid_t pid)
	526	{
	527	char *cmd;
	528	int result;
	529
08b8805e DG	530	if (asprintf(&cmd, "%s %s", "set_sock_path", sock_path) < 0) {
	531	ERR("ustcmd_set_sock_path : asprintf failed (set_sock_path, %s",
	532	sock_path);
	533	return -1;
	534	}
b2fb2f91 AH	535
	536	result = ustcmd_send_cmd(cmd, pid, NULL);
	537	if (result != 1) {
	538	free(cmd);
	539	return USTCMD_ERR_GEN;
	540	}
	541
	542	free(cmd);
	543	return 0;
	544	}
	545
	546	/**
	547	* Get socket path
	548	*
	549	* @param sock_path Pointer to where the socket path will be returned
	550	* @param pid Traced process ID
	551	* @return 0 if successful, or error
	552	*/
	553	int ustcmd_get_sock_path(char **sock_path, pid_t pid)
	554	{
	555	char cmd, reply;
	556	int result;
	557
08b8805e DG	558	if (asprintf(&cmd, "%s", "get_sock_path") < 0) {
	559	ERR("ustcmd_get_sock_path : asprintf failed");
	560	return USTCMD_ERR_GEN;
	561	}
b2fb2f91 AH	562
	563	result = ustcmd_send_cmd(cmd, pid, &reply);
	564	if (result != 1) {
	565	free(cmd);
b2fb2f91 AH	566	return USTCMD_ERR_GEN;
	567	}
	568
	569	free(cmd);
	570	*sock_path = reply;
	571	return 0;
	572	}
	573
b9318b35 AH	574	int ustcmd_force_switch(pid_t pid)
	575	{
	576	int result;
	577
	578	result = ustcmd_send_cmd("force_switch", pid, NULL);
	579	if (result != 1) {
	580	return USTCMD_ERR_GEN;
	581	}
	582
	583	return 0;
	584	}
	585
ab33e65c	586	/**
2a79ceeb	587	* Sends a given command to a traceable process
ab33e65c	588	*
2a79ceeb	589	* @param cmd Null-terminated command to send
ab33e65c PP	590	* @param pid Targeted PID
	591	* @param reply Pointer to string to be filled with a reply string (must
	592	* be NULL if no reply is needed for the given command).
9d20cbf2	593	* @return -1 if not successful, 0 on EOT, 1 on success
ab33e65c	594	*/
772030fe	595
08230db7	596	int ustcmd_send_cmd(const char cmd, const pid_t pid, char *reply)
772030fe PMF	597	{
772030fe PMF	598	struct ustcomm_connection conn;
2a79ceeb	599	int retval;
ab33e65c	600
ab33e65c	601	if (ustcomm_connect_app(pid, &conn)) {
2a79ceeb PMF	602	ERR("could not connect to PID %u", (unsigned int) pid);
2a79ceeb PMF	603	return -1;
ab33e65c PP	604	}
ab33e65c PP	605
2a79ceeb	606	retval = ustcomm_send_request(&conn, cmd, reply);
ab33e65c	607
2a79ceeb PMF	608	ustcomm_close_app(&conn);
	609
	610	return retval;
ab33e65c	611	}