1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
|
/*
* Copyright (C) 2020, Matthias Weckbecker <matthias@weckbecker.name>
*
* License: GNU GPL, version 2 or later.
* See the COPYING file in the top-level directory.
*/
#include <inttypes.h>
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <stdio.h>
#include <glib.h>
#include <qemu-plugin.h>
QEMU_PLUGIN_EXPORT int qemu_plugin_version = QEMU_PLUGIN_VERSION;
typedef struct {
int64_t num;
int64_t calls;
int64_t errors;
} SyscallStats;
static GMutex lock;
static GHashTable *statistics;
static SyscallStats *get_or_create_entry(int64_t num)
{
SyscallStats *entry =
(SyscallStats *) g_hash_table_lookup(statistics, GINT_TO_POINTER(num));
if (!entry) {
entry = g_new0(SyscallStats, 1);
entry->num = num;
g_hash_table_insert(statistics, GINT_TO_POINTER(num), (gpointer) entry);
}
return entry;
}
static void vcpu_syscall(qemu_plugin_id_t id, unsigned int vcpu_index,
int64_t num, uint64_t a1, uint64_t a2,
uint64_t a3, uint64_t a4, uint64_t a5,
uint64_t a6, uint64_t a7, uint64_t a8)
{
if (statistics) {
SyscallStats *entry;
g_mutex_lock(&lock);
entry = get_or_create_entry(num);
entry->calls++;
g_mutex_unlock(&lock);
} else {
g_autofree gchar *out = g_strdup_printf("syscall #%" PRIi64 "\n", num);
qemu_plugin_outs(out);
}
}
static void vcpu_syscall_ret(qemu_plugin_id_t id, unsigned int vcpu_idx,
int64_t num, int64_t ret)
{
if (statistics) {
SyscallStats *entry;
g_mutex_lock(&lock);
/* Should always return an existent entry. */
entry = get_or_create_entry(num);
if (ret < 0) {
entry->errors++;
}
g_mutex_unlock(&lock);
} else {
g_autofree gchar *out = g_strdup_printf(
"syscall #%" PRIi64 " returned -> %" PRIi64 "\n", num, ret);
qemu_plugin_outs(out);
}
}
static void print_entry(gpointer val, gpointer user_data)
{
SyscallStats *entry = (SyscallStats *) val;
int64_t syscall_num = entry->num;
g_autofree gchar *out = g_strdup_printf(
"%-13" PRIi64 "%-6" PRIi64 " %" PRIi64 "\n",
syscall_num, entry->calls, entry->errors);
qemu_plugin_outs(out);
}
static gint comp_func(gconstpointer ea, gconstpointer eb)
{
SyscallStats *ent_a = (SyscallStats *) ea;
SyscallStats *ent_b = (SyscallStats *) eb;
return ent_a->calls > ent_b->calls ? -1 : 1;
}
/* ************************************************************************* */
static void plugin_exit(qemu_plugin_id_t id, void *p)
{
if (!statistics) {
return;
}
g_mutex_lock(&lock);
GList *entries = g_hash_table_get_values(statistics);
entries = g_list_sort(entries, comp_func);
qemu_plugin_outs("syscall no. calls errors\n");
g_list_foreach(entries, print_entry, NULL);
g_list_free(entries);
g_hash_table_destroy(statistics);
g_mutex_unlock(&lock);
}
QEMU_PLUGIN_EXPORT int qemu_plugin_install(qemu_plugin_id_t id,
const qemu_info_t *info,
int argc, char **argv)
{
bool do_print = false;
for (int i = 0; i < argc; i++) {
char *opt = argv[i];
g_auto(GStrv) tokens = g_strsplit(opt, "=", 2);
if (g_strcmp0(tokens[0], "print") == 0) {
if (!qemu_plugin_bool_parse(tokens[0], tokens[1], &do_print)) {
fprintf(stderr, "boolean argument parsing failed: %s\n", opt);
}
} else {
fprintf(stderr, "unsupported argument: %s\n", argv[i]);
return -1;
}
}
if (!do_print) {
statistics = g_hash_table_new_full(NULL, g_direct_equal, NULL, g_free);
}
qemu_plugin_register_vcpu_syscall_cb(id, vcpu_syscall);
qemu_plugin_register_vcpu_syscall_ret_cb(id, vcpu_syscall_ret);
qemu_plugin_register_atexit_cb(id, plugin_exit, NULL);
return 0;
}
|
