[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.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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)
{
	struct files *tmp_file;
	struct processtop *parent;
	int size;

	size = proc->process_files_table->len;
	parent = proc->threadparent;
	if (parent)
		insert_file(parent, fd);
	if (size <= fd) {
		g_ptr_array_set_size(proc->process_files_table, fd);
		g_ptr_array_add(proc->process_files_table, file);
	} else {
		tmp_file = g_ptr_array_index(proc->process_files_table, fd);
		if (tmp_file == NULL)
			g_ptr_array_index(proc->process_files_table, fd) = file;
		else {
			if (strcmp(tmp_file->name, file->name) != 0) {
				size = proc->process_files_table->len;
				g_ptr_array_set_size(proc->process_files_table,
								size+1);
				g_ptr_array_index(proc->process_files_table,
							size) = tmp_file;
				g_ptr_array_index(proc->process_files_table,
							fd) = file;
			} else
				tmp_file->flag = __NR_open;
		}
	}
	/*
	 * The file may have be created in the parent
	 */
	if (file->flag == -1) {
		file->fd = fd;
		file->flag = __NR_open;
		lttngtop.nbfiles++;
		lttngtop.nbnewfiles++;
	}
}

/*
 * Edit the file
 * Called by handled_statedump_filename
 */
void edit_file(struct processtop *proc, struct files *file, int fd)
{
	int size = proc->process_files_table->len;
	struct files *tmpfile;

	if (fd >= size) {
		add_file(proc, file, fd);
	} else {
		tmpfile = g_ptr_array_index(proc->process_files_table, fd);
		if (tmpfile) {
			tmpfile->name = strdup(file->name);
			free(file);
		} else
			add_file(proc, file, fd);
	}
}

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

	if (fd < 0)
		return;
	if (fd >= proc->process_files_table->len) {
		tmp = g_new0(struct files, 1);
		tmp->name = "Unknown";
		tmp->read = 0;
		tmp->write = 0;
		tmp->fd = fd;
		tmp->flag = -1;
		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;
			tmp->flag = -1;
			add_file(proc, tmp, fd);
		} else {
			parent = proc->threadparent;
			if (parent) {
				tmp_parent = g_ptr_array_index(
					parent->process_files_table, fd);
				if (tmp_parent &&
				   (strcmp(tmp->name, tmp_parent->name)) != 0)
					tmp->name = strdup(tmp_parent->name);
			}
		}
	}
}

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

	file = get_file(proc, fd);
	if (file != NULL) {
		file->flag = __NR_close;
		lttngtop.nbfiles--;
	}
	lttngtop.nbclosedfiles++;
}

struct files *get_file(struct processtop *proc, int fd)
{
	int len;
	struct files *tmp = NULL;

	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 && fd >= 0)
		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");
}

void show_history(struct file_history *history)
{
	struct file_history *tmp = history;

	while (tmp != NULL) {
		fprintf(stderr, "fd = %d, name = %s\n", tmp->file->fd,
					tmp->file->name);
		tmp = tmp->next;
	}

}

int update_iostream_ret(struct lttngtop *ctx, int tid, char *comm,
		unsigned long timestamp, uint64_t 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);
			if (tmpfile)
				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);
			if (tmpfile)
				tmpfile->write += ret;
		} else if (tmp->syscall_info->type == __NR_open
			&& ret > 0) {
			tmpfile = tmp->files_history->file;
			add_file(tmp, tmpfile, ret);
			tmpfile->fd = ret;
		} else {
			err = -1;
		}
		g_free(tmp->syscall_info);
		tmp->syscall_info = NULL;
 	}
	return err;
}

struct syscalls *create_syscall_info(unsigned int type, uint64_t 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_file->flag = -1;
	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)
{
	const struct definition *scope;
	unsigned long timestamp;
	char *comm;
	uint64_t ret, tid;
	uint64_t cpu_id;

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

	comm = get_context_comm(call_data);
	tid = get_context_tid(call_data);

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

	cpu_id = get_cpu_id(call_data);

	/*
	 * 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)
{
	const struct definition *scope;
	struct processtop *tmp;
	unsigned long timestamp;
	uint64_t cpu_id;
	int64_t tid, pid;
	int fd;

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

	tid = get_context_tid(call_data);
	cpu_id = get_cpu_id(call_data);

	pid = get_context_pid(call_data);

	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_pid(&lttngtop, tid, pid, 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;
	const struct definition *scope;
	unsigned long timestamp;
	uint64_t cpu_id;
	int64_t tid, pid;
	int fd;

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

	tid = get_context_tid(call_data);
	cpu_id = get_cpu_id(call_data);

	pid = get_context_pid(call_data);

	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_pid(&lttngtop, tid, pid, 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;
	const struct definition *scope;
	unsigned long timestamp;
	uint64_t cpu_id;
	int64_t tid, pid;
	char *file;

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

	tid = get_context_tid(call_data);
	cpu_id = get_cpu_id(call_data);

	pid = get_context_pid(call_data);

	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 file name context info\n");
		goto error;
	}

	tmp = get_proc_pid(&lttngtop, tid, pid, 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)
{
	const struct definition *scope;
	unsigned long timestamp;
	int64_t tid, pid;
	struct processtop *tmp;
	int fd;

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

	tid = get_context_tid(call_data);

	pid = get_context_pid(call_data);

	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_pid(&lttngtop, tid, pid, timestamp);

	close_file(tmp, fd);

	return BT_CB_OK;

error:
	return BT_CB_ERROR_STOP;
}

enum bt_cb_ret handle_statedump_file_descriptor(struct bt_ctf_event *call_data,
		void *private_data)
{
	const struct definition *scope;
	struct processtop *parent;
	struct files *file;
	unsigned long timestamp;
	int64_t pid;
	char *file_name;
	int fd;

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

	scope = bt_ctf_get_top_level_scope(call_data,
			 BT_EVENT_FIELDS);
	pid = bt_ctf_get_int64(bt_ctf_get_field(call_data,
			     scope, "_pid"));
	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_int64(bt_ctf_get_field(call_data,
				scope, "_fd"));
	if (bt_ctf_field_get_error()) {
		fprintf(stderr, "Missing fd context info\n");
		goto error;
	}

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

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