[lttng-tools.git] / src / bin / lttng-sessiond / syscall.c

/*
 * Copyright (C) 2014 - David Goulet <dgoulet@efficios.com>
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License, version 2 only, as
 * published by the Free Software Foundation.
 *
 * 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.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc., 51
 * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#define _GNU_SOURCE
#define _LGPL_SOURCE
#include <common/bitfield.h>
#include <common/common.h>
#include <common/kernel-ctl/kernel-ctl.h>

#include "lttng-sessiond.h"
#include "kernel.h"
#include "syscall.h"
#include "utils.h"

/* Global syscall table. */
struct syscall *syscall_table;

/* Number of entry in the syscall table. */
static size_t syscall_table_nb_entry;

/*
 * Populate the system call table using the kernel tracer.
 *
 * Return 0 on success and the syscall table is allocated. On error, a negative
 * value is returned.
 */
int syscall_init_table(void)
{
	int ret, fd, err;
	size_t nbmem;
	FILE *fp;
	/* Syscall data from the kernel. */
	size_t index;
	uint32_t bitness;
	char name[SYSCALL_NAME_LEN];

	DBG3("Syscall init system call table");

	fd = kernctl_syscall_list(kernel_tracer_fd);
	if (fd < 0) {
		ret = -errno;
		PERROR("kernelctl syscall list");
		goto error_ioctl;
	}

	fp = fdopen(fd, "r");
	if (!fp) {
		ret = -errno;
		PERROR("syscall list fdopen");
		goto error_fp;
	}

	nbmem = SYSCALL_TABLE_INIT_SIZE;
	syscall_table = zmalloc(sizeof(struct syscall) * nbmem);
	if (!syscall_table) {
		ret = -errno;
		PERROR("syscall list zmalloc");
		goto error;
	}

	while (fscanf(fp,
				"syscall { index = %lu; \
				name = %" XSTR(SYSCALL_NAME_LEN) "[^;]; \
				bitness = %u; };\n",
				&index, name, &bitness) == 3) {
		if (index >= nbmem ) {
			struct syscall *new_list;
			size_t new_nbmem;

			/* Double memory size. */
			new_nbmem = max(index, nbmem << 1);
			if (new_nbmem < nbmem) {
				/* Overflow, stop everything, something went really wrong. */
				ERR("Syscall listing memory size overflow. Stopping");
				free(syscall_table);
				syscall_table = NULL;
				ret = -EINVAL;
				goto error;
			}

			DBG("Reallocating syscall table from %zu to %zu entries", nbmem,
					new_nbmem);
			new_list = realloc(syscall_table, new_nbmem * sizeof(*new_list));
			if (!new_list) {
				ret = -errno;
				PERROR("syscall list realloc");
				goto error;
			}

			/* Zero out the new memory. */
			memset(new_list + nbmem, 0,
					(new_nbmem - nbmem) * sizeof(*new_list));
			nbmem = new_nbmem;
			syscall_table = new_list;
		}
		syscall_table[index].index = index;
		syscall_table[index].bitness = bitness;
		strncpy(syscall_table[index].name, name,
				sizeof(syscall_table[index].name));
		/*
		DBG("Syscall name '%s' at index %" PRIu32 " of bitness %u",
				syscall_table[index].name,
				syscall_table[index].index,
				syscall_table[index].bitness);
		*/
	}

	syscall_table_nb_entry = index;

	ret = 0;

error:
	err = fclose(fp);
	if (err) {
		PERROR("syscall list fclose");
	}
	return ret;

error_fp:
	err = close(fd);
	if (err) {
		PERROR("syscall list close");
	}

error_ioctl:
	return ret;
}

/*
 * Helper function for the list syscalls command that empty the temporary
 * syscall hashtable used to track duplicate between 32 and 64 bit arch.
 *
 * This empty the hash table and destroys it after. After this, the pointer is
 * unsuable. RCU read side lock MUST be acquired before calling this.
 */
static void destroy_syscall_ht(struct lttng_ht *ht)
{
	struct lttng_ht_iter iter;
	struct syscall *ksyscall;

	DBG3("Destroying syscall hash table.");

	if (!ht) {
		return;
	}

	cds_lfht_for_each_entry(ht->ht, &iter.iter, ksyscall, node.node) {
		int ret;

		ret = lttng_ht_del(ht, &iter);
		assert(!ret);
		free(ksyscall);
	}
	ht_cleanup_push(ht);
}

/*
 * Allocate the given hashtable pointer.
 *
 * Return 0 on success else a negative LTTNG error value.
 */
static int init_syscall_ht(struct lttng_ht **ht)
{
	int ret;

	*ht = lttng_ht_new(0, LTTNG_HT_TYPE_STRING);
	if (!*ht) {
		ret = -LTTNG_ERR_NOMEM;
	} else {
		ret = 0;
	}

	return ret;
}

/*
 * Lookup a syscall in the given hash table by name.
 *
 * Return syscall object if found or else NULL.
 */
static struct syscall *lookup_syscall(struct lttng_ht *ht, const char *name)
{
	struct lttng_ht_node_str *node;
	struct lttng_ht_iter iter;
	struct syscall *ksyscall = NULL;

	assert(ht);
	assert(name);

	lttng_ht_lookup(ht, (void *) name, &iter);
	node = lttng_ht_iter_get_node_str(&iter);
	if (node) {
		ksyscall = caa_container_of(node, struct syscall, node);
	}

	return ksyscall;
}

/*
 * Using the given syscall object in the events array with the bitness of the
 * syscall at index in the syscall table.
 */
static void update_event_syscall_bitness(struct lttng_event *events,
		unsigned int index, unsigned int syscall_index)
{
	assert(events);

	if (syscall_table[index].bitness == 32) {
		events[syscall_index].flags |= LTTNG_EVENT_FLAG_SYSCALL_32;
	} else {
		events[syscall_index].flags |= LTTNG_EVENT_FLAG_SYSCALL_64;
	}
}

/*
 * Allocate and initialize syscall object and add it to the given hashtable.
 *
 * Return 0 on success else -LTTNG_ERR_NOMEM.
 */
static int add_syscall_to_ht(struct lttng_ht *ht, unsigned int index,
		unsigned int syscall_index)
{
	int ret;
	struct syscall *ksyscall;

	assert(ht);

	ksyscall = zmalloc(sizeof(*ksyscall));
	if (!ksyscall) {
		ret = -LTTNG_ERR_NOMEM;
		goto error;
	}

	strncpy(ksyscall->name, syscall_table[index].name,
			sizeof(ksyscall->name));
	ksyscall->bitness = syscall_table[index].bitness;
	ksyscall->index = syscall_index;
	lttng_ht_node_init_str(&ksyscall->node, ksyscall->name);
	lttng_ht_add_unique_str(ht, &ksyscall->node);
	ret = 0;

error:
	return ret;
}

/*
 * List syscalls present in the kernel syscall global array, allocate and
 * populate the events structure with them. Skip the empty syscall name.
 *
 * Return the number of entries in the array else a negative value.
 */
ssize_t syscall_table_list(struct lttng_event **_events)
{
	int i, index = 0;
	ssize_t ret;
	struct lttng_event *events;
	/* Hash table used to filter duplicate out. */
	struct lttng_ht *syscalls_ht = NULL;

	assert(_events);

	DBG("Syscall table listing.");

	rcu_read_lock();

	/*
	 * Allocate at least the number of total syscall we have even if some of
	 * them might not be valid. The count below will make sure to return the
	 * right size of the events array.
	 */
	events = zmalloc(syscall_table_nb_entry * sizeof(*events));
	if (!events) {
		PERROR("syscall table list zmalloc");
		ret = -LTTNG_ERR_NOMEM;
		goto error;
	}

	ret = init_syscall_ht(&syscalls_ht);
	if (ret < 0) {
		goto error;
	}

	for (i = 0; i < syscall_table_nb_entry; i++) {
		struct syscall *ksyscall;

		/* Skip empty syscalls. */
		if (*syscall_table[i].name == '\0') {
			continue;
		}

		ksyscall = lookup_syscall(syscalls_ht, syscall_table[i].name);
		if (ksyscall) {
			update_event_syscall_bitness(events, i, ksyscall->index);
			continue;
		}

		ret = add_syscall_to_ht(syscalls_ht, i, index);
		if (ret < 0) {
			goto error;
		}

		/* Copy the event information in the event's array. */
		strncpy(events[index].name, syscall_table[i].name,
				sizeof(events[index].name));
		update_event_syscall_bitness(events, i, index);
		events[index].type = LTTNG_EVENT_SYSCALL;
		/* This makes the command line not print the enabled/disabled field. */
		events[index].enabled = -1;
		index++;
	}

	destroy_syscall_ht(syscalls_ht);
	*_events = events;
	rcu_read_unlock();
	return index;

error:
	destroy_syscall_ht(syscalls_ht);
	free(events);
	rcu_read_unlock();
	return ret;
}

/*
 * Add enabled syscall to the events list using the given kernel channel.
 *
 * Return the number of entry of the events array that is different from size
 * if the array grows. On error, return negative value and events is untouched.
 */
ssize_t syscall_list_channel(struct ltt_kernel_channel *kchan,
		struct lttng_event **_events, size_t size)
{
	int err, i;
	size_t new_size;
	ssize_t ret, count;
	char *mask = NULL;
	uint32_t len;
	struct lttng_event *events = NULL;
	/* Hash table used to filter duplicate out. */
	struct lttng_ht *syscalls_ht = NULL;

	assert(kchan);

	/* Get syscall mask from the kernel tracer. */
	err = kernel_syscall_mask(kchan->fd, &mask, &len);
	if (err < 0) {
		ret = err;
		goto error;
	}

	ret = init_syscall_ht(&syscalls_ht);
	if (ret < 0) {
		goto error;
	}

	count = new_size = size;
	events = *_events;

	for (i = 0; i < len; i++) {
		unsigned char val;
		struct syscall *ksyscall;

		bitfield_read_be(mask, unsigned char, i, 1, &val);
		if (!val) {
			/* Syscall is disabled, continue the loop. */
			continue;
		}

		/* Skip empty syscall. */
		if (*syscall_table[i].name == '\0') {
			continue;
		}

		/* Syscall is enabled thus add it to the events list. */

		if (count >= new_size) {
			struct lttng_event *new_events;

			/* Get the maximum here since count can be 0. */
			new_size = max(count << 1, 1);
			DBG3("Listing syscall realloc events array from %zu to %zu", count,
					new_size);
			new_events = realloc(events, new_size * sizeof(*new_events));
			if (!new_events) {
				PERROR("realloc kernel events list");
				ret = -ENOMEM;
				goto error;
			}
			memset(new_events + count, 0,
					(new_size - count) * sizeof(*new_events));
			events = new_events;
		}

		rcu_read_lock();
		ksyscall = lookup_syscall(syscalls_ht, syscall_table[i].name);
		if (ksyscall) {
			update_event_syscall_bitness(events, i, ksyscall->index);
			rcu_read_unlock();
			continue;
		}
		ksyscall = NULL;
		rcu_read_unlock();

		ret = add_syscall_to_ht(syscalls_ht, i, count);
		if (ret < 0) {
			goto error;
		}

		update_event_syscall_bitness(events, i, count);
		strncpy(events[count].name, syscall_table[i].name,
				sizeof(events[count].name));
		events[count].enabled = 1;
		events[count].type = LTTNG_KERNEL_SYSCALL;
		count++;
	}

	*_events = events;

	return count;

error:
	rcu_read_lock();
	destroy_syscall_ht(syscalls_ht);
	rcu_read_unlock();

	free(events);
	return ret;
}
Commit	Line	Data
834978fd DG	1	/*
	2	* Copyright (C) 2014 - David Goulet <dgoulet@efficios.com>
	3	*
	4	* This program is free software; you can redistribute it and/or modify it
	5	* under the terms of the GNU General Public License, version 2 only, as
	6	* published by the Free Software Foundation.
	7	*
	8	* This program is distributed in the hope that it will be useful, but WITHOUT
	9	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	10	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	11	* more details.
	12	*
	13	* You should have received a copy of the GNU General Public License along with
	14	* this program; if not, write to the Free Software Foundation, Inc., 51
	15	* Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
	16	*/
	17
	18	#define _GNU_SOURCE
6c1c0768	19	#define _LGPL_SOURCE
834978fd DG	20	#include <common/bitfield.h>
	21	#include <common/common.h>
	22	#include <common/kernel-ctl/kernel-ctl.h>
	23
	24	#include "lttng-sessiond.h"
	25	#include "kernel.h"
	26	#include "syscall.h"
	27	#include "utils.h"
	28
	29	/* Global syscall table. */
	30	struct syscall *syscall_table;
	31
	32	/* Number of entry in the syscall table. */
	33	static size_t syscall_table_nb_entry;
	34
	35	/*
	36	* Populate the system call table using the kernel tracer.
	37	*
	38	* Return 0 on success and the syscall table is allocated. On error, a negative
1f47715a	39	* value is returned.
834978fd DG	40	*/
	41	int syscall_init_table(void)
	42	{
	43	int ret, fd, err;
	44	size_t nbmem;
	45	FILE *fp;
	46	/* Syscall data from the kernel. */
	47	size_t index;
	48	uint32_t bitness;
	49	char name[SYSCALL_NAME_LEN];
	50
	51	DBG3("Syscall init system call table");
	52
	53	fd = kernctl_syscall_list(kernel_tracer_fd);
	54	if (fd < 0) {
	55	ret = -errno;
	56	PERROR("kernelctl syscall list");
	57	goto error_ioctl;
	58	}
	59
	60	fp = fdopen(fd, "r");
	61	if (!fp) {
	62	ret = -errno;
	63	PERROR("syscall list fdopen");
	64	goto error_fp;
	65	}
	66
	67	nbmem = SYSCALL_TABLE_INIT_SIZE;
	68	syscall_table = zmalloc(sizeof(struct syscall) * nbmem);
	69	if (!syscall_table) {
	70	ret = -errno;
	71	PERROR("syscall list zmalloc");
	72	goto error;
	73	}
	74
	75	while (fscanf(fp,
	76	"syscall { index = %lu; \
	77	name = %" XSTR(SYSCALL_NAME_LEN) "[^;]; \
	78	bitness = %u; };\n",
	79	&index, name, &bitness) == 3) {
	80	if (index >= nbmem ) {
	81	struct syscall *new_list;
	82	size_t new_nbmem;
	83
	84	/* Double memory size. */
4b47b6a9	85	new_nbmem = max(index, nbmem << 1);
1f47715a DG	86	if (new_nbmem < nbmem) {
	87	/* Overflow, stop everything, something went really wrong. */
	88	ERR("Syscall listing memory size overflow. Stopping");
	89	free(syscall_table);
	90	syscall_table = NULL;
	91	ret = -EINVAL;
	92	goto error;
	93	}
834978fd DG	94
	95	DBG("Reallocating syscall table from %zu to %zu entries", nbmem,
	96	new_nbmem);
	97	new_list = realloc(syscall_table, new_nbmem * sizeof(*new_list));
	98	if (!new_list) {
	99	ret = -errno;
	100	PERROR("syscall list realloc");
	101	goto error;
	102	}
	103
	104	/* Zero out the new memory. */
	105	memset(new_list + nbmem, 0,
	106	(new_nbmem - nbmem) * sizeof(*new_list));
	107	nbmem = new_nbmem;
	108	syscall_table = new_list;
	109	}
	110	syscall_table[index].index = index;
	111	syscall_table[index].bitness = bitness;
	112	strncpy(syscall_table[index].name, name,
	113	sizeof(syscall_table[index].name));
	114	/*
	115	DBG("Syscall name '%s' at index %" PRIu32 " of bitness %u",
	116	syscall_table[index].name,
	117	syscall_table[index].index,
	118	syscall_table[index].bitness);
	119	*/
	120	}
	121
	122	syscall_table_nb_entry = index;
	123
	124	ret = 0;
	125
	126	error:
	127	err = fclose(fp);
	128	if (err) {
	129	PERROR("syscall list fclose");
	130	}
	131	return ret;
	132
	133	error_fp:
	134	err = close(fd);
	135	if (err) {
	136	PERROR("syscall list close");
	137	}
	138
	139	error_ioctl:
	140	return ret;
	141	}
	142
	143	/*
	144	* Helper function for the list syscalls command that empty the temporary
	145	* syscall hashtable used to track duplicate between 32 and 64 bit arch.
	146	*
	147	* This empty the hash table and destroys it after. After this, the pointer is
	148	* unsuable. RCU read side lock MUST be acquired before calling this.
	149	*/
	150	static void destroy_syscall_ht(struct lttng_ht *ht)
	151	{
	152	struct lttng_ht_iter iter;
	153	struct syscall *ksyscall;
	154
	155	DBG3("Destroying syscall hash table.");
	156
	157	if (!ht) {
158	return;
159	}
160
161	cds_lfht_for_each_entry(ht->ht, &iter.iter, ksyscall, node.node) {
162	int ret;
163
164	ret = lttng_ht_del(ht, &iter);
165	assert(!ret);
166	free(ksyscall);
167	}
168	ht_cleanup_push(ht);
169	}
170
171	/*
172	* Allocate the given hashtable pointer.
173	*
174	* Return 0 on success else a negative LTTNG error value.
175	*/
176	static int init_syscall_ht(struct lttng_ht **ht)
177	{
178	int ret;
179
180	*ht = lttng_ht_new(0, LTTNG_HT_TYPE_STRING);
181	if (!*ht) {
182	ret = -LTTNG_ERR_NOMEM;
183	} else {
184	ret = 0;
185	}
186
187	return ret;
188	}
189
190	/*
191	* Lookup a syscall in the given hash table by name.
192	*
193	* Return syscall object if found or else NULL.
194	*/
195	static struct syscall lookup_syscall(struct lttng_ht ht, const char *name)
196	{
197	struct lttng_ht_node_str *node;
198	struct lttng_ht_iter iter;
199	struct syscall *ksyscall = NULL;
200
201	assert(ht);
202	assert(name);
203
204	lttng_ht_lookup(ht, (void *) name, &iter);
205	node = lttng_ht_iter_get_node_str(&iter);
206	if (node) {
207	ksyscall = caa_container_of(node, struct syscall, node);
208	}
209
210	return ksyscall;
211	}
212
213	/*
214	* Using the given syscall object in the events array with the bitness of the
215	* syscall at index in the syscall table.
216	*/
217	static void update_event_syscall_bitness(struct lttng_event *events,
218	unsigned int index, unsigned int syscall_index)
219	{
220	assert(events);
221
222	if (syscall_table[index].bitness == 32) {
223	events[syscall_index].flags \|= LTTNG_EVENT_FLAG_SYSCALL_32;
224	} else {
225	events[syscall_index].flags \|= LTTNG_EVENT_FLAG_SYSCALL_64;
226	}
227	}
228
229	/*
230	* Allocate and initialize syscall object and add it to the given hashtable.
231	*
232	* Return 0 on success else -LTTNG_ERR_NOMEM.
233	*/
234	static int add_syscall_to_ht(struct lttng_ht *ht, unsigned int index,
235	unsigned int syscall_index)
236	{
237	int ret;
238	struct syscall *ksyscall;
239
240	assert(ht);
241
242	ksyscall = zmalloc(sizeof(*ksyscall));
243	if (!ksyscall) {
244	ret = -LTTNG_ERR_NOMEM;
245	goto error;
246	}
247
248	strncpy(ksyscall->name, syscall_table[index].name,
249	sizeof(ksyscall->name));
250	ksyscall->bitness = syscall_table[index].bitness;
251	ksyscall->index = syscall_index;
252	lttng_ht_node_init_str(&ksyscall->node, ksyscall->name);
253	lttng_ht_add_unique_str(ht, &ksyscall->node);
254	ret = 0;
255
256	error:
257	return ret;
258	}
259
260	/*
261	* List syscalls present in the kernel syscall global array, allocate and
262	* populate the events structure with them. Skip the empty syscall name.
263	*
264	* Return the number of entries in the array else a negative value.
265	*/
266	ssize_t syscall_table_list(struct lttng_event **_events)
267	{
268	int i, index = 0;
269	ssize_t ret;
270	struct lttng_event *events;
271	/* Hash table used to filter duplicate out. */
272	struct lttng_ht *syscalls_ht = NULL;
273
274	assert(_events);
275
276	DBG("Syscall table listing.");
277
278	rcu_read_lock();
279
280	/*
281	* Allocate at least the number of total syscall we have even if some of
282	* them might not be valid. The count below will make sure to return the
283	* right size of the events array.
284	*/
285	events = zmalloc(syscall_table_nb_entry * sizeof(*events));
286	if (!events) {
287	PERROR("syscall table list zmalloc");
288	ret = -LTTNG_ERR_NOMEM;
289	goto error;
290	}
291
292	ret = init_syscall_ht(&syscalls_ht);
293	if (ret < 0) {
294	goto error;
295	}
296
297	for (i = 0; i < syscall_table_nb_entry; i++) {
298	struct syscall *ksyscall;
299
300	/* Skip empty syscalls. */
301	if (*syscall_table[i].name == '\0') {
302	continue;
303	}
304
305	ksyscall = lookup_syscall(syscalls_ht, syscall_table[i].name);
306	if (ksyscall) {
307	update_event_syscall_bitness(events, i, ksyscall->index);
308	continue;
309	}
310
311	ret = add_syscall_to_ht(syscalls_ht, i, index);
312	if (ret < 0) {
313	goto error;
314	}
315
316	/* Copy the event information in the event's array. */
317	strncpy(events[index].name, syscall_table[i].name,
318	sizeof(events[index].name));
319	update_event_syscall_bitness(events, i, index);
320	events[index].type = LTTNG_EVENT_SYSCALL;
321	/* This makes the command line not print the enabled/disabled field. */
322	events[index].enabled = -1;
323	index++;
324	}
325
326	destroy_syscall_ht(syscalls_ht);
327	*_events = events;
328	rcu_read_unlock();
329	return index;
330
331	error:
332	destroy_syscall_ht(syscalls_ht);
333	free(events);
334	rcu_read_unlock();
335	return ret;
336	}
337
338	/*
339	* Add enabled syscall to the events list using the given kernel channel.
340	*
341	* Return the number of entry of the events array that is different from size
342	* if the array grows. On error, return negative value and events is untouched.
343	*/
344	ssize_t syscall_list_channel(struct ltt_kernel_channel *kchan,
345	struct lttng_event **_events, size_t size)
346	{
347	int err, i;
348	size_t new_size;
349	ssize_t ret, count;
350	char *mask = NULL;
351	uint32_t len;
352	struct lttng_event *events = NULL;
353	/* Hash table used to filter duplicate out. */
354	struct lttng_ht *syscalls_ht = NULL;
355
356	assert(kchan);
357
358	/* Get syscall mask from the kernel tracer. */
359	err = kernel_syscall_mask(kchan->fd, &mask, &len);
360	if (err < 0) {
361	ret = err;
362	goto error;
363	}
364
365	ret = init_syscall_ht(&syscalls_ht);
366	if (ret < 0) {
367	goto error;
368	}
369
370	count = new_size = size;
371	events = *_events;
372
373	for (i = 0; i < len; i++) {
374	unsigned char val;
375	struct syscall *ksyscall;
376
377	bitfield_read_be(mask, unsigned char, i, 1, &val);
378	if (!val) {
379	/* Syscall is disabled, continue the loop. */
380	continue;
381	}
382
383	/* Skip empty syscall. */
384	if (*syscall_table[i].name == '\0') {
385	continue;
386	}
387
388	/* Syscall is enabled thus add it to the events list. */
389
390	if (count >= new_size) {
391	struct lttng_event *new_events;
392
393	/* Get the maximum here since count can be 0. */
394	new_size = max(count << 1, 1);
395	DBG3("Listing syscall realloc events array from %zu to %zu", count,
396	new_size);
397	new_events = realloc(events, new_size * sizeof(*new_events));
398	if (!new_events) {
399	PERROR("realloc kernel events list");
400	ret = -ENOMEM;
401	goto error;
402	}
403	memset(new_events + count, 0,
404	(new_size - count) * sizeof(*new_events));
405	events = new_events;
406	}
407
24eb8569	408	rcu_read_lock();
834978fd DG	409	ksyscall = lookup_syscall(syscalls_ht, syscall_table[i].name);
	410	if (ksyscall) {
	411	update_event_syscall_bitness(events, i, ksyscall->index);
69d8ecd9	412	rcu_read_unlock();
834978fd DG	413	continue;
834978fd DG	414	}
24eb8569 JG	415	ksyscall = NULL;
24eb8569 JG	416	rcu_read_unlock();
834978fd DG	417
	418	ret = add_syscall_to_ht(syscalls_ht, i, count);
	419	if (ret < 0) {
	420	goto error;
	421	}
	422
	423	update_event_syscall_bitness(events, i, count);
	424	strncpy(events[count].name, syscall_table[i].name,
	425	sizeof(events[count].name));
	426	events[count].enabled = 1;
	427	events[count].type = LTTNG_KERNEL_SYSCALL;
	428	count++;
	429	}
	430
	431	*_events = events;
	432
	433	return count;
	434
	435	error:
24eb8569	436	rcu_read_lock();
834978fd	437	destroy_syscall_ht(syscalls_ht);
24eb8569 JG	438	rcu_read_unlock();
24eb8569 JG	439
834978fd DG	440	free(events);
	441	return ret;
	442	}