[lttngtop.git] / src / iostreamtop.c

/*
 * Copyright (C) 2011 Mathieu Bain <mathieu.bain@polymtl.ca>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License Version 2 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., 59 Temple Place - Suite 330, Boston,
 * MA 02111-1307, USA.
 */

#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>
#include <babeltrace/babeltrace.h>

#include "lttngtoptypes.h"
#include "common.h"
#include "iostreamtop.h"

void add_file(struct processtop *proc, struct files *file, int fd)
{
	if (proc->process_files_table->len <= fd) {
		g_ptr_array_set_size(proc->process_files_table, fd);
		g_ptr_array_add(proc->process_files_table, file);
	} else {
		g_ptr_array_index(proc->process_files_table, fd) = file;
	}
	file->fd = fd;
}


void insert_file(struct processtop *proc, int fd)
{
	struct files *tmp;

	if (fd >= proc->process_files_table->len) {
		tmp = g_new0(struct files, 1);
		tmp->name = "Unknown";
		add_file(proc, tmp, fd);
	} else {

		tmp = g_ptr_array_index(proc->process_files_table, fd);
		if (tmp == NULL) {
			tmp = g_new0(struct files, 1);
			tmp->name = "Unknown";
			tmp->read = 0;
			tmp->write = 0;
			tmp->fd = fd;
			add_file(proc, tmp, fd);
		}
	}
}

void close_file(struct processtop *proc, int fd)
{
	int len;

	len = proc->process_files_table->len;

	/*
	 * It is possible that a file was open before taking the trace
	 * and its fd could be greater than all of the others fd
	 * used by the process
	 */
	if (fd < len) {
		g_ptr_array_remove_index_fast(proc->process_files_table, fd);
		g_ptr_array_set_size(proc->process_files_table, len + 1);
	}
}

struct files *get_file(struct processtop *proc, int fd)
{
	struct files *tmp;
	tmp = g_ptr_array_index(proc->process_files_table, fd);
	return tmp;
}

void show_table(GPtrArray *tab)
{
	int i;
	struct files *file;

	for (i = 0 ; i < tab->len; i++) {
		file = g_ptr_array_index(tab, i);
		if (file == NULL)
			fprintf(stderr, "NULL, ");
		else
			fprintf(stderr, "%s, ", file->name);
	}
	fprintf(stderr, "]\n\n");
}

int update_iostream_ret(struct lttngtop *ctx, int tid, char *comm,
		unsigned long timestamp, int cpu_id, int ret)
{
	struct processtop *tmp;
	struct files *tmpfile;
	int err = 0;

	tmp = get_proc(ctx, tid, comm, timestamp);

	if (tmp->syscall_info != NULL) {
		if (tmp->syscall_info->type == __NR_read
			&& ret > 0) {
			tmp->totalfileread += ret;
			tmp->fileread += ret;
			tmpfile = get_file(tmp, tmp->syscall_info->fd);
			tmpfile->read += ret;
		} else if (tmp->syscall_info->type == __NR_write
			&& ret > 0) {
			tmp->totalfilewrite += ret;
			tmp->filewrite += ret;
			tmpfile = get_file(tmp, tmp->syscall_info->fd);
			tmpfile->write += ret;
		} else if (tmp->syscall_info->type == __NR_open
			&& ret > 0) {
			add_file(tmp, tmp->files_history->file, ret);
		} else {
			err = -1;
		}
		g_free(tmp->syscall_info);
		tmp->syscall_info = NULL;
 	}
	return err;
}

struct syscalls *create_syscall_info(unsigned int type, unsigned int cpu_id,
		unsigned int tid, int fd)
{
	struct syscalls *syscall_info;
	
	syscall_info = g_new0(struct syscalls, 1);
	syscall_info->type = type;
	syscall_info->cpu_id = cpu_id;
	syscall_info->tid = tid;
	syscall_info->fd = fd;

	return syscall_info;
}

struct file_history *create_file(struct file_history *history, char *file_name)
{
	struct files *new_file;
	struct file_history *new_history;

	new_file = g_new0(struct files, 1);
	new_history = g_new0(struct file_history, 1);
	new_file->name = strdup(file_name);
	new_file->read = 0;
	new_file->write = 0;
	new_history->file = new_file;
	new_history->next = history;

	return new_history;
}

enum bt_cb_ret handle_exit_syscall(struct bt_ctf_event *call_data,
		void *private_data)
{
	struct definition *scope;
	unsigned long timestamp;
	char *comm;
	uint64_t ret, tid;
	int64_t cpu_id;

	timestamp = bt_ctf_get_timestamp(call_data);
	if (timestamp == -1ULL)
		goto error;

	scope = bt_ctf_get_top_level_scope(call_data,
			BT_STREAM_EVENT_CONTEXT);
	comm = bt_ctf_get_char_array(bt_ctf_get_field(call_data,
				scope, "_procname"));
	if (bt_ctf_field_get_error()) {
		fprintf(stderr, "Missing procname context info\n");
		goto error;
	}

	tid = bt_ctf_get_int64(bt_ctf_get_field(call_data,
				scope, "_tid"));
	if (bt_ctf_field_get_error()) {
		fprintf(stderr, "Missing tid context info\n");
		goto error;
	}

	scope = bt_ctf_get_top_level_scope(call_data,
			BT_EVENT_FIELDS);
	ret = bt_ctf_get_int64(bt_ctf_get_field(call_data,
				scope, "_ret"));
	if (bt_ctf_field_get_error()) {
		fprintf(stderr, "Missing ret context info\n");
		goto error;
	}

	scope = bt_ctf_get_top_level_scope(call_data,
			BT_STREAM_PACKET_CONTEXT);
	cpu_id = bt_ctf_get_uint64(bt_ctf_get_field(call_data,
				scope, "cpu_id"));
	if (bt_ctf_field_get_error()) {
		fprintf(stderr, "Missing cpu_id context info\n");
		goto error;
	}

	/*
	 * if we encounter an exit_syscall and
	 * it is not for a syscall read or write
	 * we just abort the execution of this callback
	 */
	if ((update_iostream_ret(&lttngtop, tid, comm, timestamp, cpu_id, ret)) < 0)
		return BT_CB_ERROR_CONTINUE;

	return BT_CB_OK;

error:
	return BT_CB_ERROR_STOP;
}


enum bt_cb_ret handle_sys_write(struct bt_ctf_event *call_data,
		void *private_data)
{
	struct definition *scope;
	struct processtop *tmp;
	unsigned long timestamp;
	uint64_t cpu_id;
	char *comm;
	int64_t tid;
	int fd;

	timestamp = bt_ctf_get_timestamp(call_data);
	if (timestamp == -1ULL)
		goto error;

	scope = bt_ctf_get_top_level_scope(call_data,
			BT_STREAM_EVENT_CONTEXT);
	comm = bt_ctf_get_char_array(bt_ctf_get_field(call_data,
				scope, "_procname"));
	if (bt_ctf_field_get_error()) {
		fprintf(stderr, "Missing procname context info\n");
		goto error;
	}

	tid = bt_ctf_get_int64(bt_ctf_get_field(call_data,
				scope, "_tid"));
	if (bt_ctf_field_get_error()) {
		fprintf(stderr, "Missing tid context info\n");
		goto error;
	}

	scope = bt_ctf_get_top_level_scope(call_data,
			BT_STREAM_PACKET_CONTEXT);
	cpu_id = bt_ctf_get_uint64(bt_ctf_get_field(call_data,
				scope, "cpu_id"));
	if (bt_ctf_field_get_error()) {
		fprintf(stderr, "Missing cpu_id context info\n");
		goto error;
	}

	scope = bt_ctf_get_top_level_scope(call_data,
			BT_EVENT_FIELDS);
	fd = bt_ctf_get_uint64(bt_ctf_get_field(call_data,
				scope, "_fd"));
	if (bt_ctf_field_get_error()) {
		fprintf(stderr, "Missing fd context info\n");
		goto error;
	}

	tmp = get_proc(&lttngtop, tid, comm, timestamp);
	tmp->syscall_info = create_syscall_info(__NR_write, cpu_id, tid, fd);

	insert_file(tmp, fd);

	return BT_CB_OK;

error:
	return BT_CB_ERROR_STOP;
}

enum bt_cb_ret handle_sys_read(struct bt_ctf_event *call_data,
		void *private_data)
{
	struct processtop *tmp;
	struct definition *scope;
	unsigned long timestamp;
	uint64_t cpu_id;
	char *comm;
	int64_t tid;
	int fd;

	timestamp = bt_ctf_get_timestamp(call_data);
	if (timestamp == -1ULL)
		goto error;

	scope = bt_ctf_get_top_level_scope(call_data,
			BT_STREAM_EVENT_CONTEXT);
	comm = bt_ctf_get_char_array(bt_ctf_get_field(call_data,
				scope, "_procname"));
	if (bt_ctf_field_get_error()) {
		fprintf(stderr, "Missing procname context info\n");
		goto error;
	}

	tid = bt_ctf_get_int64(bt_ctf_get_field(call_data,
				scope, "_tid"));
	if (bt_ctf_field_get_error()) {
		fprintf(stderr, "Missing tid context info\n");
		goto error;
	}

	scope = bt_ctf_get_top_level_scope(call_data,
			BT_STREAM_PACKET_CONTEXT);
	cpu_id = bt_ctf_get_uint64(bt_ctf_get_field(call_data,
				scope, "cpu_id"));
	if (bt_ctf_field_get_error()) {
		fprintf(stderr, "Missing cpu_id context info\n");
		goto error;
	}

	scope = bt_ctf_get_top_level_scope(call_data,
			BT_EVENT_FIELDS);
	fd = bt_ctf_get_uint64(bt_ctf_get_field(call_data,
				scope, "_fd"));
	if (bt_ctf_field_get_error()) {
		fprintf(stderr, "Missing fd context info\n");
		goto error;
	}

	tmp = get_proc(&lttngtop, tid, comm, timestamp);
	tmp->syscall_info = create_syscall_info(__NR_read, cpu_id, tid, fd);

	insert_file(tmp, fd);

	return BT_CB_OK;

error:
	return BT_CB_ERROR_STOP;
}


enum bt_cb_ret handle_sys_open(struct bt_ctf_event *call_data,
		void *private_data)
{

	struct processtop *tmp;
	struct definition *scope;
	unsigned long timestamp;
	uint64_t cpu_id;
	char *comm;
	int64_t tid;
	char *file;

	timestamp = bt_ctf_get_timestamp(call_data);
	if (timestamp == -1ULL)
		goto error;

	scope = bt_ctf_get_top_level_scope(call_data,
			BT_STREAM_EVENT_CONTEXT);
	comm = bt_ctf_get_char_array(bt_ctf_get_field(call_data,
				scope, "_procname"));
	if (bt_ctf_field_get_error()) {
		fprintf(stderr, "Missing procname context info\n");
		goto error;
	}

	tid = bt_ctf_get_int64(bt_ctf_get_field(call_data,
				scope, "_tid"));
	if (bt_ctf_field_get_error()) {
		fprintf(stderr, "Missing tid context info\n");
		goto error;
	}

	scope = bt_ctf_get_top_level_scope(call_data,
			BT_STREAM_PACKET_CONTEXT);
	cpu_id = bt_ctf_get_uint64(bt_ctf_get_field(call_data,
				scope, "cpu_id"));
	if (bt_ctf_field_get_error()) {
		fprintf(stderr, "Missing cpu_id context info\n");
		goto error;
	}

	scope = bt_ctf_get_top_level_scope(call_data,
			BT_EVENT_FIELDS);
	file = bt_ctf_get_string(bt_ctf_get_field(call_data,
				scope, "_filename"));
	if (bt_ctf_field_get_error()) {
		fprintf(stderr, "Missing fd context info\n");
		goto error;
	}

	tmp = get_proc(&lttngtop, tid, comm, timestamp);
	tmp->syscall_info = create_syscall_info(__NR_open, cpu_id, tid, -1);

	tmp->files_history = create_file(tmp->files_history, file);

	return BT_CB_OK;

error:
	return BT_CB_ERROR_STOP;
}


enum bt_cb_ret handle_sys_close(struct bt_ctf_event *call_data,
		void *private_data)
{
	struct definition *scope;
	unsigned long timestamp;
	int64_t tid;
	struct processtop *tmp;
	char *comm;
	int fd;

	timestamp = bt_ctf_get_timestamp(call_data);
	if (timestamp == -1ULL)
		goto error;

	scope = bt_ctf_get_top_level_scope(call_data,
			BT_STREAM_EVENT_CONTEXT);
	comm = bt_ctf_get_char_array(bt_ctf_get_field(call_data,
				scope, "_procname"));
	if (bt_ctf_field_get_error()) {
		fprintf(stderr, "Missing procname context info\n");
		goto error;
	}

	tid = bt_ctf_get_int64(bt_ctf_get_field(call_data,
				scope, "_tid"));
	if (bt_ctf_field_get_error()) {
		fprintf(stderr, "Missing tid context info\n");
		goto error;
	}

	scope = bt_ctf_get_top_level_scope(call_data,
			BT_EVENT_FIELDS);
	fd = bt_ctf_get_uint64(bt_ctf_get_field(call_data,
				scope, "_fd"));
	if (bt_ctf_field_get_error()) {
		fprintf(stderr, "Missing fd context info\n");
		goto error;
	}

	tmp = get_proc(&lttngtop, tid, comm, timestamp);
	close_file(tmp, fd);

	return BT_CB_OK;

error:
	return BT_CB_ERROR_STOP;
}
Commit	Line	Data
1fc22eb4 JD	1	/*
	2	* Copyright (C) 2011 Mathieu Bain <mathieu.bain@polymtl.ca>
	3	*
	4	* This program is free software; you can redistribute it and/or modify
	5	* it under the terms of the GNU General Public License Version 2 as
	6	* published by the Free Software Foundation;
	7	*
	8	* This program is distributed in the hope that it will be useful,
	9	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	10	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	11	* GNU General Public License for more details.
	12	*
	13	* You should have received a copy of the GNU General Public License
	14	* along with this program; if not, write to the Free Software
	15	* Foundation, Inc., 59 Temple Place - Suite 330, Boston,
	16	* MA 02111-1307, USA.
	17	*/
	18
b093de8a MB	19	#include <stdlib.h>
	20	#include <unistd.h>
	21	#include <sys/types.h>
	22	#include <sys/stat.h>
	23	#include <string.h>
1fc22eb4 JD	24	#include <babeltrace/babeltrace.h>
	25
	26	#include "lttngtoptypes.h"
	27	#include "common.h"
	28	#include "iostreamtop.h"
	29
b093de8a MB	30	void add_file(struct processtop proc, struct files file, int fd)
	31	{
	32	if (proc->process_files_table->len <= fd) {
	33	g_ptr_array_set_size(proc->process_files_table, fd);
	34	g_ptr_array_add(proc->process_files_table, file);
	35	} else {
	36	g_ptr_array_index(proc->process_files_table, fd) = file;
	37	}
	38	file->fd = fd;
	39	}
	40
	41
	42	void insert_file(struct processtop *proc, int fd)
	43	{
	44	struct files *tmp;
	45
	46	if (fd >= proc->process_files_table->len) {
	47	tmp = g_new0(struct files, 1);
	48	tmp->name = "Unknown";
	49	add_file(proc, tmp, fd);
	50	} else {
	51
	52	tmp = g_ptr_array_index(proc->process_files_table, fd);
	53	if (tmp == NULL) {
	54	tmp = g_new0(struct files, 1);
	55	tmp->name = "Unknown";
	56	tmp->read = 0;
	57	tmp->write = 0;
	58	tmp->fd = fd;
	59	add_file(proc, tmp, fd);
	60	}
	61	}
	62	}
	63
	64	void close_file(struct processtop *proc, int fd)
	65	{
	66	int len;
	67
	68	len = proc->process_files_table->len;
	69
	70	/*
	71	* It is possible that a file was open before taking the trace
	72	* and its fd could be greater than all of the others fd
	73	* used by the process
	74	*/
	75	if (fd < len) {
	76	g_ptr_array_remove_index_fast(proc->process_files_table, fd);
	77	g_ptr_array_set_size(proc->process_files_table, len + 1);
	78	}
	79	}
	80
	81	struct files get_file(struct processtop proc, int fd)
	82	{
	83	struct files *tmp;
	84	tmp = g_ptr_array_index(proc->process_files_table, fd);
	85	return tmp;
	86	}
	87
	88	void show_table(GPtrArray *tab)
	89	{
	90	int i;
	91	struct files *file;
	92
	93	for (i = 0 ; i < tab->len; i++) {
94	file = g_ptr_array_index(tab, i);
95	if (file == NULL)
96	fprintf(stderr, "NULL, ");
97	else
98	fprintf(stderr, "%s, ", file->name);
99	}
100	fprintf(stderr, "]\n\n");
101	}
1fc22eb4 JD	102
	103	int update_iostream_ret(struct lttngtop ctx, int tid, char comm,
	104	unsigned long timestamp, int cpu_id, int ret)
	105	{
	106	struct processtop *tmp;
b093de8a	107	struct files *tmpfile;
1fc22eb4 JD	108	int err = 0;
	109
	110	tmp = get_proc(ctx, tid, comm, timestamp);
b093de8a MB	111
	112	if (tmp->syscall_info != NULL) {
	113	if (tmp->syscall_info->type == __NR_read
	114	&& ret > 0) {
	115	tmp->totalfileread += ret;
	116	tmp->fileread += ret;
	117	tmpfile = get_file(tmp, tmp->syscall_info->fd);
	118	tmpfile->read += ret;
	119	} else if (tmp->syscall_info->type == __NR_write
	120	&& ret > 0) {
	121	tmp->totalfilewrite += ret;
	122	tmp->filewrite += ret;
	123	tmpfile = get_file(tmp, tmp->syscall_info->fd);
	124	tmpfile->write += ret;
	125	} else if (tmp->syscall_info->type == __NR_open
	126	&& ret > 0) {
	127	add_file(tmp, tmp->files_history->file, ret);
	128	} else {
1fc22eb4 JD	129	err = -1;
1fc22eb4 JD	130	}
b093de8a MB	131	g_free(tmp->syscall_info);
	132	tmp->syscall_info = NULL;
	133	}
1fc22eb4 JD	134	return err;
	135	}
	136
b093de8a MB	137	struct syscalls *create_syscall_info(unsigned int type, unsigned int cpu_id,
	138	unsigned int tid, int fd)
	139	{
	140	struct syscalls *syscall_info;
	141
	142	syscall_info = g_new0(struct syscalls, 1);
	143	syscall_info->type = type;
	144	syscall_info->cpu_id = cpu_id;
	145	syscall_info->tid = tid;
	146	syscall_info->fd = fd;
	147
	148	return syscall_info;
	149	}
	150
	151	struct file_history create_file(struct file_history history, char *file_name)
	152	{
	153	struct files *new_file;
	154	struct file_history *new_history;
	155
	156	new_file = g_new0(struct files, 1);
	157	new_history = g_new0(struct file_history, 1);
	158	new_file->name = strdup(file_name);
	159	new_file->read = 0;
	160	new_file->write = 0;
	161	new_history->file = new_file;
	162	new_history->next = history;
	163
	164	return new_history;
	165	}
	166
1fc22eb4 JD	167	enum bt_cb_ret handle_exit_syscall(struct bt_ctf_event *call_data,
	168	void *private_data)
	169	{
	170	struct definition *scope;
	171	unsigned long timestamp;
	172	char *comm;
	173	uint64_t ret, tid;
	174	int64_t cpu_id;
	175
	176	timestamp = bt_ctf_get_timestamp(call_data);
	177	if (timestamp == -1ULL)
	178	goto error;
	179
	180	scope = bt_ctf_get_top_level_scope(call_data,
	181	BT_STREAM_EVENT_CONTEXT);
	182	comm = bt_ctf_get_char_array(bt_ctf_get_field(call_data,
	183	scope, "_procname"));
	184	if (bt_ctf_field_get_error()) {
	185	fprintf(stderr, "Missing procname context info\n");
	186	goto error;
	187	}
	188
	189	tid = bt_ctf_get_int64(bt_ctf_get_field(call_data,
	190	scope, "_tid"));
	191	if (bt_ctf_field_get_error()) {
	192	fprintf(stderr, "Missing tid context info\n");
	193	goto error;
	194	}
	195
	196	scope = bt_ctf_get_top_level_scope(call_data,
	197	BT_EVENT_FIELDS);
	198	ret = bt_ctf_get_int64(bt_ctf_get_field(call_data,
	199	scope, "_ret"));
	200	if (bt_ctf_field_get_error()) {
	201	fprintf(stderr, "Missing ret context info\n");
	202	goto error;
	203	}
	204
	205	scope = bt_ctf_get_top_level_scope(call_data,
	206	BT_STREAM_PACKET_CONTEXT);
	207	cpu_id = bt_ctf_get_uint64(bt_ctf_get_field(call_data,
	208	scope, "cpu_id"));
	209	if (bt_ctf_field_get_error()) {
	210	fprintf(stderr, "Missing cpu_id context info\n");
	211	goto error;
	212	}
	213
	214	/*
b093de8a MB	215	* if we encounter an exit_syscall and
b093de8a MB	216	* it is not for a syscall read or write
1fc22eb4 JD	217	* we just abort the execution of this callback
	218	*/
	219	if ((update_iostream_ret(&lttngtop, tid, comm, timestamp, cpu_id, ret)) < 0)
	220	return BT_CB_ERROR_CONTINUE;
	221
	222	return BT_CB_OK;
	223
	224	error:
	225	return BT_CB_ERROR_STOP;
	226	}
	227
	228
	229	enum bt_cb_ret handle_sys_write(struct bt_ctf_event *call_data,
	230	void *private_data)
	231	{
	232	struct definition *scope;
	233	struct processtop *tmp;
1fc22eb4 JD	234	unsigned long timestamp;
	235	uint64_t cpu_id;
	236	char *comm;
	237	int64_t tid;
b093de8a	238	int fd;
1fc22eb4 JD	239
	240	timestamp = bt_ctf_get_timestamp(call_data);
	241	if (timestamp == -1ULL)
	242	goto error;
	243
	244	scope = bt_ctf_get_top_level_scope(call_data,
	245	BT_STREAM_EVENT_CONTEXT);
	246	comm = bt_ctf_get_char_array(bt_ctf_get_field(call_data,
	247	scope, "_procname"));
	248	if (bt_ctf_field_get_error()) {
	249	fprintf(stderr, "Missing procname context info\n");
	250	goto error;
	251	}
	252
	253	tid = bt_ctf_get_int64(bt_ctf_get_field(call_data,
	254	scope, "_tid"));
	255	if (bt_ctf_field_get_error()) {
	256	fprintf(stderr, "Missing tid context info\n");
	257	goto error;
	258	}
	259
	260	scope = bt_ctf_get_top_level_scope(call_data,
	261	BT_STREAM_PACKET_CONTEXT);
	262	cpu_id = bt_ctf_get_uint64(bt_ctf_get_field(call_data,
	263	scope, "cpu_id"));
	264	if (bt_ctf_field_get_error()) {
	265	fprintf(stderr, "Missing cpu_id context info\n");
	266	goto error;
	267	}
	268
b093de8a MB	269	scope = bt_ctf_get_top_level_scope(call_data,
	270	BT_EVENT_FIELDS);
	271	fd = bt_ctf_get_uint64(bt_ctf_get_field(call_data,
	272	scope, "_fd"));
	273	if (bt_ctf_field_get_error()) {
	274	fprintf(stderr, "Missing fd context info\n");
	275	goto error;
	276	}
	277
1fc22eb4	278	tmp = get_proc(&lttngtop, tid, comm, timestamp);
b093de8a MB	279	tmp->syscall_info = create_syscall_info(__NR_write, cpu_id, tid, fd);
	280
	281	insert_file(tmp, fd);
1fc22eb4 JD	282
	283	return BT_CB_OK;
	284
	285	error:
	286	return BT_CB_ERROR_STOP;
	287	}
	288
	289	enum bt_cb_ret handle_sys_read(struct bt_ctf_event *call_data,
	290	void *private_data)
	291	{
	292	struct processtop *tmp;
	293	struct definition *scope;
1fc22eb4 JD	294	unsigned long timestamp;
	295	uint64_t cpu_id;
	296	char *comm;
	297	int64_t tid;
b093de8a	298	int fd;
1fc22eb4 JD	299
	300	timestamp = bt_ctf_get_timestamp(call_data);
	301	if (timestamp == -1ULL)
	302	goto error;
	303
	304	scope = bt_ctf_get_top_level_scope(call_data,
	305	BT_STREAM_EVENT_CONTEXT);
	306	comm = bt_ctf_get_char_array(bt_ctf_get_field(call_data,
	307	scope, "_procname"));
	308	if (bt_ctf_field_get_error()) {
	309	fprintf(stderr, "Missing procname context info\n");
	310	goto error;
	311	}
	312
	313	tid = bt_ctf_get_int64(bt_ctf_get_field(call_data,
	314	scope, "_tid"));
	315	if (bt_ctf_field_get_error()) {
	316	fprintf(stderr, "Missing tid context info\n");
	317	goto error;
	318	}
	319
	320	scope = bt_ctf_get_top_level_scope(call_data,
	321	BT_STREAM_PACKET_CONTEXT);
	322	cpu_id = bt_ctf_get_uint64(bt_ctf_get_field(call_data,
	323	scope, "cpu_id"));
	324	if (bt_ctf_field_get_error()) {
	325	fprintf(stderr, "Missing cpu_id context info\n");
	326	goto error;
	327	}
	328
b093de8a MB	329	scope = bt_ctf_get_top_level_scope(call_data,
	330	BT_EVENT_FIELDS);
	331	fd = bt_ctf_get_uint64(bt_ctf_get_field(call_data,
	332	scope, "_fd"));
	333	if (bt_ctf_field_get_error()) {
	334	fprintf(stderr, "Missing fd context info\n");
	335	goto error;
	336	}
	337
	338	tmp = get_proc(&lttngtop, tid, comm, timestamp);
	339	tmp->syscall_info = create_syscall_info(__NR_read, cpu_id, tid, fd);
	340
	341	insert_file(tmp, fd);
	342
	343	return BT_CB_OK;
	344
	345	error:
	346	return BT_CB_ERROR_STOP;
	347	}
	348
	349
	350	enum bt_cb_ret handle_sys_open(struct bt_ctf_event *call_data,
	351	void *private_data)
	352	{
	353
	354	struct processtop *tmp;
	355	struct definition *scope;
	356	unsigned long timestamp;
	357	uint64_t cpu_id;
	358	char *comm;
	359	int64_t tid;
	360	char *file;
	361
	362	timestamp = bt_ctf_get_timestamp(call_data);
	363	if (timestamp == -1ULL)
	364	goto error;
	365
	366	scope = bt_ctf_get_top_level_scope(call_data,
	367	BT_STREAM_EVENT_CONTEXT);
	368	comm = bt_ctf_get_char_array(bt_ctf_get_field(call_data,
	369	scope, "_procname"));
	370	if (bt_ctf_field_get_error()) {
	371	fprintf(stderr, "Missing procname context info\n");
	372	goto error;
	373	}
	374
	375	tid = bt_ctf_get_int64(bt_ctf_get_field(call_data,
	376	scope, "_tid"));
	377	if (bt_ctf_field_get_error()) {
	378	fprintf(stderr, "Missing tid context info\n");
	379	goto error;
	380	}
	381
	382	scope = bt_ctf_get_top_level_scope(call_data,
	383	BT_STREAM_PACKET_CONTEXT);
	384	cpu_id = bt_ctf_get_uint64(bt_ctf_get_field(call_data,
	385	scope, "cpu_id"));
	386	if (bt_ctf_field_get_error()) {
	387	fprintf(stderr, "Missing cpu_id context info\n");
	388	goto error;
	389	}
	390
	391	scope = bt_ctf_get_top_level_scope(call_data,
	392	BT_EVENT_FIELDS);
393	file = bt_ctf_get_string(bt_ctf_get_field(call_data,
394	scope, "_filename"));
395	if (bt_ctf_field_get_error()) {
396	fprintf(stderr, "Missing fd context info\n");
397	goto error;
398	}
399
1fc22eb4	400	tmp = get_proc(&lttngtop, tid, comm, timestamp);
b093de8a MB	401	tmp->syscall_info = create_syscall_info(__NR_open, cpu_id, tid, -1);
	402
	403	tmp->files_history = create_file(tmp->files_history, file);
1fc22eb4 JD	404
	405	return BT_CB_OK;
	406
	407	error:
	408	return BT_CB_ERROR_STOP;
	409	}
	410
b093de8a MB	411
	412	enum bt_cb_ret handle_sys_close(struct bt_ctf_event *call_data,
	413	void *private_data)
	414	{
	415	struct definition *scope;
	416	unsigned long timestamp;
	417	int64_t tid;
	418	struct processtop *tmp;
	419	char *comm;
	420	int fd;
	421
	422	timestamp = bt_ctf_get_timestamp(call_data);
	423	if (timestamp == -1ULL)
	424	goto error;
	425
	426	scope = bt_ctf_get_top_level_scope(call_data,
	427	BT_STREAM_EVENT_CONTEXT);
	428	comm = bt_ctf_get_char_array(bt_ctf_get_field(call_data,
	429	scope, "_procname"));
	430	if (bt_ctf_field_get_error()) {
	431	fprintf(stderr, "Missing procname context info\n");
	432	goto error;
	433	}
	434
	435	tid = bt_ctf_get_int64(bt_ctf_get_field(call_data,
	436	scope, "_tid"));
	437	if (bt_ctf_field_get_error()) {
	438	fprintf(stderr, "Missing tid context info\n");
	439	goto error;
	440	}
	441
	442	scope = bt_ctf_get_top_level_scope(call_data,
	443	BT_EVENT_FIELDS);
	444	fd = bt_ctf_get_uint64(bt_ctf_get_field(call_data,
	445	scope, "_fd"));
	446	if (bt_ctf_field_get_error()) {
	447	fprintf(stderr, "Missing fd context info\n");
	448	goto error;
	449	}
	450
	451	tmp = get_proc(&lttngtop, tid, comm, timestamp);
	452	close_file(tmp, fd);
	453
	454	return BT_CB_OK;
	455
	456	error:
	457	return BT_CB_ERROR_STOP;
	458	}