coroutine: Clean up includes
Subsystems (3)
cover coroutine: Clean up includes
Markus Armbruster (4):
coroutine: Clean up superfluous inclusion of qemu/coroutine.h
coroutine: Move coroutine_fn to qemu/osdep.h, trim includes
coroutine: Clean up superfluous inclusion of qemu/lockable.h
coroutine: Break inclusion loop
crypto/block-luks-priv.h | 1 - include/block/aio_task.h | 2 -- include/block/block-common.h | 1 - include/block/raw-aio.h | 1 - include/monitor/hmp.h | 1 - include/qemu/coroutine.h | 21 ++++++++------------- include/qemu/lockable.h | 1 - include/qemu/osdep.h | 16 ++++++++++++++++ include/qemu/progress_meter.h | 2 +- include/qemu/ratelimit.h | 2 +- include/qemu/seqlock.h | 2 +- include/scsi/pr-manager.h | 1 - linux-user/fd-trans.h | 2 +- nbd/nbd-internal.h | 1 - backends/tpm/tpm_emulator.c | 2 +- block/progress_meter.c | 2 ++ blockjob.c | 1 - cpus-common.c | 2 +- crypto/block-luks.c | 1 - hw/9pfs/codir.c | 1 - hw/9pfs/cofile.c | 1 - hw/9pfs/cofs.c | 1 - hw/9pfs/coxattr.c | 1 - hw/hyperv/hyperv.c | 2 +- hw/usb/ccid-card-emulated.c | 2 +- hw/vfio/platform.c | 2 +- plugins/core.c | 2 +- plugins/loader.c | 2 +- tests/unit/test-coroutine.c | 2 -- tests/unit/test-vmstate.c | 1 - ui/spice-display.c | 2 +- util/log.c | 2 +- util/qemu-coroutine-lock.c | 1 - util/qemu-coroutine-sleep.c | 1 - util/qemu-coroutine.c | 1 - util/qemu-timer.c | 2 +- util/rcu.c | 2 +- util/vfio-helpers.c | 2 +- util/yank.c | 2 +- 39 files changed, 43 insertions(+), 51 deletions(-)
Signature · 1 line
2.37.3
PATCH 1/4 coroutine: Clean up superfluous inclusion of qemu/coroutine.h
--- crypto/block-luks-priv.h | 1 - include/block/raw-aio.h | 1 - include/scsi/pr-manager.h | 1 - nbd/nbd-internal.h | 1 - blockjob.c | 1 - crypto/block-luks.c | 1 - hw/9pfs/codir.c | 1 - hw/9pfs/cofile.c | 1 - hw/9pfs/cofs.c | 1 - hw/9pfs/coxattr.c | 1 - tests/unit/test-coroutine.c | 1 - tests/unit/test-vmstate.c | 1 - util/qemu-coroutine-lock.c | 1 - util/qemu-coroutine-sleep.c | 1 - util/qemu-coroutine.c | 1 - 15 files changed, 15 deletions(-)
crypto/block-luks-priv.h +0 -1
@@ -31,7 +31,6 @@#include "crypto/random.h" #include "qemu/uuid.h" -#include "qemu/coroutine.h" #include "qemu/bitmap.h" /*
include/block/raw-aio.h +0 -1
@@ -17,7 +17,6 @@#define QEMU_RAW_AIO_H #include "block/aio.h" -#include "qemu/coroutine.h" #include "qemu/iov.h" /* AIO request types */
include/scsi/pr-manager.h +0 -1
@@ -5,7 +5,6 @@#include "qapi/visitor.h" #include "qom/object_interfaces.h" #include "block/aio.h" -#include "qemu/coroutine.h" #define TYPE_PR_MANAGER "pr-manager"
nbd/nbd-internal.h +0 -1
@@ -13,7 +13,6 @@#include "sysemu/block-backend.h" #include "io/channel-tls.h" -#include "qemu/coroutine.h" #include "qemu/iov.h" #ifndef _WIN32
blockjob.c +0 -1
@@ -32,7 +32,6 @@#include "qapi/error.h" #include "qapi/qapi-events-block-core.h" #include "qapi/qmp/qerror.h" -#include "qemu/coroutine.h" #include "qemu/main-loop.h" #include "qemu/timer.h"
crypto/block-luks.c +0 -1
@@ -32,7 +32,6 @@#include "crypto/random.h" #include "qemu/uuid.h" -#include "qemu/coroutine.h" #include "qemu/bitmap.h" /*
hw/9pfs/codir.c +0 -1
@@ -19,7 +19,6 @@#include "qemu/osdep.h" #include "fsdev/qemu-fsdev.h" #include "qemu/thread.h" -#include "qemu/coroutine.h" #include "qemu/main-loop.h" #include "coth.h" #include "9p-xattr.h"
hw/9pfs/cofile.c +0 -1
@@ -19,7 +19,6 @@#include "qemu/osdep.h" #include "fsdev/qemu-fsdev.h" #include "qemu/thread.h" -#include "qemu/coroutine.h" #include "qemu/main-loop.h" #include "coth.h"
hw/9pfs/cofs.c +0 -1
@@ -19,7 +19,6 @@#include "qemu/osdep.h" #include "fsdev/qemu-fsdev.h" #include "qemu/thread.h" -#include "qemu/coroutine.h" #include "qemu/main-loop.h" #include "coth.h"
hw/9pfs/coxattr.c +0 -1
@@ -19,7 +19,6 @@#include "qemu/osdep.h" #include "fsdev/qemu-fsdev.h" #include "qemu/thread.h" -#include "qemu/coroutine.h" #include "qemu/main-loop.h" #include "coth.h"
tests/unit/test-coroutine.c +0 -1
@@ -12,7 +12,6 @@*/ #include "qemu/osdep.h" -#include "qemu/coroutine.h" #include "qemu/coroutine_int.h" #include "qemu/lockable.h"
tests/unit/test-vmstate.c +0 -1
@@ -29,7 +29,6 @@#include "migration/qemu-file-types.h" #include "../migration/qemu-file.h" #include "../migration/savevm.h" -#include "qemu/coroutine.h" #include "qemu/module.h" #include "io/channel-file.h"
util/qemu-coroutine-lock.c +0 -1
@@ -27,7 +27,6 @@*/ #include "qemu/osdep.h" -#include "qemu/coroutine.h" #include "qemu/coroutine_int.h" #include "qemu/processor.h" #include "qemu/queue.h"
util/qemu-coroutine-sleep.c +0 -1
@@ -12,7 +12,6 @@*/ #include "qemu/osdep.h" -#include "qemu/coroutine.h" #include "qemu/coroutine_int.h" #include "qemu/timer.h" #include "block/aio.h"
util/qemu-coroutine.c +0 -1
@@ -16,7 +16,6 @@#include "trace.h" #include "qemu/thread.h" #include "qemu/atomic.h" -#include "qemu/coroutine.h" #include "qemu/coroutine_int.h" #include "qemu/coroutine-tls.h" #include "block/aio.h"
Signature · 1 line
2.37.3
Re: [PATCH 1/4] coroutine: Clean up superfluous inclusion of qemu/coroutine.h
Probably because block layer, aio.h, and coroutine_int.h header files already include "qemu/coroutine.h"?
Re: [PATCH 1/4] coroutine: Clean up superfluous inclusion of qemu/coroutine.h
Quoted 2 lines · Stefan Hajnoczi
Probably because block layer,
aio.h, andcoroutine_int.hheader files already include "qemu/coroutine.h"?
Mostly, but not always. For instance, crypto/block-luks-priv.h compiles fine without it, and doesn't include it after this patch.
Quoted 1 line
Reviewed-by Stefan Hajnoczi <[email protected]>
Thanks!
PATCH 2/4 coroutine: Move coroutine_fn to qemu/osdep.h, trim includes
In reply to Markus Armbrusterblock/block-hmp-cmds.h and qemu/co-shared-resource.h use coroutine_fn without including qemu/coroutine.h. They compile only if it's already included from elsewhere.
I could fix that, but pulling in qemu/coroutine.h and everything it includes just for a macro that expands into nothing feels silly. Instead, move the macro to qemu/osdep.h.
Inclusions of qemu/coroutine.h just for coroutine_fn become superfluous. Drop them.
--- include/block/aio_task.h | 2 -- include/block/block-common.h | 1 - include/monitor/hmp.h | 1 - include/qemu/coroutine.h | 18 +++++++----------- include/qemu/osdep.h | 16 ++++++++++++++++ 5 files changed, 23 insertions(+), 15 deletions(-)
include/block/aio_task.h +0 -2
@@ -25,8 +25,6 @@#ifndef BLOCK_AIO_TASK_H #define BLOCK_AIO_TASK_H -#include "qemu/coroutine.h" -typedef struct AioTaskPool AioTaskPool ;typedef struct AioTask AioTask ; typedef int coroutine_fn (*AioTaskFunc)(AioTask *task);
include/block/block-common.h +0 -1
@@ -27,7 +27,6 @@#include "block/aio.h" #include "block/aio-wait.h" #include "qemu/iov.h" -#include "qemu/coroutine.h" #include "block/accounting.h" #include "block/dirty-bitmap.h" #include "block/blockjob.h"
include/monitor/hmp.h +0 -1
@@ -15,7 +15,6 @@#define HMP_H #include "qemu/readline.h" -#include "qemu/coroutine.h" #include "qapi/qapi-types-common.h" bool hmp_handle_error (Monitor *mon,Error *err);
include/qemu/coroutine.h +7 -11
@@ -26,23 +26,19 @@* waiting for events to complete. * * These functions are re-entrant and may be used outside the global mutex. -*/ - -/** -* Mark a function that executes in coroutine context * -* Functions that execute in coroutine context cannot be called directly from -* normal functions. In the future it would be nice to enable compiler or -* static checker support for catching such errors. This annotation might make -* it possible and in the meantime it serves as documentation. -* -* For example: +* Functions that execute in coroutine context cannot be called +* directly from normal functions. Use @coroutine_fn to mark such +* functions. For example: * * static void coroutine_fn foo(void) { * .... * } +* +* In the future it would be nice to have the compiler or a static +* checker catch misuse of such functions. This annotation might make +* it possible and in the meantime it serves as documentation. */ -#define coroutine_fntypedef struct Coroutine Coroutine ;
include/qemu/osdep.h +16 -0
@@ -157,6 +157,22 @@ extern "C" {#include "qemu/typedefs.h" +/** +* Mark a function that executes in coroutine context +* +* Functions that execute in coroutine context cannot be called directly from +* normal functions. In the future it would be nice to enable compiler or +* static checker support for catching such errors. This annotation might make +* it possible and in the meantime it serves as documentation. +* +* For example: +* +* static void coroutine_fn foo(void) { +* .... +* } +*/ +#define coroutine_fn +/* * For mingw, as of v6.0.0, the function implementing the assert macro is * not marked as noreturn, so the compiler cannot delete code following an
Signature · 1 line
2.37.3
Re: [PATCH 2/4] coroutine: Move coroutine_fn to qemu/osdep.h, trim includes
Quoted 12 lines · Markus Armbruster
block/block-hmp-cmds.handqemu/co-shared-resource.husecoroutine_fnwithout includingqemu/coroutine.h. They compile only if it's already included from elsewhere.I could fix that, but pulling in
qemu/coroutine.hand everything it includes just for a macro that expands into nothing feels silly. Instead, move the macro toqemu/osdep.h.Inclusions of
qemu/coroutine.hjust forcoroutine_fnbecome superfluous. Drop them.
Quoted 8 lines
Signed-off-by Markus Armbruster <[email protected]>--- include/block/aio_task.h | 2 -- include/block/block-common.h | 1 - include/monitor/hmp.h | 1 - include/qemu/coroutine.h | 18 +++++++----------- include/qemu/osdep.h | 16 ++++++++++++++++ 5 files changed, 23 insertions(+), 15 deletions(-)
PATCH 3/4 coroutine: Clean up superfluous inclusion of qemu/lockable.h
In reply to Markus Armbruster--- include/qemu/progress_meter.h | 2 +- block/progress_meter.c | 2 ++ tests/unit/test-coroutine.c | 1 - 3 files changed, 3 insertions(+), 2 deletions(-)
include/qemu/progress_meter.h +1 -1
@@ -27,7 +27,7 @@ #ifndef QEMU_PROGRESS_METER_H #define QEMU_PROGRESS_METER_H -#include "qemu/lockable.h" +#include "qemu/thread.h" typedef struct ProgressMeter { /**
block/progress_meter.c +2 -0
@@ -23,7 +23,9 @@* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE. */ +#include "qemu/osdep.h" +#include "qemu/coroutine.h" #include "qemu/progress_meter.h" void progress_init (ProgressMeter *pm)
tests/unit/test-coroutine.c +0 -1
@@ -13,7 +13,6 @@#include "qemu/osdep.h" #include "qemu/coroutine_int.h" -#include "qemu/lockable.h" /* * Check that qemu_in_coroutine() works
Signature · 1 line
2.37.3
Re: [PATCH 3/4] coroutine: Clean up superfluous inclusion of qemu/lockable.h
PATCH 4/4 coroutine: Break inclusion loop
In reply to Markus Armbrusterqemu/coroutine.h and qemu/lockable.h include each other. Neither header actually needs the other one.
Drop #include "qemu/coroutine.h" from qemu/lockable.h to break the loop. All users of lockable.h actually need qemu/coroutine.h, so adjust their #include directives.
I'm not dropping the #include "qemu/lockable" from qemu/coroutine.h, because that would require adding it back next to #include "qemu/coroutine.h" all over the place. It's in an unusual place, though. Move it to the usual place, next to the other #include directives.
--- include/qemu/coroutine.h | 3 +-- include/qemu/lockable.h | 1 - include/qemu/ratelimit.h | 2 +- include/qemu/seqlock.h | 2 +- linux-user/fd-trans.h | 2 +- backends/tpm/tpm_emulator.c | 2 +- cpus-common.c | 2 +- hw/hyperv/hyperv.c | 2 +- hw/usb/ccid-card-emulated.c | 2 +- hw/vfio/platform.c | 2 +- plugins/core.c | 2 +- plugins/loader.c | 2 +- ui/spice-display.c | 2 +- util/log.c | 2 +- util/qemu-timer.c | 2 +- util/rcu.c | 2 +- util/vfio-helpers.c | 2 +- util/yank.c | 2 +- 18 files changed, 17 insertions(+), 19 deletions(-)
include/qemu/coroutine.h +1 -2
@@ -15,6 +15,7 @@#ifndef QEMU_COROUTINE_H #define QEMU_COROUTINE_H +#include "qemu/lockable.h" #include "qemu/queue.h" #include "qemu/timer.h"
@@ -376,8 +377,6 @@ void qemu_coroutine_inc_pool_size(unsigned int additional_pool_size);*/ void qemu_coroutine_dec_pool_size (unsigned int additional_pool_size); -#include "qemu/lockable.h" -/** * Sends a (part of) iovec down a socket, yielding when the socket is full, or * Receives data into a (part of) iovec from a socket,
include/qemu/lockable.h +0 -1
@@ -13,7 +13,6 @@#ifndef QEMU_LOCKABLE_H #define QEMU_LOCKABLE_H -#include "qemu/coroutine.h" #include "qemu/thread.h" typedef void QemuLockUnlockFunc (void *);
include/qemu/ratelimit.h +1 -1
@@ -14,7 +14,7 @@ #ifndef QEMU_RATELIMIT_H #define QEMU_RATELIMIT_H -#include "qemu/lockable.h" +#include "qemu/coroutine.h" #include "qemu/timer.h" typedef struct {
include/qemu/seqlock.h +1 -1
@@ -16,7 +16,7 @@#include "qemu/atomic.h" #include "qemu/thread.h" -#include "qemu/lockable.h" +#include "qemu/coroutine.h" typedef struct QemuSeqLock QemuSeqLock ;
linux-user/fd-trans.h +1 -1
@@ -16,7 +16,7 @@#ifndef FD_TRANS_H #define FD_TRANS_H -#include "qemu/lockable.h" +#include "qemu/coroutine.h" typedef abi_long (*TargetFdDataFunc )(void *,size_t );typedef abi_long (*TargetFdAddrFunc )(void *,abi_ulong ,socklen_t );
backends/tpm/tpm_emulator.c +1 -1
@@ -30,7 +30,7 @@#include "qemu/error-report.h" #include "qemu/module.h" #include "qemu/sockets.h" -#include "qemu/lockable.h" +#include "qemu/coroutine.h" #include "io/channel-socket.h" #include "sysemu/runstate.h" #include "sysemu/tpm_backend.h"
cpus-common.c +1 -1
@@ -22,7 +22,7 @@#include "exec/cpu-common.h" #include "hw/core/cpu.h" #include "sysemu/cpus.h" -#include "qemu/lockable.h" +#include "qemu/coroutine.h" static QemuMutex qemu_cpu_list_lock;static QemuCond exclusive_cond;
hw/hyperv/hyperv.c +1 -1
@@ -15,7 +15,7 @@#include "sysemu/kvm.h" #include "qemu/bitops.h" #include "qemu/error-report.h" -#include "qemu/lockable.h" +#include "qemu/coroutine.h" #include "qemu/queue.h" #include "qemu/rcu.h" #include "qemu/rcu_queue.h"
hw/usb/ccid-card-emulated.c +1 -1
@@ -30,7 +30,7 @@#include <libcacard.h> #include "qemu/thread.h" -#include "qemu/lockable.h" +#include "qemu/coroutine.h" #include "qemu/main-loop.h" #include "qemu/module.h" #include "ccid.h"
hw/vfio/platform.c +1 -1
@@ -22,7 +22,7 @@#include "hw/vfio/vfio-platform.h" #include "migration/vmstate.h" #include "qemu/error-report.h" -#include "qemu/lockable.h" +#include "qemu/coroutine.h" #include "qemu/main-loop.h" #include "qemu/module.h" #include "qemu/range.h"
plugins/core.c +1 -1
@@ -15,7 +15,7 @@#include "qemu/error-report.h" #include "qemu/config-file.h" #include "qapi/error.h" -#include "qemu/lockable.h" +#include "qemu/coroutine.h" #include "qemu/option.h" #include "qemu/rcu_queue.h" #include "qemu/xxhash.h"
plugins/loader.c +1 -1
@@ -19,7 +19,7 @@#include "qemu/error-report.h" #include "qemu/config-file.h" #include "qapi/error.h" -#include "qemu/lockable.h" +#include "qemu/coroutine.h" #include "qemu/option.h" #include "qemu/rcu_queue.h" #include "qemu/qht.h"
ui/spice-display.c +1 -1
@@ -18,7 +18,7 @@#include "qemu/osdep.h" #include "ui/qemu-spice.h" #include "qemu/timer.h" -#include "qemu/lockable.h" +#include "qemu/coroutine.h" #include "qemu/main-loop.h" #include "qemu/option.h" #include "qemu/queue.h"
util/log.c +1 -1
@@ -25,7 +25,7 @@#include "qemu/cutils.h" #include "trace/control.h" #include "qemu/thread.h" -#include "qemu/lockable.h" +#include "qemu/coroutine.h" #include "qemu/rcu.h" #ifdef CONFIG_LINUX #include <sys/syscall.h>
util/qemu-timer.c +1 -1
@@ -25,7 +25,7 @@#include "qemu/osdep.h" #include "qemu/main-loop.h" #include "qemu/timer.h" -#include "qemu/lockable.h" +#include "qemu/coroutine.h" #include "sysemu/cpu-timers.h" #include "sysemu/replay.h" #include "sysemu/cpus.h"
util/rcu.c +1 -1
@@ -31,7 +31,7 @@#include "qemu/atomic.h" #include "qemu/thread.h" #include "qemu/main-loop.h" -#include "qemu/lockable.h" +#include "qemu/coroutine.h" #if defined(CONFIG_MALLOC_TRIM )#include <malloc.h> #endif
util/vfio-helpers.c +1 -1
@@ -22,7 +22,7 @@#include "standard-headers/linux/pci_regs.h" #include "qemu/event_notifier.h" #include "qemu/vfio-helpers.h" -#include "qemu/lockable.h" +#include "qemu/coroutine.h" #include "trace.h" #define QEMU_VFIO_DEBUG 0
util/yank.c +1 -1
@@ -11,7 +11,7 @@#include "qapi/error.h" #include "qemu/thread.h" #include "qemu/queue.h" -#include "qemu/lockable.h" +#include "qemu/coroutine.h" #include "qapi/qapi-commands-yank.h" #include "qapi/qapi-visit-yank.h" #include "qapi/clone-visitor.h"
Signature · 1 line
2.37.3
Re: [PATCH 4/4] coroutine: Break inclusion loop
A message that is not in the archive (sent off-list or not yet received): [email protected]
Re: [PATCH 4/4] coroutine: Break inclusion loop
dropped qemu-devel by mistake.
Paolo
Il lun 12 dic 2022, 23:16 Paolo Bonzini <[email protected]> ha scritto:
Quoted 62 lines · Markus Armbruster
Quoted 2 lines
qemu/coroutine.handqemu/lockable.hinclude each other. Neither header actually needs the other one.
qemu/lockable.hwantsqemu/coroutine.hbecause of the reference to qemu_co_mutex_lock/unlock in theQEMU_MAKE_LOCKABLEmacro. Said reference only happens when the macro is used, so strictly speaking only code that uses of qemu/lockable.h's functionality needs to includeqemu/coroutine.h. The order doesn't matter.
qemu/coroutine.hsimilarly wantsqemu/lockable.honly for a macro: it uses QemuLockable for the prototype ofqemu_co_queue_wait_impl, but QemuLockable is defined inqemu/typedefs.h. On the other hand, theqemu_co_queue_waitmacro needsQEMU_MAKE_LOCKABLE. Again, the order does not matter but callers ofqemu_co_queue_waitappreciate it if both files are included.So, this is why the inclusion loop works. This patch makes some files include
qemu/coroutine.heven if they only needqemu/lockable.hforQEMU_LOCK_GUARDof a "regular" QemuMutex; for example, linux-user/ does not use coroutines, so I'd like to avoid that it includesqemu/coroutine.h.One way is to just keep the cycle. Another is to break the cycle is as follows:
1)
qemu/coroutine.hkeeps includingqemu/lockable.h2)
qemu/lockable.his modified as follows to omit the reference to CoMutex:include/qemu/lockable.h +3
-1@@ -71,9 +71,11 @@ qemu_null_lockable(void *x) void *: qemu_null_lockable(x), \ QemuMutex *: qemu_make_lockable(x, QML_OBJ_(x, mutex)), \ QemuRecMutex *: qemu_make_lockable(x, QML_OBJ_(x,rec_mutex )), \ - CoMutex *: qemu_make_lockable(x, QML_OBJ_(x, co_mutex)), \ + QEMU_MAKE_CO_MUTEX_LOCKABLE(x) \ QemuSpin *: qemu_make_lockable(x, QML_OBJ_(x, spin))) +#define QEMU_MAKE_CO_MUTEX_LOCKABLE(x) +/** * QEMU_MAKE_LOCKABLE_NONNULL - Make a polymorphic QemuLockable *3) the following hack is added in
qemu/coroutine.h, right after includingqemu/lockable.h:#undef
QEMU_MAKE_CO_MUTEX_LOCKABLE(x)
#defineQEMU_MAKE_CO_MUTEX_LOCKABLE(x)\
CoMutex *:qemu_make_lockable(x, QML_OBJ_(x, co_mutex)),Neither is particularly pretty, so I vote for leaving things as is with a comment above the two #include directives.
Paolo
Re: [PATCH 4/4] coroutine: Break inclusion loop
Quoted 29 lines · Paolo Bonzini
dropped qemu-devel by mistake.
Paolo
Il lun 12 dic 2022, 23:16 Paolo Bonzini <[email protected]> ha scritto:
Quoted 22 lines · Markus Armbruster
Quoted 2 lines
qemu/coroutine.handqemu/lockable.hinclude each other. Neither header actually needs the other one.
qemu/lockable.hwantsqemu/coroutine.hbecause of the reference to qemu_co_mutex_lock/unlock in theQEMU_MAKE_LOCKABLEmacro. Said reference only happens when the macro is used, so strictly speaking only code that uses of qemu/lockable.h's functionality needs to includeqemu/coroutine.h. The order doesn't matter.
qemu/coroutine.hsimilarly wantsqemu/lockable.honly for a macro: it uses QemuLockable for the prototype ofqemu_co_queue_wait_impl, but QemuLockable is defined inqemu/typedefs.h. On the other hand, theqemu_co_queue_waitmacro needsQEMU_MAKE_LOCKABLE. Again, the order does not matter but callers ofqemu_co_queue_waitappreciate it if both files are included.So, this is why the inclusion loop works. This patch makes some files include
qemu/coroutine.heven if they only needqemu/lockable.hforQEMU_LOCK_GUARDof a "regular" QemuMutex; for example, linux-user/ does not use coroutines, so I'd like to avoid that it includesqemu/coroutine.h.
They include it even before the patch, via lockable.h.
My patch actually enables *not* including coroutine.h: with it applied, including lockable.h no longer gets you coroutine.h as well.
If you include lockable.h and make use of certain macros, the compile fails, and you fix it by including coroutine.h instead like pretty much everything else. Is this really too objectionable to be committed?
Quoted 4 lines
Quoted 4 lines
One way is to just keep the cycle. Another is to break the cycle is as follows:
1)
qemu/coroutine.hkeeps includingqemu/lockable.h
As in my patch.
Quoted 21 lines
Quoted 21 lines
2)
qemu/lockable.his modified as follows to omit the reference to CoMutex:include/qemu/lockable.h +3
-1@@ -71,9 +71,11 @@ qemu_null_lockable(void *x) void *: qemu_null_lockable(x), \ QemuMutex *: qemu_make_lockable(x, QML_OBJ_(x, mutex)), \ QemuRecMutex *: qemu_make_lockable(x, QML_OBJ_(x,rec_mutex )), \ - CoMutex *: qemu_make_lockable(x, QML_OBJ_(x, co_mutex)), \ + QEMU_MAKE_CO_MUTEX_LOCKABLE(x) \ QemuSpin *: qemu_make_lockable(x, QML_OBJ_(x, spin))) +#define QEMU_MAKE_CO_MUTEX_LOCKABLE(x) +/** * QEMU_MAKE_LOCKABLE_NONNULL - Make a polymorphic QemuLockable *
Quoted 6 lines
Quoted 6 lines
3) the following hack is added in
qemu/coroutine.h, right after includingqemu/lockable.h:#undef
QEMU_MAKE_CO_MUTEX_LOCKABLE(x)
#defineQEMU_MAKE_CO_MUTEX_LOCKABLE(x)\
CoMutex *:qemu_make_lockable(x, QML_OBJ_(x, co_mutex)),
Let me see... if I include just lockable.h and make use of certain (generic) macro(s), the macro(s) won't have a case for QemuMutex *. Using them with a QemuMutex * argument won't compile.
Quoted 2 lines
Quoted 2 lines
Neither is particularly pretty, so I vote for leaving things as is with a comment above the two #include directives.
Inlusion loops are landmines. Evidence: the compilation failure Phil ran in, leading to his
Subject: [PATCH-for-8.0] coroutine: Add missing <qemu/atomic.h> include
Message-Id: <[email protected]>
Your macro hack I find too off-putting :)
Quoted 11 lines
Quoted 11 lines
Quoted 11 lines
Drop #include "
qemu/coroutine.h" fromqemu/lockable.hto break the loop. All users oflockable.hactually needqemu/coroutine.h, so adjust their #include directives.I'm not dropping the #include "
qemu/lockable.h" fromqemu/coroutine.h, because that would require adding it back next to #include "qemu/coroutine.h" all over the place. It's in an unusual place, though. Move it to the usual place, next to the other #include directives.Signed-off-by Markus Armbruster <[email protected]>
Re: [PATCH 4/4] coroutine: Break inclusion loop
Quoted 4 lines · Markus Armbruster
Quoted 2 lines
linux-user/ does not use coroutines, so I'd like to avoid that it includes
qemu/coroutine.h.They include it even before the patch, via
lockable.h.
They do but there's a difference between "including lockable.h and implictly getting coroutine.h due to dependencies" and "including coroutine.h when you really wanted QEMU_LOCK_GUARD()".
Quoted 6 lines
My patch actually enables*not* including
coroutine.h: with it applied, includinglockable.hno longer gets youcoroutine.has well.If you include
lockable.hand make use of certain macros, the compile fails, and you fix it by includingcoroutine.hinstead like pretty much everything else. Is this really too objectionable to be committed?
s/certain macros/all macros/. All you can do is qemu_lockable_lock/unlock, which is the less common usage of qemu/lockable.h:
- qemu_lockable_lock/unlock: used in include/qemu/seqlock.h, tests/unit/test-coroutine.c, util/qemu-coroutine-lock.c
- QEMU_LOCK_GUARD and WITH_QEMU_LOCK_GUARD are used in 49 files.
Quoted 3 lines
Quoted 1 line
Quoted 1 line
1)
qemu/coroutine.hkeeps includingqemu/lockable.hAs in my patch.
That's where the similarity ends. :)
Quoted 24 lines
Quoted 24 lines
Quoted 24 lines
2)
qemu/lockable.his modified as follows to omit the reference to CoMutex:include/qemu/lockable.h +3
-1@@ -71,9 +71,11 @@ qemu_null_lockable(void *x) void *: qemu_null_lockable(x), \ QemuMutex *: qemu_make_lockable(x, QML_OBJ_(x, mutex)), \ QemuRecMutex *: qemu_make_lockable(x, QML_OBJ_(x,rec_mutex )), \ - CoMutex *: qemu_make_lockable(x, QML_OBJ_(x, co_mutex)), \ + QEMU_MAKE_CO_MUTEX_LOCKABLE(x) \ QemuSpin *: qemu_make_lockable(x, QML_OBJ_(x, spin))) +#define QEMU_MAKE_CO_MUTEX_LOCKABLE(x) +/** * QEMU_MAKE_LOCKABLE_NONNULL - Make a polymorphic QemuLockable *3) the following hack is added in
qemu/coroutine.h, right after includingqemu/lockable.h:
Quoted 7 lines
Quoted 3 lines
Quoted 3 lines
#undef
QEMU_MAKE_CO_MUTEX_LOCKABLE(x)
#defineQEMU_MAKE_CO_MUTEX_LOCKABLE(x)\
CoMutex *:qemu_make_lockable(x, QML_OBJ_(x, co_mutex)),Let me see... if I include just
lockable.hand make use of certain (generic) macro(s), the macro(s) won't have a case for QemuMutex *. Using them with a QemuMutex * argument won't compile.
s/QemuMutex/CoMutex/. That is, you get the CoMutex case only if you include qemu/coroutine.h. Which you probably did anyway, because CoMutexes are almost always embedded (not used as pointers). In fact I suspect the above trick also makes it possible to remove CoMutex from qemu/typedefs.h.
Furthermore, using qemu_lockable_lock/unlock with CoMutexes still works, even if you don't include qemu/coroutine.h, just like in your patch.
Quoted 9 lines
Quoted 2 lines
Quoted 2 lines
Neither is particularly pretty, so I vote for leaving things as is with a comment above the two #include directives.
Inlusion loops are landmines. Evidence: the compilation failure Phil ran in, leading to his
Subject: [PATCH-for-8.0] coroutine: Add missing <
qemu/atomic.h> include Message-Id:<[email protected]>Your macro hack I find too off-putting 😄
I think the macro is much better than nerfing qemu/lockable.h.
Another alternative is to add a new header qemu/lockable-protos.h and move qemu_co_mutex_{lock,unlock} there (possibly other prototypes as well). Then include it from both qemu/lockable.h and qemu/coroutine.h.
Paolo
Re: [PATCH 4/4] coroutine: Break inclusion loop
Quoted 68 lines · Paolo Bonzini
Quoted 3 lines · Markus Armbruster
Quoted 2 lines
linux-user/ does not use coroutines, so I'd like to avoid that it includes
qemu/coroutine.h.They include it even before the patch, via
lockable.h.They do but there's a difference between "including
lockable.hand implictly gettingcoroutine.hdue to dependencies" and "includingcoroutine.hwhen you really wantedQEMU_LOCK_GUARD()".Quoted 5 lines
My patch actually enables*not* including
coroutine.h: with it applied, includinglockable.hno longer gets youcoroutine.has well. If you includelockable.hand make use of certain macros, the compile fails, and you fix it by includingcoroutine.hinstead like pretty much everything else. Is this really too objectionable to be committed?s/certain macros/all macros/. All you can do is qemu_lockable_lock/unlock, which is the less common usage of
qemu/lockable.h:- qemu_lockable_lock/unlock: used in
include/qemu/seqlock.h,tests/unit/test-coroutine.c,util/qemu-coroutine-lock.c-
QEMU_LOCK_GUARDandWITH_QEMU_LOCK_GUARDare used in 49 files.Quoted 3 lines
Quoted 1 line
Quoted 1 line
1)
qemu/coroutine.hkeeps includingqemu/lockable.hAs in my patch.
That's where the similarity ends. :)
Quoted 24 lines
Quoted 24 lines
Quoted 24 lines
2)
qemu/lockable.his modified as follows to omit the reference to CoMutex:include/qemu/lockable.h +3
-1@@ -71,9 +71,11 @@ qemu_null_lockable(void *x) void *: qemu_null_lockable(x), \ QemuMutex *: qemu_make_lockable(x, QML_OBJ_(x, mutex)), \ QemuRecMutex *: qemu_make_lockable(x, QML_OBJ_(x,rec_mutex )), \ - CoMutex *: qemu_make_lockable(x, QML_OBJ_(x, co_mutex)), \ + QEMU_MAKE_CO_MUTEX_LOCKABLE(x) \ QemuSpin *: qemu_make_lockable(x, QML_OBJ_(x, spin))) +#define QEMU_MAKE_CO_MUTEX_LOCKABLE(x) +/** * QEMU_MAKE_LOCKABLE_NONNULL - Make a polymorphic QemuLockable *3) the following hack is added in
qemu/coroutine.h, right after includingqemu/lockable.h:Quoted 7 lines
Quoted 3 lines
Quoted 3 lines
#undef
QEMU_MAKE_CO_MUTEX_LOCKABLE(x)
#defineQEMU_MAKE_CO_MUTEX_LOCKABLE(x)\
CoMutex *:qemu_make_lockable(x, QML_OBJ_(x, co_mutex)),Let me see... if I include just
lockable.hand make use of certain (generic) macro(s), the macro(s) won't have a case for QemuMutex *. Using them with a QemuMutex * argument won't compile.s/QemuMutex/CoMutex/. That is, you get the CoMutex case only if you include
qemu/coroutine.h. Which you probably did anyway, because CoMutexes are almost always embedded (not used as pointers). In fact I suspect the above trick also makes it possible to remove CoMutex fromqemu/typedefs.h.Furthermore, using qemu_lockable_lock/unlock with CoMutexes still works, even if you don't include
qemu/coroutine.h, just like in your patch.Quoted 3 lines
Quoted 2 lines
Quoted 2 lines
Neither is particularly pretty, so I vote for leaving things as is with a comment above the two #include directives.
Quoted 7 lines
Quoted 5 lines
Inlusion loops are landmines. Evidence: the compilation failure Phil ran in, leading to his
Subject: [PATCH-for-8.0] coroutine: Add missing <qemu/atomic.h> include Message-Id:<[email protected]>
Your macro hack I find too off-putting 😄I think the macro is much better than nerfing
qemu/lockable.h.
The core of the problem is that lockable.h wants to provide _Generic() with a CoMutex case if CoMutex exists.
The solution you proposed approximates this as follows. lockable.h makes the case configurable, default off. coroutine.h configures it to on, and includes lockable.h. Works as long as we include only coroutine.h, or coroutine.h before lockable.h. Falls apart if we include lockable.h, and only then coroutine.h.
For a robust solution, we'd need to enable lockable.h to detect "this compilation unit may use coroutines". Could CONFIG_USB_ONLY be pressed into service?
Quoted 2 lines
Another alternative is to add a new header
qemu/lockable-protos.hand move qemu_co_mutex_{lock,unlock} there (possibly other prototypes as well). Then include it from bothqemu/lockable.handqemu/coroutine.h.
Only from lockable.h, because coroutine.h gets it via lockable.h, right?
Lazy^Wpragmatic solution: move the coroutine.h parts lockable.h needs to lockable.h. As far as I can tell:
typedef CoMutex (unless we keep it in typedefs.h) qemu_co_mutex_lock() qemu_co_mutex_unlock()
Could throw in
qemu_co_mutex_init()
qemu_co_mutex_assert_locked()
to avoid splitting the co_mutex interface.
If keeping this in lockable.h bothers you, we could create comutex.h for it.
Can't see what adding more to the new header would buy us (other than arguments on how to name it). Happy to be enlightened there, of course.
Re: [PATCH 4/4] coroutine: Break inclusion loop
In reply to Paolo BonziniQuoted 9 lines · Paolo Bonzini
On 12/8/22 15:23, Markus Armbruster wrote:
>qemu/coroutine.handqemu/lockable.hinclude each other. Neither > header actually needs the other one.
qemu/lockable.hwantsqemu/coroutine.hbecause of the reference to qemu_co_mutex_lock/unlock in theQEMU_MAKE_LOCKABLEmacro. Said reference only happens when the macro is used, so strictly speaking only code that uses of qemu/lockable.h's functionality needs to include qemu/coroutine.h. The order doesn't matter.
[*]
Quoted 21 lines
qemu/coroutine.hsimilarly wantsqemu/lockable.honly for a macro: it uses QemuLockable for the prototype ofqemu_co_queue_wait_impl, but QemuLockable is defined in qemu/typedefs.h. On the other hand, theqemu_co_queue_waitmacro needs QEMU_MAKE_LOCKABLE. Again, the order does not matter but callers ofqemu_co_queue_waitappreciate it if both files are included.So, this is why the inclusion loop works. This patch makes some files include
qemu/coroutine.heven if they only needqemu/lockable.hforQEMU_LOCK_GUARDof a "regular" QemuMutex; for example, linux-user/ does not use coroutines, so I'd like to avoid that it includesqemu/coroutine.h.One way is to just keep the cycle. Another is to break the cycle is as follows:
1)
qemu/coroutine.hkeeps includingqemu/lockable.h2)
qemu/lockable.his modified as follows to omit the reference to CoMutex:
Quoted 15 lines
diff --git
a/include/qemu/lockable.hb/include/qemu/lockable.hindex86db7cb04c9c..db59656538a4100644
---a/include/qemu/lockable.h
+++b/include/qemu/lockable.h
@@ -71,9 +71,11 @@qemu_null_lockable(void *x)
void *:qemu_null_lockable(x),
\
QemuMutex *: qemu_make_lockable(x, QML_OBJ_(x,
mutex)), \
QemuRecMutex *: qemu_make_lockable(x, QML_OBJ_(x,
rec_mutex)), \
- CoMutex *:qemu_make_lockable(x, QML_OBJ_(x, co_mutex)), \
+ QEMU_MAKE_CO_MUTEX_LOCKABLE(x)
\
Interesting, I ended doing something similar today because this line is the single sysemu-specific part of this file (user emulation shouldn't have access to qemu/coroutine.h). So back to [*], the order seems to matter for user-mode.
Quoted 21 lines
QemuSpin *:
qemu_make_lockable(x, QML_OBJ_(x, spin)))+#define
QEMU_MAKE_CO_MUTEX_LOCKABLE(x)
+
/**
*QEMU_MAKE_LOCKABLE_NONNULL- Make a polymorphic QemuLockable *3) the following hack is added in
qemu/coroutine.h, right after includingqemu/lockable.h:#undef
QEMU_MAKE_CO_MUTEX_LOCKABLE(x)
#defineQEMU_MAKE_CO_MUTEX_LOCKABLE(x)\
CoMutex *:qemu_make_lockable(x, QML_OBJ_(x, co_mutex)),Neither is particularly pretty, so I vote for leaving things as is with a comment above the two #include directives.
Paolo