quic/qbox
Loading...
Searching...
No Matches
libqemu-cxx.h
1/*
2 * This file is part of libqemu-cxx
3 * Copyright (c) 2022-2024 Qualcomm Innovation Center, Inc. All Rights Reserved.
4 * Author: GreenSocs 2015-2019
5 *
6 * SPDX-License-Identifier: BSD-3-Clause
7 */
8
9#pragma once
10
11#include <string>
12#include <unordered_map>
13#include <memory>
14#include <functional>
15#include <set>
16#include <vector>
17#include <map>
18
19#include <libqemu-cxx/target_info.h>
20#include <libqemu-cxx/exceptions.h>
21#include <libqemu-cxx/loader.h>
22
23#include <scp/report.h>
24
25/* libqemu types forward declaration */
26struct LibQemuExports;
27struct QemuObject;
28struct DisplayGLCtxOps;
29struct DisplayGLCtx;
30struct QemuConsole;
31struct DisplaySurface;
32struct DisplayOptions;
33struct QEMUCursor;
34struct SDL_Window;
35struct sdl2_console;
38struct MemTxAttrs;
39struct QemuMemoryRegion;
42struct QemuAddressSpace;
44struct QemuTimer;
45typedef void* QEMUGLContext;
46struct QEMUGLParams;
47typedef void (*LibQemuGfxUpdateFn)(DisplayChangeListener*, int, int, int, int);
48typedef void (*LibQemuGfxSwitchFn)(DisplayChangeListener*, DisplaySurface*);
49typedef void (*LibQemuRefreshFn)(DisplayChangeListener*);
50typedef void (*LibQemuWindowCreateFn)(DisplayChangeListener*);
51typedef void (*LibQemuWindowDestroyFn)(DisplayChangeListener*);
52typedef void (*LibQemuWindowResizeFn)(DisplayChangeListener*);
53typedef void (*LibQemuPollEventsFn)(DisplayChangeListener*);
54typedef void (*LibQemuMouseSetFn)(DisplayChangeListener*, int, int, int);
55typedef void (*LibQemuCursorDefineFn)(DisplayChangeListener*, QEMUCursor*);
56typedef void (*LibQemuGLScanoutDisableFn)(DisplayChangeListener*);
57typedef void (*LibQemuGLScanoutTextureFn)(DisplayChangeListener*, uint32_t, bool, uint32_t, uint32_t, uint32_t,
58 uint32_t, uint32_t, uint32_t);
59typedef void (*LibQemuGLUpdateFn)(DisplayChangeListener*, uint32_t, uint32_t, uint32_t, uint32_t);
60
61typedef bool (*LibQemuIsCompatibleDclFn)(DisplayGLCtx*, DisplayChangeListener*);
62
63namespace qemu {
64
65class LibQemuInternals;
66class Object;
67class MemoryRegion;
68class MemoryRegionOps;
69class IOMMUMemoryRegion;
70class AddressSpace;
71class MemoryListener;
72class Gpio;
73class Timer;
74class Bus;
75class Chardev;
76class DisplayOptions;
77class DisplayGLCtxOps;
78class Console;
79class SDL2Console;
80class Dcl;
81class DclOps;
82class RcuReadLock;
83
85{
86private:
87 std::shared_ptr<LibQemuInternals> m_int;
88 LibraryLoaderIface& m_library_loader;
89 const char* m_lib_path;
90 Target m_target;
91 bool m_auto_start;
92
93 std::vector<char*> m_qemu_argv;
94
95 LibraryLoaderIface::LibraryIfacePtr m_lib;
96
97 QemuObject* object_new_unparented(const char* type_name);
98 QemuObject* object_new_internal(const char* type_name, const char* id);
99
100 void check_cast(Object& o, const char* type);
101
102 void init_callbacks();
103
104 void rcu_read_lock();
105 void rcu_read_unlock();
106
107public:
110 ~LibQemu();
111
112 void push_qemu_arg(const char* arg);
113 void push_qemu_arg(std::initializer_list<const char*> args);
114 const std::vector<char*>& get_qemu_args() const { return m_qemu_argv; }
115
116 void init();
117 bool is_inited() const { return m_lib != nullptr; }
118
119 /* QEMU GDB stub
120 * @port: port the gdb server will be listening on. (ex: "tcp::1234") */
121 void start_gdb_server(std::string port);
122 void vm_start();
123 void vm_stop_paused();
124
125 void lock_iothread();
126 void unlock_iothread();
127
128 RcuReadLock rcu_read_lock_new();
129
130 void finish_qemu_init();
131 Bus sysbus_get_default();
132
133 void coroutine_yield();
134
135 void system_reset();
136
137 template <class T>
138 T object_new()
139 {
140 T o(Object(object_new_internal(T::TYPE, NULL), m_int));
141 check_cast(o, T::TYPE);
142
143 return o;
144 }
145
146 template <class T>
147 T object_new_unparented()
148 {
149 T o(Object(object_new_unparented(T::TYPE), m_int));
150 check_cast(o, T::TYPE);
151
152 return o;
153 }
154 int64_t get_virtual_clock();
155
156 Object object_new(const char* type_name, const char* id);
157 std::shared_ptr<MemoryRegionOps> memory_region_ops_new();
158 std::shared_ptr<AddressSpace> address_space_new();
159 std::shared_ptr<AddressSpace> address_space_get_system_memory();
160 std::shared_ptr<MemoryRegion> get_system_memory();
161 std::shared_ptr<MemoryListener> memory_listener_new();
162 Gpio gpio_new();
163
164 std::shared_ptr<Timer> timer_new();
165
166 Chardev chardev_new(const char* label, const char* type);
167
168 void tb_invalidate_phys_range(uint64_t start, uint64_t end);
169
170 void enable_opengl();
171 DisplayOptions display_options_new();
172 std::vector<Console> get_all_consoles();
173 Console console_lookup_by_index(int index);
174 DisplayGLCtxOps display_gl_ctx_ops_new(LibQemuIsCompatibleDclFn);
175 Dcl dcl_new(DisplayChangeListener* dcl);
176 DclOps dcl_ops_new();
177
178 int sdl2_init() const;
179 const char* sdl2_get_error() const;
180
181 std::vector<SDL2Console> sdl2_create_consoles(int num);
182 void sdl2_cleanup();
183 void sdl2_2d_update(DisplayChangeListener* dcl, int x, int y, int w, int h);
184 void sdl2_2d_switch(DisplayChangeListener* dcl, DisplaySurface* new_surface);
185 void sdl2_2d_refresh(DisplayChangeListener* dcl);
186
187 void sdl2_gl_update(DisplayChangeListener* dcl, int x, int y, int w, int h);
188 void sdl2_gl_switch(DisplayChangeListener* dcl, DisplaySurface* new_surface);
189 void sdl2_gl_refresh(DisplayChangeListener* dcl);
190
191 void sdl2_window_create(DisplayChangeListener* dcl);
192 void sdl2_window_destroy(DisplayChangeListener* dcl);
193 void sdl2_window_resize(DisplayChangeListener* dcl);
194 void sdl2_poll_events(DisplayChangeListener* dcl);
195
196 void dcl_dpy_gfx_replace_surface(DisplayChangeListener* dcl, DisplaySurface* new_surface);
197
198 QEMUGLContext sdl2_gl_create_context(DisplayGLCtx* dgc, QEMUGLParams* p);
199 void sdl2_gl_destroy_context(DisplayGLCtx* dgc, QEMUGLContext gl_ctx);
200 int sdl2_gl_make_context_current(DisplayGLCtx* dgc, QEMUGLContext gl_ctx);
201
202 bool virgl_has_blob() const;
203};
204
206{
207private:
208 std::shared_ptr<LibQemuInternals> m_int;
209 RcuReadLock() = default;
210
211public:
212 RcuReadLock(std::shared_ptr<LibQemuInternals> internals);
213 ~RcuReadLock();
214
215 RcuReadLock(const RcuReadLock&) = delete;
216 RcuReadLock& operator=(const RcuReadLock&) = delete;
218 RcuReadLock& operator=(RcuReadLock&&);
219};
220
222{
223protected:
224 QemuObject* m_obj = nullptr;
225 std::shared_ptr<LibQemuInternals> m_int;
226
227 bool check_cast_by_type(const char* type_name) const { return true; }
228
229public:
230 Object() = default;
231 Object(QemuObject* obj, std::shared_ptr<LibQemuInternals>& internals);
232 Object(const Object& o);
233 Object(Object&& o);
234
235 Object& operator=(Object o);
236
237 virtual ~Object();
238
239 bool valid() const { return m_obj != nullptr; }
240
241 void set_prop_bool(const char* name, bool val);
242 void set_prop_int(const char* name, int64_t val);
243 void set_prop_uint(const char* name, uint64_t val);
244 void set_prop_str(const char* name, const char* val);
245 void set_prop_link(const char* name, const Object& link);
246 void set_prop_parse(const char* name, const char* value);
247
248 Object get_prop_link(const char* name);
249
250 QemuObject* get_qemu_obj() const { return m_obj; }
251
252 LibQemu& get_inst();
253 uintptr_t get_inst_id() const { return reinterpret_cast<uintptr_t>(m_int.get()); }
254 bool same_inst_as(const Object& o) const { return get_inst_id() == o.get_inst_id(); }
255
256 template <class T>
257 bool check_cast() const
258 {
259 return check_cast_by_type(T::TYPE);
260 }
261
262 void clear_callbacks();
263};
264
265class Gpio : public Object
266{
267public:
268 typedef std::function<void(bool)> GpioEventFn;
269
271 {
272 protected:
273 bool m_prev_valid = false;
274 bool m_prev;
275 GpioEventFn m_cb;
276
277 public:
278 void event(bool level)
279 {
280 if (!m_prev_valid || (level != m_prev)) {
281 if (m_cb) m_cb(level);
282 }
283
284 m_prev_valid = true;
285 m_prev = level;
286 }
287
288 void set_callback(GpioEventFn cb) { m_cb = cb; }
289 };
290
291private:
292 std::shared_ptr<GpioProxy> m_proxy;
293
294public:
295 static constexpr const char* const TYPE = "irq";
296
297 Gpio() = default;
298 Gpio(const Gpio& o) = default;
299 Gpio(const Object& o): Object(o) {}
300
301 void set(bool lvl);
302
303 void set_proxy(std::shared_ptr<GpioProxy> proxy) { m_proxy = proxy; }
304
305 void set_event_callback(GpioEventFn cb)
306 {
307 if (m_proxy) {
308 m_proxy->set_callback(cb);
309 }
310 }
311};
312
314{
315public:
316 enum MemTxResult { MemTxOK, MemTxError, MemTxDecodeError, MemTxOKExitTB };
317
318 struct MemTxAttrs {
319 bool secure = false;
320 bool debug = false;
321
322 MemTxAttrs() = default;
323 MemTxAttrs(const ::MemTxAttrs& qemu_attrs);
324 };
325
326 typedef std::function<MemTxResult(uint64_t, uint64_t*, unsigned int, MemTxAttrs)> ReadCallback;
327
328 typedef std::function<MemTxResult(uint64_t, uint64_t, unsigned int, MemTxAttrs)> WriteCallback;
329
330private:
331 QemuMemoryRegionOps* m_ops;
332 std::shared_ptr<LibQemuInternals> m_int;
333
334 ReadCallback m_read_cb;
335 WriteCallback m_write_cb;
336
337public:
338 MemoryRegionOps(QemuMemoryRegionOps* ops, std::shared_ptr<LibQemuInternals> internals);
340
341 void set_read_callback(ReadCallback cb);
342 void set_write_callback(WriteCallback cb);
343
344 void set_max_access_size(unsigned size);
345
346 ReadCallback get_read_callback() { return m_read_cb; }
347 WriteCallback get_write_callback() { return m_write_cb; }
348
349 QemuMemoryRegionOps* get_qemu_mr_ops() { return m_ops; }
350};
351
352typedef std::shared_ptr<MemoryRegionOps> MemoryRegionOpsPtr;
353
354class MemoryRegion : public Object
355{
356private:
357 MemoryRegionOpsPtr m_ops;
358 std::set<MemoryRegion> m_subregions;
359 int m_priority = 0;
360
361 void internal_del_subregion(const MemoryRegion& mr);
362
363public:
364 using MemTxResult = MemoryRegionOps::MemTxResult;
366
367 static constexpr const char* const TYPE = "memory-region";
368
369 MemoryRegion* container = nullptr;
370
371 MemoryRegion() = default;
372 MemoryRegion(const MemoryRegion&) = default;
373 MemoryRegion(const Object& o): Object(o) {}
374 MemoryRegion(QemuMemoryRegion* mr, std::shared_ptr<LibQemuInternals> internals);
375
377 void removeSubRegions();
378
379 uint64_t get_size();
380 int get_priority() const { return m_priority; }
381 /* Make sure to set the priority before calling `add_subregion_overlap()` */
382 void set_priority(int priority) { m_priority = priority; }
383
384 void init(const Object& owner, const char* name, uint64_t size);
385 void init_io(Object owner, const char* name, uint64_t size, MemoryRegionOpsPtr ops);
386 void init_ram_ptr(Object owner, const char* name, uint64_t size, void* ptr, int fd = -1);
387 void init_alias(Object owner, const char* name, const MemoryRegion& root, uint64_t offset, uint64_t size);
388
389 void add_subregion(MemoryRegion& mr, uint64_t offset);
390 void add_subregion_overlap(MemoryRegion& mr, uint64_t offset);
391 void del_subregion(const MemoryRegion& mr);
392
393 MemTxResult dispatch_read(uint64_t addr, uint64_t* data, uint64_t size, MemTxAttrs attrs);
394
395 MemTxResult dispatch_write(uint64_t addr, uint64_t data, uint64_t size, MemTxAttrs attrs);
396
397 void set_ops(const MemoryRegionOpsPtr ops);
398
399 bool operator<(const MemoryRegion& mr) const { return m_obj < mr.m_obj; }
400};
401
403{
404private:
405 QemuAddressSpace* m_as;
406 std::shared_ptr<LibQemuInternals> m_int;
407
408 bool m_inited = false;
409 bool m_global = false;
410
411public:
412 using MemTxResult = MemoryRegionOps::MemTxResult;
414
415 AddressSpace(QemuAddressSpace* as, std::shared_ptr<LibQemuInternals> internals);
416 AddressSpace(const AddressSpace&) = delete;
417
419
420 QemuAddressSpace* get_ptr() { return m_as; }
421
422 void init(MemoryRegion mr, const char* name, bool global = false);
423
424 MemTxResult read(uint64_t addr, void* data, size_t size, MemTxAttrs attrs);
425 MemTxResult write(uint64_t addr, const void* data, size_t size, MemTxAttrs attrs);
426
427 void update_topology();
428};
429
430/* this is simply used to hold shared_ptr's for memory management and
431 * to check if the DMIRegions exist.
432 */
434};
436{
437public:
438 static constexpr const char* const TYPE = "libqemu-iommu-memory-region";
439
440 qemu::MemoryRegion m_root_te;
441 std::shared_ptr<qemu::AddressSpace> m_as_te;
442 qemu::MemoryRegion m_root;
443 std::shared_ptr<qemu::AddressSpace> m_as;
444 std::map<uint64_t, std::shared_ptr<DmiRegionBase>> m_dmi_aliases_te;
445 std::map<uint64_t, std::shared_ptr<DmiRegionBase>> m_dmi_aliases_io;
446 uint64_t min_page_sz;
447
449 : MemoryRegion(o)
450 , m_root_te(get_inst().object_new_unparented<qemu::MemoryRegion>())
451 , m_as_te(get_inst().address_space_new())
452 , m_root(get_inst().object_new_unparented<qemu::MemoryRegion>())
453 , m_as(get_inst().address_space_new())
454 {
455 }
456
457 typedef enum {
458 IOMMU_NONE = 0,
459 IOMMU_RO = 1,
460 IOMMU_WO = 2,
461 IOMMU_RW = 3,
462 } IOMMUAccessFlags;
463
465 QemuAddressSpace* target_as;
466 uint64_t iova;
467 uint64_t translated_addr;
468 uint64_t addr_mask;
469 IOMMUAccessFlags perm;
470 };
471
472 std::unordered_map<uint64_t, qemu::IOMMUMemoryRegion::IOMMUTLBEntry> m_mapped_te;
473
474 using IOMMUTranslateCallbackFn = std::function<void(IOMMUTLBEntry*, uint64_t, IOMMUAccessFlags, int)>;
475 void init(const Object& owner, const char* name, uint64_t size, MemoryRegionOpsPtr ops,
476 IOMMUTranslateCallbackFn cb);
477 void iommu_unmap(IOMMUTLBEntry*);
478};
479
481{
482public:
483 typedef std::function<void(MemoryListener&, uint64_t addr, uint64_t len)> MapCallback;
484
485private:
486 QemuMemoryListener* m_ml;
487 std::shared_ptr<LibQemuInternals> m_int;
488 std::shared_ptr<AddressSpace> m_as;
489
490 MapCallback m_map_cb;
491
492public:
493 MemoryListener(std::shared_ptr<LibQemuInternals> internals);
494 MemoryListener(const MemoryListener&) = delete;
496
497 void set_ml(QemuMemoryListener* ml);
498
499 void set_map_callback(MapCallback cb);
500 MapCallback& get_map_callback() { return m_map_cb; }
501
502 void register_as(std::shared_ptr<AddressSpace> as);
503};
504
506{
507public:
508 ::DisplayOptions* m_opts;
509 std::shared_ptr<LibQemuInternals> m_int;
510
511 DisplayOptions() = default;
512 DisplayOptions(::DisplayOptions* opts, std::shared_ptr<LibQemuInternals>& internals);
513 DisplayOptions(const DisplayOptions&) = default;
514};
515
517{
518public:
519 ::DisplayGLCtxOps* m_ops;
520 std::shared_ptr<LibQemuInternals> m_int;
521
522 DisplayGLCtxOps() = default;
523 DisplayGLCtxOps(::DisplayGLCtxOps* ops, std::shared_ptr<LibQemuInternals>& internals);
524 DisplayGLCtxOps(const DisplayGLCtxOps&) = default;
525};
526
528{
529public:
530 QemuConsole* m_cons;
531 std::shared_ptr<LibQemuInternals> m_int;
532
533 Console() = default;
534 Console(QemuConsole* cons, std::shared_ptr<LibQemuInternals>& internals);
535 Console(const Console&) = default;
536
537 int get_index() const;
538 bool is_graphic() const;
539 void set_display_gl_ctx(DisplayGLCtx*);
540 void set_window_id(int id);
541};
542
544{
545public:
546 struct sdl2_console* m_cons;
547 std::shared_ptr<LibQemuInternals> m_int;
548
549 SDL2Console() = default;
550 SDL2Console(struct sdl2_console* cons, std::shared_ptr<LibQemuInternals>& internals);
551 SDL2Console(const SDL2Console&) = default;
552
553 void init(Console& con, void* user_data);
554 void set_hidden(bool hidden);
555 void set_idx(int idx);
556 void set_opts(DisplayOptions& opts);
557 void set_opengl(bool opengl);
558 void set_dcl_ops(DclOps& dcl_ops);
559 void set_dgc_ops(DisplayGLCtxOps& dgc_ops);
560
561 SDL_Window* get_real_window() const;
562 DisplayChangeListener* get_dcl() const;
563 DisplayGLCtx* get_dgc() const;
564
565 void register_dcl() const;
566
567 void set_window_id(Console& con) const;
568};
569
570class Dcl
571{
572private:
574 std::shared_ptr<LibQemuInternals> m_int;
575
576public:
577 Dcl(DisplayChangeListener* dcl, std::shared_ptr<LibQemuInternals>& internals);
578
579 void* get_user_data();
580};
581
583{
584public:
586 std::shared_ptr<LibQemuInternals> m_int;
587
588 DclOps() = default;
589 DclOps(DisplayChangeListenerOps* ops, std::shared_ptr<LibQemuInternals>& internals);
590 DclOps(const DclOps&) = default;
591
592 void set_name(const char* name);
593 bool is_used_by(DisplayChangeListener* dcl) const;
594 void set_gfx_update(LibQemuGfxUpdateFn gfx_update_fn);
595 void set_gfx_switch(LibQemuGfxSwitchFn gfx_switch_fn);
596 void set_refresh(LibQemuRefreshFn refresh_fn);
597
598 void set_window_create(LibQemuWindowCreateFn window_create_fn);
599 void set_window_destroy(LibQemuWindowDestroyFn window_destroy_fn);
600 void set_window_resize(LibQemuWindowResizeFn window_resize_fn);
601 void set_poll_events(LibQemuPollEventsFn poll_events_fn);
602};
603
604class Device : public Object
605{
606public:
607 static constexpr const char* const TYPE = "device";
608
609 Device() = default;
610 Device(const Device&) = default;
611 Device(const Object& o): Object(o) {}
612
613 void connect_gpio_out(int idx, Gpio gpio);
614 void connect_gpio_out_named(const char* name, int idx, Gpio gpio);
615
616 Gpio get_gpio_in(int idx);
617 Gpio get_gpio_in_named(const char* name, int idx);
618
619 Bus get_child_bus(const char* name);
620 void set_parent_bus(Bus bus);
621
622 void set_prop_chardev(const char* name, Chardev chr);
623 void set_prop_uint_array(const char* name, std::vector<unsigned int> vec);
624};
625
626class SysBusDevice : public Device
627{
628public:
629 static constexpr const char* const TYPE = "sys-bus-device";
630
631 SysBusDevice() = default;
632 SysBusDevice(const SysBusDevice&) = default;
633 SysBusDevice(const Object& o): Device(o) {}
634
635 MemoryRegion mmio_get_region(int id);
636
637 void connect_gpio_out(int idx, Gpio gpio);
638};
639
640class GpexHost : public SysBusDevice
641{
642public:
643 static constexpr const char* const TYPE = "gpex-pcihost";
644
645 GpexHost() = default;
646 GpexHost(const GpexHost&) = default;
647 GpexHost(const Object& o): SysBusDevice(o) {}
648
649 void set_irq_num(int idx, int gic_irq);
650};
651
652class Cpu : public Device
653{
654public:
655 static constexpr const char* const TYPE = "cpu";
656
657 using EndOfLoopCallbackFn = std::function<void()>;
658 using CpuKickCallbackFn = std::function<void()>;
659 using AsyncJobFn = std::function<void()>;
660
661 Cpu() = default;
662 Cpu(const Cpu&) = default;
663 Cpu(const Object& o): Device(o) {}
664
665 int get_index() const;
666
667 void loop();
668 bool loop_is_busy();
669
670 bool can_run();
671
672 void set_soft_stopped(bool stopped);
673 void halt(bool halted);
674
675 void reset(bool reset); /* Reset: on true, enter reset, call cpu_pause and cpu_reset
676 * on false exit reset and call cpu_resume */
677
678 void set_unplug(bool unplug);
679 void remove_sync();
680
681 void register_thread();
682
683 Cpu set_as_current();
684
685 void kick();
686
687 [[noreturn]] void exit_loop_from_io();
688
689 void async_run(AsyncJobFn job);
690 void async_safe_run(AsyncJobFn job);
691
692 void set_end_of_loop_callback(EndOfLoopCallbackFn cb);
693 void set_kick_callback(CpuKickCallbackFn cb);
694
695 bool is_in_exclusive_context() const;
696
697 void set_vcpu_dirty(bool dirty) const;
698};
699
700class Timer
701{
702public:
703 typedef std::function<void()> TimerCallbackFn;
704
705private:
706 std::shared_ptr<LibQemuInternals> m_int;
707 QemuTimer* m_timer = nullptr;
708 TimerCallbackFn m_cb;
709
710public:
711 Timer(std::shared_ptr<LibQemuInternals> internals);
712 ~Timer();
713
714 void set_callback(TimerCallbackFn cb);
715
716 void mod(int64_t deadline);
717 void del();
718};
719
720class Bus : public Object
721{
722public:
723 static constexpr const char* const TYPE = "bus";
724
725 Bus() = default;
726 Bus(const Bus& o) = default;
727 Bus(const Object& o): Object(o) {}
728};
729
730class Chardev : public Object
731{
732public:
733 static constexpr const char* const TYPE = "chardev";
734
735 Chardev() = default;
736 Chardev(const Chardev& o) = default;
737 Chardev(const Object& o): Object(o) {}
738};
739
740}; /* namespace qemu */
Definition target.h:160
Definition libqemu-cxx.h:403
Definition libqemu-cxx.h:721
Definition libqemu-cxx.h:731
Definition libqemu-cxx.h:528
Definition libqemu-cxx.h:653
Definition libqemu-cxx.h:583
Definition libqemu-cxx.h:571
Definition libqemu-cxx.h:605
Definition libqemu-cxx.h:517
Definition libqemu-cxx.h:506
Definition libqemu-cxx.h:641
Definition libqemu-cxx.h:271
Definition libqemu-cxx.h:266
Definition libqemu-cxx.h:436
Definition libqemu-cxx.h:85
Definition loader.h:22
Definition libqemu-cxx.h:481
Definition libqemu-cxx.h:314
Definition libqemu-cxx.h:355
Definition libqemu-cxx.h:222
Definition libqemu-cxx.h:206
Definition libqemu-cxx.h:544
Definition libqemu-cxx.h:627
Definition libqemu-cxx.h:701
Definition libqemu-cxx.h:433
Definition libqemu-cxx.h:464
Definition libqemu-cxx.h:318