From nobody Sat Nov 23 19:51:22 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org ARC-Seal: i=1; a=rsa-sha256; t=1729766090; cv=none; d=zohomail.com; s=zohoarc; b=OUycsIH3VLeqjcKemdJ7InpyqJ+jazdnLzTwhAj7yd4caPFRyu75gZAXgTlly2H1HPDbjWPbDYZRVTpq2LtNgbSe+3pHbtd1iQePFeYYQO38avwX/m7iJcjM/C8qhCEA4gv4EkrwdGqKLNDGf1gjiTBlKzjdyoR9K3wvrZL6b1g= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1729766090; h=Content-Transfer-Encoding:Cc:Cc:Date:Date:From:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:Subject:To:To:Message-Id:Reply-To; bh=awe07NOksR1ao1OasiHRde1JNGh5DYeYO6Ef7uq8wQo=; b=JuC3771H/exADvqLXFwiUMi5fA2MjN+6h9TNqKLOmJJ3b18hcckZxFigFhY+MZXouf4waI4LA9wj9TT1kIOUXLPvkI/vK5lvbpsB62dAjeY+QeSFULpWVckqlGFAh1z6cSsK4kfIxLVAigonjEaQB2NeVcVItVdvRFUWycyMpOM= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1729766090703322.98750503126007; Thu, 24 Oct 2024 03:34:50 -0700 (PDT) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1t3v54-0000n9-2G; Thu, 24 Oct 2024 06:28:38 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1t3v51-0000le-BG for qemu-devel@nongnu.org; Thu, 24 Oct 2024 06:28:35 -0400 Received: from mail-ej1-x630.google.com ([2a00:1450:4864:20::630]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1t3v4t-00087u-CX for qemu-devel@nongnu.org; Thu, 24 Oct 2024 06:28:35 -0400 Received: by mail-ej1-x630.google.com with SMTP id a640c23a62f3a-a9acafdb745so153003866b.0 for ; Thu, 24 Oct 2024 03:28:25 -0700 (PDT) Received: from localhost.localdomain (h082218084190.host.wavenet.at. [82.218.84.190]) by smtp.gmail.com with ESMTPSA id a640c23a62f3a-a9a913706d3sm601019066b.134.2024.10.24.03.28.22 (version=TLS1_3 cipher=TLS_CHACHA20_POLY1305_SHA256 bits=256/256); Thu, 24 Oct 2024 03:28:23 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=philjordan-eu.20230601.gappssmtp.com; s=20230601; t=1729765704; x=1730370504; darn=nongnu.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=awe07NOksR1ao1OasiHRde1JNGh5DYeYO6Ef7uq8wQo=; b=ZYV8QUT5q08k8i5tRsTYl6HAPszXN+ZSN5Unq32+SbrWmwyayAKBfA0+rnd4KHL57u np5bb4nZY+s2BlFFIhU6y/JH5n/lDwlmjHydt9c6ccqwyAl8nbwrxgD+CmLZdN/P5exS YbQFTDZj+mBagwQo/AqR6bSnJi+IgxB6x11sE4sTU8sQurhHU3hGCuiLLqrUetlU3Rrj OVzqJTDnk4RapWcCG+vyMGXRR0FIUjRvZ6liDHuoHK4sGTuEH6NxQrrDa6IMh9sCO76F 2d0Ebif7Sbt30G54YnfGvcJGW87panKfGFGEeGT/h/i1DiSRXthEhwdXzoFTZk+CnDws lU7A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1729765704; x=1730370504; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=awe07NOksR1ao1OasiHRde1JNGh5DYeYO6Ef7uq8wQo=; b=rxLdGCdeFOevfp0IbrhhTVj8nTEMtuMKpPcCuDLfMNPjECOMomK/MyngL//gKYO+XY 2Fg+nSMm17a5k2e9dsE1tvi3wK7v4hU7zD0uCaYZEf5ORrE9vavNQj2SFcy39KUsr7u1 vASvJDe9E50l+fAM2NzTjnT9uJyspeNm6Xu3z750R/8PvaJsIR5e6CXkfspT6VEa+RDw SJtYxBJm/knmyNTcdzbwkKOi/3W4R8cG5aZdrUbC7mAgrAwMS7P3UUvYGORkybP5wDh1 12g7kH2pn/g9VrJm80Le/PtS3F05wvOXw2NDniGI95T+MN4kNegDAqlf/wEWluJ6neWH am+A== X-Gm-Message-State: AOJu0YwCVxQg9LcW4slA+c4ED6HHMVg2m3x+YHzK4u7nHc3ceRpYLyJ8 ZXR46Fzv7OfWUYiE7nPPD+//ZL7L2VwZVRHsOwwuat6aU1rKV8sOO6WBnl5VB+689+T4QVJiTCD e2w== X-Google-Smtp-Source: AGHT+IFnwOlVGXvu5vMdnRrj88KCizIA04RU/tOWWBoYvFgXUz86j957W1cQi3V/VPCBA1bIERXcYA== X-Received: by 2002:a17:907:7211:b0:a9a:ca:4436 with SMTP id a640c23a62f3a-a9ad19a8b5amr159060266b.13.1729765704224; Thu, 24 Oct 2024 03:28:24 -0700 (PDT) From: Phil Dennis-Jordan To: qemu-devel@nongnu.org Cc: agraf@csgraf.de, phil@philjordan.eu, peter.maydell@linaro.org, pbonzini@redhat.com, rad@semihalf.com, quic_llindhol@quicinc.com, marcin.juszkiewicz@linaro.org, stefanha@redhat.com, mst@redhat.com, slp@redhat.com, richard.henderson@linaro.org, eduardo@habkost.net, marcel.apfelbaum@gmail.com, gaosong@loongson.cn, jiaxun.yang@flygoat.com, chenhuacai@kernel.org, kwolf@redhat.com, hreitz@redhat.com, philmd@linaro.org, shorne@gmail.com, palmer@dabbelt.com, alistair.francis@wdc.com, bmeng.cn@gmail.com, liwei1518@gmail.com, dbarboza@ventanamicro.com, zhiwei_liu@linux.alibaba.com, jcmvbkbc@gmail.com, marcandre.lureau@redhat.com, berrange@redhat.com, akihiko.odaki@daynix.com, qemu-arm@nongnu.org, qemu-block@nongnu.org, qemu-riscv@nongnu.org Subject: [PATCH v4 01/15] ui & main loop: Redesign of system-specific main thread event handling Date: Thu, 24 Oct 2024 12:27:59 +0200 Message-Id: <20241024102813.9855-2-phil@philjordan.eu> X-Mailer: git-send-email 2.39.3 (Apple Git-145) In-Reply-To: <20241024102813.9855-1-phil@philjordan.eu> References: <20241024102813.9855-1-phil@philjordan.eu> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: neutral client-ip=2a00:1450:4864:20::630; envelope-from=phil@philjordan.eu; helo=mail-ej1-x630.google.com X-Spam_score_int: -10 X-Spam_score: -1.1 X-Spam_bar: - X-Spam_report: (-1.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_NEUTRAL=0.779 autolearn=no autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @philjordan-eu.20230601.gappssmtp.com) X-ZM-MESSAGEID: 1729766092807116600 Content-Type: text/plain; charset="utf-8" macOS's Cocoa event handling must be done on the initial (main) thread of the process. Furthermore, if library or application code uses libdispatch, the main dispatch queue must be handling events on the main thread as well. So far, this has affected Qemu in both the Cocoa and SDL UIs, although in different ways: the Cocoa UI replaces the default qemu_main function with one that spins Qemu's internal main event loop off onto a background thread. SDL (which uses Cocoa internally) on the other hand uses a polling approach within Qemu's main event loop. Events are polled during the SDL UI's dpy_refresh callback, which happens to run on the main thread by default. As UIs are mutually exclusive, this works OK as long as nothing else needs platform-native event handling. In the next patch, a new device is introduced based on the ParavirtualizedGraphics.framework in macOS. This uses libdispatch internally, and only works when events are being handled on the main runloop. With the current system, it works when using either the Cocoa or the SDL UI. However, it does not when running headless. Moreover, any attempt to install a similar scheme to the Cocoa UI's main thread replacement fails when combined with the SDL UI. This change formalises main thread handling. UI (Display) and OS platform implementations can declare requirements or preferences: * The Cocoa UI specifies that Qemu's main loop must run on a background thread and provides a function to run on the main thread which runs the NSApplication event handling runloop. * The SDL UI specifies that Qemu's main loop must run on the main thread. * For other UIs, or in the absence of UIs, the platform's default behaviour is followed. * The Darwin platform provides a default function to run on the main thread, which runs the main CFRunLoop. * Other OSes do not provide their own default main function and thus fall back to running Qemu's main loop on the main thread, as usual. This means that on macOS, the platform's runloop events are always handled, regardless of chosen UI. The new PV graphics device will thus work in all configurations. Signed-off-by: Phil Dennis-Jordan --- include/qemu-main.h | 3 +-- include/qemu/typedefs.h | 1 + include/sysemu/os-posix.h | 2 ++ include/sysemu/os-win32.h | 2 ++ include/ui/console.h | 12 +++++++++ os-posix.c | 20 ++++++++++++++ system/main.c | 45 +++++++++++++++++++++++++++----- system/vl.c | 2 ++ ui/cocoa.m | 55 +++++++++------------------------------ ui/console.c | 32 +++++++++++++++++++++-- ui/sdl2.c | 2 ++ ui/trace-events | 1 + 12 files changed, 123 insertions(+), 54 deletions(-) diff --git a/include/qemu-main.h b/include/qemu-main.h index 940960a7dbc..4bd0d667edc 100644 --- a/include/qemu-main.h +++ b/include/qemu-main.h @@ -5,7 +5,6 @@ #ifndef QEMU_MAIN_H #define QEMU_MAIN_H =20 -int qemu_default_main(void); -extern int (*qemu_main)(void); +extern qemu_main_fn qemu_main; =20 #endif /* QEMU_MAIN_H */ diff --git a/include/qemu/typedefs.h b/include/qemu/typedefs.h index 3d84efcac47..b02cfe1f328 100644 --- a/include/qemu/typedefs.h +++ b/include/qemu/typedefs.h @@ -131,5 +131,6 @@ typedef struct IRQState *qemu_irq; * Function types */ typedef void (*qemu_irq_handler)(void *opaque, int n, int level); +typedef int (*qemu_main_fn)(void); =20 #endif /* QEMU_TYPEDEFS_H */ diff --git a/include/sysemu/os-posix.h b/include/sysemu/os-posix.h index b881ac6c6f7..51bbb5370e0 100644 --- a/include/sysemu/os-posix.h +++ b/include/sysemu/os-posix.h @@ -26,6 +26,7 @@ #ifndef QEMU_OS_POSIX_H #define QEMU_OS_POSIX_H =20 +#include "qemu/typedefs.h" #include #include #include @@ -54,6 +55,7 @@ void os_set_chroot(const char *path); void os_setup_limits(void); void os_setup_post(void); int os_mlock(void); +qemu_main_fn os_non_loop_main_thread_fn(void); =20 /** * qemu_alloc_stack: diff --git a/include/sysemu/os-win32.h b/include/sysemu/os-win32.h index b82a5d3ad93..db0daba9a52 100644 --- a/include/sysemu/os-win32.h +++ b/include/sysemu/os-win32.h @@ -26,6 +26,7 @@ #ifndef QEMU_OS_WIN32_H #define QEMU_OS_WIN32_H =20 +#include "qemu/typedefs.h" #include #include #include @@ -105,6 +106,7 @@ void os_set_line_buffering(void); void os_setup_early_signal_handling(void); =20 int getpagesize(void); +static inline qemu_main_fn os_non_loop_main_thread_fn(void) { return NULL;= } =20 #if !defined(EPROTONOSUPPORT) # define EPROTONOSUPPORT EINVAL diff --git a/include/ui/console.h b/include/ui/console.h index 5832d52a8a6..4e3dc7da146 100644 --- a/include/ui/console.h +++ b/include/ui/console.h @@ -440,6 +440,18 @@ typedef struct QemuDisplay QemuDisplay; =20 struct QemuDisplay { DisplayType type; + /* + * Some UIs have special requirements, for the qemu_main event loop ru= nning + * on either the process's initial (main) thread ('Off'), or on an + * explicitly created background thread ('On') because of platform-spe= cific + * event handling. + * The default, 'Auto', indicates the display will work with both setu= ps. + * If 'On', either a qemu_main_thread_fn must be supplied, or it must = be + * ensured that all applicable host OS platforms supply a default main. + * (via os_non_loop_main_thread_fn()) + */ + OnOffAuto qemu_main_on_bg_thread; + qemu_main_fn qemu_main_thread_fn; void (*early_init)(DisplayOptions *opts); void (*init)(DisplayState *ds, DisplayOptions *opts); const char *vc; diff --git a/os-posix.c b/os-posix.c index 43f9a43f3fe..a173c026f6c 100644 --- a/os-posix.c +++ b/os-posix.c @@ -37,6 +37,8 @@ =20 #ifdef CONFIG_LINUX #include +#elif defined(CONFIG_DARWIN) +#include #endif =20 =20 @@ -342,3 +344,21 @@ int os_mlock(void) return -ENOSYS; #endif } + +#ifdef CONFIG_DARWIN +static int os_darwin_cfrunloop_main(void) +{ + CFRunLoopRun(); + abort(); +} +#endif + +qemu_main_fn os_non_loop_main_thread_fn(void) +{ +#ifdef CONFIG_DARWIN + /* By default, run the OS's event runloop on the main thread. */ + return os_darwin_cfrunloop_main; +#else + return NULL; +#endif +} diff --git a/system/main.c b/system/main.c index 9b91d21ea8c..358eab281b0 100644 --- a/system/main.c +++ b/system/main.c @@ -24,13 +24,10 @@ =20 #include "qemu/osdep.h" #include "qemu-main.h" +#include "qemu/main-loop.h" #include "sysemu/sysemu.h" =20 -#ifdef CONFIG_SDL -#include -#endif - -int qemu_default_main(void) +static int qemu_default_main(void) { int status; =20 @@ -40,10 +37,44 @@ int qemu_default_main(void) return status; } =20 -int (*qemu_main)(void) =3D qemu_default_main; +/* + * Various macOS system libraries, including the Cocoa UI and anything usi= ng + * libdispatch, such as ParavirtualizedGraphics.framework, requires that t= he + * main runloop, on the main (initial) thread be running or at least regul= arly + * polled for events. A special mode is therefore supported, where the QEMU + * main loop runs on a separate thread and the main thread handles the + * CF/Cocoa runloop. + */ + +static void *call_qemu_default_main(void *opaque) +{ + int status; + + bql_lock(); + status =3D qemu_default_main(); + bql_unlock(); + + exit(status); +} + +static void qemu_run_default_main_on_new_thread(void) +{ + QemuThread thread; + + qemu_thread_create(&thread, "qemu_main", call_qemu_default_main, + NULL, QEMU_THREAD_DETACHED); +} + +qemu_main_fn qemu_main; =20 int main(int argc, char **argv) { qemu_init(argc, argv); - return qemu_main(); + if (qemu_main) { + qemu_run_default_main_on_new_thread(); + bql_unlock(); + return qemu_main(); + } else { + qemu_default_main(); + } } diff --git a/system/vl.c b/system/vl.c index e83b3b2608b..c1db20dbee9 100644 --- a/system/vl.c +++ b/system/vl.c @@ -134,6 +134,7 @@ #include "sysemu/iothread.h" #include "qemu/guest-random.h" #include "qemu/keyval.h" +#include "qemu-main.h" =20 #define MAX_VIRTIO_CONSOLES 1 =20 @@ -3667,6 +3668,7 @@ void qemu_init(int argc, char **argv) trace_init_file(); =20 qemu_init_main_loop(&error_fatal); + qemu_main =3D os_non_loop_main_thread_fn(); cpu_timers_init(); =20 user_register_global_props(); diff --git a/ui/cocoa.m b/ui/cocoa.m index 4c2dd335323..393b3800491 100644 --- a/ui/cocoa.m +++ b/ui/cocoa.m @@ -73,6 +73,8 @@ int height; } QEMUScreen; =20 +@class QemuCocoaPasteboardTypeOwner; + static void cocoa_update(DisplayChangeListener *dcl, int x, int y, int w, int h); =20 @@ -107,6 +109,7 @@ static void cocoa_switch(DisplayChangeListener *dcl, static NSInteger cbchangecount =3D -1; static QemuClipboardInfo *cbinfo; static QemuEvent cbevent; +static QemuCocoaPasteboardTypeOwner *cbowner; =20 // Utility functions to run specified code block with the BQL held typedef void (^CodeBlock)(void); @@ -1321,8 +1324,10 @@ - (void) dealloc { COCOA_DEBUG("QemuCocoaAppController: dealloc\n"); =20 - if (cocoaView) - [cocoaView release]; + [cocoaView release]; + [cbowner release]; + cbowner =3D nil; + [super dealloc]; } =20 @@ -1938,8 +1943,6 @@ - (void)pasteboard:(NSPasteboard *)sender provideData= ForType:(NSPasteboardType)t =20 @end =20 -static QemuCocoaPasteboardTypeOwner *cbowner; - static void cocoa_clipboard_notify(Notifier *notifier, void *data); static void cocoa_clipboard_request(QemuClipboardInfo *info, QemuClipboardType type); @@ -2002,43 +2005,8 @@ static void cocoa_clipboard_request(QemuClipboardInf= o *info, } } =20 -/* - * The startup process for the OSX/Cocoa UI is complicated, because - * OSX insists that the UI runs on the initial main thread, and so we - * need to start a second thread which runs the qemu_default_main(): - * in main(): - * in cocoa_display_init(): - * assign cocoa_main to qemu_main - * create application, menus, etc - * in cocoa_main(): - * create qemu-main thread - * enter OSX run loop - */ - -static void *call_qemu_main(void *opaque) -{ - int status; - - COCOA_DEBUG("Second thread: calling qemu_default_main()\n"); - bql_lock(); - status =3D qemu_default_main(); - bql_unlock(); - COCOA_DEBUG("Second thread: qemu_default_main() returned, exiting\n"); - [cbowner release]; - exit(status); -} - static int cocoa_main(void) { - QemuThread thread; - - COCOA_DEBUG("Entered %s()\n", __func__); - - bql_unlock(); - qemu_thread_create(&thread, "qemu_main", call_qemu_main, - NULL, QEMU_THREAD_DETACHED); - - // Start the main event loop COCOA_DEBUG("Main thread: entering OSX run loop\n"); [NSApp run]; COCOA_DEBUG("Main thread: left OSX run loop, which should never happen= \n"); @@ -2120,8 +2088,6 @@ static void cocoa_display_init(DisplayState *ds, Disp= layOptions *opts) =20 COCOA_DEBUG("qemu_cocoa: cocoa_display_init\n"); =20 - qemu_main =3D cocoa_main; - // Pull this console process up to being a fully-fledged graphical // app with a menubar and Dock icon ProcessSerialNumber psn =3D { 0, kCurrentProcess }; @@ -2188,8 +2154,11 @@ static void cocoa_display_init(DisplayState *ds, Dis= playOptions *opts) } =20 static QemuDisplay qemu_display_cocoa =3D { - .type =3D DISPLAY_TYPE_COCOA, - .init =3D cocoa_display_init, + .type =3D DISPLAY_TYPE_COCOA, + .init =3D cocoa_display_init, + /* The Cocoa UI will run the NSApplication runloop on the main thread.= */ + .qemu_main_on_bg_thread =3D ON_OFF_AUTO_ON, + .qemu_main_thread_fn =3D cocoa_main, }; =20 static void register_cocoa(void) diff --git a/ui/console.c b/ui/console.c index 5165f171257..1599d8b7095 100644 --- a/ui/console.c +++ b/ui/console.c @@ -33,6 +33,7 @@ #include "qemu/main-loop.h" #include "qemu/module.h" #include "qemu/option.h" +#include "qemu-main.h" #include "chardev/char.h" #include "trace.h" #include "exec/memory.h" @@ -1569,12 +1570,39 @@ void qemu_display_early_init(DisplayOptions *opts) =20 void qemu_display_init(DisplayState *ds, DisplayOptions *opts) { + QemuDisplay *display; + bool bg_main_loop; + assert(opts->type < DISPLAY_TYPE__MAX); if (opts->type =3D=3D DISPLAY_TYPE_NONE) { return; } - assert(dpys[opts->type] !=3D NULL); - dpys[opts->type]->init(ds, opts); + display =3D dpys[opts->type]; + assert(display !=3D NULL); + display->init(ds, opts); + + switch (display->qemu_main_on_bg_thread) { + case ON_OFF_AUTO_OFF: + bg_main_loop =3D false; + qemu_main =3D NULL; + break; + case ON_OFF_AUTO_ON: + bg_main_loop =3D true; + break; + case ON_OFF_AUTO_AUTO: + default: + bg_main_loop =3D qemu_main; + break; + } + + trace_qemu_display_init_main_thread( + DisplayType_str(display->type), display->qemu_main_thread_fn, qemu= _main, + OnOffAuto_lookup.array[display->qemu_main_on_bg_thread], + display->qemu_main_on_bg_thread, bg_main_loop); + if (bg_main_loop && display->qemu_main_thread_fn) { + qemu_main =3D display->qemu_main_thread_fn; + } + assert(!bg_main_loop || qemu_main); } =20 const char *qemu_display_get_vc(DisplayOptions *opts) diff --git a/ui/sdl2.c b/ui/sdl2.c index bd4f5a9da14..35e22785119 100644 --- a/ui/sdl2.c +++ b/ui/sdl2.c @@ -971,6 +971,8 @@ static QemuDisplay qemu_display_sdl2 =3D { .type =3D DISPLAY_TYPE_SDL, .early_init =3D sdl2_display_early_init, .init =3D sdl2_display_init, + /* SDL must poll for events (via dpy_refresh) on main thread */ + .qemu_main_on_bg_thread =3D ON_OFF_AUTO_OFF, }; =20 static void register_sdl1(void) diff --git a/ui/trace-events b/ui/trace-events index 3da0d5e2800..1e72c967399 100644 --- a/ui/trace-events +++ b/ui/trace-events @@ -16,6 +16,7 @@ displaysurface_free(void *display_surface) "surface=3D%p" displaychangelistener_register(void *dcl, const char *name) "%p [ %s ]" displaychangelistener_unregister(void *dcl, const char *name) "%p [ %s ]" ppm_save(int fd, void *image) "fd=3D%d image=3D%p" +qemu_display_init_main_thread(const char *display_name, bool qemu_display_= sets_main_fn, bool qemu_main_is_set, const char *display_bg_main_loop_prefe= rence, int preference, bool bg_main_loop) "display '%s': sets main thread f= unction: %d, platform provides main function: %d, display background main l= oop preference: %s (%d); main loop will run on background thread: %d" =20 # gtk-egl.c # gtk-gl-area.c --=20 2.39.3 (Apple Git-145)