2018-02-16 17:50:12 +01:00
|
|
|
/*
|
|
|
|
* AioContext wait support
|
|
|
|
*
|
|
|
|
* Copyright (C) 2018 Red Hat, Inc.
|
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
|
|
* in the Software without restriction, including without limitation the rights
|
|
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
|
|
* furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice shall be included in
|
|
|
|
* all copies or substantial portions of the Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
|
|
* THE SOFTWARE.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef QEMU_AIO_WAIT_H
|
|
|
|
#define QEMU_AIO_WAIT_H
|
|
|
|
|
|
|
|
#include "block/aio.h"
|
2020-04-07 16:07:45 +02:00
|
|
|
#include "qemu/main-loop.h"
|
2018-02-16 17:50:12 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* AioWait:
|
|
|
|
*
|
2018-09-18 17:09:16 +02:00
|
|
|
* An object that facilitates synchronous waiting on a condition. A single
|
|
|
|
* global AioWait object (global_aio_wait) is used internally.
|
|
|
|
*
|
|
|
|
* The main loop can wait on an operation running in an IOThread as follows:
|
2018-02-16 17:50:12 +01:00
|
|
|
*
|
|
|
|
* AioContext *ctx = ...;
|
|
|
|
* MyWork work = { .done = false };
|
|
|
|
* schedule_my_work_in_iothread(ctx, &work);
|
2018-09-18 17:09:16 +02:00
|
|
|
* AIO_WAIT_WHILE(ctx, !work.done);
|
2018-02-16 17:50:12 +01:00
|
|
|
*
|
|
|
|
* The IOThread must call aio_wait_kick() to notify the main loop when
|
|
|
|
* work.done changes:
|
|
|
|
*
|
|
|
|
* static void do_work(...)
|
|
|
|
* {
|
|
|
|
* ...
|
|
|
|
* work.done = true;
|
2018-09-18 17:09:16 +02:00
|
|
|
* aio_wait_kick();
|
2018-02-16 17:50:12 +01:00
|
|
|
* }
|
|
|
|
*/
|
|
|
|
typedef struct {
|
2018-03-07 13:46:19 +01:00
|
|
|
/* Number of waiting AIO_WAIT_WHILE() callers. Accessed with atomic ops. */
|
|
|
|
unsigned num_waiters;
|
2018-02-16 17:50:12 +01:00
|
|
|
} AioWait;
|
|
|
|
|
2018-09-18 17:09:16 +02:00
|
|
|
extern AioWait global_aio_wait;
|
|
|
|
|
2018-02-16 17:50:12 +01:00
|
|
|
/**
|
|
|
|
* AIO_WAIT_WHILE:
|
2018-04-10 15:51:52 +02:00
|
|
|
* @ctx: the aio context, or NULL if multiple aio contexts (for which the
|
|
|
|
* caller does not hold a lock) are involved in the polling condition.
|
2018-02-16 17:50:12 +01:00
|
|
|
* @cond: wait while this conditional expression is true
|
|
|
|
*
|
|
|
|
* Wait while a condition is true. Use this to implement synchronous
|
|
|
|
* operations that require event loop activity.
|
|
|
|
*
|
|
|
|
* The caller must be sure that something calls aio_wait_kick() when the value
|
|
|
|
* of @cond might have changed.
|
|
|
|
*
|
|
|
|
* The caller's thread must be the IOThread that owns @ctx or the main loop
|
|
|
|
* thread (with @ctx acquired exactly once). This function cannot be used to
|
|
|
|
* wait on conditions between two IOThreads since that could lead to deadlock,
|
|
|
|
* go via the main loop instead.
|
|
|
|
*/
|
2018-09-18 17:09:16 +02:00
|
|
|
#define AIO_WAIT_WHILE(ctx, cond) ({ \
|
2018-03-07 13:46:19 +01:00
|
|
|
bool waited_ = false; \
|
2018-09-18 17:09:16 +02:00
|
|
|
AioWait *wait_ = &global_aio_wait; \
|
2018-03-07 13:46:19 +01:00
|
|
|
AioContext *ctx_ = (ctx); \
|
2018-09-05 18:14:17 +02:00
|
|
|
/* Increment wait_->num_waiters before evaluating cond. */ \
|
|
|
|
atomic_inc(&wait_->num_waiters); \
|
2018-04-10 15:51:52 +02:00
|
|
|
if (ctx_ && in_aio_context_home_thread(ctx_)) { \
|
2018-03-22 10:57:14 +01:00
|
|
|
while ((cond)) { \
|
|
|
|
aio_poll(ctx_, true); \
|
|
|
|
waited_ = true; \
|
2018-03-07 13:46:19 +01:00
|
|
|
} \
|
|
|
|
} else { \
|
|
|
|
assert(qemu_get_current_aio_context() == \
|
|
|
|
qemu_get_aio_context()); \
|
2018-03-22 10:57:14 +01:00
|
|
|
while ((cond)) { \
|
2018-04-10 15:51:52 +02:00
|
|
|
if (ctx_) { \
|
|
|
|
aio_context_release(ctx_); \
|
|
|
|
} \
|
2018-03-22 10:57:14 +01:00
|
|
|
aio_poll(qemu_get_aio_context(), true); \
|
2018-04-10 15:51:52 +02:00
|
|
|
if (ctx_) { \
|
|
|
|
aio_context_acquire(ctx_); \
|
|
|
|
} \
|
2018-03-22 10:57:14 +01:00
|
|
|
waited_ = true; \
|
2018-03-07 13:46:19 +01:00
|
|
|
} \
|
|
|
|
} \
|
2018-09-05 18:14:17 +02:00
|
|
|
atomic_dec(&wait_->num_waiters); \
|
2018-02-16 17:50:12 +01:00
|
|
|
waited_; })
|
|
|
|
|
|
|
|
/**
|
|
|
|
* aio_wait_kick:
|
|
|
|
* Wake up the main thread if it is waiting on AIO_WAIT_WHILE(). During
|
|
|
|
* synchronous operations performed in an IOThread, the main thread lets the
|
|
|
|
* IOThread's event loop run, waiting for the operation to complete. A
|
|
|
|
* aio_wait_kick() call will wake up the main thread.
|
|
|
|
*/
|
2018-09-18 17:09:16 +02:00
|
|
|
void aio_wait_kick(void);
|
2018-02-16 17:50:12 +01:00
|
|
|
|
2018-03-07 15:42:02 +01:00
|
|
|
/**
|
|
|
|
* aio_wait_bh_oneshot:
|
|
|
|
* @ctx: the aio context
|
|
|
|
* @cb: the BH callback function
|
|
|
|
* @opaque: user data for the BH callback function
|
|
|
|
*
|
|
|
|
* Run a BH in @ctx and wait for it to complete.
|
|
|
|
*
|
|
|
|
* Must be called from the main loop thread with @ctx acquired exactly once.
|
|
|
|
* Note that main loop event processing may occur.
|
|
|
|
*/
|
|
|
|
void aio_wait_bh_oneshot(AioContext *ctx, QEMUBHFunc *cb, void *opaque);
|
|
|
|
|
2020-04-07 16:07:45 +02:00
|
|
|
/**
|
|
|
|
* in_aio_context_home_thread:
|
|
|
|
* @ctx: the aio context
|
|
|
|
*
|
|
|
|
* Return whether we are running in the thread that normally runs @ctx. Note
|
|
|
|
* that acquiring/releasing ctx does not affect the outcome, each AioContext
|
|
|
|
* still only has one home thread that is responsible for running it.
|
|
|
|
*/
|
|
|
|
static inline bool in_aio_context_home_thread(AioContext *ctx)
|
|
|
|
{
|
|
|
|
if (ctx == qemu_get_current_aio_context()) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ctx == qemu_get_aio_context()) {
|
|
|
|
return qemu_mutex_iothread_locked();
|
|
|
|
} else {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-03-15 15:51:23 +01:00
|
|
|
#endif /* QEMU_AIO_WAIT_H */
|