[ltt-control.git] / ltt-control / liblttctl / liblttctl.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.
 * 	
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <liblttctl/lttctl.h>
#include <errno.h>
#include <stdio.h>
#include <error.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <string.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, unsigned subbuf_size, unsigned n_subbufs)
{
	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.new_trace.mode = mode;
	req.msg.args.new_trace.subbuf_size = subbuf_size;
	req.msg.args.new_trace.n_subbufs = n_subbufs;

	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 err;
	}

	return 0;

senderr:
	lttctl_perror("Create Trace Error");
  err = EPERM;
	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 err;
	}

	return 0;

senderr:
	lttctl_perror("Destroy Trace Channels Error");
  err = EPERM;
	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 err;
	}

	return 0;

senderr:
  err = EPERM;
	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 err;
	}

	return 0;

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