OpenE2K
/
qemu-e2k
13
4
Fork 0
Code Issues 4 Pull Requests Projects 2 Releases Activity

Pull request 

(Resent due to an email preparation mistake.)
 -----BEGIN PGP SIGNATURE-----
 
 iQEzBAABCAAdFiEEhpWov9P5fNqsNXdanKSrs4Grc8gFAmCro7YACgkQnKSrs4Gr
 c8g3TQgAkdY2B+YgxkAwcsBYyPi6CCHEft46KiBprhb3v0GrdV2dSyFz3Wf/TiOI
 y0IqPVahI2WeEmw55o3I62Xyl9Hgw+z1kJeUJXJdZtfqP3UYgoL3tgkCth7KrRZS
 QUrOd6X6Yem+YTxtfAwo9NBpYiJVeLgUoJNQShP+M8UqBOMX/SFcp6eRvRm1d6uA
 RCPRufPGwhJicqZzQmF4Haepn+yg9TRAaJUO9iWwj4HAeIHCXrbpcaJ59yvP6L4I
 ObJSZAe1ERB2ugLKT8e1BibY2BZUKymp8lk+00yZ/O7PM98m8vPXUaoQlqA4Sv+4
 IiKaVeGlWhyeEF70wRRRDBtqagTxlA==
 =lWeh
 -----END PGP SIGNATURE-----

Merge remote-tracking branch 'remotes/stefanha-gitlab/tags/block-pull-request' into staging

Pull request

(Resent due to an email preparation mistake.)

# gpg: Signature made Mon 24 May 2021 14:01:42 BST
# gpg:                using RSA key 8695A8BFD3F97CDAAC35775A9CA4ABB381AB73C8
# gpg: Good signature from "Stefan Hajnoczi <stefanha@redhat.com>" [full]
# gpg:                 aka "Stefan Hajnoczi <stefanha@gmail.com>" [full]
# Primary key fingerprint: 8695 A8BF D3F9 7CDA AC35  775A 9CA4 ABB3 81AB 73C8

* remotes/stefanha-gitlab/tags/block-pull-request:
  coroutine-sleep: introduce qemu_co_sleep
  coroutine-sleep: replace QemuCoSleepState pointer with struct in the API
  coroutine-sleep: move timer out of QemuCoSleepState
  coroutine-sleep: allow qemu_co_sleep_wake that wakes nothing
  coroutine-sleep: disallow NULL QemuCoSleepState** argument
  coroutine-sleep: use a stack-allocated timer
  bitops.h: Improve find_xxx_bit() documentation
  multi-process: Initialize variables declared with g_auto*

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
This commit is contained in:
Peter Maydell 2021-05-24 15:48:08 +01:00
parent 371ebfe286 0a6f0c76a0
commit 0dab1d36f5
7 changed files with 80 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
block/block-copy.c
View File

@ -50,7 +50,7 @@ typedef struct BlockCopyCallState {
/* State */
int ret;
bool finished;
QemuCoSleepState *sleep_state;
QemuCoSleep sleep;
bool cancelled;
/* OUT parameters */
@ -625,8 +625,8 @@ block_copy_dirty_clusters(BlockCopyCallState *call_state)
if (ns > 0) {
block_copy_task_end(task, -EAGAIN);
g_free(task);
qemu_co_sleep_ns_wakeable(QEMU_CLOCK_REALTIME, ns,
&call_state->sleep_state);
qemu_co_sleep_ns_wakeable(&call_state->sleep,
QEMU_CLOCK_REALTIME, ns);
continue;
}
}
@ -674,9 +674,7 @@ out:
void block_copy_kick(BlockCopyCallState *call_state)
{
if (call_state->sleep_state) {
qemu_co_sleep_wake(call_state->sleep_state);
}
qemu_co_sleep_wake(&call_state->sleep);
}
/*

14
block/nbd.c
View File

@ -116,7 +116,7 @@ typedef struct BDRVNBDState {
CoQueue free_sema;
Coroutine *connection_co;
Coroutine *teardown_co;
QemuCoSleepState *connection_co_sleep_ns_state;
QemuCoSleep reconnect_sleep;
bool drained;
bool wait_drained_end;
int in_flight;
@ -289,9 +289,7 @@ static void coroutine_fn nbd_client_co_drain_begin(BlockDriverState *bs)
BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
s->drained = true;
if (s->connection_co_sleep_ns_state) {
qemu_co_sleep_wake(s->connection_co_sleep_ns_state);
}
qemu_co_sleep_wake(&s->reconnect_sleep);
nbd_co_establish_connection_cancel(bs, false);
@ -330,9 +328,7 @@ static void nbd_teardown_connection(BlockDriverState *bs)
s->state = NBD_CLIENT_QUIT;
if (s->connection_co) {
if (s->connection_co_sleep_ns_state) {
qemu_co_sleep_wake(s->connection_co_sleep_ns_state);
}
qemu_co_sleep_wake(&s->reconnect_sleep);
nbd_co_establish_connection_cancel(bs, true);
}
if (qemu_in_coroutine()) {
@ -689,8 +685,8 @@ static coroutine_fn void nbd_co_reconnect_loop(BDRVNBDState *s)
}
bdrv_inc_in_flight(s->bs);
} else {
qemu_co_sleep_ns_wakeable(QEMU_CLOCK_REALTIME, timeout,
&s->connection_co_sleep_ns_state);
qemu_co_sleep_ns_wakeable(&s->reconnect_sleep,
QEMU_CLOCK_REALTIME, timeout);
if (s->drained) {
continue;
}

5
hw/remote/memory.c
View File

@ -41,10 +41,9 @@ void remote_sysmem_reconfig(MPQemuMsg *msg, Error **errp)
remote_sysmem_reset();
for (region = 0; region < msg->num_fds; region++) {
g_autofree char *name;
for (region = 0; region < msg->num_fds; region++, suffix++) {
g_autofree char *name = g_strdup_printf("remote-mem-%u", suffix);
subregion = g_new(MemoryRegion, 1);
name = g_strdup_printf("remote-mem-%u", suffix++);
memory_region_init_ram_from_fd(subregion, NULL,
name, sysmem_info->sizes[region],
true, msg->fds[region],

3
hw/remote/proxy.c
View File

@ -347,13 +347,12 @@ static void probe_pci_info(PCIDevice *dev, Error **errp)
PCI_BASE_ADDRESS_SPACE_IO : PCI_BASE_ADDRESS_SPACE_MEMORY;
if (size) {
g_autofree char *name;
g_autofree char *name = g_strdup_printf("bar-region-%d", i);
pdev->region[i].dev = pdev;
pdev->region[i].present = true;
if (type == PCI_BASE_ADDRESS_SPACE_MEMORY) {
pdev->region[i].memory = true;
}
name = g_strdup_printf("bar-region-%d", i);
memory_region_init_io(&pdev->region[i].mr, OBJECT(pdev),
&proxy_mr_ops, &pdev->region[i],
name, size);

15
include/qemu/bitops.h
View File

@ -140,7 +140,8 @@ static inline int test_bit(long nr, const unsigned long *addr)
* @addr: The address to start the search at
* @size: The maximum size to search
*
* Returns the bit number of the first set bit, or size.
* Returns the bit number of the last set bit,
* or @size if there is no set bit in the bitmap.
*/
unsigned long find_last_bit(const unsigned long *addr,
unsigned long size);
@ -150,6 +151,9 @@ unsigned long find_last_bit(const unsigned long *addr,
* @addr: The address to base the search on
* @offset: The bitnumber to start searching at
* @size: The bitmap size in bits
*
* Returns the bit number of the next set bit,
* or @size if there are no further set bits in the bitmap.
*/
unsigned long find_next_bit(const unsigned long *addr,
unsigned long size,
@ -160,6 +164,9 @@ unsigned long find_next_bit(const unsigned long *addr,
* @addr: The address to base the search on
* @offset: The bitnumber to start searching at
* @size: The bitmap size in bits
*
* Returns the bit number of the next cleared bit,
* or @size if there are no further clear bits in the bitmap.
*/
unsigned long find_next_zero_bit(const unsigned long *addr,
@ -171,7 +178,8 @@ unsigned long find_next_zero_bit(const unsigned long *addr,
* @addr: The address to start the search at
* @size: The maximum size to search
*
* Returns the bit number of the first set bit.
* Returns the bit number of the first set bit,
* or @size if there is no set bit in the bitmap.
*/
static inline unsigned long find_first_bit(const unsigned long *addr,
unsigned long size)
@ -194,7 +202,8 @@ static inline unsigned long find_first_bit(const unsigned long *addr,
* @addr: The address to start the search at
* @size: The maximum size to search
*
* Returns the bit number of the first cleared bit.
* Returns the bit number of the first cleared bit,
* or @size if there is no clear bit in the bitmap.
*/
static inline unsigned long find_first_zero_bit(const unsigned long *addr,
unsigned long size)

27
include/qemu/coroutine.h
View File

@ -291,20 +291,27 @@ void qemu_co_rwlock_wrlock(CoRwlock *lock);
*/
void qemu_co_rwlock_unlock(CoRwlock *lock);
typedef struct QemuCoSleepState QemuCoSleepState;
typedef struct QemuCoSleep {
Coroutine *to_wake;
} QemuCoSleep;
/**
* Yield the coroutine for a given duration. During this yield, @sleep_state
* (if not NULL) is set to an opaque pointer, which may be used for
* qemu_co_sleep_wake(). Be careful, the pointer is set back to zero when the
* timer fires. Don't save the obtained value to other variables and don't call
* qemu_co_sleep_wake from another aio context.
* Yield the coroutine for a given duration. Initializes @w so that,
* during this yield, it can be passed to qemu_co_sleep_wake() to
* terminate the sleep.
*/
void coroutine_fn qemu_co_sleep_ns_wakeable(QEMUClockType type, int64_t ns,
QemuCoSleepState **sleep_state);
void coroutine_fn qemu_co_sleep_ns_wakeable(QemuCoSleep *w,
QEMUClockType type, int64_t ns);
/**
* Yield the coroutine until the next call to qemu_co_sleep_wake.
*/
void coroutine_fn qemu_co_sleep(QemuCoSleep *w);
static inline void coroutine_fn qemu_co_sleep_ns(QEMUClockType type, int64_t ns)
{
qemu_co_sleep_ns_wakeable(type, ns, NULL);
QemuCoSleep w = { 0 };
qemu_co_sleep_ns_wakeable(&w, type, ns);
}
/**
@ -313,7 +320,7 @@ static inline void coroutine_fn qemu_co_sleep_ns(QEMUClockType type, int64_t ns)
* qemu_co_sleep_ns() and should be checked to be non-NULL before calling
* qemu_co_sleep_wake().
*/
void qemu_co_sleep_wake(QemuCoSleepState *sleep_state);
void qemu_co_sleep_wake(QemuCoSleep *w);
/**
* Yield until a file descriptor becomes readable

77
util/qemu-coroutine-sleep.c
View File

@ -19,43 +19,34 @@
static const char *qemu_co_sleep_ns__scheduled = "qemu_co_sleep_ns";
struct QemuCoSleepState {
Coroutine *co;
QEMUTimer *ts;
QemuCoSleepState **user_state_pointer;
};
void qemu_co_sleep_wake(QemuCoSleepState *sleep_state)
void qemu_co_sleep_wake(QemuCoSleep *w)
{
/* Write of schedule protected by barrier write in aio_co_schedule */
const char *scheduled = qatomic_cmpxchg(&sleep_state->co->scheduled,
qemu_co_sleep_ns__scheduled, NULL);
Coroutine *co;
assert(scheduled == qemu_co_sleep_ns__scheduled);
if (sleep_state->user_state_pointer) {
*sleep_state->user_state_pointer = NULL;
co = w->to_wake;
w->to_wake = NULL;
if (co) {
/* Write of schedule protected by barrier write in aio_co_schedule */
const char *scheduled = qatomic_cmpxchg(&co->scheduled,
qemu_co_sleep_ns__scheduled, NULL);
assert(scheduled == qemu_co_sleep_ns__scheduled);
aio_co_wake(co);
}
timer_del(sleep_state->ts);
aio_co_wake(sleep_state->co);
}
static void co_sleep_cb(void *opaque)
{
qemu_co_sleep_wake(opaque);
QemuCoSleep *w = opaque;
qemu_co_sleep_wake(w);
}
void coroutine_fn qemu_co_sleep_ns_wakeable(QEMUClockType type, int64_t ns,
QemuCoSleepState **sleep_state)
void coroutine_fn qemu_co_sleep(QemuCoSleep *w)
{
AioContext *ctx = qemu_get_current_aio_context();
QemuCoSleepState state = {
.co = qemu_coroutine_self(),
.ts = aio_timer_new(ctx, type, SCALE_NS, co_sleep_cb, &state),
.user_state_pointer = sleep_state,
};
Coroutine *co = qemu_coroutine_self();
const char *scheduled = qatomic_cmpxchg(&state.co->scheduled, NULL,
qemu_co_sleep_ns__scheduled);
const char *scheduled = qatomic_cmpxchg(&co->scheduled, NULL,
qemu_co_sleep_ns__scheduled);
if (scheduled) {
fprintf(stderr,
"%s: Co-routine was already scheduled in '%s'\n",
@ -63,17 +54,27 @@ void coroutine_fn qemu_co_sleep_ns_wakeable(QEMUClockType type, int64_t ns,
abort();
}
if (sleep_state) {
*sleep_state = &state;
}
timer_mod(state.ts, qemu_clock_get_ns(type) + ns);
w->to_wake = co;
qemu_coroutine_yield();
if (sleep_state) {
/*
* Note that *sleep_state is cleared during qemu_co_sleep_wake
* before resuming this coroutine.
*/
assert(*sleep_state == NULL);
}
timer_free(state.ts);
/* w->to_wake is cleared before resuming this coroutine. */
assert(w->to_wake == NULL);
}
void coroutine_fn qemu_co_sleep_ns_wakeable(QemuCoSleep *w,
QEMUClockType type, int64_t ns)
{
AioContext *ctx = qemu_get_current_aio_context();
QEMUTimer ts;
aio_timer_init(ctx, &ts, type, SCALE_NS, co_sleep_cb, w);
timer_mod(&ts, qemu_clock_get_ns(type) + ns);
/*
* The timer will fire in the current AiOContext, so the callback
* must happen after qemu_co_sleep yields and there is no race
* between timer_mod and qemu_co_sleep.
*/
qemu_co_sleep(w);
timer_del(&ts);
}