[babeltrace.git] / lib / debuginfo.c

/*
 * Babeltrace - Debug Information State Tracker
 *
 * Copyright (c) 2015 EfficiOS Inc. and Linux Foundation
 * Copyright (c) 2015 Philippe Proulx <pproulx@efficios.com>
 * Copyright (c) 2015 Antoine Busque <abusque@efficios.com>
 * Copyright (c) 2016 Jérémie Galarneau <jeremie.galarneau@efficios.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#include <assert.h>
#include <glib.h>
#include <babeltrace/types.h>
#include <babeltrace/ctf-ir/metadata.h>
#include <babeltrace/debuginfo.h>
#include <babeltrace/so-info.h>
#include <babeltrace/babeltrace-internal.h>

struct proc_debug_info_sources {
	/*
	 * Hash table: base address (pointer to uint64_t) to so info; owned by
	 * proc_debug_info_sources.
	 */
	GHashTable *baddr_to_so_info;

	/*
	 * Hash table: IP (pointer to uint64_t) to (struct debug_info_source *);
	 * owned by proc_debug_info_sources.
	 */
	GHashTable *ip_to_debug_info_src;
};

struct debug_info {
	/*
	 * Hash table of VPIDs (pointer to int64_t) to
	 * (struct ctf_proc_debug_infos*); owned by debug_info.
	 */
	GHashTable *vpid_to_proc_dbg_info_src;
	GQuark q_statedump_soinfo;
	GQuark q_statedump_debug_link;
	GQuark q_statedump_build_id;
	GQuark q_statedump_start;
	GQuark q_dl_open;
};

static
int debug_info_init(struct debug_info *info)
{
	info->q_statedump_soinfo = g_quark_from_string(
			"lttng_ust_statedump:soinfo");
	info->q_statedump_debug_link = g_quark_from_string(
			"lttng_ust_statedump:debug_link)");
	info->q_statedump_build_id = g_quark_from_string(
			"lttng_ust_statedump:build_id");
	info->q_statedump_start = g_quark_from_string(
			"lttng_ust_statedump:start");
	info->q_dl_open = g_quark_from_string("lttng_ust_dl:dlopen");

	return so_info_init();
}

static
void debug_info_source_destroy(struct debug_info_source *debug_info_src)
{
	if (!debug_info_src) {
		return;
	}

	free(debug_info_src->func);
	free(debug_info_src->src_path);
	free(debug_info_src->bin_path);
	g_free(debug_info_src);
}

/*
 * Returns the location of a path's file (the last element of the path).
 * Returns the original path on error.
 */
static
const char *get_filename_from_path(const char *path)
{
	size_t i = strlen(path);

	if (i == 0) {
		goto end;
	}

	if (path[i - 1] == '/') {
		/*
		 * Path ends with a trailing slash, no filename to return.
		 * Return the original path.
		 */
		goto end;
	}

	while (i-- > 0) {
		if (path[i] == '/') {
			path = &path[i + 1];
			goto end;
		}
	}
end:
	return path;
}

static
struct debug_info_source *debug_info_source_create_from_so(struct so_info *so,
		uint64_t ip)
{
	int ret;
	struct debug_info_source *debug_info_src = NULL;
	struct source_location *src_loc = NULL;

	debug_info_src = g_new0(struct debug_info_source, 1);

	if (!debug_info_src) {
		goto end;
	}

	/* Lookup function name */
	ret = so_info_lookup_function_name(so, ip, &debug_info_src->func);
	if (ret) {
		goto error;
	}

	/* Can't retrieve src_loc from ELF only, skip it */
	if (so->is_elf_only) {
		goto end;
	}

	/* Lookup source location */
	ret = so_info_lookup_source_location(so, ip, &src_loc);
	if (ret) {
		goto error;
	}

	if (src_loc) {
		debug_info_src->line_no = src_loc->line_no;

		if (src_loc->filename) {
			debug_info_src->src_path = strdup(src_loc->filename);
			if (!debug_info_src->src_path) {
				goto error;
			}

			debug_info_src->short_src_path = get_filename_from_path(
					src_loc->filename);

		}

		source_location_destroy(src_loc);
	}

	if (so->elf_path) {
		debug_info_src->bin_path = strdup(so->elf_path);
		if (!debug_info_src->bin_path) {
			goto error;
		}

		debug_info_src->short_bin_path = get_filename_from_path(
				debug_info_src->bin_path);
	}

end:
	return debug_info_src;

error:
	debug_info_source_destroy(debug_info_src);
	return NULL;
}

static
void proc_debug_info_sources_destroy(
		struct proc_debug_info_sources *proc_dbg_info_src)
{
	if (!proc_dbg_info_src) {
		return;
	}

	if (proc_dbg_info_src->baddr_to_so_info) {
		g_hash_table_destroy(proc_dbg_info_src->baddr_to_so_info);
	}

	if (proc_dbg_info_src->ip_to_debug_info_src) {
		g_hash_table_destroy(proc_dbg_info_src->ip_to_debug_info_src);
	}

	g_free(proc_dbg_info_src);
}

static
struct proc_debug_info_sources *proc_debug_info_sources_create(void)
{
	struct proc_debug_info_sources *proc_dbg_info_src = NULL;

	proc_dbg_info_src = g_new0(struct proc_debug_info_sources, 1);
	if (!proc_dbg_info_src) {
		goto end;
	}

	proc_dbg_info_src->baddr_to_so_info = g_hash_table_new_full(
			g_int64_hash, g_int64_equal, (GDestroyNotify) g_free,
			(GDestroyNotify) so_info_destroy);
	if (!proc_dbg_info_src->baddr_to_so_info) {
		goto error;
	}

	proc_dbg_info_src->ip_to_debug_info_src = g_hash_table_new_full(
			g_int64_hash, g_int64_equal, (GDestroyNotify) g_free,
			(GDestroyNotify) debug_info_source_destroy);
	if (!proc_dbg_info_src->ip_to_debug_info_src) {
		goto error;
	}

end:
	return proc_dbg_info_src;

error:
	proc_debug_info_sources_destroy(proc_dbg_info_src);
	return NULL;
}

static
struct proc_debug_info_sources *proc_debug_info_sources_ht_get_entry(
		GHashTable *ht, int64_t vpid)
{
	gpointer key = g_new0(int64_t, 1);
	struct proc_debug_info_sources *proc_dbg_info_src = NULL;

	if (!key) {
		goto end;
	}

	*((int64_t *) key) = vpid;

	/* Exists? Return it */
	proc_dbg_info_src = g_hash_table_lookup(ht, key);
	if (proc_dbg_info_src) {
		goto end;
	}

	/* Otherwise, create and return it */
	proc_dbg_info_src = proc_debug_info_sources_create();
	if (!proc_dbg_info_src) {
		goto end;
	}

	g_hash_table_insert(ht, key, proc_dbg_info_src);
	/* Ownership passed to ht */
	key = NULL;
end:
	g_free(key);
	return proc_dbg_info_src;
}

static
struct debug_info_source *proc_debug_info_sources_get_entry(
		struct proc_debug_info_sources *proc_dbg_info_src, uint64_t ip)
{
	struct debug_info_source *debug_info_src = NULL;
	gpointer key = g_new0(uint64_t, 1);
	GHashTableIter iter;
	gpointer baddr, value;

	if (!key) {
		goto end;
	}

	*((uint64_t *) key) = ip;

	/* Look in IP to debug infos hash table first. */
	debug_info_src = g_hash_table_lookup(
			proc_dbg_info_src->ip_to_debug_info_src,
			key);
	if (debug_info_src) {
		goto end;
	}

	/* Check in all so_infos. */
	g_hash_table_iter_init(&iter, proc_dbg_info_src->baddr_to_so_info);

	while (g_hash_table_iter_next(&iter, &baddr, &value))
	{
		struct so_info *so = value;

		if (!so_info_has_address(value, ip)) {
			continue;
		}

		/*
		 * Found; add it to cache.
		 *
		 * FIXME: this should be bounded in size (and implement
		 * a caching policy), and entries should be prunned when
		 * libraries are unmapped.
		 */
		debug_info_src = debug_info_source_create_from_so(so, ip);
		if (debug_info_src) {
			g_hash_table_insert(
					proc_dbg_info_src->ip_to_debug_info_src,
					key, debug_info_src);
			/* Ownership passed to ht. */
			key = NULL;
		}
		break;
	}

end:
	free(key);
	return debug_info_src;
}

BT_HIDDEN
struct debug_info_source *debug_info_query(struct debug_info *debug_info,
		int64_t vpid, uint64_t ip)
{
	struct debug_info_source *dbg_info_src = NULL;
	struct proc_debug_info_sources *proc_dbg_info_src;

	proc_dbg_info_src = proc_debug_info_sources_ht_get_entry(
			debug_info->vpid_to_proc_dbg_info_src, vpid);
	if (!proc_dbg_info_src) {
		goto end;
	}

	dbg_info_src = proc_debug_info_sources_get_entry(
			proc_dbg_info_src, ip);
	if (!dbg_info_src) {
		goto end;
	}

end:
	return dbg_info_src;
}

BT_HIDDEN
struct debug_info *debug_info_create(void)
{
	int ret;
	struct debug_info *debug_info;

	debug_info = g_new0(struct debug_info, 1);
	if (!debug_info) {
		goto end;
	}

	debug_info->vpid_to_proc_dbg_info_src = g_hash_table_new_full(
			g_int64_hash, g_int64_equal, (GDestroyNotify) g_free,
			(GDestroyNotify) proc_debug_info_sources_destroy);
	if (!debug_info->vpid_to_proc_dbg_info_src) {
		goto error;
	}

	ret = debug_info_init(debug_info);
	if (ret) {
		goto error;
	}

end:
	return debug_info;
error:
	g_free(debug_info);
	return NULL;
}

BT_HIDDEN
void debug_info_destroy(struct debug_info *debug_info)
{
	if (!debug_info) {
		goto end;
	}

	if (debug_info->vpid_to_proc_dbg_info_src) {
		g_hash_table_destroy(debug_info->vpid_to_proc_dbg_info_src);
	}

	g_free(debug_info);
end:
	return;
}

static
void handle_statedump_build_id_event(struct debug_info *debug_info,
		struct ctf_event_definition *event_def)
{
	struct proc_debug_info_sources *proc_dbg_info_src;
	struct bt_definition *event_fields_def = NULL;
	struct bt_definition *sec_def = NULL;
	struct bt_definition *baddr_def = NULL;
	struct bt_definition *vpid_def = NULL;
	struct bt_definition *build_id_def = NULL;
	struct definition_sequence *build_id_seq;
	struct so_info *so = NULL;
	int i;
	int64_t vpid;
	uint64_t baddr;
	uint8_t *build_id = NULL;
	uint64_t build_id_len;

	event_fields_def = (struct bt_definition *) event_def->event_fields;
	sec_def = (struct bt_definition *)
			event_def->stream->stream_event_context;

	if (!event_fields_def || !sec_def) {
		goto end;
	}

	baddr_def = bt_lookup_definition(event_fields_def, "_baddr");
	if (!baddr_def) {
		goto end;
	}

	vpid_def = bt_lookup_definition(sec_def, "_vpid");
	if (!vpid_def) {
		goto end;
	}

	build_id_def = bt_lookup_definition(event_fields_def, "_build_id");
	if (!build_id_def) {
		goto end;
	}

	if (baddr_def->declaration->id != CTF_TYPE_INTEGER) {
		goto end;
	}

	if (vpid_def->declaration->id != CTF_TYPE_INTEGER) {
		goto end;
	}

	if (build_id_def->declaration->id != CTF_TYPE_SEQUENCE) {
		goto end;
	}

	baddr = bt_get_unsigned_int(baddr_def);
	vpid = bt_get_signed_int(vpid_def);
	build_id_seq = container_of(build_id_def,
			struct definition_sequence, p);
	build_id_len = build_id_seq->length->value._unsigned;

	build_id = g_malloc(build_id_len);
	if (!build_id) {
		goto end;
	}

	for (i = 0; i < build_id_len; ++i) {
		struct bt_definition **field;

		field = (struct bt_definition **) &g_ptr_array_index(
				build_id_seq->elems, i);
		build_id[i] = bt_get_unsigned_int(*field);
	}

	proc_dbg_info_src = proc_debug_info_sources_ht_get_entry(
			debug_info->vpid_to_proc_dbg_info_src, vpid);
	if (!proc_dbg_info_src) {
		goto end;
	}

	so = g_hash_table_lookup(proc_dbg_info_src->baddr_to_so_info,
			(gpointer) &baddr);
	if (!so) {
		/*
		 * The build_id event comes after the so has been
		 * created. If it isn't found, just ignore this event.
		 */
		goto end;
	}

	so_info_set_build_id(so, build_id, build_id_len);

end:
	free(build_id);
	return;
}

static
void handle_statedump_debug_link_event(struct debug_info *debug_info,
		struct ctf_event_definition *event_def)
{
	struct proc_debug_info_sources *proc_dbg_info_src;
	struct bt_definition *event_fields_def = NULL;
	struct bt_definition *sec_def = NULL;
	struct bt_definition *baddr_def = NULL;
	struct bt_definition *vpid_def = NULL;
	struct bt_definition *filename_def = NULL;
	struct bt_definition *crc32_def = NULL;
	struct so_info *so = NULL;
	int64_t vpid;
	uint64_t baddr;
	char *filename = NULL;
	uint32_t crc32;

	event_fields_def = (struct bt_definition *) event_def->event_fields;
	sec_def = (struct bt_definition *)
			event_def->stream->stream_event_context;

	if (!event_fields_def || !sec_def) {
		goto end;
	}

	baddr_def = bt_lookup_definition(event_fields_def, "_baddr");
	if (!baddr_def) {
		goto end;
	}

	vpid_def = bt_lookup_definition(sec_def, "_vpid");
	if (!vpid_def) {
		goto end;
	}

	filename_def = bt_lookup_definition(event_fields_def, "_filename");
	if (!filename_def) {
		goto end;
	}

	crc32_def = bt_lookup_definition(event_fields_def, "_crc32");
	if (!crc32_def) {
		goto end;
	}

	if (baddr_def->declaration->id != CTF_TYPE_INTEGER) {
		goto end;
	}

	if (vpid_def->declaration->id != CTF_TYPE_INTEGER) {
		goto end;
	}

	if (filename_def->declaration->id != CTF_TYPE_STRING) {
		goto end;
	}

	if (crc32_def->declaration->id != CTF_TYPE_INTEGER) {
		goto end;
	}

	baddr = bt_get_unsigned_int(baddr_def);
	vpid = bt_get_signed_int(vpid_def);

	proc_dbg_info_src = proc_debug_info_sources_ht_get_entry(
			debug_info->vpid_to_proc_dbg_info_src, vpid);
	if (!proc_dbg_info_src) {
		goto end;
	}

	so = g_hash_table_lookup(proc_dbg_info_src->baddr_to_so_info,
			(gpointer) &baddr);
	if (!so) {
		/*
		 * The debug_link event comes after the so has been
		 * created. If it isn't found, just ignore this event.
		 */
		goto end;
	}

	filename = bt_get_string(filename_def);
	crc32 = bt_get_unsigned_int(crc32_def);

	so_info_set_debug_link(so, filename, crc32);

end:
	return;
}

static
void handle_statedump_soinfo_event(struct debug_info *debug_info,
		struct ctf_event_definition *event_def)
{
	struct bt_definition *baddr_def = NULL;
	struct bt_definition *memsz_def = NULL;
	struct bt_definition *sopath_def = NULL;
	struct bt_definition *vpid_def = NULL;
	struct bt_definition *event_fields_def = NULL;
	struct bt_definition *sec_def = NULL;
	struct proc_debug_info_sources *proc_dbg_info_src;
	struct so_info *so;
	uint64_t baddr, memsz;
	int64_t vpid;
	const char *sopath;
	gpointer key = NULL;

	event_fields_def = (struct bt_definition *) event_def->event_fields;
	sec_def = (struct bt_definition *)
		event_def->stream->stream_event_context;

	if (!event_fields_def || !sec_def) {
		goto end;
	}

	baddr_def = bt_lookup_definition(event_fields_def, "_baddr");
	if (!baddr_def) {
		goto end;
	}

	memsz_def = bt_lookup_definition(event_fields_def, "_memsz");
	if (!memsz_def) {
		goto end;
	}

	sopath_def = bt_lookup_definition(event_fields_def, "_sopath");
	if (!sopath_def) {
		goto end;
	}

	vpid_def = bt_lookup_definition(sec_def, "_vpid");
	if (!vpid_def) {
		goto end;
	}

	if (baddr_def->declaration->id != CTF_TYPE_INTEGER) {
		goto end;
	}

	if (memsz_def->declaration->id != CTF_TYPE_INTEGER) {
		goto end;
	}

	if (sopath_def->declaration->id != CTF_TYPE_STRING) {
		goto end;
	}

	if (vpid_def->declaration->id != CTF_TYPE_INTEGER) {
		goto end;
	}

	baddr = bt_get_unsigned_int(baddr_def);
	memsz = bt_get_unsigned_int(memsz_def);
	sopath = bt_get_string(sopath_def);
	vpid = bt_get_signed_int(vpid_def);

	if (!sopath) {
		goto end;
	}

	if (memsz == 0) {
		/* Ignore VDSO. */
		goto end;
	}

	proc_dbg_info_src = proc_debug_info_sources_ht_get_entry(
			debug_info->vpid_to_proc_dbg_info_src, vpid);
	if (!proc_dbg_info_src) {
		goto end;
	}

	key = g_new0(uint64_t, 1);
	if (!key) {
		goto end;
	}

	*((uint64_t *) key) = baddr;

	so = g_hash_table_lookup(proc_dbg_info_src->baddr_to_so_info,
			key);
	if (so) {
		goto end;
	}

	so = so_info_create(sopath, baddr, memsz);
	if (!so) {
		goto end;
	}

	g_hash_table_insert(proc_dbg_info_src->baddr_to_so_info,
			key, so);
	/* Ownership passed to ht. */
	key = NULL;

end:
	g_free(key);
	return;
}

static
void handle_statedump_start(struct debug_info *debug_info,
		struct ctf_event_definition *event_def)
{
	struct bt_definition *vpid_def = NULL;
	struct bt_definition *sec_def = NULL;
	struct proc_debug_info_sources *proc_dbg_info_src;
	int64_t vpid;

	sec_def = (struct bt_definition *)
			event_def->stream->stream_event_context;
	if (!sec_def) {
		goto end;
	}

	vpid_def = bt_lookup_definition(sec_def, "_vpid");
	if (!vpid_def) {
		goto end;
	}

	vpid = bt_get_signed_int(vpid_def);

	proc_dbg_info_src = proc_debug_info_sources_ht_get_entry(
			debug_info->vpid_to_proc_dbg_info_src, vpid);
	if (!proc_dbg_info_src) {
		goto end;
	}

	g_hash_table_remove_all(proc_dbg_info_src->baddr_to_so_info);
	g_hash_table_remove_all(proc_dbg_info_src->ip_to_debug_info_src);

end:
	return;
}

static
void register_event_debug_infos(struct debug_info *debug_info,
		struct ctf_event_definition *event)
{
	struct bt_definition *ip_def, *vpid_def;
	int64_t vpid;
	uint64_t ip;
	struct bt_definition *sec_def;

	/* Get stream event context definition. */
	sec_def = (struct bt_definition *) event->stream->stream_event_context;
	if (!sec_def) {
		goto end;
	}

	/* Get "ip" and "vpid" definitions. */
	vpid_def = bt_lookup_definition((struct bt_definition *) sec_def,
			 "_vpid");
	ip_def = bt_lookup_definition((struct bt_definition *) sec_def, "_ip");

	if (!vpid_def || !ip_def) {
		 goto end;
	}

	vpid = bt_get_signed_int(vpid_def);
	ip = bt_get_unsigned_int(ip_def);

	/* Get debug info for this context. */
	((struct definition_integer *) ip_def)->debug_info_src =
			debug_info_query(debug_info, vpid, ip);

end:
	return;
}

BT_HIDDEN
void debug_info_handle_event(struct debug_info *debug_info,
		struct ctf_event_definition *event)
{
	struct ctf_event_declaration *event_class;
	struct ctf_stream_declaration *stream_class;

	if (!debug_info || !event) {
		goto end;
	}

	stream_class = event->stream->stream_class;
	event_class = g_ptr_array_index(stream_class->events_by_id,
			event->stream->event_id);

	if (event_class->name == debug_info->q_statedump_soinfo ||
			event_class->name == debug_info->q_dl_open) {
		/* State dump/dlopen() */
		handle_statedump_soinfo_event(debug_info, event);
	} else if (event_class->name == debug_info->q_statedump_start) {
		/* Start state dump */
		handle_statedump_start(debug_info, event);
	} else if (event_class->name == debug_info->q_statedump_debug_link) {
		/* Debug link info */
		handle_statedump_debug_link_event(debug_info, event);
	} else if (event_class->name == debug_info->q_statedump_build_id) {
		/* Build ID info */
		handle_statedump_build_id_event(debug_info, event);
	} else {
		/* Other events: register debug infos */
		register_event_debug_infos(debug_info, event);
	}

end:
	return;
}
Commit	Line	Data
b5a8598f AB	1	/*
	2	* Babeltrace - Debug Information State Tracker
	3	*
	4	* Copyright (c) 2015 EfficiOS Inc. and Linux Foundation
	5	* Copyright (c) 2015 Philippe Proulx <pproulx@efficios.com>
	6	* Copyright (c) 2015 Antoine Busque <abusque@efficios.com>
458af89d	7	* Copyright (c) 2016 Jérémie Galarneau <jeremie.galarneau@efficios.com>
b5a8598f AB	8	*
	9	* Permission is hereby granted, free of charge, to any person obtaining a copy
	10	* of this software and associated documentation files (the "Software"), to deal
	11	* in the Software without restriction, including without limitation the rights
	12	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	13	* copies of the Software, and to permit persons to whom the Software is
	14	* furnished to do so, subject to the following conditions:
	15	*
	16	* The above copyright notice and this permission notice shall be included in
	17	* all copies or substantial portions of the Software.
	18	*
	19	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	20	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	21	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	22	* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	23	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	24	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	25	* SOFTWARE.
	26	*/
	27
	28	#include <assert.h>
	29	#include <glib.h>
	30	#include <babeltrace/types.h>
	31	#include <babeltrace/ctf-ir/metadata.h>
	32	#include <babeltrace/debuginfo.h>
	33	#include <babeltrace/so-info.h>
458af89d	34	#include <babeltrace/babeltrace-internal.h>
b5a8598f AB	35
	36	struct proc_debug_info_sources {
	37	/*
71235b6d	38	* Hash table: base address (pointer to uint64_t) to so info; owned by
b5a8598f AB	39	* proc_debug_info_sources.
	40	*/
	41	GHashTable *baddr_to_so_info;
	42
	43	/*
71235b6d JG	44	* Hash table: IP (pointer to uint64_t) to (struct debug_info_source *);
71235b6d JG	45	* owned by proc_debug_info_sources.
b5a8598f AB	46	*/
	47	GHashTable *ip_to_debug_info_src;
	48	};
	49
	50	struct debug_info {
	51	/*
71235b6d JG	52	* Hash table of VPIDs (pointer to int64_t) to
71235b6d JG	53	* (struct ctf_proc_debug_infos*); owned by debug_info.
b5a8598f AB	54	*/
	55	GHashTable *vpid_to_proc_dbg_info_src;
	56	GQuark q_statedump_soinfo;
	57	GQuark q_statedump_debug_link;
	58	GQuark q_statedump_build_id;
	59	GQuark q_statedump_start;
	60	GQuark q_dl_open;
	61	};
	62
	63	static
	64	int debug_info_init(struct debug_info *info)
	65	{
	66	info->q_statedump_soinfo = g_quark_from_string(
	67	"lttng_ust_statedump:soinfo");
	68	info->q_statedump_debug_link = g_quark_from_string(
	69	"lttng_ust_statedump:debug_link)");
	70	info->q_statedump_build_id = g_quark_from_string(
	71	"lttng_ust_statedump:build_id");
	72	info->q_statedump_start = g_quark_from_string(
	73	"lttng_ust_statedump:start");
	74	info->q_dl_open = g_quark_from_string("lttng_ust_dl:dlopen");
	75
	76	return so_info_init();
	77	}
	78
	79	static
	80	void debug_info_source_destroy(struct debug_info_source *debug_info_src)
	81	{
	82	if (!debug_info_src) {
	83	return;
	84	}
	85
	86	free(debug_info_src->func);
ad2b5b38 JG	87	free(debug_info_src->src_path);
ad2b5b38 JG	88	free(debug_info_src->bin_path);
b5a8598f AB	89	g_free(debug_info_src);
	90	}
	91
458af89d JG	92	/*
	93	* Returns the location of a path's file (the last element of the path).
	94	* Returns the original path on error.
	95	*/
	96	static
	97	const char get_filename_from_path(const char path)
	98	{
	99	size_t i = strlen(path);
	100
	101	if (i == 0) {
	102	goto end;
	103	}
	104
	105	if (path[i - 1] == '/') {
	106	/*
	107	* Path ends with a trailing slash, no filename to return.
	108	* Return the original path.
	109	*/
	110	goto end;
	111	}
	112
	113	while (i-- > 0) {
	114	if (path[i] == '/') {
	115	path = &path[i + 1];
	116	goto end;
	117	}
	118	}
	119	end:
	120	return path;
	121	}
	122
b5a8598f AB	123	static
	124	struct debug_info_source debug_info_source_create_from_so(struct so_info so,
	125	uint64_t ip)
	126	{
	127	int ret;
	128	struct debug_info_source *debug_info_src = NULL;
	129	struct source_location *src_loc = NULL;
	130
	131	debug_info_src = g_new0(struct debug_info_source, 1);
	132
	133	if (!debug_info_src) {
	134	goto end;
	135	}
	136
	137	/* Lookup function name */
	138	ret = so_info_lookup_function_name(so, ip, &debug_info_src->func);
	139	if (ret) {
	140	goto error;
	141	}
	142
	143	/* Can't retrieve src_loc from ELF only, skip it */
	144	if (so->is_elf_only) {
	145	goto end;
	146	}
	147
	148	/* Lookup source location */
	149	ret = so_info_lookup_source_location(so, ip, &src_loc);
	150	if (ret) {
	151	goto error;
	152	}
	153
	154	if (src_loc) {
	155	debug_info_src->line_no = src_loc->line_no;
	156
	157	if (src_loc->filename) {
ad2b5b38 JG	158	debug_info_src->src_path = strdup(src_loc->filename);
ad2b5b38 JG	159	if (!debug_info_src->src_path) {
b5a8598f AB	160	goto error;
b5a8598f AB	161	}
458af89d	162
ad2b5b38	163	debug_info_src->short_src_path = get_filename_from_path(
458af89d JG	164	src_loc->filename);
458af89d JG	165
b5a8598f AB	166	}
	167
	168	source_location_destroy(src_loc);
	169	}
	170
ad2b5b38 JG	171	if (so->elf_path) {
	172	debug_info_src->bin_path = strdup(so->elf_path);
	173	if (!debug_info_src->bin_path) {
	174	goto error;
	175	}
	176
	177	debug_info_src->short_bin_path = get_filename_from_path(
	178	debug_info_src->bin_path);
	179	}
	180
b5a8598f AB	181	end:
	182	return debug_info_src;
	183
	184	error:
	185	debug_info_source_destroy(debug_info_src);
	186	return NULL;
	187	}
	188
	189	static
	190	void proc_debug_info_sources_destroy(
	191	struct proc_debug_info_sources *proc_dbg_info_src)
	192	{
	193	if (!proc_dbg_info_src) {
	194	return;
	195	}
	196
	197	if (proc_dbg_info_src->baddr_to_so_info) {
	198	g_hash_table_destroy(proc_dbg_info_src->baddr_to_so_info);
	199	}
	200
	201	if (proc_dbg_info_src->ip_to_debug_info_src) {
	202	g_hash_table_destroy(proc_dbg_info_src->ip_to_debug_info_src);
	203	}
	204
	205	g_free(proc_dbg_info_src);
	206	}
	207
	208	static
	209	struct proc_debug_info_sources *proc_debug_info_sources_create(void)
	210	{
	211	struct proc_debug_info_sources *proc_dbg_info_src = NULL;
	212
	213	proc_dbg_info_src = g_new0(struct proc_debug_info_sources, 1);
	214	if (!proc_dbg_info_src) {
	215	goto end;
	216	}
	217
	218	proc_dbg_info_src->baddr_to_so_info = g_hash_table_new_full(
71235b6d JG	219	g_int64_hash, g_int64_equal, (GDestroyNotify) g_free,
71235b6d JG	220	(GDestroyNotify) so_info_destroy);
b5a8598f AB	221	if (!proc_dbg_info_src->baddr_to_so_info) {
	222	goto error;
	223	}
	224
	225	proc_dbg_info_src->ip_to_debug_info_src = g_hash_table_new_full(
71235b6d	226	g_int64_hash, g_int64_equal, (GDestroyNotify) g_free,
b5a8598f AB	227	(GDestroyNotify) debug_info_source_destroy);
	228	if (!proc_dbg_info_src->ip_to_debug_info_src) {
	229	goto error;
	230	}
	231
	232	end:
	233	return proc_dbg_info_src;
	234
	235	error:
	236	proc_debug_info_sources_destroy(proc_dbg_info_src);
	237	return NULL;
	238	}
	239
	240	static
	241	struct proc_debug_info_sources *proc_debug_info_sources_ht_get_entry(
	242	GHashTable *ht, int64_t vpid)
	243	{
71235b6d	244	gpointer key = g_new0(int64_t, 1);
b5a8598f AB	245	struct proc_debug_info_sources *proc_dbg_info_src = NULL;
b5a8598f AB	246
71235b6d JG	247	if (!key) {
	248	goto end;
	249	}
	250
	251	((int64_t ) key) = vpid;
	252
b5a8598f AB	253	/* Exists? Return it */
	254	proc_dbg_info_src = g_hash_table_lookup(ht, key);
	255	if (proc_dbg_info_src) {
	256	goto end;
	257	}
	258
	259	/* Otherwise, create and return it */
	260	proc_dbg_info_src = proc_debug_info_sources_create();
	261	if (!proc_dbg_info_src) {
	262	goto end;
	263	}
	264
	265	g_hash_table_insert(ht, key, proc_dbg_info_src);
71235b6d JG	266	/* Ownership passed to ht */
71235b6d JG	267	key = NULL;
b5a8598f	268	end:
71235b6d	269	g_free(key);
b5a8598f AB	270	return proc_dbg_info_src;
	271	}
	272
	273	static
	274	struct debug_info_source *proc_debug_info_sources_get_entry(
	275	struct proc_debug_info_sources *proc_dbg_info_src, uint64_t ip)
	276	{
	277	struct debug_info_source *debug_info_src = NULL;
71235b6d	278	gpointer key = g_new0(uint64_t, 1);
b5a8598f AB	279	GHashTableIter iter;
	280	gpointer baddr, value;
	281
71235b6d JG	282	if (!key) {
	283	goto end;
	284	}
	285
	286	((uint64_t ) key) = ip;
	287
b5a8598f AB	288	/* Look in IP to debug infos hash table first. */
	289	debug_info_src = g_hash_table_lookup(
	290	proc_dbg_info_src->ip_to_debug_info_src,
71235b6d	291	key);
b5a8598f AB	292	if (debug_info_src) {
	293	goto end;
	294	}
	295
	296	/* Check in all so_infos. */
	297	g_hash_table_iter_init(&iter, proc_dbg_info_src->baddr_to_so_info);
	298
	299	while (g_hash_table_iter_next(&iter, &baddr, &value))
	300	{
	301	struct so_info *so = value;
	302
	303	if (!so_info_has_address(value, ip)) {
	304	continue;
	305	}
	306
71235b6d JG	307	/*
	308	* Found; add it to cache.
	309	*
	310	* FIXME: this should be bounded in size (and implement
	311	* a caching policy), and entries should be prunned when
	312	* libraries are unmapped.
	313	*/
b5a8598f AB	314	debug_info_src = debug_info_source_create_from_so(so, ip);
	315	if (debug_info_src) {
	316	g_hash_table_insert(
	317	proc_dbg_info_src->ip_to_debug_info_src,
71235b6d JG	318	key, debug_info_src);
	319	/* Ownership passed to ht. */
	320	key = NULL;
b5a8598f AB	321	}
	322	break;
	323	}
	324
	325	end:
71235b6d	326	free(key);
b5a8598f AB	327	return debug_info_src;
	328	}
	329
	330	BT_HIDDEN
	331	struct debug_info_source debug_info_query(struct debug_info debug_info,
	332	int64_t vpid, uint64_t ip)
	333	{
	334	struct debug_info_source *dbg_info_src = NULL;
	335	struct proc_debug_info_sources *proc_dbg_info_src;
	336
	337	proc_dbg_info_src = proc_debug_info_sources_ht_get_entry(
	338	debug_info->vpid_to_proc_dbg_info_src, vpid);
	339	if (!proc_dbg_info_src) {
	340	goto end;
	341	}
	342
	343	dbg_info_src = proc_debug_info_sources_get_entry(
	344	proc_dbg_info_src, ip);
	345	if (!dbg_info_src) {
	346	goto end;
	347	}
	348
	349	end:
	350	return dbg_info_src;
	351	}
	352
	353	BT_HIDDEN
	354	struct debug_info *debug_info_create(void)
	355	{
	356	int ret;
	357	struct debug_info *debug_info;
	358
	359	debug_info = g_new0(struct debug_info, 1);
	360	if (!debug_info) {
	361	goto end;
	362	}
	363
71235b6d JG	364	debug_info->vpid_to_proc_dbg_info_src = g_hash_table_new_full(
71235b6d JG	365	g_int64_hash, g_int64_equal, (GDestroyNotify) g_free,
b5a8598f AB	366	(GDestroyNotify) proc_debug_info_sources_destroy);
	367	if (!debug_info->vpid_to_proc_dbg_info_src) {
	368	goto error;
	369	}
	370
	371	ret = debug_info_init(debug_info);
	372	if (ret) {
	373	goto error;
	374	}
	375
	376	end:
	377	return debug_info;
	378	error:
	379	g_free(debug_info);
	380	return NULL;
	381	}
	382
	383	BT_HIDDEN
	384	void debug_info_destroy(struct debug_info *debug_info)
	385	{
	386	if (!debug_info) {
	387	goto end;
	388	}
	389
	390	if (debug_info->vpid_to_proc_dbg_info_src) {
	391	g_hash_table_destroy(debug_info->vpid_to_proc_dbg_info_src);
	392	}
	393
	394	g_free(debug_info);
	395	end:
	396	return;
	397	}
	398
	399	static
	400	void handle_statedump_build_id_event(struct debug_info *debug_info,
	401	struct ctf_event_definition *event_def)
	402	{
	403	struct proc_debug_info_sources *proc_dbg_info_src;
	404	struct bt_definition *event_fields_def = NULL;
	405	struct bt_definition *sec_def = NULL;
	406	struct bt_definition *baddr_def = NULL;
	407	struct bt_definition *vpid_def = NULL;
	408	struct bt_definition *build_id_def = NULL;
	409	struct definition_sequence *build_id_seq;
	410	struct so_info *so = NULL;
	411	int i;
	412	int64_t vpid;
	413	uint64_t baddr;
	414	uint8_t *build_id = NULL;
	415	uint64_t build_id_len;
	416
	417	event_fields_def = (struct bt_definition *) event_def->event_fields;
	418	sec_def = (struct bt_definition *)
	419	event_def->stream->stream_event_context;
	420
	421	if (!event_fields_def \|\| !sec_def) {
	422	goto end;
	423	}
	424
	425	baddr_def = bt_lookup_definition(event_fields_def, "_baddr");
	426	if (!baddr_def) {
	427	goto end;
	428	}
	429
430	vpid_def = bt_lookup_definition(sec_def, "_vpid");
431	if (!vpid_def) {
432	goto end;
433	}
434
435	build_id_def = bt_lookup_definition(event_fields_def, "_build_id");
436	if (!build_id_def) {
437	goto end;
438	}
439
440	if (baddr_def->declaration->id != CTF_TYPE_INTEGER) {
441	goto end;
442	}
443
444	if (vpid_def->declaration->id != CTF_TYPE_INTEGER) {
445	goto end;
446	}
447
448	if (build_id_def->declaration->id != CTF_TYPE_SEQUENCE) {
449	goto end;
450	}
451
452	baddr = bt_get_unsigned_int(baddr_def);
453	vpid = bt_get_signed_int(vpid_def);
454	build_id_seq = container_of(build_id_def,
455	struct definition_sequence, p);
456	build_id_len = build_id_seq->length->value._unsigned;
457
458	build_id = g_malloc(build_id_len);
459	if (!build_id) {
460	goto end;
461	}
462
463	for (i = 0; i < build_id_len; ++i) {
464	struct bt_definition **field;
465
466	field = (struct bt_definition **) &g_ptr_array_index(
467	build_id_seq->elems, i);
468	build_id[i] = bt_get_unsigned_int(*field);
469	}
470
471	proc_dbg_info_src = proc_debug_info_sources_ht_get_entry(
472	debug_info->vpid_to_proc_dbg_info_src, vpid);
473	if (!proc_dbg_info_src) {
474	goto end;
475	}
476
477	so = g_hash_table_lookup(proc_dbg_info_src->baddr_to_so_info,
478	(gpointer) &baddr);
479	if (!so) {
480	/*
481	* The build_id event comes after the so has been
482	* created. If it isn't found, just ignore this event.
483	*/
484	goto end;
485	}
486
487	so_info_set_build_id(so, build_id, build_id_len);
488
489	end:
490	free(build_id);
491	return;
492	}
493
494	static
495	void handle_statedump_debug_link_event(struct debug_info *debug_info,
496	struct ctf_event_definition *event_def)
497	{
498	struct proc_debug_info_sources *proc_dbg_info_src;
499	struct bt_definition *event_fields_def = NULL;
500	struct bt_definition *sec_def = NULL;
501	struct bt_definition *baddr_def = NULL;
502	struct bt_definition *vpid_def = NULL;
503	struct bt_definition *filename_def = NULL;
504	struct bt_definition *crc32_def = NULL;
505	struct so_info *so = NULL;
506	int64_t vpid;
507	uint64_t baddr;
508	char *filename = NULL;
509	uint32_t crc32;
510
511	event_fields_def = (struct bt_definition *) event_def->event_fields;
512	sec_def = (struct bt_definition *)
513	event_def->stream->stream_event_context;
514
515	if (!event_fields_def \|\| !sec_def) {
516	goto end;
517	}
518
519	baddr_def = bt_lookup_definition(event_fields_def, "_baddr");
520	if (!baddr_def) {
521	goto end;
522	}
523
524	vpid_def = bt_lookup_definition(sec_def, "_vpid");
525	if (!vpid_def) {
526	goto end;
527	}
528
529	filename_def = bt_lookup_definition(event_fields_def, "_filename");
530	if (!filename_def) {
531	goto end;
532	}
533
534	crc32_def = bt_lookup_definition(event_fields_def, "_crc32");
535	if (!crc32_def) {
536	goto end;
537	}
538
539	if (baddr_def->declaration->id != CTF_TYPE_INTEGER) {
540	goto end;
541	}
542
543	if (vpid_def->declaration->id != CTF_TYPE_INTEGER) {
544	goto end;
545	}
546
547	if (filename_def->declaration->id != CTF_TYPE_STRING) {
548	goto end;
549	}
550
551	if (crc32_def->declaration->id != CTF_TYPE_INTEGER) {
552	goto end;
553	}
554
555	baddr = bt_get_unsigned_int(baddr_def);
556	vpid = bt_get_signed_int(vpid_def);
557
558	proc_dbg_info_src = proc_debug_info_sources_ht_get_entry(
559	debug_info->vpid_to_proc_dbg_info_src, vpid);
560	if (!proc_dbg_info_src) {
561	goto end;
562	}
563
564	so = g_hash_table_lookup(proc_dbg_info_src->baddr_to_so_info,
565	(gpointer) &baddr);
566	if (!so) {
567	/*
568	* The debug_link event comes after the so has been
569	* created. If it isn't found, just ignore this event.
570	*/
571	goto end;
572	}
573
574	filename = bt_get_string(filename_def);
575	crc32 = bt_get_unsigned_int(crc32_def);
576
577	so_info_set_debug_link(so, filename, crc32);
578
579	end:
580	return;
581	}
582
583	static
584	void handle_statedump_soinfo_event(struct debug_info *debug_info,
585	struct ctf_event_definition *event_def)
586	{
587	struct bt_definition *baddr_def = NULL;
588	struct bt_definition *memsz_def = NULL;
589	struct bt_definition *sopath_def = NULL;
590	struct bt_definition *vpid_def = NULL;
591	struct bt_definition *event_fields_def = NULL;
592	struct bt_definition *sec_def = NULL;
593	struct proc_debug_info_sources *proc_dbg_info_src;
594	struct so_info *so;
595	uint64_t baddr, memsz;
596	int64_t vpid;
597	const char *sopath;
71235b6d	598	gpointer key = NULL;
b5a8598f AB	599
	600	event_fields_def = (struct bt_definition *) event_def->event_fields;
	601	sec_def = (struct bt_definition *)
	602	event_def->stream->stream_event_context;
	603
	604	if (!event_fields_def \|\| !sec_def) {
	605	goto end;
	606	}
	607
	608	baddr_def = bt_lookup_definition(event_fields_def, "_baddr");
	609	if (!baddr_def) {
	610	goto end;
	611	}
	612
	613	memsz_def = bt_lookup_definition(event_fields_def, "_memsz");
	614	if (!memsz_def) {
	615	goto end;
	616	}
	617
	618	sopath_def = bt_lookup_definition(event_fields_def, "_sopath");
	619	if (!sopath_def) {
	620	goto end;
	621	}
	622
	623	vpid_def = bt_lookup_definition(sec_def, "_vpid");
	624	if (!vpid_def) {
	625	goto end;
	626	}
	627
	628	if (baddr_def->declaration->id != CTF_TYPE_INTEGER) {
	629	goto end;
	630	}
	631
	632	if (memsz_def->declaration->id != CTF_TYPE_INTEGER) {
	633	goto end;
	634	}
	635
	636	if (sopath_def->declaration->id != CTF_TYPE_STRING) {
	637	goto end;
	638	}
	639
	640	if (vpid_def->declaration->id != CTF_TYPE_INTEGER) {
	641	goto end;
	642	}
	643
	644	baddr = bt_get_unsigned_int(baddr_def);
	645	memsz = bt_get_unsigned_int(memsz_def);
	646	sopath = bt_get_string(sopath_def);
	647	vpid = bt_get_signed_int(vpid_def);
	648
	649	if (!sopath) {
	650	goto end;
	651	}
	652
	653	if (memsz == 0) {
	654	/* Ignore VDSO. */
	655	goto end;
	656	}
	657
	658	proc_dbg_info_src = proc_debug_info_sources_ht_get_entry(
	659	debug_info->vpid_to_proc_dbg_info_src, vpid);
	660	if (!proc_dbg_info_src) {
	661	goto end;
	662	}
663
71235b6d JG	664	key = g_new0(uint64_t, 1);
	665	if (!key) {
	666	goto end;
	667	}
	668
	669	((uint64_t ) key) = baddr;
	670
b5a8598f	671	so = g_hash_table_lookup(proc_dbg_info_src->baddr_to_so_info,
71235b6d	672	key);
b5a8598f AB	673	if (so) {
	674	goto end;
	675	}
	676
	677	so = so_info_create(sopath, baddr, memsz);
	678	if (!so) {
	679	goto end;
	680	}
	681
	682	g_hash_table_insert(proc_dbg_info_src->baddr_to_so_info,
71235b6d JG	683	key, so);
	684	/* Ownership passed to ht. */
	685	key = NULL;
b5a8598f AB	686
b5a8598f AB	687	end:
71235b6d	688	g_free(key);
b5a8598f AB	689	return;
	690	}
	691
	692	static
	693	void handle_statedump_start(struct debug_info *debug_info,
	694	struct ctf_event_definition *event_def)
	695	{
	696	struct bt_definition *vpid_def = NULL;
	697	struct bt_definition *sec_def = NULL;
	698	struct proc_debug_info_sources *proc_dbg_info_src;
	699	int64_t vpid;
	700
	701	sec_def = (struct bt_definition *)
	702	event_def->stream->stream_event_context;
	703	if (!sec_def) {
	704	goto end;
	705	}
	706
	707	vpid_def = bt_lookup_definition(sec_def, "_vpid");
	708	if (!vpid_def) {
	709	goto end;
	710	}
	711
	712	vpid = bt_get_signed_int(vpid_def);
	713
	714	proc_dbg_info_src = proc_debug_info_sources_ht_get_entry(
	715	debug_info->vpid_to_proc_dbg_info_src, vpid);
	716	if (!proc_dbg_info_src) {
	717	goto end;
	718	}
	719
	720	g_hash_table_remove_all(proc_dbg_info_src->baddr_to_so_info);
	721	g_hash_table_remove_all(proc_dbg_info_src->ip_to_debug_info_src);
	722
	723	end:
	724	return;
	725	}
	726
	727	static
	728	void register_event_debug_infos(struct debug_info *debug_info,
	729	struct ctf_event_definition *event)
	730	{
	731	struct bt_definition ip_def, vpid_def;
	732	int64_t vpid;
	733	uint64_t ip;
	734	struct bt_definition *sec_def;
	735
	736	/* Get stream event context definition. */
	737	sec_def = (struct bt_definition *) event->stream->stream_event_context;
	738	if (!sec_def) {
	739	goto end;
	740	}
	741
	742	/* Get "ip" and "vpid" definitions. */
	743	vpid_def = bt_lookup_definition((struct bt_definition *) sec_def,
	744	"_vpid");
	745	ip_def = bt_lookup_definition((struct bt_definition *) sec_def, "_ip");
	746
	747	if (!vpid_def \|\| !ip_def) {
	748	goto end;
	749	}
	750
	751	vpid = bt_get_signed_int(vpid_def);
	752	ip = bt_get_unsigned_int(ip_def);
753
754	/* Get debug info for this context. */
755	((struct definition_integer *) ip_def)->debug_info_src =
756	debug_info_query(debug_info, vpid, ip);
757
758	end:
759	return;
760	}
761
762	BT_HIDDEN
763	void debug_info_handle_event(struct debug_info *debug_info,
764	struct ctf_event_definition *event)
765	{
766	struct ctf_event_declaration *event_class;
767	struct ctf_stream_declaration *stream_class;
768
769	if (!debug_info \|\| !event) {
770	goto end;
771	}
772
773	stream_class = event->stream->stream_class;
774	event_class = g_ptr_array_index(stream_class->events_by_id,
775	event->stream->event_id);
776
777	if (event_class->name == debug_info->q_statedump_soinfo \|\|
778	event_class->name == debug_info->q_dl_open) {
779	/* State dump/dlopen() */
780	handle_statedump_soinfo_event(debug_info, event);
781	} else if (event_class->name == debug_info->q_statedump_start) {
782	/* Start state dump */
783	handle_statedump_start(debug_info, event);
784	} else if (event_class->name == debug_info->q_statedump_debug_link) {
785	/* Debug link info */
786	handle_statedump_debug_link_event(debug_info, event);
787	} else if (event_class->name == debug_info->q_statedump_build_id) {
788	/* Build ID info */
789	handle_statedump_build_id_event(debug_info, event);
790	} else {
791	/* Other events: register debug infos */
792	register_event_debug_infos(debug_info, event);
793	}
794
795	end:
796	return;
797	}