We can now demonstrate what previous changes allow us to do. Since all callbacks have a userdata pointer, we can use that mechanism to move an object through all of them.
In other words, we can now have stateful plugins without resorting to any global variable. As an example, we implement tb counting plugin with our cpp plugin. It produces an output similar to hotblocks, with same performance. Signed-off-by: Pierrick Bouvier <[email protected]> --- contrib/plugins/cpp.cpp | 89 +++++++++++++++++++++++++++++++++++++++-- 1 file changed, 86 insertions(+), 3 deletions(-) diff --git a/contrib/plugins/cpp.cpp b/contrib/plugins/cpp.cpp index a0bb261fbe8..c5099456525 100644 --- a/contrib/plugins/cpp.cpp +++ b/contrib/plugins/cpp.cpp @@ -363,14 +363,97 @@ QEMU_PLUGIN_EXPORT int qemu_plugin_version = QEMU_PLUGIN_VERSION; -static void vcpu_tb_trans(struct qemu_plugin_tb *tb, void *userdata) +class PluginInstance { -} + public: + void tb_exec(std::atomic<uint64_t> &count) + { + count++; + } + + void tb_trans(struct qemu_plugin_tb *tb) + { + auto vaddr = qemu_plugin_tb_vaddr(tb); + + TbData *data = [&]() { + std::lock_guard l(tb_trans_lock); + auto [it, is_new] = tb_data.try_emplace(vaddr); + TbData &in = it->second; + if (is_new) { + in.second = this; + } + return ∈ + } (); + + qemu_plugin_register_vcpu_tb_exec_cb( + tb, + [](unsigned int cpu_index, void *udata) { + auto &[counter, p] = *static_cast<TbData*>(udata); + p->tb_exec(counter); + }, + QEMU_PLUGIN_CB_NO_REGS, + data); + } + + void at_exit() + { + std::vector<std::pair<Vaddr, uint64_t>> v; + for (auto &[vaddr, data] : tb_data) { + uint64_t count = data.first; + v.push_back({vaddr, count}); + } + std::sort(v.begin(), v.end(), + [](const auto &a, const auto &b) { + return a.second > b.second; + }); + std::stringstream ss; + ss << "Top 10 executed TB are:\n"; + size_t idx = 0; + for (auto &tb : v) { + if (idx >= 10) { + break; + } + ss << std::hex << "0x" << tb.first << std::dec << ": " + << tb.second << '\n'; + ++idx; + } + qemu_plugin_outs(ss.str().c_str()); + } + + private: + using Vaddr = uint64_t; + using Counter = std::atomic<uint64_t>; + using TbData = std::pair<Counter, PluginInstance*>; + std::unordered_map<Vaddr, TbData> tb_data; + std::mutex tb_trans_lock; +}; QEMU_PLUGIN_EXPORT int qemu_plugin_install(qemu_plugin_id_t id, const qemu_info_t *info, int argc, char **argv) { - qemu_plugin_register_vcpu_tb_trans_cb(id, vcpu_tb_trans, NULL); + PluginInstance *plugin = new PluginInstance; + + /* + * We can register a cb with any function, which may be a free + * function, a static class function, or a captureless lambda. + */ + qemu_plugin_register_vcpu_tb_trans_cb( + id, + [](struct qemu_plugin_tb *tb, void *userdata) { + PluginInstance *p = static_cast<PluginInstance*>(userdata); + p->tb_trans(tb); + }, + plugin); + + qemu_plugin_register_atexit_cb( + id, + [](void *userdata) { + PluginInstance *p = static_cast<PluginInstance*>(userdata); + p->at_exit(); + delete p; + }, + plugin); + return 0; } -- 2.43.0
