[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, char *trace_type, 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);
	strncpy(req.msg.trace_type, trace_type, 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,
9f46b64c	301	char name, enum trace_mode mode, char trace_type, unsigned subbuf_size, unsigned n_subbufs)
2727692a	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);
9f46b64c	323	strncpy(req.msg.trace_type, trace_type, NAME_MAX);
2727692a	324	req.msg.op = OP_CREATE;
	325	req.msg.args.new_trace.mode = mode;
	326	req.msg.args.new_trace.subbuf_size = subbuf_size;
	327	req.msg.args.new_trace.n_subbufs = n_subbufs;
	328
	329	err = lttctl_netlink_sendto(h, (void *)&req, req.nlh.nlmsg_len);
	330	if(err < 0) goto senderr;
	331
	332	err = lttctl_netlink_recvfrom(h, (void*)&ack, sizeof(ack), 0);
	333	if(err < 0) goto senderr;
	334
	335	err = ack.nlerr.error;
	336	if(err != 0) {
	337	errno = err;
	338	lttctl_perror("Create Trace Error");
	339	return err;
	340	}
	341
	342	return 0;
	343
	344	senderr:
	345	lttctl_perror("Create Trace Error");
	346	err = EPERM;
	347	return err;
	348	}
	349
	350	int lttctl_destroy_trace(const struct lttctl_handle *h,
	351	char *name)
	352	{
	353	struct {
	354	struct nlmsghdr nlh;
	355	lttctl_peer_msg_t msg;
	356	} req;
	357	struct {
	358	struct nlmsghdr nlh;
	359	struct nlmsgerr nlerr;
	360	lttctl_peer_msg_t msg;
	361	} ack;
	362	int err;
	363
	364	memset(&req, 0, sizeof(req));
	365	req.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(lttctl_peer_msg_t));
	366	req.nlh.nlmsg_flags = NLM_F_REQUEST;
	367	req.nlh.nlmsg_type = LTTCTLM_CONTROL;
	368	req.nlh.nlmsg_pid = h->local.nl_pid;
	369
	370	strncpy(req.msg.trace_name, name, NAME_MAX);
	371	req.msg.op = OP_DESTROY;
	372
	373	err = lttctl_netlink_sendto(h, (void *)&req, req.nlh.nlmsg_len);
	374	if(err < 0) goto senderr;
	375
	376	err = lttctl_netlink_recvfrom(h, (void*)&ack, sizeof(ack), 0);
	377	if(err < 0) goto senderr;
	378
	379	err = ack.nlerr.error;
	380	if(err != 0) {
	381	errno = err;
	382	lttctl_perror("Destroy Trace Channels Error");
	383	return err;
	384	}
	385
	386	return 0;
	387
388	senderr:
389	lttctl_perror("Destroy Trace Channels Error");
390	err = EPERM;
391	return err;
392
393	}
394
395	int lttctl_start(const struct lttctl_handle *h,
396	char *name)
397	{
398	struct {
399	struct nlmsghdr nlh;
400	lttctl_peer_msg_t msg;
401	} req;
402	struct {
403	struct nlmsghdr nlh;
404	struct nlmsgerr nlerr;
405	lttctl_peer_msg_t msg;
406	} ack;
407
408	int err;
409
410	memset(&req, 0, sizeof(req));
411	req.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(lttctl_peer_msg_t));
412	req.nlh.nlmsg_flags = NLM_F_REQUEST;
413	req.nlh.nlmsg_type = LTTCTLM_CONTROL;
414	req.nlh.nlmsg_pid = h->local.nl_pid;
415
416	strncpy(req.msg.trace_name, name, NAME_MAX);
417	req.msg.op = OP_START;
418
419	err = lttctl_netlink_sendto(h, (void *)&req, req.nlh.nlmsg_len);
420	if(err < 0) goto senderr;
421
422	err = lttctl_netlink_recvfrom(h, (void*)&ack, sizeof(ack), 0);
423	if(err < 0) goto senderr;
424
425	err = ack.nlerr.error;
426	if(err != 0) {
427	errno = err;
428	lttctl_perror("Start Trace Error");
429	return err;
430	}
431
432	return 0;
433
434	senderr:
435	err = EPERM;
436	lttctl_perror("Start Trace Error");
437	return err;
438
439	}
440
441	int lttctl_stop(const struct lttctl_handle *h,
442	char *name)
443	{
444	struct {
445	struct nlmsghdr nlh;
446	lttctl_peer_msg_t msg;
447	} req;
448	struct {
449	struct nlmsghdr nlh;
450	struct nlmsgerr nlerr;
451	lttctl_peer_msg_t msg;
452	} ack;
453	int err;
454
455	memset(&req, 0, sizeof(req));
456	req.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(lttctl_peer_msg_t));
457	req.nlh.nlmsg_flags = NLM_F_REQUEST;
458	req.nlh.nlmsg_type = LTTCTLM_CONTROL;
459	req.nlh.nlmsg_pid = h->local.nl_pid;
460
461	strncpy(req.msg.trace_name, name, NAME_MAX);
462	req.msg.op = OP_STOP;
463
464	err = lttctl_netlink_sendto(h, (void *)&req, req.nlh.nlmsg_len);
465	if(err < 0) goto senderr;
466
467	err = lttctl_netlink_recvfrom(h, (void*)&ack, sizeof(ack), 0);
468	if(err < 0) goto senderr;
469
470	err = ack.nlerr.error;
471	if(err != 0) {
472	errno = err;
473	lttctl_perror("Stop Trace Error");
474	return err;
475	}
476
477	return 0;
478
479	senderr:
480	err = EPERM;
481	lttctl_perror("Stop Trace Error");
482	return err;
483	}
484