[mirror_ubuntu-focal-kernel.git] / tools / perf / tests / hists_link.c

// SPDX-License-Identifier: GPL-2.0
#include "perf.h"
#include "tests.h"
#include "debug.h"
#include "symbol.h"
#include "sort.h"
#include "evsel.h"
#include "evlist.h"
#include "machine.h"
#include "thread.h"
#include "parse-events.h"
#include "hists_common.h"
#include <errno.h>
#include <linux/kernel.h>

struct sample {
	u32 pid;
	u64 ip;
	struct thread *thread;
	struct map *map;
	struct symbol *sym;
};

/* For the numbers, see hists_common.c */
static struct sample fake_common_samples[] = {
	/* perf [kernel] schedule() */
	{ .pid = FAKE_PID_PERF1, .ip = FAKE_IP_KERNEL_SCHEDULE, },
	/* perf [perf]   main() */
	{ .pid = FAKE_PID_PERF2, .ip = FAKE_IP_PERF_MAIN, },
	/* perf [perf]   cmd_record() */
	{ .pid = FAKE_PID_PERF2, .ip = FAKE_IP_PERF_CMD_RECORD, },
	/* bash [bash]   xmalloc() */
	{ .pid = FAKE_PID_BASH,  .ip = FAKE_IP_BASH_XMALLOC, },
	/* bash [libc]   malloc() */
	{ .pid = FAKE_PID_BASH,  .ip = FAKE_IP_LIBC_MALLOC, },
};

static struct sample fake_samples[][5] = {
	{
		/* perf [perf]   run_command() */
		{ .pid = FAKE_PID_PERF1, .ip = FAKE_IP_PERF_RUN_COMMAND, },
		/* perf [libc]   malloc() */
		{ .pid = FAKE_PID_PERF1, .ip = FAKE_IP_LIBC_MALLOC, },
		/* perf [kernel] page_fault() */
		{ .pid = FAKE_PID_PERF1, .ip = FAKE_IP_KERNEL_PAGE_FAULT, },
		/* perf [kernel] sys_perf_event_open() */
		{ .pid = FAKE_PID_PERF2, .ip = FAKE_IP_KERNEL_SYS_PERF_EVENT_OPEN, },
		/* bash [libc]   free() */
		{ .pid = FAKE_PID_BASH,  .ip = FAKE_IP_LIBC_FREE, },
	},
	{
		/* perf [libc]   free() */
		{ .pid = FAKE_PID_PERF2, .ip = FAKE_IP_LIBC_FREE, },
		/* bash [libc]   malloc() */
		{ .pid = FAKE_PID_BASH,  .ip = FAKE_IP_LIBC_MALLOC, }, /* will be merged */
		/* bash [bash]   xfee() */
		{ .pid = FAKE_PID_BASH,  .ip = FAKE_IP_BASH_XFREE, },
		/* bash [libc]   realloc() */
		{ .pid = FAKE_PID_BASH,  .ip = FAKE_IP_LIBC_REALLOC, },
		/* bash [kernel] page_fault() */
		{ .pid = FAKE_PID_BASH,  .ip = FAKE_IP_KERNEL_PAGE_FAULT, },
	},
};

static int add_hist_entries(struct perf_evlist *evlist, struct machine *machine)
{
	struct perf_evsel *evsel;
	struct addr_location al;
	struct hist_entry *he;
	struct perf_sample sample = { .period = 1, .weight = 1, };
	size_t i = 0, k;

	/*
	 * each evsel will have 10 samples - 5 common and 5 distinct.
	 * However the second evsel also has a collapsed entry for
	 * "bash [libc] malloc" so total 9 entries will be in the tree.
	 */
	evlist__for_each_entry(evlist, evsel) {
		struct hists *hists = evsel__hists(evsel);

		for (k = 0; k < ARRAY_SIZE(fake_common_samples); k++) {
			sample.cpumode = PERF_RECORD_MISC_USER;
			sample.pid = fake_common_samples[k].pid;
			sample.tid = fake_common_samples[k].pid;
			sample.ip = fake_common_samples[k].ip;

			if (machine__resolve(machine, &al, &sample) < 0)
				goto out;

			he = hists__add_entry(hists, &al, NULL,
						NULL, NULL, &sample, true);
			if (he == NULL) {
				addr_location__put(&al);
				goto out;
			}

			fake_common_samples[k].thread = al.thread;
			fake_common_samples[k].map = al.map;
			fake_common_samples[k].sym = al.sym;
		}

		for (k = 0; k < ARRAY_SIZE(fake_samples[i]); k++) {
			sample.pid = fake_samples[i][k].pid;
			sample.tid = fake_samples[i][k].pid;
			sample.ip = fake_samples[i][k].ip;
			if (machine__resolve(machine, &al, &sample) < 0)
				goto out;

			he = hists__add_entry(hists, &al, NULL,
						NULL, NULL, &sample, true);
			if (he == NULL) {
				addr_location__put(&al);
				goto out;
			}

			fake_samples[i][k].thread = al.thread;
			fake_samples[i][k].map = al.map;
			fake_samples[i][k].sym = al.sym;
		}
		i++;
	}

	return 0;

out:
	pr_debug("Not enough memory for adding a hist entry\n");
	return -1;
}

static int find_sample(struct sample *samples, size_t nr_samples,
		       struct thread *t, struct map *m, struct symbol *s)
{
	while (nr_samples--) {
		if (samples->thread == t && samples->map == m &&
		    samples->sym == s)
			return 1;
		samples++;
	}
	return 0;
}

static int __validate_match(struct hists *hists)
{
	size_t count = 0;
	struct rb_root *root;
	struct rb_node *node;

	/*
	 * Only entries from fake_common_samples should have a pair.
	 */
	if (hists__has(hists, need_collapse))
		root = &hists->entries_collapsed;
	else
		root = hists->entries_in;

	node = rb_first(root);
	while (node) {
		struct hist_entry *he;

		he = rb_entry(node, struct hist_entry, rb_node_in);

		if (hist_entry__has_pairs(he)) {
			if (find_sample(fake_common_samples,
					ARRAY_SIZE(fake_common_samples),
					he->thread, he->ms.map, he->ms.sym)) {
				count++;
			} else {
				pr_debug("Can't find the matched entry\n");
				return -1;
			}
		}

		node = rb_next(node);
	}

	if (count != ARRAY_SIZE(fake_common_samples)) {
		pr_debug("Invalid count for matched entries: %zd of %zd\n",
			 count, ARRAY_SIZE(fake_common_samples));
		return -1;
	}

	return 0;
}

static int validate_match(struct hists *leader, struct hists *other)
{
	return __validate_match(leader) || __validate_match(other);
}

static int __validate_link(struct hists *hists, int idx)
{
	size_t count = 0;
	size_t count_pair = 0;
	size_t count_dummy = 0;
	struct rb_root *root;
	struct rb_node *node;

	/*
	 * Leader hists (idx = 0) will have dummy entries from other,
	 * and some entries will have no pair.  However every entry
	 * in other hists should have (dummy) pair.
	 */
	if (hists__has(hists, need_collapse))
		root = &hists->entries_collapsed;
	else
		root = hists->entries_in;

	node = rb_first(root);
	while (node) {
		struct hist_entry *he;

		he = rb_entry(node, struct hist_entry, rb_node_in);

		if (hist_entry__has_pairs(he)) {
			if (!find_sample(fake_common_samples,
					 ARRAY_SIZE(fake_common_samples),
					 he->thread, he->ms.map, he->ms.sym) &&
			    !find_sample(fake_samples[idx],
					 ARRAY_SIZE(fake_samples[idx]),
					 he->thread, he->ms.map, he->ms.sym)) {
				count_dummy++;
			}
			count_pair++;
		} else if (idx) {
			pr_debug("A entry from the other hists should have pair\n");
			return -1;
		}

		count++;
		node = rb_next(node);
	}

	/*
	 * Note that we have a entry collapsed in the other (idx = 1) hists.
	 */
	if (idx == 0) {
		if (count_dummy != ARRAY_SIZE(fake_samples[1]) - 1) {
			pr_debug("Invalid count of dummy entries: %zd of %zd\n",
				 count_dummy, ARRAY_SIZE(fake_samples[1]) - 1);
			return -1;
		}
		if (count != count_pair + ARRAY_SIZE(fake_samples[0])) {
			pr_debug("Invalid count of total leader entries: %zd of %zd\n",
				 count, count_pair + ARRAY_SIZE(fake_samples[0]));
			return -1;
		}
	} else {
		if (count != count_pair) {
			pr_debug("Invalid count of total other entries: %zd of %zd\n",
				 count, count_pair);
			return -1;
		}
		if (count_dummy > 0) {
			pr_debug("Other hists should not have dummy entries: %zd\n",
				 count_dummy);
			return -1;
		}
	}

	return 0;
}

static int validate_link(struct hists *leader, struct hists *other)
{
	return __validate_link(leader, 0) || __validate_link(other, 1);
}

int test__hists_link(struct test *test __maybe_unused, int subtest __maybe_unused)
{
	int err = -1;
	struct hists *hists, *first_hists;
	struct machines machines;
	struct machine *machine = NULL;
	struct perf_evsel *evsel, *first;
	struct perf_evlist *evlist = perf_evlist__new();

	if (evlist == NULL)
                return -ENOMEM;

	err = parse_events(evlist, "cpu-clock", NULL);
	if (err)
		goto out;
	err = parse_events(evlist, "task-clock", NULL);
	if (err)
		goto out;

	err = TEST_FAIL;
	/* default sort order (comm,dso,sym) will be used */
	if (setup_sorting(NULL) < 0)
		goto out;

	machines__init(&machines);

	/* setup threads/dso/map/symbols also */
	machine = setup_fake_machine(&machines);
	if (!machine)
		goto out;

	if (verbose > 1)
		machine__fprintf(machine, stderr);

	/* process sample events */
	err = add_hist_entries(evlist, machine);
	if (err < 0)
		goto out;

	evlist__for_each_entry(evlist, evsel) {
		hists = evsel__hists(evsel);
		hists__collapse_resort(hists, NULL);

		if (verbose > 2)
			print_hists_in(hists);
	}

	first = perf_evlist__first(evlist);
	evsel = perf_evlist__last(evlist);

	first_hists = evsel__hists(first);
	hists = evsel__hists(evsel);

	/* match common entries */
	hists__match(first_hists, hists);
	err = validate_match(first_hists, hists);
	if (err)
		goto out;

	/* link common and/or dummy entries */
	hists__link(first_hists, hists);
	err = validate_link(first_hists, hists);
	if (err)
		goto out;

	err = 0;

out:
	/* tear down everything */
	perf_evlist__delete(evlist);
	reset_output_field();
	machines__exit(&machines);

	return err;
}
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
f8ebb0cd NK	2	#include "perf.h"
	3	#include "tests.h"
	4	#include "debug.h"
	5	#include "symbol.h"
	6	#include "sort.h"
	7	#include "evsel.h"
	8	#include "evlist.h"
	9	#include "machine.h"
	10	#include "thread.h"
	11	#include "parse-events.h"
6e344a95	12	#include "hists_common.h"
a43783ae	13	#include <errno.h>
877a7a11	14	#include <linux/kernel.h>
f8ebb0cd NK	15
	16	struct sample {
	17	u32 pid;
	18	u64 ip;
	19	struct thread *thread;
	20	struct map *map;
	21	struct symbol *sym;
	22	};
	23
6e344a95	24	/* For the numbers, see hists_common.c */
f8ebb0cd NK	25	static struct sample fake_common_samples[] = {
f8ebb0cd NK	26	/* perf [kernel] schedule() */
a1891aa4	27	{ .pid = FAKE_PID_PERF1, .ip = FAKE_IP_KERNEL_SCHEDULE, },
f8ebb0cd	28	/* perf [perf] main() */
a1891aa4	29	{ .pid = FAKE_PID_PERF2, .ip = FAKE_IP_PERF_MAIN, },
f8ebb0cd	30	/* perf [perf] cmd_record() */
a1891aa4	31	{ .pid = FAKE_PID_PERF2, .ip = FAKE_IP_PERF_CMD_RECORD, },
f8ebb0cd	32	/* bash [bash] xmalloc() */
a1891aa4	33	{ .pid = FAKE_PID_BASH, .ip = FAKE_IP_BASH_XMALLOC, },
f8ebb0cd	34	/* bash [libc] malloc() */
a1891aa4	35	{ .pid = FAKE_PID_BASH, .ip = FAKE_IP_LIBC_MALLOC, },
f8ebb0cd NK	36	};
	37
	38	static struct sample fake_samples[][5] = {
	39	{
	40	/* perf [perf] run_command() */
a1891aa4	41	{ .pid = FAKE_PID_PERF1, .ip = FAKE_IP_PERF_RUN_COMMAND, },
f8ebb0cd	42	/* perf [libc] malloc() */
a1891aa4	43	{ .pid = FAKE_PID_PERF1, .ip = FAKE_IP_LIBC_MALLOC, },
f8ebb0cd	44	/* perf [kernel] page_fault() */
a1891aa4	45	{ .pid = FAKE_PID_PERF1, .ip = FAKE_IP_KERNEL_PAGE_FAULT, },
f8ebb0cd	46	/* perf [kernel] sys_perf_event_open() */
a1891aa4	47	{ .pid = FAKE_PID_PERF2, .ip = FAKE_IP_KERNEL_SYS_PERF_EVENT_OPEN, },
f8ebb0cd	48	/* bash [libc] free() */
a1891aa4	49	{ .pid = FAKE_PID_BASH, .ip = FAKE_IP_LIBC_FREE, },
f8ebb0cd NK	50	},
	51	{
	52	/* perf [libc] free() */
a1891aa4	53	{ .pid = FAKE_PID_PERF2, .ip = FAKE_IP_LIBC_FREE, },
f8ebb0cd	54	/* bash [libc] malloc() */
a1891aa4	55	{ .pid = FAKE_PID_BASH, .ip = FAKE_IP_LIBC_MALLOC, }, /* will be merged */
f8ebb0cd	56	/* bash [bash] xfee() */
a1891aa4	57	{ .pid = FAKE_PID_BASH, .ip = FAKE_IP_BASH_XFREE, },
f8ebb0cd	58	/* bash [libc] realloc() */
a1891aa4	59	{ .pid = FAKE_PID_BASH, .ip = FAKE_IP_LIBC_REALLOC, },
f8ebb0cd	60	/* bash [kernel] page_fault() */
a1891aa4	61	{ .pid = FAKE_PID_BASH, .ip = FAKE_IP_KERNEL_PAGE_FAULT, },
f8ebb0cd NK	62	},
	63	};
	64
	65	static int add_hist_entries(struct perf_evlist evlist, struct machine machine)
	66	{
	67	struct perf_evsel *evsel;
	68	struct addr_location al;
	69	struct hist_entry *he;
fd36f3dd	70	struct perf_sample sample = { .period = 1, .weight = 1, };
f8ebb0cd NK	71	size_t i = 0, k;
	72
	73	/*
	74	* each evsel will have 10 samples - 5 common and 5 distinct.
	75	* However the second evsel also has a collapsed entry for
	76	* "bash [libc] malloc" so total 9 entries will be in the tree.
	77	*/
e5cadb93	78	evlist__for_each_entry(evlist, evsel) {
4ea062ed ACM	79	struct hists *hists = evsel__hists(evsel);
4ea062ed ACM	80
f8ebb0cd	81	for (k = 0; k < ARRAY_SIZE(fake_common_samples); k++) {
473398a2	82	sample.cpumode = PERF_RECORD_MISC_USER;
ef89325f	83	sample.pid = fake_common_samples[k].pid;
13ce34df	84	sample.tid = fake_common_samples[k].pid;
ef89325f	85	sample.ip = fake_common_samples[k].ip;
bb3eb566 ACM	86
bb3eb566 ACM	87	if (machine__resolve(machine, &al, &sample) < 0)
f8ebb0cd NK	88	goto out;
f8ebb0cd NK	89
0102ef3e	90	he = hists__add_entry(hists, &al, NULL,
fd36f3dd	91	NULL, NULL, &sample, true);
b91fc39f ACM	92	if (he == NULL) {
b91fc39f ACM	93	addr_location__put(&al);
f8ebb0cd	94	goto out;
b91fc39f	95	}
f8ebb0cd NK	96
	97	fake_common_samples[k].thread = al.thread;
	98	fake_common_samples[k].map = al.map;
	99	fake_common_samples[k].sym = al.sym;
	100	}
	101
	102	for (k = 0; k < ARRAY_SIZE(fake_samples[i]); k++) {
ef89325f	103	sample.pid = fake_samples[i][k].pid;
13ce34df	104	sample.tid = fake_samples[i][k].pid;
ef89325f	105	sample.ip = fake_samples[i][k].ip;
bb3eb566	106	if (machine__resolve(machine, &al, &sample) < 0)
f8ebb0cd NK	107	goto out;
f8ebb0cd NK	108
0102ef3e	109	he = hists__add_entry(hists, &al, NULL,
fd36f3dd	110	NULL, NULL, &sample, true);
b91fc39f ACM	111	if (he == NULL) {
b91fc39f ACM	112	addr_location__put(&al);
f8ebb0cd	113	goto out;
b91fc39f	114	}
f8ebb0cd NK	115
	116	fake_samples[i][k].thread = al.thread;
	117	fake_samples[i][k].map = al.map;
	118	fake_samples[i][k].sym = al.sym;
	119	}
	120	i++;
	121	}
	122
	123	return 0;
	124
	125	out:
	126	pr_debug("Not enough memory for adding a hist entry\n");
	127	return -1;
	128	}
	129
	130	static int find_sample(struct sample *samples, size_t nr_samples,
	131	struct thread t, struct map m, struct symbol *s)
	132	{
	133	while (nr_samples--) {
	134	if (samples->thread == t && samples->map == m &&
	135	samples->sym == s)
	136	return 1;
	137	samples++;
	138	}
	139	return 0;
	140	}
	141
	142	static int __validate_match(struct hists *hists)
	143	{
	144	size_t count = 0;
	145	struct rb_root *root;
	146	struct rb_node *node;
	147
	148	/*
	149	* Only entries from fake_common_samples should have a pair.
	150	*/
52225036	151	if (hists__has(hists, need_collapse))
f8ebb0cd NK	152	root = &hists->entries_collapsed;
	153	else
	154	root = hists->entries_in;
	155
	156	node = rb_first(root);
	157	while (node) {
	158	struct hist_entry *he;
	159
	160	he = rb_entry(node, struct hist_entry, rb_node_in);
	161
	162	if (hist_entry__has_pairs(he)) {
	163	if (find_sample(fake_common_samples,
	164	ARRAY_SIZE(fake_common_samples),
	165	he->thread, he->ms.map, he->ms.sym)) {
	166	count++;
	167	} else {
	168	pr_debug("Can't find the matched entry\n");
	169	return -1;
	170	}
	171	}
	172
	173	node = rb_next(node);
	174	}
	175
	176	if (count != ARRAY_SIZE(fake_common_samples)) {
	177	pr_debug("Invalid count for matched entries: %zd of %zd\n",
	178	count, ARRAY_SIZE(fake_common_samples));
	179	return -1;
	180	}
	181
	182	return 0;
	183	}
	184
	185	static int validate_match(struct hists leader, struct hists other)
	186	{
	187	return __validate_match(leader) \|\| __validate_match(other);
	188	}
	189
	190	static int __validate_link(struct hists *hists, int idx)
	191	{
	192	size_t count = 0;
	193	size_t count_pair = 0;
	194	size_t count_dummy = 0;
	195	struct rb_root *root;
	196	struct rb_node *node;
	197
	198	/*
	199	* Leader hists (idx = 0) will have dummy entries from other,
	200	* and some entries will have no pair. However every entry
	201	* in other hists should have (dummy) pair.
	202	*/
52225036	203	if (hists__has(hists, need_collapse))
f8ebb0cd NK	204	root = &hists->entries_collapsed;
	205	else
	206	root = hists->entries_in;
	207
	208	node = rb_first(root);
	209	while (node) {
	210	struct hist_entry *he;
	211
	212	he = rb_entry(node, struct hist_entry, rb_node_in);
	213
	214	if (hist_entry__has_pairs(he)) {
	215	if (!find_sample(fake_common_samples,
	216	ARRAY_SIZE(fake_common_samples),
	217	he->thread, he->ms.map, he->ms.sym) &&
	218	!find_sample(fake_samples[idx],
	219	ARRAY_SIZE(fake_samples[idx]),
	220	he->thread, he->ms.map, he->ms.sym)) {
	221	count_dummy++;
	222	}
	223	count_pair++;
	224	} else if (idx) {
	225	pr_debug("A entry from the other hists should have pair\n");
	226	return -1;
	227	}
	228
	229	count++;
	230	node = rb_next(node);
	231	}
	232
	233	/*
	234	* Note that we have a entry collapsed in the other (idx = 1) hists.
	235	*/
	236	if (idx == 0) {
	237	if (count_dummy != ARRAY_SIZE(fake_samples[1]) - 1) {
	238	pr_debug("Invalid count of dummy entries: %zd of %zd\n",
	239	count_dummy, ARRAY_SIZE(fake_samples[1]) - 1);
	240	return -1;
	241	}
	242	if (count != count_pair + ARRAY_SIZE(fake_samples[0])) {
	243	pr_debug("Invalid count of total leader entries: %zd of %zd\n",
	244	count, count_pair + ARRAY_SIZE(fake_samples[0]));
	245	return -1;
	246	}
	247	} else {
	248	if (count != count_pair) {
	249	pr_debug("Invalid count of total other entries: %zd of %zd\n",
	250	count, count_pair);
	251	return -1;
	252	}
	253	if (count_dummy > 0) {
	254	pr_debug("Other hists should not have dummy entries: %zd\n",
	255	count_dummy);
	256	return -1;
	257	}
	258	}
	259
	260	return 0;
	261	}
	262
	263	static int validate_link(struct hists leader, struct hists other)
	264	{
	265	return __validate_link(leader, 0) \|\| __validate_link(other, 1);
	266	}
	267
81f17c90	268	int test__hists_link(struct test *test __maybe_unused, int subtest __maybe_unused)
f8ebb0cd NK	269	{
f8ebb0cd NK	270	int err = -1;
4ea062ed	271	struct hists hists, first_hists;
876650e6	272	struct machines machines;
f8ebb0cd NK	273	struct machine *machine = NULL;
f8ebb0cd NK	274	struct perf_evsel evsel, first;
334fe7a3	275	struct perf_evlist *evlist = perf_evlist__new();
f8ebb0cd NK	276
	277	if (evlist == NULL)
	278	return -ENOMEM;
	279
b39b8393	280	err = parse_events(evlist, "cpu-clock", NULL);
f8ebb0cd NK	281	if (err)
f8ebb0cd NK	282	goto out;
b39b8393	283	err = parse_events(evlist, "task-clock", NULL);
f8ebb0cd NK	284	if (err)
	285	goto out;
	286
b0500c16	287	err = TEST_FAIL;
f8ebb0cd	288	/* default sort order (comm,dso,sym) will be used */
40184c46	289	if (setup_sorting(NULL) < 0)
55309985	290	goto out;
f8ebb0cd	291
876650e6 ACM	292	machines__init(&machines);
876650e6 ACM	293
f8ebb0cd	294	/* setup threads/dso/map/symbols also */
876650e6	295	machine = setup_fake_machine(&machines);
f8ebb0cd NK	296	if (!machine)
	297	goto out;
	298
	299	if (verbose > 1)
	300	machine__fprintf(machine, stderr);
	301
	302	/* process sample events */
	303	err = add_hist_entries(evlist, machine);
	304	if (err < 0)
	305	goto out;
	306
e5cadb93	307	evlist__for_each_entry(evlist, evsel) {
4ea062ed ACM	308	hists = evsel__hists(evsel);
4ea062ed ACM	309	hists__collapse_resort(hists, NULL);
f8ebb0cd NK	310
f8ebb0cd NK	311	if (verbose > 2)
4ea062ed	312	print_hists_in(hists);
f8ebb0cd NK	313	}
	314
	315	first = perf_evlist__first(evlist);
	316	evsel = perf_evlist__last(evlist);
	317
4ea062ed ACM	318	first_hists = evsel__hists(first);
	319	hists = evsel__hists(evsel);
	320
f8ebb0cd	321	/* match common entries */
4ea062ed ACM	322	hists__match(first_hists, hists);
4ea062ed ACM	323	err = validate_match(first_hists, hists);
f8ebb0cd NK	324	if (err)
	325	goto out;
	326
	327	/* link common and/or dummy entries */
4ea062ed ACM	328	hists__link(first_hists, hists);
4ea062ed ACM	329	err = validate_link(first_hists, hists);
f8ebb0cd NK	330	if (err)
	331	goto out;
	332
	333	err = 0;
	334
	335	out:
	336	/* tear down everything */
	337	perf_evlist__delete(evlist);
f21d1815	338	reset_output_field();
876650e6	339	machines__exit(&machines);
f8ebb0cd NK	340
	341	return err;
	342	}