[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
#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;
		}

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