1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24#include "qemu/osdep.h"
25#include "qemu/cutils.h"
26#include "qemu/dbus.h"
27#include "qemu/main-loop.h"
28#include "qemu/option.h"
29#include "qom/object_interfaces.h"
30#include "sysemu/sysemu.h"
31#include "ui/dbus-module.h"
32#include "ui/egl-helpers.h"
33#include "ui/egl-context.h"
34#include "audio/audio.h"
35#include "audio/audio_int.h"
36#include "qapi/error.h"
37#include "trace.h"
38
39#include "dbus.h"
40
41static DBusDisplay *dbus_display;
42
43static QEMUGLContext dbus_create_context(DisplayGLCtx *dgc,
44 QEMUGLParams *params)
45{
46 eglMakeCurrent(qemu_egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE,
47 qemu_egl_rn_ctx);
48 return qemu_egl_create_context(dgc, params);
49}
50
51static bool
52dbus_is_compatible_dcl(DisplayGLCtx *dgc,
53 DisplayChangeListener *dcl)
54{
55 return dcl->ops == &dbus_gl_dcl_ops || dcl->ops == &dbus_console_dcl_ops;
56}
57
58static void
59dbus_create_texture(DisplayGLCtx *ctx, DisplaySurface *surface)
60{
61 surface_gl_create_texture(ctx->gls, surface);
62}
63
64static void
65dbus_destroy_texture(DisplayGLCtx *ctx, DisplaySurface *surface)
66{
67 surface_gl_destroy_texture(ctx->gls, surface);
68}
69
70static void
71dbus_update_texture(DisplayGLCtx *ctx, DisplaySurface *surface,
72 int x, int y, int w, int h)
73{
74 surface_gl_update_texture(ctx->gls, surface, x, y, w, h);
75}
76
77static const DisplayGLCtxOps dbus_gl_ops = {
78 .dpy_gl_ctx_is_compatible_dcl = dbus_is_compatible_dcl,
79 .dpy_gl_ctx_create = dbus_create_context,
80 .dpy_gl_ctx_destroy = qemu_egl_destroy_context,
81 .dpy_gl_ctx_make_current = qemu_egl_make_context_current,
82 .dpy_gl_ctx_create_texture = dbus_create_texture,
83 .dpy_gl_ctx_destroy_texture = dbus_destroy_texture,
84 .dpy_gl_ctx_update_texture = dbus_update_texture,
85};
86
87static NotifierList dbus_display_notifiers =
88 NOTIFIER_LIST_INITIALIZER(dbus_display_notifiers);
89
90void
91dbus_display_notifier_add(Notifier *notifier)
92{
93 notifier_list_add(&dbus_display_notifiers, notifier);
94}
95
96static void
97dbus_display_notifier_remove(Notifier *notifier)
98{
99 notifier_remove(notifier);
100}
101
102void
103dbus_display_notify(DBusDisplayEvent *event)
104{
105 notifier_list_notify(&dbus_display_notifiers, event);
106}
107
108static void
109dbus_display_init(Object *o)
110{
111 DBusDisplay *dd = DBUS_DISPLAY(o);
112 g_autoptr(GDBusObjectSkeleton) vm = NULL;
113
114 dd->glctx.ops = &dbus_gl_ops;
115 if (display_opengl) {
116 dd->glctx.gls = qemu_gl_init_shader();
117 }
118 dd->iface = qemu_dbus_display1_vm_skeleton_new();
119 dd->consoles = g_ptr_array_new_with_free_func(g_object_unref);
120
121 dd->server = g_dbus_object_manager_server_new(DBUS_DISPLAY1_ROOT);
122
123 vm = g_dbus_object_skeleton_new(DBUS_DISPLAY1_ROOT "/VM");
124 g_dbus_object_skeleton_add_interface(
125 vm, G_DBUS_INTERFACE_SKELETON(dd->iface));
126 g_dbus_object_manager_server_export(dd->server, vm);
127
128 dbus_clipboard_init(dd);
129 dbus_chardev_init(dd);
130}
131
132static void
133dbus_display_finalize(Object *o)
134{
135 DBusDisplay *dd = DBUS_DISPLAY(o);
136
137 if (dd->notifier.notify) {
138 dbus_display_notifier_remove(&dd->notifier);
139 }
140
141 qemu_clipboard_peer_unregister(&dd->clipboard_peer);
142 g_clear_object(&dd->clipboard);
143
144 g_clear_object(&dd->server);
145 g_clear_pointer(&dd->consoles, g_ptr_array_unref);
146 if (dd->add_client_cancellable) {
147 g_cancellable_cancel(dd->add_client_cancellable);
148 }
149 g_clear_object(&dd->add_client_cancellable);
150 g_clear_object(&dd->bus);
151 g_clear_object(&dd->iface);
152 g_free(dd->dbus_addr);
153 g_free(dd->audiodev);
154 g_clear_pointer(&dd->glctx.gls, qemu_gl_fini_shader);
155 dbus_display = NULL;
156}
157
158static bool
159dbus_display_add_console(DBusDisplay *dd, int idx, Error **errp)
160{
161 QemuConsole *con;
162 DBusDisplayConsole *dbus_console;
163
164 con = qemu_console_lookup_by_index(idx);
165 assert(con);
166
167 if (qemu_console_is_graphic(con) &&
168 dd->gl_mode != DISPLAYGL_MODE_OFF) {
169 qemu_console_set_display_gl_ctx(con, &dd->glctx);
170 }
171
172 dbus_console = dbus_display_console_new(dd, con);
173 g_ptr_array_insert(dd->consoles, idx, dbus_console);
174 g_dbus_object_manager_server_export(dd->server,
175 G_DBUS_OBJECT_SKELETON(dbus_console));
176 return true;
177}
178
179static void
180dbus_display_complete(UserCreatable *uc, Error **errp)
181{
182 DBusDisplay *dd = DBUS_DISPLAY(uc);
183 g_autoptr(GError) err = NULL;
184 g_autofree char *uuid = qemu_uuid_unparse_strdup(&qemu_uuid);
185 g_autoptr(GArray) consoles = NULL;
186 GVariant *console_ids;
187 int idx;
188
189 if (!object_resolve_path_type("", TYPE_DBUS_DISPLAY, NULL)) {
190 error_setg(errp, "There is already an instance of %s",
191 TYPE_DBUS_DISPLAY);
192 return;
193 }
194
195 if (dd->p2p) {
196
197 dbus_display = dd;
198 } else if (dd->dbus_addr && *dd->dbus_addr) {
199 dd->bus = g_dbus_connection_new_for_address_sync(dd->dbus_addr,
200 G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT |
201 G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION,
202 NULL, NULL, &err);
203 } else {
204 dd->bus = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, &err);
205 }
206 if (err) {
207 error_setg(errp, "failed to connect to DBus: %s", err->message);
208 return;
209 }
210
211 if (dd->audiodev && *dd->audiodev) {
212 AudioState *audio_state = audio_state_by_name(dd->audiodev);
213 if (!audio_state) {
214 error_setg(errp, "Audiodev '%s' not found", dd->audiodev);
215 return;
216 }
217 if (!g_str_equal(audio_state->drv->name, "dbus")) {
218 error_setg(errp, "Audiodev '%s' is not compatible with DBus",
219 dd->audiodev);
220 return;
221 }
222 audio_state->drv->set_dbus_server(audio_state, dd->server);
223 }
224
225 consoles = g_array_new(FALSE, FALSE, sizeof(guint32));
226 for (idx = 0;; idx++) {
227 if (!qemu_console_lookup_by_index(idx)) {
228 break;
229 }
230 if (!dbus_display_add_console(dd, idx, errp)) {
231 return;
232 }
233 g_array_append_val(consoles, idx);
234 }
235
236 console_ids = g_variant_new_from_data(
237 G_VARIANT_TYPE("au"),
238 consoles->data, consoles->len * sizeof(guint32), TRUE,
239 (GDestroyNotify)g_array_unref, consoles);
240 g_steal_pointer(&consoles);
241 g_object_set(dd->iface,
242 "name", qemu_name ?: "QEMU " QEMU_VERSION,
243 "uuid", uuid,
244 "console-ids", console_ids,
245 NULL);
246
247 if (dd->bus) {
248 g_dbus_object_manager_server_set_connection(dd->server, dd->bus);
249 g_bus_own_name_on_connection(dd->bus, "org.qemu",
250 G_BUS_NAME_OWNER_FLAGS_NONE,
251 NULL, NULL, NULL, NULL);
252 }
253}
254
255static void
256dbus_display_add_client_ready(GObject *source_object,
257 GAsyncResult *res,
258 gpointer user_data)
259{
260 g_autoptr(GError) err = NULL;
261 g_autoptr(GDBusConnection) conn = NULL;
262
263 g_clear_object(&dbus_display->add_client_cancellable);
264
265 conn = g_dbus_connection_new_finish(res, &err);
266 if (!conn) {
267 error_printf("Failed to accept D-Bus client: %s", err->message);
268 }
269
270 g_dbus_object_manager_server_set_connection(dbus_display->server, conn);
271 g_dbus_connection_start_message_processing(conn);
272}
273
274
275static bool
276dbus_display_add_client(int csock, Error **errp)
277{
278 g_autoptr(GError) err = NULL;
279 g_autoptr(GSocket) socket = NULL;
280 g_autoptr(GSocketConnection) conn = NULL;
281 g_autofree char *guid = g_dbus_generate_guid();
282
283 if (!dbus_display) {
284 error_setg(errp, "p2p connections not accepted in bus mode");
285 return false;
286 }
287
288 if (dbus_display->add_client_cancellable) {
289 g_cancellable_cancel(dbus_display->add_client_cancellable);
290 }
291
292 socket = g_socket_new_from_fd(csock, &err);
293 if (!socket) {
294 error_setg(errp, "Failed to setup D-Bus socket: %s", err->message);
295 return false;
296 }
297
298 conn = g_socket_connection_factory_create_connection(socket);
299
300 dbus_display->add_client_cancellable = g_cancellable_new();
301
302 g_dbus_connection_new(G_IO_STREAM(conn),
303 guid,
304 G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER |
305 G_DBUS_CONNECTION_FLAGS_DELAY_MESSAGE_PROCESSING,
306 NULL,
307 dbus_display->add_client_cancellable,
308 dbus_display_add_client_ready,
309 NULL);
310
311 return true;
312}
313
314static bool
315get_dbus_p2p(Object *o, Error **errp)
316{
317 DBusDisplay *dd = DBUS_DISPLAY(o);
318
319 return dd->p2p;
320}
321
322static void
323set_dbus_p2p(Object *o, bool p2p, Error **errp)
324{
325 DBusDisplay *dd = DBUS_DISPLAY(o);
326
327 dd->p2p = p2p;
328}
329
330static char *
331get_dbus_addr(Object *o, Error **errp)
332{
333 DBusDisplay *dd = DBUS_DISPLAY(o);
334
335 return g_strdup(dd->dbus_addr);
336}
337
338static void
339set_dbus_addr(Object *o, const char *str, Error **errp)
340{
341 DBusDisplay *dd = DBUS_DISPLAY(o);
342
343 g_free(dd->dbus_addr);
344 dd->dbus_addr = g_strdup(str);
345}
346
347static char *
348get_audiodev(Object *o, Error **errp)
349{
350 DBusDisplay *dd = DBUS_DISPLAY(o);
351
352 return g_strdup(dd->audiodev);
353}
354
355static void
356set_audiodev(Object *o, const char *str, Error **errp)
357{
358 DBusDisplay *dd = DBUS_DISPLAY(o);
359
360 g_free(dd->audiodev);
361 dd->audiodev = g_strdup(str);
362}
363
364
365static int
366get_gl_mode(Object *o, Error **errp)
367{
368 DBusDisplay *dd = DBUS_DISPLAY(o);
369
370 return dd->gl_mode;
371}
372
373static void
374set_gl_mode(Object *o, int val, Error **errp)
375{
376 DBusDisplay *dd = DBUS_DISPLAY(o);
377
378 dd->gl_mode = val;
379}
380
381static void
382dbus_display_class_init(ObjectClass *oc, void *data)
383{
384 UserCreatableClass *ucc = USER_CREATABLE_CLASS(oc);
385
386 ucc->complete = dbus_display_complete;
387 object_class_property_add_bool(oc, "p2p", get_dbus_p2p, set_dbus_p2p);
388 object_class_property_add_str(oc, "addr", get_dbus_addr, set_dbus_addr);
389 object_class_property_add_str(oc, "audiodev", get_audiodev, set_audiodev);
390 object_class_property_add_enum(oc, "gl-mode",
391 "DisplayGLMode", &DisplayGLMode_lookup,
392 get_gl_mode, set_gl_mode);
393}
394
395#define TYPE_CHARDEV_VC "chardev-vc"
396
397typedef struct DBusVCClass {
398 DBusChardevClass parent_class;
399
400 void (*parent_parse)(QemuOpts *opts, ChardevBackend *b, Error **errp);
401} DBusVCClass;
402
403DECLARE_CLASS_CHECKERS(DBusVCClass, DBUS_VC,
404 TYPE_CHARDEV_VC)
405
406static void
407dbus_vc_parse(QemuOpts *opts, ChardevBackend *backend,
408 Error **errp)
409{
410 DBusVCClass *klass = DBUS_VC_CLASS(object_class_by_name(TYPE_CHARDEV_VC));
411 const char *name = qemu_opt_get(opts, "name");
412 const char *id = qemu_opts_id(opts);
413
414 if (name == NULL) {
415 if (g_str_has_prefix(id, "compat_monitor")) {
416 name = "org.qemu.monitor.hmp.0";
417 } else if (g_str_has_prefix(id, "serial")) {
418 name = "org.qemu.console.serial.0";
419 } else {
420 name = "";
421 }
422 if (!qemu_opt_set(opts, "name", name, errp)) {
423 return;
424 }
425 }
426
427 klass->parent_parse(opts, backend, errp);
428}
429
430static void
431dbus_vc_class_init(ObjectClass *oc, void *data)
432{
433 DBusVCClass *klass = DBUS_VC_CLASS(oc);
434 ChardevClass *cc = CHARDEV_CLASS(oc);
435
436 klass->parent_parse = cc->parse;
437 cc->parse = dbus_vc_parse;
438}
439
440static const TypeInfo dbus_vc_type_info = {
441 .name = TYPE_CHARDEV_VC,
442 .parent = TYPE_CHARDEV_DBUS,
443 .class_size = sizeof(DBusVCClass),
444 .class_init = dbus_vc_class_init,
445};
446
447static void
448early_dbus_init(DisplayOptions *opts)
449{
450 DisplayGLMode mode = opts->has_gl ? opts->gl : DISPLAYGL_MODE_OFF;
451
452 if (mode != DISPLAYGL_MODE_OFF) {
453 if (egl_rendernode_init(opts->u.dbus.rendernode, mode) < 0) {
454 error_report("dbus: render node init failed");
455 exit(1);
456 }
457
458 display_opengl = 1;
459 }
460
461 type_register(&dbus_vc_type_info);
462}
463
464static void
465dbus_init(DisplayState *ds, DisplayOptions *opts)
466{
467 DisplayGLMode mode = opts->has_gl ? opts->gl : DISPLAYGL_MODE_OFF;
468
469 if (opts->u.dbus.addr && opts->u.dbus.p2p) {
470 error_report("dbus: can't accept both addr=X and p2p=yes options");
471 exit(1);
472 }
473
474 using_dbus_display = 1;
475
476 object_new_with_props(TYPE_DBUS_DISPLAY,
477 object_get_objects_root(),
478 "dbus-display", &error_fatal,
479 "addr", opts->u.dbus.addr ?: "",
480 "audiodev", opts->u.dbus.audiodev ?: "",
481 "gl-mode", DisplayGLMode_str(mode),
482 "p2p", yes_no(opts->u.dbus.p2p),
483 NULL);
484}
485
486static const TypeInfo dbus_display_info = {
487 .name = TYPE_DBUS_DISPLAY,
488 .parent = TYPE_OBJECT,
489 .instance_size = sizeof(DBusDisplay),
490 .instance_init = dbus_display_init,
491 .instance_finalize = dbus_display_finalize,
492 .class_init = dbus_display_class_init,
493 .interfaces = (InterfaceInfo[]) {
494 { TYPE_USER_CREATABLE },
495 { }
496 }
497};
498
499static QemuDisplay qemu_display_dbus = {
500 .type = DISPLAY_TYPE_DBUS,
501 .early_init = early_dbus_init,
502 .init = dbus_init,
503};
504
505static void register_dbus(void)
506{
507 qemu_dbus_display = (struct QemuDBusDisplayOps) {
508 .add_client = dbus_display_add_client,
509 };
510 type_register_static(&dbus_display_info);
511 qemu_display_register(&qemu_display_dbus);
512}
513
514type_init(register_dbus);
515
516#ifdef CONFIG_OPENGL
517module_dep("ui-opengl");
518#endif
519
