Merge pull request #116 from AFLplusplus/update_qemu_v10_0_3

Update QEMU to V10.0.3

Author: rmalmain

.github/workflows/build_and_test.yaml

@@ -16,7 +16,7 @@ concurrency:
 
 jobs:
  build:
- runs-on: [self-hosted, qemu]
+ runs-on: ubuntu-24.04
  container: registry.gitlab.com/qemu-project/qemu/qemu/ubuntu2204:latest
  steps:
  - uses: actions/checkout@v4

VERSION

@@ -1 +1 @@
-10.0.0
+10.0.3

accel/kvm/kvm-all.c

@@ -443,9 +443,8 @@ int kvm_unpark_vcpu(KVMState *s, unsigned long vcpu_id)
  return kvm_fd;
 }
 
-static void kvm_reset_parked_vcpus(void *param)
+static void kvm_reset_parked_vcpus(KVMState *s)
 {
- KVMState *s = param;
  struct KVMParkedVcpu *cpu;
 
  QLIST_FOREACH(cpu, &s->kvm_parked_vcpus, node) {
@@ -2563,8 +2562,7 @@ static int kvm_init(MachineState *ms)
 {
  MachineClass *mc = MACHINE_GET_CLASS(ms);
  static const char upgrade_note[] =
- "Please upgrade to at least kernel 2.6.29 or recent kvm-kmod\n"
- "(see http://sourceforge.net/projects/kvm).\n";
+ "Please upgrade to at least kernel 4.5.\n";
  const struct {
  const char *name;
  int num;
@@ -2744,7 +2742,6 @@ static int kvm_init(MachineState *ms)
  }
 
  qemu_register_reset(kvm_unpoison_all, NULL);
- qemu_register_reset(kvm_reset_parked_vcpus, s);
 
  if (s->kernel_irqchip_allowed) {
  kvm_irqchip_create(s);
@@ -2914,6 +2911,10 @@ static void do_kvm_cpu_synchronize_post_reset(CPUState *cpu, run_on_cpu_data arg
 void kvm_cpu_synchronize_post_reset(CPUState *cpu)
 {
  run_on_cpu(cpu, do_kvm_cpu_synchronize_post_reset, RUN_ON_CPU_NULL);
+
+ if (cpu == first_cpu) {
+ kvm_reset_parked_vcpus(kvm_state);
+ }
 }
 
 static void do_kvm_cpu_synchronize_post_init(CPUState *cpu, run_on_cpu_data arg)

accel/tcg/translate-all.c

@@ -113,7 +113,7 @@ static int64_t decode_sleb128(const uint8_t **pp)
  val |= (int64_t)(byte & 0x7f) << shift;
  shift += 7;
  } while (byte & 0x80);
- if (shift < TARGET_LONG_BITS && (byte & 0x40)) {
+ if (shift < 64 && (byte & 0x40)) {
  val |= -(int64_t)1 << shift;
  }
 

audio/audio.c

@@ -905,6 +905,14 @@ size_t AUD_read(SWVoiceIn *sw, void *buf, size_t size)
 
 int AUD_get_buffer_size_out(SWVoiceOut *sw)
 {
+ if (!sw) {
+ return 0;
+ }
+
+ if (audio_get_pdo_out(sw->s->dev)->mixing_engine) {
+ return sw->resample_buf.size * sw->info.bytes_per_frame;
+ }
+
  return sw->hw->samples * sw->hw->info.bytes_per_frame;
 }
 

block/file-posix.c

@@ -2484,9 +2484,9 @@ static inline bool raw_check_linux_aio(BDRVRawState *s)
 }
 #endif
 
-static int coroutine_fn raw_co_prw(BlockDriverState *bs, int64_t *offset_ptr,
- uint64_t bytes, QEMUIOVector *qiov, int type,
-   int flags)
+static int coroutine_fn GRAPH_RDLOCK
+raw_co_prw(BlockDriverState *bs, int64_t *offset_ptr, uint64_t bytes,
+ QEMUIOVector *qiov, int type, int flags)
 {
  BDRVRawState *s = bs->opaque;
  RawPosixAIOData acb;
@@ -2545,7 +2545,7 @@ static int coroutine_fn raw_co_prw(BlockDriverState *bs, int64_t *offset_ptr,
  ret = raw_thread_pool_submit(handle_aiocb_rw, &acb);
  if (ret == 0 && (flags & BDRV_REQ_FUA)) {
  /* TODO Use pwritev2() instead if it's available */
- ret = raw_co_flush_to_disk(bs);
+ ret = bdrv_co_flush(bs);
  }
  goto out; /* Avoid the compiler err of unused label */
 
@@ -2580,16 +2580,16 @@ static int coroutine_fn raw_co_prw(BlockDriverState *bs, int64_t *offset_ptr,
  return ret;
 }
 
-static int coroutine_fn raw_co_preadv(BlockDriverState *bs, int64_t offset,
- int64_t bytes, QEMUIOVector *qiov,
-   BdrvRequestFlags flags)
+static int coroutine_fn GRAPH_RDLOCK
+raw_co_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes,
+ QEMUIOVector *qiov, BdrvRequestFlags flags)
 {
  return raw_co_prw(bs, &offset, bytes, qiov, QEMU_AIO_READ, flags);
 }
 
-static int coroutine_fn raw_co_pwritev(BlockDriverState *bs, int64_t offset,
- int64_t bytes, QEMUIOVector *qiov,
-   BdrvRequestFlags flags)
+static int coroutine_fn GRAPH_RDLOCK
+raw_co_pwritev(BlockDriverState *bs, int64_t offset, int64_t bytes,
+ QEMUIOVector *qiov, BdrvRequestFlags flags)
 {
  return raw_co_prw(bs, &offset, bytes, qiov, QEMU_AIO_WRITE, flags);
 }
@@ -3525,10 +3525,11 @@ static int coroutine_fn raw_co_zone_mgmt(BlockDriverState *bs, BlockZoneOp op,
 #endif
 
 #if defined(CONFIG_BLKZONED)
-static int coroutine_fn raw_co_zone_append(BlockDriverState *bs,
- int64_t *offset,
- QEMUIOVector *qiov,
- BdrvRequestFlags flags) {
+static int coroutine_fn GRAPH_RDLOCK
+raw_co_zone_append(BlockDriverState *bs,
+ int64_t *offset,
+ QEMUIOVector *qiov,
+ BdrvRequestFlags flags) {
  assert(flags == 0);
  int64_t zone_size_mask = bs->bl.zone_size - 1;
  int64_t iov_len = 0;

common-user/host/riscv/safe-syscall.inc.S

@@ -69,11 +69,11 @@ safe_syscall_end:
 
  /* code path setting errno */
 0: neg a0, a0
- j  safe_syscall_set_errno_tail
+ tail safe_syscall_set_errno_tail
 
  /* code path when we didn't execute the syscall */
 2: li a0, QEMU_ERESTARTSYS
- j  safe_syscall_set_errno_tail
+ tail safe_syscall_set_errno_tail
 
  .cfi_endproc
  .size safe_syscall_base, .-safe_syscall_base

docs/devel/codebase.rst

@@ -116,7 +116,7 @@ yet, so sometimes the source code is all you have.
 * `monitor <https://gitlab.com/qemu-project/qemu/-/tree/master/monitor>`_:
  `Monitor <QEMU monitor>` implementation (HMP & QMP).
 * `nbd <https://gitlab.com/qemu-project/qemu/-/tree/master/nbd>`_:
- QEMU `NBD (Network Block Device) <nbd>` server.
+ QEMU NBD (Network Block Device) server.
 * `net <https://gitlab.com/qemu-project/qemu/-/tree/master/net>`_:
  Network (host) support.
 * `pc-bios <https://gitlab.com/qemu-project/qemu/-/tree/master/pc-bios>`_:

docs/system/qemu-block-drivers.rst.inc

@@ -500,8 +500,6 @@ What you should *never* do:
 - expect it to work when loadvm'ing
 - write to the FAT directory on the host system while accessing it with the guest system
 
-.. _nbd:
-
 NBD access
 ~~~~~~~~~~
 

hw/9pfs/9p.c

@@ -434,16 +434,24 @@ void coroutine_fn v9fs_reclaim_fd(V9fsPDU *pdu)
  V9fsFidState *f;
  GHashTableIter iter;
  gpointer fid;
+ int err;
+ int nclosed = 0;
+
+ /* prevent multiple coroutines running this function simultaniously */
+ if (s->reclaiming) {
+ return;
+ }
+ s->reclaiming = true;
 
  g_hash_table_iter_init(&iter, s->fids);
 
  QSLIST_HEAD(, V9fsFidState) reclaim_list =
  QSLIST_HEAD_INITIALIZER(reclaim_list);
 
+ /* Pick FIDs to be closed, collect them on reclaim_list. */
  while (g_hash_table_iter_next(&iter, &fid, (gpointer *) &f)) {
  /*
- * Unlink fids cannot be reclaimed. Check
- * for them and skip them. Also skip fids
+ * Unlinked fids cannot be reclaimed, skip those, and also skip fids
  * currently being operated on.
  */
  if (f->ref || f->flags & FID_NON_RECLAIMABLE) {
@@ -493,23 +501,34 @@ void coroutine_fn v9fs_reclaim_fd(V9fsPDU *pdu)
  }
  }
  /*
- * Now close the fid in reclaim list. Free them if they
- * are already clunked.
+ * Close the picked FIDs altogether on a background I/O driver thread. Do
+ * this all at once to keep latency (i.e. amount of thread hops between main
+ * thread <-> fs driver background thread) as low as possible.
  */
+ v9fs_co_run_in_worker({
+ QSLIST_FOREACH(f, &reclaim_list, reclaim_next) {
+ err = (f->fid_type == P9_FID_DIR) ?
+ s->ops->closedir(&s->ctx, &f->fs_reclaim) :
+ s->ops->close(&s->ctx, &f->fs_reclaim);
+ if (!err) {
+ /* total_open_fd must only be mutated on main thread */
+ nclosed++;
+ }
+ }
+ });
+ total_open_fd -= nclosed;
+ /* Free the closed FIDs. */
  while (!QSLIST_EMPTY(&reclaim_list)) {
  f = QSLIST_FIRST(&reclaim_list);
  QSLIST_REMOVE(&reclaim_list, f, V9fsFidState, reclaim_next);
- if (f->fid_type == P9_FID_FILE) {
- v9fs_co_close(pdu, &f->fs_reclaim);
- } else if (f->fid_type == P9_FID_DIR) {
- v9fs_co_closedir(pdu, &f->fs_reclaim);
- }
  /*
  * Now drop the fid reference, free it
  * if clunked.
  */
  put_fid(pdu, f);
  }
+
+ s->reclaiming = false;
 }
 
 /*
@@ -4324,6 +4343,8 @@ int v9fs_device_realize_common(V9fsState *s, const V9fsTransport *t,
  s->ctx.fst = &fse->fst;
  fsdev_throttle_init(s->ctx.fst);
 
+ s->reclaiming = false;
+
  rc = 0;
 out:
  if (rc) {