[lttv.git] / ltt / branches / poly / libltt / libltt.c

/* libltt
 *
 * Linux Trace Toolkit Netlink Control Library
 *
 * Controls the ltt-control kernel module through a netlink socket.
 *
 * Heavily inspired from libipq.c (iptables) made by 
 * James Morris <jmorris@intercode.com.au>
 *
 * Copyright 2005 -
 * 	Mathieu Desnoyers <mathieu.desnoyers@polymtl.ca>
 *
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 * 	
 */

#include <linux/socket.h>
#include <linux/types.h>
#include <linux/time.h>
#include <linux/netlink.h>
#include <libltt/libltt.h>
#include <errno.h>
#include <stdio.h>

/* Private interface */

enum {
	LTTCTL_ERR_NONE = 0,
	LTTCTL_ERR_IMPL,
	LTTCTL_ERR_HANDLE,
	LTTCTL_ERR_SOCKET,
	LTTCTL_ERR_BIND,
	LTTCTL_ERR_BUFFER,
	LTTCTL_ERR_RECV,
	LTTCTL_ERR_NLEOF,
	LTTCTL_ERR_ADDRLEN,
	LTTCTL_ERR_STRUNC,
	LTTCTL_ERR_RTRUNC,
	LTTCTL_ERR_NLRECV,
	LTTCTL_ERR_SEND,
	LTTCTL_ERR_SUPP,
	LTTCTL_ERR_RECVBUF,
	LTTCTL_ERR_TIMEOUT,
        LTTCTL_ERR_PROTOCOL
};
#define LTTCTL_MAXERR LTTCTL_ERR_PROTOCOL


struct lttctl_errmap_t {
	int errcode;
	char *message;
} lttctl_errmap[] = {
	{ LTTCTL_ERR_NONE, "Unknown error" },
	{ LTTCTL_ERR_IMPL, "Implementation error" },
	{ LTTCTL_ERR_HANDLE, "Unable to create netlink handle" },
	{ LTTCTL_ERR_SOCKET, "Unable to create netlink socket" },
	{ LTTCTL_ERR_BIND, "Unable to bind netlink socket" },
	{ LTTCTL_ERR_BUFFER, "Unable to allocate buffer" },
	{ LTTCTL_ERR_RECV, "Failed to receive netlink message" },
	{ LTTCTL_ERR_NLEOF, "Received EOF on netlink socket" },
	{ LTTCTL_ERR_ADDRLEN, "Invalid peer address length" },
	{ LTTCTL_ERR_STRUNC, "Sent message truncated" },
	{ LTTCTL_ERR_RTRUNC, "Received message truncated" },
	{ LTTCTL_ERR_NLRECV, "Received error from netlink" },
	{ LTTCTL_ERR_SEND, "Failed to send netlink message" },
	{ LTTCTL_ERR_SUPP, "Operation not supported" },
	{ LTTCTL_ERR_RECVBUF, "Receive buffer size invalid" },
	{ LTTCTL_ERR_TIMEOUT, "Timeout"},
	{ LTTCTL_ERR_PROTOCOL, "Invalid protocol specified" }
};

static int lttctl_errno = LTTCTL_ERR_NONE;


static ssize_t lttctl_netlink_sendto(const struct lttctl_handle *h,
                                  const void *msg, size_t len);

static ssize_t lttctl_netlink_recvfrom(const struct lttctl_handle *h,
                                    unsigned char *buf, size_t len,
                                    int timeout);

static ssize_t lttctl_netlink_sendmsg(const struct lttctl_handle *h,
                                   const struct msghdr *msg,
                                   unsigned int flags);

static char *lttctl_strerror(int errcode);

void lttctl_perror(const char *s);

static ssize_t lttctl_netlink_sendto(const struct lttctl_handle *h,
                                  const void *msg, size_t len)
{
	int status = sendto(h->fd, msg, len, 0,
	                    (struct sockaddr *)&h->peer, sizeof(h->peer));
	if (status < 0)
		lttctl_errno = LTTCTL_ERR_SEND;
	
	return status;
}

static ssize_t lttctl_netlink_sendmsg(const struct lttctl_handle *h,
                                   const struct msghdr *msg,
                                   unsigned int flags)
{
	int status = sendmsg(h->fd, msg, flags);
	if (status < 0)
		lttctl_errno = LTTCTL_ERR_SEND;
	return status;
}

static ssize_t lttctl_netlink_recvfrom(const struct lttctl_handle *h,
                                    unsigned char *buf, size_t len,
                                    int timeout)
{
	int addrlen, status;
	struct nlmsghdr *nlh;

	if (len < sizeof(struct nlmsghdr)) {
		lttctl_errno = LTTCTL_ERR_RECVBUF;
		lttctl_perror("Netlink recvfrom");
		return -1;
	}
	addrlen = sizeof(h->peer);

	if (timeout != 0) {
		int ret;
		struct timeval tv;
		fd_set read_fds;
		
		if (timeout < 0) {
			/* non-block non-timeout */
			tv.tv_sec = 0;
			tv.tv_usec = 0;
		} else {
			tv.tv_sec = timeout / 1000000;
			tv.tv_usec = timeout % 1000000;
		}

		FD_ZERO(&read_fds);
		FD_SET(h->fd, &read_fds);
		ret = select(h->fd+1, &read_fds, NULL, NULL, &tv);
		if (ret < 0) {
			if (errno == EINTR) {
				printf("eintr\n");
				return 0;
			} else {
				lttctl_errno = LTTCTL_ERR_RECV;
				lttctl_perror("Netlink recvfrom");
				return -1;
			}
		}
		if (!FD_ISSET(h->fd, &read_fds)) {
			lttctl_errno = LTTCTL_ERR_TIMEOUT;
			printf("timeout\n");
			return 0;
		}
	}
	status = recvfrom(h->fd, buf, len, 0,
	                      (struct sockaddr *)&h->peer, &addrlen);
	
	if (status < 0) {
		lttctl_errno = LTTCTL_ERR_RECV;
		lttctl_perror("Netlink recvfrom");
		return status;
	}
	if (addrlen != sizeof(h->peer)) {
		lttctl_errno = LTTCTL_ERR_RECV;
		lttctl_perror("Netlink recvfrom");
		return -1;
	}
	if (h->peer.nl_pid != 0) {
		lttctl_errno = LTTCTL_ERR_RECV;
		lttctl_perror("Netlink recvfrom");
		return -1;
	}
	if (status == 0) {
		lttctl_errno = LTTCTL_ERR_NLEOF;
		lttctl_perror("Netlink recvfrom");
		return -1;
	}
	nlh = (struct nlmsghdr *)buf;
	if (nlh->nlmsg_flags & MSG_TRUNC || nlh->nlmsg_len > status) {
		lttctl_errno = LTTCTL_ERR_RTRUNC;
		lttctl_perror("Netlink recvfrom");
		return -1;
	}
	

	return status;
}


static char *lttctl_strerror(int errcode)
{
	if (errcode < 0 || errcode > LTTCTL_MAXERR)
		errcode = LTTCTL_ERR_IMPL;
	return lttctl_errmap[errcode].message;
}


char *lttctl_errstr(void)
{
	return lttctl_strerror(lttctl_errno);
}

void lttctl_perror(const char *s)
{
	if (s)
		fputs(s, stderr);
	else
		fputs("ERROR", stderr);
	if (lttctl_errno)
		fprintf(stderr, ": %s", lttctl_errstr());
	if (errno)
		fprintf(stderr, ": %s", strerror(errno));
	fputc('\n', stderr);
}

/* public interface */

/*
 * Create and initialise an lttctl handle.
 */
struct lttctl_handle *lttctl_create_handle(void)
{
	int status;
	struct lttctl_handle *h;

	h = (struct lttctl_handle *)malloc(sizeof(struct lttctl_handle));
	if (h == NULL) {
		lttctl_errno = LTTCTL_ERR_HANDLE;
		lttctl_perror("Create handle");
		goto alloc_error;
	}
	
	memset(h, 0, sizeof(struct lttctl_handle));
	
  h->fd = socket(PF_NETLINK, SOCK_RAW, NETLINK_LTT);
        
	if (h->fd == -1) {
		lttctl_errno = LTTCTL_ERR_SOCKET;
		lttctl_perror("Create handle");
		goto socket_error;
	}
	memset(&h->local, 0, sizeof(struct sockaddr_nl));
	h->local.nl_family = AF_NETLINK;
	h->local.nl_pid = getpid();
	h->local.nl_groups = 0;
	status = bind(h->fd, (struct sockaddr *)&h->local, sizeof(h->local));
	if (status == -1) {
		lttctl_errno = LTTCTL_ERR_BIND;
		lttctl_perror("Create handle");
		goto bind_error;
	}
	memset(&h->peer, 0, sizeof(struct sockaddr_nl));
	h->peer.nl_family = AF_NETLINK;
	h->peer.nl_pid = 0;
	h->peer.nl_groups = 0;
	return h;
	
	/* Error condition */
bind_error:
socket_error:
		close(h->fd);
alloc_error:
		free(h);
	return NULL;
}

/*
 * No error condition is checked here at this stage, but it may happen
 * if/when reliable messaging is implemented.
 */
int lttctl_destroy_handle(struct lttctl_handle *h)
{
	if (h) {
		close(h->fd);
		free(h);
	}
	return 0;
}


int lttctl_create_trace(const struct lttctl_handle *h,
		char *name, enum trace_mode mode)
{
	int err;
	
	struct {
		struct nlmsghdr	nlh;
		lttctl_peer_msg_t	msg;
	} req;
	struct {
		struct nlmsghdr	nlh;
		struct nlmsgerr	nlerr;
		lttctl_peer_msg_t	msg;
	} ack;

	memset(&req, 0, sizeof(req));
	req.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(lttctl_peer_msg_t));
	req.nlh.nlmsg_flags = NLM_F_REQUEST|NLM_F_ACK;
	req.nlh.nlmsg_type = LTTCTLM_CONTROL;
	req.nlh.nlmsg_pid = h->local.nl_pid;
	req.nlh.nlmsg_seq = 0;

	strncpy(req.msg.trace_name, name, NAME_MAX);
	req.msg.op = OP_CREATE;
	req.msg.args.mode = mode;

	err = lttctl_netlink_sendto(h, (void *)&req, req.nlh.nlmsg_len);
	if(err < 0) goto senderr;

	err = lttctl_netlink_recvfrom(h, (void*)&ack, sizeof(ack), 0);
	if(err < 0) goto senderr;

	err = ack.nlerr.error;
	if(err != 0) {
		errno = err;
		lttctl_perror("Create Trace Error");
		return -1;
	}

	return 0;

senderr:
	lttctl_perror("Create Trace Error");
	return err;
}

int lttctl_destroy_trace(const struct lttctl_handle *h,
		char *name)
{
	struct {
		struct nlmsghdr	nlh;
		lttctl_peer_msg_t	msg;
	} req;
	struct {
		struct nlmsghdr	nlh;
		struct nlmsgerr	nlerr;
		lttctl_peer_msg_t	msg;
	} ack;
	int err;

	memset(&req, 0, sizeof(req));
	req.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(lttctl_peer_msg_t));
	req.nlh.nlmsg_flags = NLM_F_REQUEST;
	req.nlh.nlmsg_type = LTTCTLM_CONTROL;
	req.nlh.nlmsg_pid = h->local.nl_pid;

	strncpy(req.msg.trace_name, name, NAME_MAX);
	req.msg.op = OP_DESTROY;

	err = lttctl_netlink_sendto(h, (void *)&req, req.nlh.nlmsg_len);
	if(err < 0) goto senderr;

	err = lttctl_netlink_recvfrom(h, (void*)&ack, sizeof(ack), 0);
	if(err < 0) goto senderr;

	err = ack.nlerr.error;
	if(err != 0) {
		errno = err;
		lttctl_perror("Destroy Trace Channels Error");
		return -1;
	}

	return 0;

senderr:
	lttctl_perror("Destroy Trace Channels Error");
	return err;

}

int lttctl_start(const struct lttctl_handle *h,
		char *name)
{
	struct {
		struct nlmsghdr	nlh;
		lttctl_peer_msg_t	msg;
	} req;
	struct {
		struct nlmsghdr	nlh;
		struct nlmsgerr	nlerr;
		lttctl_peer_msg_t	msg;
	} ack;

	int err;

	memset(&req, 0, sizeof(req));
	req.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(lttctl_peer_msg_t));
	req.nlh.nlmsg_flags = NLM_F_REQUEST;
	req.nlh.nlmsg_type = LTTCTLM_CONTROL;
	req.nlh.nlmsg_pid = h->local.nl_pid;

	strncpy(req.msg.trace_name, name, NAME_MAX);
	req.msg.op = OP_START;

	err = lttctl_netlink_sendto(h, (void *)&req, req.nlh.nlmsg_len);
	if(err < 0) goto senderr;

	err = lttctl_netlink_recvfrom(h, (void*)&ack, sizeof(ack), 0);
	if(err < 0) goto senderr;

	err = ack.nlerr.error;
	if(err != 0) {
		errno = err;
		lttctl_perror("Start Trace Error");
		return -1;
	}

	return 0;

senderr:
	lttctl_perror("Start Trace Error");
	return err;

}

int lttctl_stop(const struct lttctl_handle *h,
		char *name)
{
	struct {
		struct nlmsghdr	nlh;
		lttctl_peer_msg_t	msg;
	} req;
	struct {
		struct nlmsghdr	nlh;
		struct nlmsgerr	nlerr;
		lttctl_peer_msg_t	msg;
	} ack;
	int err;

	memset(&req, 0, sizeof(req));
	req.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(lttctl_peer_msg_t));
	req.nlh.nlmsg_flags = NLM_F_REQUEST;
	req.nlh.nlmsg_type = LTTCTLM_CONTROL;
	req.nlh.nlmsg_pid = h->local.nl_pid;

	strncpy(req.msg.trace_name, name, NAME_MAX);
	req.msg.op = OP_STOP;

	err = lttctl_netlink_sendto(h, (void *)&req, req.nlh.nlmsg_len);
	if(err < 0) goto senderr;

	err = lttctl_netlink_recvfrom(h, (void*)&ack, sizeof(ack), 0);
	if(err < 0) goto senderr;

	err = ack.nlerr.error;
	if(err != 0) {
		errno = err;
		lttctl_perror("Stop Trace Error");
		return -1;
	}

	return 0;

senderr:
	lttctl_perror("Stop Trace Error");
	return err;
}
Commit	Line	Data
31d2c6b0	1	/* libltt
	2	*
	3	* Linux Trace Toolkit Netlink Control Library
	4	*
	5	* Controls the ltt-control kernel module through a netlink socket.
	6	*
	7	* Heavily inspired from libipq.c (iptables) made by
	8	* James Morris <jmorris@intercode.com.au>
	9	*
	10	* Copyright 2005 -
	11	* Mathieu Desnoyers <mathieu.desnoyers@polymtl.ca>
	12	*
	13	*
	14	* This program is free software; you can redistribute it and/or modify
	15	* it under the terms of the GNU General Public License as published by
	16	* the Free Software Foundation; either version 2 of the License, or
	17	* (at your option) any later version.
	18	*
	19	* This program is distributed in the hope that it will be useful,
	20	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	21	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	22	* GNU General Public License for more details.
	23	*
	24	*/
	25
264cbffe	26	#include <linux/socket.h>
264cbffe	27	#include <linux/types.h>
be0caed2	28	#include <linux/time.h>
ace0e68d	29	#include <linux/netlink.h>
264cbffe	30	#include <libltt/libltt.h>
ace0e68d	31	#include <errno.h>
ace0e68d	32	#include <stdio.h>
31d2c6b0	33
	34	/* Private interface */
	35
	36	enum {
	37	LTTCTL_ERR_NONE = 0,
	38	LTTCTL_ERR_IMPL,
	39	LTTCTL_ERR_HANDLE,
	40	LTTCTL_ERR_SOCKET,
	41	LTTCTL_ERR_BIND,
	42	LTTCTL_ERR_BUFFER,
	43	LTTCTL_ERR_RECV,
	44	LTTCTL_ERR_NLEOF,
	45	LTTCTL_ERR_ADDRLEN,
	46	LTTCTL_ERR_STRUNC,
	47	LTTCTL_ERR_RTRUNC,
	48	LTTCTL_ERR_NLRECV,
	49	LTTCTL_ERR_SEND,
	50	LTTCTL_ERR_SUPP,
	51	LTTCTL_ERR_RECVBUF,
	52	LTTCTL_ERR_TIMEOUT,
	53	LTTCTL_ERR_PROTOCOL
	54	};
	55	#define LTTCTL_MAXERR LTTCTL_ERR_PROTOCOL
	56
	57
	58	struct lttctl_errmap_t {
	59	int errcode;
	60	char *message;
	61	} lttctl_errmap[] = {
ace0e68d	62	{ LTTCTL_ERR_NONE, "Unknown error" },
	63	{ LTTCTL_ERR_IMPL, "Implementation error" },
	64	{ LTTCTL_ERR_HANDLE, "Unable to create netlink handle" },
	65	{ LTTCTL_ERR_SOCKET, "Unable to create netlink socket" },
	66	{ LTTCTL_ERR_BIND, "Unable to bind netlink socket" },
	67	{ LTTCTL_ERR_BUFFER, "Unable to allocate buffer" },
	68	{ LTTCTL_ERR_RECV, "Failed to receive netlink message" },
	69	{ LTTCTL_ERR_NLEOF, "Received EOF on netlink socket" },
	70	{ LTTCTL_ERR_ADDRLEN, "Invalid peer address length" },
	71	{ LTTCTL_ERR_STRUNC, "Sent message truncated" },
	72	{ LTTCTL_ERR_RTRUNC, "Received message truncated" },
	73	{ LTTCTL_ERR_NLRECV, "Received error from netlink" },
	74	{ LTTCTL_ERR_SEND, "Failed to send netlink message" },
	75	{ LTTCTL_ERR_SUPP, "Operation not supported" },
	76	{ LTTCTL_ERR_RECVBUF, "Receive buffer size invalid" },
	77	{ LTTCTL_ERR_TIMEOUT, "Timeout"},
	78	{ LTTCTL_ERR_PROTOCOL, "Invalid protocol specified" }
31d2c6b0	79	};
	80
	81	static int lttctl_errno = LTTCTL_ERR_NONE;
	82
	83
	84	static ssize_t lttctl_netlink_sendto(const struct lttctl_handle *h,
	85	const void *msg, size_t len);
	86
	87	static ssize_t lttctl_netlink_recvfrom(const struct lttctl_handle *h,
	88	unsigned char *buf, size_t len,
	89	int timeout);
	90
	91	static ssize_t lttctl_netlink_sendmsg(const struct lttctl_handle *h,
	92	const struct msghdr *msg,
	93	unsigned int flags);
	94
	95	static char *lttctl_strerror(int errcode);
	96
ace0e68d	97	void lttctl_perror(const char *s);
ace0e68d	98
31d2c6b0	99	static ssize_t lttctl_netlink_sendto(const struct lttctl_handle *h,
	100	const void *msg, size_t len)
	101	{
	102	int status = sendto(h->fd, msg, len, 0,
	103	(struct sockaddr *)&h->peer, sizeof(h->peer));
	104	if (status < 0)
	105	lttctl_errno = LTTCTL_ERR_SEND;
ace0e68d	106
31d2c6b0	107	return status;
	108	}
	109
	110	static ssize_t lttctl_netlink_sendmsg(const struct lttctl_handle *h,
	111	const struct msghdr *msg,
	112	unsigned int flags)
	113	{
	114	int status = sendmsg(h->fd, msg, flags);
	115	if (status < 0)
	116	lttctl_errno = LTTCTL_ERR_SEND;
	117	return status;
	118	}
	119
	120	static ssize_t lttctl_netlink_recvfrom(const struct lttctl_handle *h,
	121	unsigned char *buf, size_t len,
	122	int timeout)
	123	{
	124	int addrlen, status;
	125	struct nlmsghdr *nlh;
	126
ace0e68d	127	if (len < sizeof(struct nlmsghdr)) {
31d2c6b0	128	lttctl_errno = LTTCTL_ERR_RECVBUF;
ace0e68d	129	lttctl_perror("Netlink recvfrom");
31d2c6b0	130	return -1;
	131	}
	132	addrlen = sizeof(h->peer);
	133
	134	if (timeout != 0) {
	135	int ret;
	136	struct timeval tv;
	137	fd_set read_fds;
	138
	139	if (timeout < 0) {
	140	/* non-block non-timeout */
	141	tv.tv_sec = 0;
	142	tv.tv_usec = 0;
	143	} else {
	144	tv.tv_sec = timeout / 1000000;
	145	tv.tv_usec = timeout % 1000000;
	146	}
	147
	148	FD_ZERO(&read_fds);
	149	FD_SET(h->fd, &read_fds);
	150	ret = select(h->fd+1, &read_fds, NULL, NULL, &tv);
	151	if (ret < 0) {
	152	if (errno == EINTR) {
ace0e68d	153	printf("eintr\n");
31d2c6b0	154	return 0;
31d2c6b0	155	} else {
ace0e68d	156	lttctl_errno = LTTCTL_ERR_RECV;
ace0e68d	157	lttctl_perror("Netlink recvfrom");
31d2c6b0	158	return -1;
	159	}
	160	}
	161	if (!FD_ISSET(h->fd, &read_fds)) {
ace0e68d	162	lttctl_errno = LTTCTL_ERR_TIMEOUT;
ace0e68d	163	printf("timeout\n");
31d2c6b0	164	return 0;
	165	}
	166	}
	167	status = recvfrom(h->fd, buf, len, 0,
	168	(struct sockaddr *)&h->peer, &addrlen);
ace0e68d	169
31d2c6b0	170	if (status < 0) {
31d2c6b0	171	lttctl_errno = LTTCTL_ERR_RECV;
ace0e68d	172	lttctl_perror("Netlink recvfrom");
31d2c6b0	173	return status;
	174	}
	175	if (addrlen != sizeof(h->peer)) {
	176	lttctl_errno = LTTCTL_ERR_RECV;
ace0e68d	177	lttctl_perror("Netlink recvfrom");
31d2c6b0	178	return -1;
	179	}
	180	if (h->peer.nl_pid != 0) {
	181	lttctl_errno = LTTCTL_ERR_RECV;
ace0e68d	182	lttctl_perror("Netlink recvfrom");
31d2c6b0	183	return -1;
	184	}
	185	if (status == 0) {
	186	lttctl_errno = LTTCTL_ERR_NLEOF;
ace0e68d	187	lttctl_perror("Netlink recvfrom");
31d2c6b0	188	return -1;
	189	}
	190	nlh = (struct nlmsghdr *)buf;
	191	if (nlh->nlmsg_flags & MSG_TRUNC \|\| nlh->nlmsg_len > status) {
	192	lttctl_errno = LTTCTL_ERR_RTRUNC;
ace0e68d	193	lttctl_perror("Netlink recvfrom");
31d2c6b0	194	return -1;
31d2c6b0	195	}
ace0e68d	196
ace0e68d	197
31d2c6b0	198	return status;
	199	}
	200
	201
	202	static char *lttctl_strerror(int errcode)
	203	{
	204	if (errcode < 0 \|\| errcode > LTTCTL_MAXERR)
	205	errcode = LTTCTL_ERR_IMPL;
	206	return lttctl_errmap[errcode].message;
	207	}
	208
	209
ace0e68d	210	char *lttctl_errstr(void)
	211	{
	212	return lttctl_strerror(lttctl_errno);
	213	}
	214
	215	void lttctl_perror(const char *s)
	216	{
	217	if (s)
	218	fputs(s, stderr);
	219	else
	220	fputs("ERROR", stderr);
	221	if (lttctl_errno)
	222	fprintf(stderr, ": %s", lttctl_errstr());
	223	if (errno)
	224	fprintf(stderr, ": %s", strerror(errno));
	225	fputc('\n', stderr);
	226	}
31d2c6b0	227
	228	/* public interface */
	229
	230	/*
	231	* Create and initialise an lttctl handle.
	232	*/
	233	struct lttctl_handle *lttctl_create_handle(void)
	234	{
	235	int status;
	236	struct lttctl_handle *h;
	237
	238	h = (struct lttctl_handle *)malloc(sizeof(struct lttctl_handle));
	239	if (h == NULL) {
ace0e68d	240	lttctl_errno = LTTCTL_ERR_HANDLE;
	241	lttctl_perror("Create handle");
	242	goto alloc_error;
31d2c6b0	243	}
	244
	245	memset(h, 0, sizeof(struct lttctl_handle));
	246
	247	h->fd = socket(PF_NETLINK, SOCK_RAW, NETLINK_LTT);
	248
	249	if (h->fd == -1) {
	250	lttctl_errno = LTTCTL_ERR_SOCKET;
ace0e68d	251	lttctl_perror("Create handle");
ace0e68d	252	goto socket_error;
31d2c6b0	253	}
	254	memset(&h->local, 0, sizeof(struct sockaddr_nl));
	255	h->local.nl_family = AF_NETLINK;
	256	h->local.nl_pid = getpid();
	257	h->local.nl_groups = 0;
	258	status = bind(h->fd, (struct sockaddr *)&h->local, sizeof(h->local));
	259	if (status == -1) {
	260	lttctl_errno = LTTCTL_ERR_BIND;
ace0e68d	261	lttctl_perror("Create handle");
ace0e68d	262	goto bind_error;
31d2c6b0	263	}
	264	memset(&h->peer, 0, sizeof(struct sockaddr_nl));
	265	h->peer.nl_family = AF_NETLINK;
	266	h->peer.nl_pid = 0;
	267	h->peer.nl_groups = 0;
	268	return h;
ace0e68d	269
	270	/* Error condition */
	271	bind_error:
	272	socket_error:
	273	close(h->fd);
	274	alloc_error:
	275	free(h);
	276	return NULL;
31d2c6b0	277	}
	278
	279	/*
	280	* No error condition is checked here at this stage, but it may happen
	281	* if/when reliable messaging is implemented.
	282	*/
	283	int lttctl_destroy_handle(struct lttctl_handle *h)
	284	{
	285	if (h) {
	286	close(h->fd);
	287	free(h);
	288	}
	289	return 0;
	290	}
	291
	292
ace0e68d	293	int lttctl_create_trace(const struct lttctl_handle *h,
31d2c6b0	294	char *name, enum trace_mode mode)
31d2c6b0	295	{
ace0e68d	296	int err;
ace0e68d	297
31d2c6b0	298	struct {
	299	struct nlmsghdr nlh;
	300	lttctl_peer_msg_t msg;
	301	} req;
ace0e68d	302	struct {
	303	struct nlmsghdr nlh;
	304	struct nlmsgerr nlerr;
	305	lttctl_peer_msg_t msg;
	306	} ack;
31d2c6b0	307
31d2c6b0	308	memset(&req, 0, sizeof(req));
ace0e68d	309	req.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(lttctl_peer_msg_t));
ace0e68d	310	req.nlh.nlmsg_flags = NLM_F_REQUEST\|NLM_F_ACK;
31d2c6b0	311	req.nlh.nlmsg_type = LTTCTLM_CONTROL;
31d2c6b0	312	req.nlh.nlmsg_pid = h->local.nl_pid;
ace0e68d	313	req.nlh.nlmsg_seq = 0;
31d2c6b0	314
	315	strncpy(req.msg.trace_name, name, NAME_MAX);
	316	req.msg.op = OP_CREATE;
	317	req.msg.args.mode = mode;
	318
ace0e68d	319	err = lttctl_netlink_sendto(h, (void *)&req, req.nlh.nlmsg_len);
	320	if(err < 0) goto senderr;
	321
	322	err = lttctl_netlink_recvfrom(h, (void*)&ack, sizeof(ack), 0);
	323	if(err < 0) goto senderr;
	324
	325	err = ack.nlerr.error;
	326	if(err != 0) {
	327	errno = err;
	328	lttctl_perror("Create Trace Error");
	329	return -1;
	330	}
	331
	332	return 0;
	333
	334	senderr:
	335	lttctl_perror("Create Trace Error");
	336	return err;
31d2c6b0	337	}
31d2c6b0	338
ace0e68d	339	int lttctl_destroy_trace(const struct lttctl_handle *h,
31d2c6b0	340	char *name)
	341	{
	342	struct {
	343	struct nlmsghdr nlh;
	344	lttctl_peer_msg_t msg;
	345	} req;
ace0e68d	346	struct {
	347	struct nlmsghdr nlh;
	348	struct nlmsgerr nlerr;
	349	lttctl_peer_msg_t msg;
	350	} ack;
	351	int err;
31d2c6b0	352
31d2c6b0	353	memset(&req, 0, sizeof(req));
ace0e68d	354	req.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(lttctl_peer_msg_t));
31d2c6b0	355	req.nlh.nlmsg_flags = NLM_F_REQUEST;
	356	req.nlh.nlmsg_type = LTTCTLM_CONTROL;
	357	req.nlh.nlmsg_pid = h->local.nl_pid;
	358
	359	strncpy(req.msg.trace_name, name, NAME_MAX);
	360	req.msg.op = OP_DESTROY;
	361
ace0e68d	362	err = lttctl_netlink_sendto(h, (void *)&req, req.nlh.nlmsg_len);
	363	if(err < 0) goto senderr;
	364
	365	err = lttctl_netlink_recvfrom(h, (void*)&ack, sizeof(ack), 0);
	366	if(err < 0) goto senderr;
	367
	368	err = ack.nlerr.error;
	369	if(err != 0) {
	370	errno = err;
	371	lttctl_perror("Destroy Trace Channels Error");
	372	return -1;
	373	}
	374
	375	return 0;
	376
	377	senderr:
	378	lttctl_perror("Destroy Trace Channels Error");
	379	return err;
	380
31d2c6b0	381	}
31d2c6b0	382
ace0e68d	383	int lttctl_start(const struct lttctl_handle *h,
31d2c6b0	384	char *name)
	385	{
	386	struct {
	387	struct nlmsghdr nlh;
	388	lttctl_peer_msg_t msg;
	389	} req;
ace0e68d	390	struct {
	391	struct nlmsghdr nlh;
	392	struct nlmsgerr nlerr;
	393	lttctl_peer_msg_t msg;
	394	} ack;
	395
	396	int err;
31d2c6b0	397
31d2c6b0	398	memset(&req, 0, sizeof(req));
ace0e68d	399	req.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(lttctl_peer_msg_t));
31d2c6b0	400	req.nlh.nlmsg_flags = NLM_F_REQUEST;
	401	req.nlh.nlmsg_type = LTTCTLM_CONTROL;
	402	req.nlh.nlmsg_pid = h->local.nl_pid;
	403
	404	strncpy(req.msg.trace_name, name, NAME_MAX);
	405	req.msg.op = OP_START;
	406
ace0e68d	407	err = lttctl_netlink_sendto(h, (void *)&req, req.nlh.nlmsg_len);
	408	if(err < 0) goto senderr;
	409
	410	err = lttctl_netlink_recvfrom(h, (void*)&ack, sizeof(ack), 0);
	411	if(err < 0) goto senderr;
	412
	413	err = ack.nlerr.error;
	414	if(err != 0) {
	415	errno = err;
	416	lttctl_perror("Start Trace Error");
	417	return -1;
	418	}
	419
	420	return 0;
	421
	422	senderr:
	423	lttctl_perror("Start Trace Error");
	424	return err;
	425
31d2c6b0	426	}
31d2c6b0	427
ace0e68d	428	int lttctl_stop(const struct lttctl_handle *h,
31d2c6b0	429	char *name)
	430	{
	431	struct {
	432	struct nlmsghdr nlh;
	433	lttctl_peer_msg_t msg;
	434	} req;
ace0e68d	435	struct {
	436	struct nlmsghdr nlh;
	437	struct nlmsgerr nlerr;
	438	lttctl_peer_msg_t msg;
	439	} ack;
	440	int err;
31d2c6b0	441
31d2c6b0	442	memset(&req, 0, sizeof(req));
ace0e68d	443	req.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(lttctl_peer_msg_t));
31d2c6b0	444	req.nlh.nlmsg_flags = NLM_F_REQUEST;
	445	req.nlh.nlmsg_type = LTTCTLM_CONTROL;
	446	req.nlh.nlmsg_pid = h->local.nl_pid;
	447
	448	strncpy(req.msg.trace_name, name, NAME_MAX);
	449	req.msg.op = OP_STOP;
	450
ace0e68d	451	err = lttctl_netlink_sendto(h, (void *)&req, req.nlh.nlmsg_len);
	452	if(err < 0) goto senderr;
	453
	454	err = lttctl_netlink_recvfrom(h, (void*)&ack, sizeof(ack), 0);
	455	if(err < 0) goto senderr;
	456
	457	err = ack.nlerr.error;
	458	if(err != 0) {
	459	errno = err;
	460	lttctl_perror("Stop Trace Error");
	461	return -1;
	462	}
	463
	464	return 0;
	465
	466	senderr:
	467	lttctl_perror("Stop Trace Error");
	468	return err;
31d2c6b0	469	}