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