qemu/atomic.h: rename atomic_ to qatomic_
Subsystems (4)
v4 cover qemu/atomic.h: rename atomic_ to qatomic_
This is a respin of Stefan's already reviewed patch, fixing checkpatch.pl issues first.
Philippe Mathieu-Daudé (1):
qemu/atomic: Update coding style to make checkpatch.pl happier
Stefan Hajnoczi (1):
qemu/atomic.h: rename atomic_ to qatomic_
docs/devel/atomics.rst | 134 +++++----- docs/devel/lockcnt.txt | 8 +- docs/devel/rcu.txt | 34 +-- accel/tcg/atomic_template.h | 20 +- include/block/aio-wait.h | 4 +- include/block/aio.h | 8 +- include/exec/cpu_ldst.h | 2 +- include/exec/exec-all.h | 6 +- include/exec/log.h | 6 +- include/exec/memory.h | 2 +- include/exec/ram_addr.h | 26 +- include/exec/ramlist.h | 2 +- include/exec/tb-lookup.h | 4 +- include/hw/core/cpu.h | 2 +- include/qemu/atomic.h | 249 +++++++++--------- include/qemu/atomic128.h | 6 +- include/qemu/bitops.h | 2 +- include/qemu/coroutine.h | 2 +- include/qemu/log.h | 6 +- include/qemu/queue.h | 7 +- include/qemu/rcu.h | 10 +- include/qemu/rcu_queue.h | 100 +++---- include/qemu/seqlock.h | 8 +- include/qemu/stats64.h | 28 +- include/qemu/thread.h | 24 +- .../infiniband/hw/vmw_pvrdma/pvrdma_ring.h | 14 +- linux-user/qemu.h | 2 +- tcg/i386/tcg-target.h | 2 +- tcg/s390/tcg-target.h | 2 +- tcg/tci/tcg-target.h | 2 +- accel/kvm/kvm-all.c | 12 +- accel/tcg/cpu-exec.c | 15 +- accel/tcg/cputlb.c | 24 +- accel/tcg/tcg-all.c | 2 +- accel/tcg/translate-all.c | 55 ++-- audio/jackaudio.c | 18 +- block.c | 4 +- block/block-backend.c | 15 +- block/io.c | 48 ++-- block/nfs.c | 2 +- block/sheepdog.c | 2 +- block/throttle-groups.c | 12 +- block/throttle.c | 4 +- blockdev.c | 2 +- blockjob.c | 2 +- contrib/libvhost-user/libvhost-user.c | 2 +- cpus-common.c | 26 +- dump/dump.c | 8 +- exec.c | 49 ++-- hw/core/cpu.c | 6 +- hw/display/qxl.c | 4 +- hw/hyperv/hyperv.c | 10 +- hw/hyperv/vmbus.c | 2 +- hw/i386/xen/xen-hvm.c | 2 +- hw/intc/rx_icu.c | 12 +- hw/intc/sifive_plic.c | 4 +- hw/misc/edu.c | 16 +- hw/net/virtio-net.c | 10 +- hw/rdma/rdma_backend.c | 18 +- hw/rdma/rdma_rm.c | 2 +- hw/rdma/vmw/pvrdma_dev_ring.c | 4 +- hw/s390x/s390-pci-bus.c | 2 +- hw/s390x/virtio-ccw.c | 2 +- hw/virtio/vhost.c | 2 +- hw/virtio/virtio-mmio.c | 6 +- hw/virtio/virtio-pci.c | 6 +- hw/virtio/virtio.c | 16 +- hw/xtensa/pic_cpu.c | 4 +- iothread.c | 6 +- linux-user/hppa/cpu_loop.c | 11 +- linux-user/signal.c | 8 +- migration/colo-failover.c | 4 +- migration/migration.c | 8 +- migration/multifd.c | 18 +- migration/postcopy-ram.c | 34 +-- migration/rdma.c | 34 +-- monitor/hmp.c | 6 +- monitor/misc.c | 2 +- monitor/monitor.c | 6 +- qemu-nbd.c | 2 +- qga/commands.c | 12 +- qom/object.c | 20 +- scsi/qemu-pr-helper.c | 4 +- softmmu/cpu-throttle.c | 10 +- softmmu/cpus.c | 42 +-- softmmu/memory.c | 6 +- softmmu/vl.c | 2 +- target/arm/mte_helper.c | 6 +- target/hppa/op_helper.c | 2 +- target/i386/mem_helper.c | 2 +- target/i386/whpx-all.c | 6 +- target/riscv/cpu_helper.c | 2 +- target/s390x/mem_helper.c | 4 +- target/xtensa/exc_helper.c | 4 +- target/xtensa/op_helper.c | 2 +- tcg/tcg.c | 58 ++-- tcg/tci.c | 2 +- tests/atomic64-bench.c | 14 +- tests/atomic_add-bench.c | 14 +- tests/iothread.c | 2 +- tests/qht-bench.c | 12 +- tests/rcutorture.c | 24 +- tests/test-aio-multithread.c | 52 ++-- tests/test-logging.c | 4 +- tests/test-rcu-list.c | 38 +-- tests/test-thread-pool.c | 10 +- util/aio-posix.c | 14 +- util/aio-wait.c | 2 +- util/aio-win32.c | 5 +- util/async.c | 28 +- util/atomic64.c | 10 +- util/bitmap.c | 15 +- util/cacheinfo.c | 2 +- util/fdmon-epoll.c | 4 +- util/fdmon-io_uring.c | 12 +- util/lockcnt.c | 52 ++-- util/log.c | 10 +- util/qemu-coroutine-lock.c | 18 +- util/qemu-coroutine-sleep.c | 4 +- util/qemu-coroutine.c | 6 +- util/qemu-sockets.c | 4 +- util/qemu-thread-posix.c | 12 +- util/qemu-thread-win32.c | 12 +- util/qemu-timer.c | 12 +- util/qht.c | 57 ++-- util/qsp.c | 50 ++-- util/rcu.c | 38 +-- util/stats64.c | 34 +-- scripts/kernel-doc | 2 +- tcg/aarch64/tcg-target.c.inc | 2 +- tcg/mips/tcg-target.c.inc | 2 +- tcg/ppc/tcg-target.c.inc | 6 +- tcg/sparc/tcg-target.c.inc | 5 +- 133 files changed, 1045 insertions(+), 1018 deletions(-)
Signature · 1 line
2.26.2
PATCH v4 1/2 qemu/atomic: Update coding style to make checkpatch.pl happier
To limit the number of checkpatch errors in the next commit, clean coding style issues first.
---
False positive:
ERROR: Use of volatile is usually wrong, please add a comment #11: FILE: include/qemu/atomic.h:328:
+#define atomic_read__nocheck(p) (*(__typeof__(*(p)) volatile *) (p))
ERROR: Use of volatile is usually wrong, please add a comment
#12: FILE: include/qemu/atomic.h:329:
+#define atomic_set__nocheck(p, i) ((*(__typeof__(*(p)) volatile *) (p)) = (i))
--- include/qemu/atomic.h | 9 +++++---- util/bitmap.c | 3 ++- util/rcu.c | 6 ++++-- 3 files changed, 11 insertions(+), 7 deletions(-)
include/qemu/atomic.h +5 -4
@@ -325,11 +325,11 @@/* These will only be atomic if the processor does the fetch or store * in a single issue memory operation */ -#define atomic_read__nocheck (p) (*(__typeof__(*(p)) volatile*) (p)) -#define atomic_set__nocheck (p, i) ((*(__typeof__(*(p)) volatile*) (p)) = (i)) +#define atomic_read__nocheck (p) (*(__typeof__(*(p)) volatile *) (p)) +#define atomic_set__nocheck (p, i) ((*(__typeof__(*(p)) volatile *) (p)) = (i))#define atomic_read (ptr) atomic_read__nocheck(ptr) -#define atomic_set (ptr, i) atomic_set__nocheck(ptr,i) +#define atomic_set (ptr, i) atomic_set__nocheck(ptr, i)/** * atomic_rcu_read - reads a RCU-protected pointer to a local variable
@@ -440,7 +440,8 @@#endif #endif -/* atomic_mb_read/set semantics map Java volatile variables. They are +/* +* atomic_mb_read/set semantics map Java volatile variables. They are * less expensive on some platforms (notably POWER) than fully * sequentially consistent operations. *
util/bitmap.c +2 -1
@@ -211,7 +211,8 @@ void bitmap_set_atomic(unsigned long *map, long start, long nr) mask_to_set &=BITMAP_LAST_WORD_MASK (size);atomic_or (p, mask_to_set); }else { -/* If we avoided the full barrier in atomic_or(), issue a +/* +* If we avoided the full barrier in atomic_or(), issue a * barrier to account for the assignments in the while loop. */ smp_mb ();
util/rcu.c +4 -2
@@ -82,7 +82,8 @@ static void wait_for_readers(void)*/ qemu_event_reset (&rcu_gp_event); -/* Instead of using atomic_mb_set for index->waiting, and +/* +* Instead of using atomic_mb_set for index->waiting, and * atomic_mb_read for index->ctr, memory barriers are placed * manually since writes to different threads are independent. * qemu_event_reset has acquire semantics, so no memory barrier
@@ -151,7 +152,8 @@ void synchronize_rcu(void)QEMU_LOCK_GUARD (&rcu_registry_lock);if (!QLIST_EMPTY (®istry)) { -/* In either case, the atomic_mb_set below blocks stores that free +/* +* In either case, the atomic_mb_set below blocks stores that free * old RCU-protected pointers. */ if (sizeof (rcu_gp_ctr) <8 ) {
Signature · 1 line
2.26.2
Re: [PATCH v4 1/2] qemu/atomic: Update coding style to make checkpatch.pl happier
Quoted 11 lines · Philippe Mathieu-Daudé
To limit the number of checkpatch errors in the next commit, clean coding style issues first.
Signed-off-by Philippe Mathieu-Daudé <[email protected]>---
False positive:ERROR: Use of volatile is usually wrong, please add a comment #11: FILE:
include/qemu/atomic.h:328:
+#defineatomic_read__nocheck(p)(*(__typeof__(*(p)) volatile *) (p))
Quoted 8 lines
ERROR: Use of volatile is usually wrong, please add a comment
#12: FILE:include/qemu/atomic.h:329:
+#defineatomic_set__nocheck(p, i)((*(__typeof__(*(p)) volatile *) (p)) = (i))--- include/qemu/atomic.h | 9 +++++---- util/bitmap.c | 3 ++- util/rcu.c | 6 ++++-- 3 files changed, 11 insertions(+), 7 deletions(-)
I already sent a pull request with the patch that renames atomic.h, but this patch can be rebased on top:
Re: [PATCH v4 1/2] qemu/atomic: Update coding style to make checkpatch.pl happier
will be also nice to squash the following on top for a complete clean checkpatch version, as the original patch introduces at least 1 issue
Carlo
--- >8 ---
Subject: fixup! [PATCH 1/2] qemu/atomic.h: rename atomic_ to qatomic_
fixes:
ERROR: Macros with multiple statements should be enclosed in a do - while loop
+#define qatomic_rcu_read__nocheck(ptr, valptr) \
+ __atomic_load(ptr, valptr, __ATOMIC_RELAXED); \
smp_read_barrier_depends();false positive:
ERROR: memory barrier without comment
+#define qatomic_xchg(ptr, i) (smp_mb(), __sync_lock_test_and_set(ptr, i))
--- include/qemu/atomic.h | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-)
include/qemu/atomic.h +3 -2
@@ -149,9 +149,10 @@#define qatomic_rcu_read__nocheck (ptr, valptr) \ __atomic_load(ptr, valptr, __ATOMIC_CONSUME);#else -#define qatomic_rcu_read__nocheck (ptr, valptr) \ +#define qatomic_rcu_read__nocheck (ptr, valptr) do { \ __atomic_load(ptr, valptr, __ATOMIC_RELAXED); \ - smp_read_barrier_depends(); + smp_read_barrier_depends(); \ +} while (0)#endif #define qatomic_rcu_read (ptr) \
Signature · 1 line
2.28.0.681.g6f77f65b4e
PATCH v4 2/2 qemu/atomic.h: rename atomic_ to qatomic_
In reply to Philippe Mathieu-DaudéFrom: Stefan Hajnoczi <[email protected]>
clang's C11 atomic_fetch_*() functions only take a C11 atomic type pointer argument. QEMU uses direct types (int, etc) and this causes a compiler error when a QEMU code calls these functions in a source file that also included <stdatomic.h> via a system header file:
$ CC=clang CXX=clang++ ./configure ... && make
../util/async.c:79:17: error: address argument to atomic operation must be a pointer to _Atomic type ('unsigned int *' invalid)Avoid using atomic_*() names in QEMU's atomic.h since that namespace is used by <stdatomic.h>. Prefix QEMU's APIs with 'q' so that atomic.h and <stdatomic.h> can co-exist. I checked /usr/include on my machine and searched GitHub for existing "qatomic_" users but there seem to be none.
This patch was generated using:
$ git grep -h -o '\<atomic\(64\)\?_[a-z0-9_]\+' include/qemu/atomic.h | \
sort -u >/tmp/changed_identifiers
$ for identifier in $(</tmp/changed_identifiers); do
sed -i "s%\<$identifier\>%q$identifier%g" \
$(git grep -I -l "\<$identifier\>")
doneI manually fixed line-wrap issues and misaligned rST tables.
Message-Id: <[email protected]>
---
Patch easier to review using 'git-diff --color-words'.
--- docs/devel/atomics.rst | 134 +++++----- docs/devel/lockcnt.txt | 8 +- docs/devel/rcu.txt | 34 +-- accel/tcg/atomic_template.h | 20 +- include/block/aio-wait.h | 4 +- include/block/aio.h | 8 +- include/exec/cpu_ldst.h | 2 +- include/exec/exec-all.h | 6 +- include/exec/log.h | 6 +- include/exec/memory.h | 2 +- include/exec/ram_addr.h | 26 +- include/exec/ramlist.h | 2 +- include/exec/tb-lookup.h | 4 +- include/hw/core/cpu.h | 2 +- include/qemu/atomic.h | 248 +++++++++--------- include/qemu/atomic128.h | 6 +- include/qemu/bitops.h | 2 +- include/qemu/coroutine.h | 2 +- include/qemu/log.h | 6 +- include/qemu/queue.h | 7 +- include/qemu/rcu.h | 10 +- include/qemu/rcu_queue.h | 100 +++---- include/qemu/seqlock.h | 8 +- include/qemu/stats64.h | 28 +- include/qemu/thread.h | 24 +- .../infiniband/hw/vmw_pvrdma/pvrdma_ring.h | 14 +- linux-user/qemu.h | 2 +- tcg/i386/tcg-target.h | 2 +- tcg/s390/tcg-target.h | 2 +- tcg/tci/tcg-target.h | 2 +- accel/kvm/kvm-all.c | 12 +- accel/tcg/cpu-exec.c | 15 +- accel/tcg/cputlb.c | 24 +- accel/tcg/tcg-all.c | 2 +- accel/tcg/translate-all.c | 55 ++-- audio/jackaudio.c | 18 +- block.c | 4 +- block/block-backend.c | 15 +- block/io.c | 48 ++-- block/nfs.c | 2 +- block/sheepdog.c | 2 +- block/throttle-groups.c | 12 +- block/throttle.c | 4 +- blockdev.c | 2 +- blockjob.c | 2 +- contrib/libvhost-user/libvhost-user.c | 2 +- cpus-common.c | 26 +- dump/dump.c | 8 +- exec.c | 49 ++-- hw/core/cpu.c | 6 +- hw/display/qxl.c | 4 +- hw/hyperv/hyperv.c | 10 +- hw/hyperv/vmbus.c | 2 +- hw/i386/xen/xen-hvm.c | 2 +- hw/intc/rx_icu.c | 12 +- hw/intc/sifive_plic.c | 4 +- hw/misc/edu.c | 16 +- hw/net/virtio-net.c | 10 +- hw/rdma/rdma_backend.c | 18 +- hw/rdma/rdma_rm.c | 2 +- hw/rdma/vmw/pvrdma_dev_ring.c | 4 +- hw/s390x/s390-pci-bus.c | 2 +- hw/s390x/virtio-ccw.c | 2 +- hw/virtio/vhost.c | 2 +- hw/virtio/virtio-mmio.c | 6 +- hw/virtio/virtio-pci.c | 6 +- hw/virtio/virtio.c | 16 +- hw/xtensa/pic_cpu.c | 4 +- iothread.c | 6 +- linux-user/hppa/cpu_loop.c | 11 +- linux-user/signal.c | 8 +- migration/colo-failover.c | 4 +- migration/migration.c | 8 +- migration/multifd.c | 18 +- migration/postcopy-ram.c | 34 +-- migration/rdma.c | 34 +-- monitor/hmp.c | 6 +- monitor/misc.c | 2 +- monitor/monitor.c | 6 +- qemu-nbd.c | 2 +- qga/commands.c | 12 +- qom/object.c | 20 +- scsi/qemu-pr-helper.c | 4 +- softmmu/cpu-throttle.c | 10 +- softmmu/cpus.c | 42 +-- softmmu/memory.c | 6 +- softmmu/vl.c | 2 +- target/arm/mte_helper.c | 6 +- target/hppa/op_helper.c | 2 +- target/i386/mem_helper.c | 2 +- target/i386/whpx-all.c | 6 +- target/riscv/cpu_helper.c | 2 +- target/s390x/mem_helper.c | 4 +- target/xtensa/exc_helper.c | 4 +- target/xtensa/op_helper.c | 2 +- tcg/tcg.c | 58 ++-- tcg/tci.c | 2 +- tests/atomic64-bench.c | 14 +- tests/atomic_add-bench.c | 14 +- tests/iothread.c | 2 +- tests/qht-bench.c | 12 +- tests/rcutorture.c | 24 +- tests/test-aio-multithread.c | 52 ++-- tests/test-logging.c | 4 +- tests/test-rcu-list.c | 38 +-- tests/test-thread-pool.c | 10 +- util/aio-posix.c | 14 +- util/aio-wait.c | 2 +- util/aio-win32.c | 5 +- util/async.c | 28 +- util/atomic64.c | 10 +- util/bitmap.c | 14 +- util/cacheinfo.c | 2 +- util/fdmon-epoll.c | 4 +- util/fdmon-io_uring.c | 12 +- util/lockcnt.c | 52 ++-- util/log.c | 10 +- util/qemu-coroutine-lock.c | 18 +- util/qemu-coroutine-sleep.c | 4 +- util/qemu-coroutine.c | 6 +- util/qemu-sockets.c | 4 +- util/qemu-thread-posix.c | 12 +- util/qemu-thread-win32.c | 12 +- util/qemu-timer.c | 12 +- util/qht.c | 57 ++-- util/qsp.c | 50 ++-- util/rcu.c | 36 +-- util/stats64.c | 34 +-- scripts/kernel-doc | 2 +- tcg/aarch64/tcg-target.c.inc | 2 +- tcg/mips/tcg-target.c.inc | 2 +- tcg/ppc/tcg-target.c.inc | 6 +- tcg/sparc/tcg-target.c.inc | 5 +- 133 files changed, 1041 insertions(+), 1018 deletions(-)
docs/devel/atomics.rst +67 -67
@@ -23,9 +23,9 @@ provides macros that fall in three camps: - compiler barriers: ``barrier()``; -- weak atomic access and manual memory barriers: ``atomic_read()``, - ``atomic_set()``, ``smp_rmb()``, ``smp_wmb()``, ``smp_mb()``, ``smp_mb_acquire()``, - ``smp_mb_release()``, ``smp_read_barrier_depends()``; +- weak atomic access and manual memory barriers: ``qatomic_read()``, + ``qatomic_set()``, ``smp_rmb()``, ``smp_wmb()``, ``smp_mb()``, + ``smp_mb_acquire()``, ``smp_mb_release()``, ``smp_read_barrier_depends()``; - sequentially consistent atomic access: everything else.
@@ -67,23 +67,23 @@ in the order specified by its program". ``qemu/atomic.h`` provides the following set of atomic read-modify-write operations:: - void atomic_inc(ptr) - void atomic_dec(ptr) - void atomic_add(ptr, val) - void atomic_sub(ptr, val) - void atomic_and(ptr, val) - void atomic_or(ptr, val) + void qatomic_inc(ptr) + void qatomic_dec(ptr) + void qatomic_add(ptr, val) + void qatomic_sub(ptr, val) + void qatomic_and(ptr, val) + void qatomic_or(ptr, val) - typeof(*ptr) atomic_fetch_inc(ptr) - typeof(*ptr) atomic_fetch_dec(ptr) - typeof(*ptr) atomic_fetch_add(ptr, val) - typeof(*ptr) atomic_fetch_sub(ptr, val) - typeof(*ptr) atomic_fetch_and(ptr, val) - typeof(*ptr) atomic_fetch_or(ptr, val) - typeof(*ptr) atomic_fetch_xor(ptr, val) - typeof(*ptr) atomic_fetch_inc_nonzero(ptr) - typeof(*ptr) atomic_xchg(ptr, val) - typeof(*ptr) atomic_cmpxchg(ptr, old, new) + typeof(*ptr) qatomic_fetch_inc(ptr) + typeof(*ptr) qatomic_fetch_dec(ptr) + typeof(*ptr) qatomic_fetch_add(ptr, val) + typeof(*ptr) qatomic_fetch_sub(ptr, val) + typeof(*ptr) qatomic_fetch_and(ptr, val) + typeof(*ptr) qatomic_fetch_or(ptr, val) + typeof(*ptr) qatomic_fetch_xor(ptr, val) + typeof(*ptr) qatomic_fetch_inc_nonzero(ptr) + typeof(*ptr) qatomic_xchg(ptr, val) + typeof(*ptr) qatomic_cmpxchg(ptr, old, new) all of which return the old value of ``*ptr``. These operations are polymorphic; they operate on any type that is as wide as a pointer or
@@ -91,19 +91,19 @@ smaller. Similar operations return the new value of ``*ptr``:: - typeof(*ptr) atomic_inc_fetch(ptr) - typeof(*ptr) atomic_dec_fetch(ptr) - typeof(*ptr) atomic_add_fetch(ptr, val) - typeof(*ptr) atomic_sub_fetch(ptr, val) - typeof(*ptr) atomic_and_fetch(ptr, val) - typeof(*ptr) atomic_or_fetch(ptr, val) - typeof(*ptr) atomic_xor_fetch(ptr, val) + typeof(*ptr) qatomic_inc_fetch(ptr) + typeof(*ptr) qatomic_dec_fetch(ptr) + typeof(*ptr) qatomic_add_fetch(ptr, val) + typeof(*ptr) qatomic_sub_fetch(ptr, val) + typeof(*ptr) qatomic_and_fetch(ptr, val) + typeof(*ptr) qatomic_or_fetch(ptr, val) + typeof(*ptr) qatomic_xor_fetch(ptr, val) ``qemu/atomic.h`` also provides loads and stores that cannot be reordered with each other:: - typeof(*ptr) atomic_mb_read(ptr) - void atomic_mb_set(ptr, val) + typeof(*ptr) qatomic_mb_read(ptr) + void qatomic_mb_set(ptr, val) However these do not provide sequential consistency and, in particular, they do not participate in the total ordering enforced by
@@ -115,11 +115,11 @@ easiest to hardest): - lightweight synchronization primitives such as ``QemuEvent`` -- RCU operations (``atomic_rcu_read``, ``atomic_rcu_set``) when publishing +- RCU operations (``qatomic_rcu_read``, ``qatomic_rcu_set``) when publishing or accessing a new version of a data structure -- other atomic accesses: ``atomic_read`` and ``atomic_load_acquire`` for - loads, ``atomic_set`` and ``atomic_store_release`` for stores, ``smp_mb`` +- other atomic accesses: ``qatomic_read`` and ``qatomic_load_acquire`` for + loads, ``qatomic_set`` and ``qatomic_store_release`` for stores, ``smp_mb`` to forbid reordering subsequent loads before a store.
@@ -149,22 +149,22 @@ The only guarantees that you can rely upon in this case are: When using this model, variables are accessed with: -- ``atomic_read()`` and ``atomic_set()``; these prevent the compiler from +- ``qatomic_read()`` and ``qatomic_set()``; these prevent the compiler from optimizing accesses out of existence and creating unsolicited accesses, but do not otherwise impose any ordering on loads and stores: both the compiler and the processor are free to reorder them. -- ``atomic_load_acquire()``, which guarantees the LOAD to appear to +- ``qatomic_load_acquire()``, which guarantees the LOAD to appear to happen, with respect to the other components of the system, before all the LOAD or STORE operations specified afterwards. - Operations coming before ``atomic_load_acquire()`` can still be + Operations coming before ``qatomic_load_acquire()`` can still be reordered after it. -- ``atomic_store_release()``, which guarantees the STORE to appear to +- ``qatomic_store_release()``, which guarantees the STORE to appear to happen, with respect to the other components of the system, after all the LOAD or STORE operations specified before. - Operations coming after ``atomic_store_release()`` can still be + Operations coming after ``qatomic_store_release()`` can still be reordered before it. Restrictions to the ordering of accesses can also be specified
@@ -229,7 +229,7 @@ They come in six kinds: dependency and a full read barrier or better is required. -Memory barriers and ``atomic_load_acquire``/``atomic_store_release`` are +Memory barriers and ``qatomic_load_acquire``/``qatomic_store_release`` are mostly used when a data structure has one thread that is always a writer and one thread that is always a reader:
@@ -238,8 +238,8 @@ and one thread that is always a reader: +==================================+==================================+ | :: | :: | | | | - | atomic_store_release(&a, x); | y = atomic_load_acquire(&b); | - | atomic_store_release(&b, y); | x = atomic_load_acquire(&a); | + | qatomic_store_release(&a, x); | y = qatomic_load_acquire(&b); | + | qatomic_store_release(&b, y); | x = qatomic_load_acquire(&a); | +----------------------------------+----------------------------------+ In this case, correctness is easy to check for using the "pairing"
@@ -258,14 +258,14 @@ outside a loop. For example: | | | | n = 0; | n = 0; | | for (i = 0; i < 10; i++) | for (i = 0; i < 10; i++) | - | n += atomic_load_acquire(&a[i]); | n += atomic_read(&a[i]); | + | n += qatomic_load_acquire(&a[i]); | n += qatomic_read(&a[i]); | | | smp_mb_acquire(); | +------------------------------------------+----------------------------------+ | :: | :: | | | | | | smp_mb_release(); | | for (i = 0; i < 10; i++) | for (i = 0; i < 10; i++) | - | atomic_store_release(&a[i], false); | atomic_set(&a[i], false); | + | qatomic_store_release(&a[i], false); | qatomic_set(&a[i], false); | +------------------------------------------+----------------------------------+ Splitting a loop can also be useful to reduce the number of barriers:
@@ -277,11 +277,11 @@ Splitting a loop can also be useful to reduce the number of barriers: | | | | n = 0; | smp_mb_release(); | | for (i = 0; i < 10; i++) { | for (i = 0; i < 10; i++) | - | atomic_store_release(&a[i], false); | atomic_set(&a[i], false); | + | qatomic_store_release(&a[i], false); | qatomic_set(&a[i], false); | | smp_mb(); | smb_mb(); | - | n += atomic_read(&b[i]); | n = 0; | + | n += qatomic_read(&b[i]); | n = 0; | | } | for (i = 0; i < 10; i++) | - | | n += atomic_read(&b[i]); | + | | n += qatomic_read(&b[i]); | +------------------------------------------+----------------------------------+ In this case, a ``smp_mb_release()`` is also replaced with a (possibly cheaper, and clearer
@@ -294,10 +294,10 @@ as well) ``smp_wmb()``: | | | | | smp_mb_release(); | | for (i = 0; i < 10; i++) { | for (i = 0; i < 10; i++) | - | atomic_store_release(&a[i], false); | atomic_set(&a[i], false); | - | atomic_store_release(&b[i], false); | smb_wmb(); | + | qatomic_store_release(&a[i], false); | qatomic_set(&a[i], false); | + | qatomic_store_release(&b[i], false); | smb_wmb(); | | } | for (i = 0; i < 10; i++) | - | | atomic_set(&b[i], false); | + | | qatomic_set(&b[i], false); | +------------------------------------------+----------------------------------+
@@ -306,7 +306,7 @@ as well) ``smp_wmb()``: Acquire/release pairing and the *synchronizes-with* relation ------------------------------------------------------------ -Atomic operations other than ``atomic_set()`` and ``atomic_read()`` have +Atomic operations other than ``qatomic_set()`` and ``qatomic_read()`` have either *acquire* or *release* semantics [#rmw]_. This has two effects: .. [#rmw] Read-modify-write operations can have both---acquire applies to the
@@ -357,16 +357,16 @@ thread 2 is relying on the *synchronizes-with* relation between ``pthread_exit`` Synchronization between threads basically descends from this pairing of a release operation and an acquire operation. Therefore, atomic operations -other than ``atomic_set()`` and ``atomic_read()`` will almost always be +other than ``qatomic_set()`` and ``qatomic_read()`` will almost always be paired with another operation of the opposite kind: an acquire operation will pair with a release operation and vice versa. This rule of thumb is extremely useful; in the case of QEMU, however, note that the other operation may actually be in a driver that runs in the guest! ``smp_read_barrier_depends()``, ``smp_rmb()``, ``smp_mb_acquire()``, -``atomic_load_acquire()`` and ``atomic_rcu_read()`` all count +``qatomic_load_acquire()`` and ``qatomic_rcu_read()`` all count as acquire operations. ``smp_wmb()``, ``smp_mb_release()``, -``atomic_store_release()`` and ``atomic_rcu_set()`` all count as release +``qatomic_store_release()`` and ``qatomic_rcu_set()`` all count as release operations. ``smp_mb()`` counts as both acquire and release, therefore it can pair with any other atomic operation. Here is an example:
@@ -375,11 +375,11 @@ it can pair with any other atomic operation. Here is an example: +======================+==============================+ | :: | :: | | | | - | atomic_set(&a, 1); | | + | qatomic_set(&a, 1);| | | smp_wmb(); | | - | atomic_set(&b, 2); | x = atomic_read(&b); | + | qatomic_set(&b, 2);| x = qatomic_read(&b); | | | smp_rmb(); | - | | y = atomic_read(&a); | + | | y = qatomic_read(&a); | +----------------------+------------------------------+ Note that a load-store pair only counts if the two operations access the
@@ -393,9 +393,9 @@ correct synchronization: +================================+================================+ | :: | :: | | | | - | atomic_set(&a, 1); | | - | atomic_store_release(&b, 2); | x = atomic_load_acquire(&b); | - | | y = atomic_read(&a); | + | qatomic_set(&a, 1); | | + | qatomic_store_release(&b, 2);| x = qatomic_load_acquire(&b);| + | | y = qatomic_read(&a); | +--------------------------------+--------------------------------+ Acquire and release semantics of higher-level primitives can also be
@@ -421,7 +421,7 @@ cannot be a data race: | smp_wmb(); | | | x->i = 2; | | | smp_wmb(); | | - | atomic_set(&a, x); | x = atomic_read(&a); | + | qatomic_set(&a, x);| x = qatomic_read(&a); | | | smp_read_barrier_depends(); | | | y = x->i; | | | smp_read_barrier_depends(); |
@@ -442,7 +442,7 @@ and memory barriers, and the equivalents in QEMU: at all. Linux 4.1 updated them to implement volatile semantics via ``ACCESS_ONCE`` (or the more recent ``READ``/``WRITE_ONCE``). - QEMU's ``atomic_read`` and ``atomic_set`` implement C11 atomic relaxed + QEMU's ``qatomic_read`` and ``qatomic_set`` implement C11 atomic relaxed semantics if the compiler supports it, and volatile semantics otherwise. Both semantics prevent the compiler from doing certain transformations; the difference is that atomic accesses are guaranteed to be atomic,
@@ -451,8 +451,8 @@ and memory barriers, and the equivalents in QEMU: since we assume the variables passed are machine-word sized and properly aligned. - No barriers are implied by ``atomic_read`` and ``atomic_set`` in either Linux - or QEMU. + No barriers are implied by ``qatomic_read`` and ``qatomic_set`` in either + Linux or QEMU. - atomic read-modify-write operations in Linux are of three kinds:
@@ -469,7 +469,7 @@ and memory barriers, and the equivalents in QEMU: a different set of memory barriers; in QEMU, all of them enforce sequential consistency. -- in QEMU, ``atomic_read()`` and ``atomic_set()`` do not participate in +- in QEMU, ``qatomic_read()`` and ``qatomic_set()`` do not participate in the total ordering enforced by sequentially-consistent operations. This is because QEMU uses the C11 memory model. The following example is correct in Linux but not in QEMU:
@@ -479,8 +479,8 @@ and memory barriers, and the equivalents in QEMU: +==================================+================================+ | :: | :: | | | | - | a = atomic_fetch_add(&x, 2); | a = atomic_fetch_add(&x, 2); | - | b = READ_ONCE(&y); | b = atomic_read(&y); | + | a = atomic_fetch_add(&x, 2); | a = qatomic_fetch_add(&x, 2);| + | b = READ_ONCE(&y); | b = qatomic_read(&y); | +----------------------------------+--------------------------------+ because the read of ``y`` can be moved (by either the processor or the
@@ -495,10 +495,10 @@ and memory barriers, and the equivalents in QEMU: +================================+ | :: | | | - | a = atomic_read(&x); | - | atomic_set(&x, a + 2); | + | a = qatomic_read(&x); | + | qatomic_set(&x, a + 2); | | smp_mb(); | - | b = atomic_read(&y); | + | b = qatomic_read(&y); | +--------------------------------+ Sources
docs/devel/lockcnt.txt +4 -4
@@ -95,7 +95,7 @@ not just frees, though there could be cases where this is not necessary. Reads, instead, can be done without taking the mutex, as long as the readers and writers use the same macros that are used for RCU, for -example atomic_rcu_read, atomic_rcu_set, QLIST_FOREACH_RCU, etc. This is +example qatomic_rcu_read, qatomic_rcu_set, QLIST_FOREACH_RCU, etc. This is because the reads are done outside a lock and a set or QLIST_INSERT_HEAD can happen concurrently with the read. The RCU API ensures that the processor and the compiler see all required memory barriers.
@@ -189,7 +189,7 @@ qemu_lockcnt_lock and qemu_lockcnt_unlock: if (!xyz) { new_xyz = g_new(XYZ, 1); ... - atomic_rcu_set(&xyz, new_xyz); + qatomic_rcu_set(&xyz, new_xyz); } qemu_lockcnt_unlock(&xyz_lockcnt);
@@ -198,7 +198,7 @@ qemu_lockcnt_dec: qemu_lockcnt_inc(&xyz_lockcnt); if (xyz) { - XYZ *p = atomic_rcu_read(&xyz); + XYZ *p = qatomic_rcu_read(&xyz); ... /* Accesses can now be done through "p". */ }
@@ -222,7 +222,7 @@ the decrement, the locking and the check on count as follows: qemu_lockcnt_inc(&xyz_lockcnt); if (xyz) { - XYZ *p = atomic_rcu_read(&xyz); + XYZ *p = qatomic_rcu_read(&xyz); ... /* Accesses can now be done through "p". */ }
docs/devel/rcu.txt +17 -17
@@ -130,13 +130,13 @@ The core RCU API is small: g_free_rcu(&foo, rcu); - typeof(*p) atomic_rcu_read(p); + typeof(*p) qatomic_rcu_read(p); - atomic_rcu_read() is similar to atomic_load_acquire(), but it makes + qatomic_rcu_read() is similar to qatomic_load_acquire(), but it makes some assumptions on the code that calls it. This allows a more optimized implementation. - atomic_rcu_read assumes that whenever a single RCU critical + qatomic_rcu_read assumes that whenever a single RCU critical section reads multiple shared data, these reads are either data-dependent or need no ordering. This is almost always the case when using RCU, because read-side critical sections typically
@@ -144,7 +144,7 @@ The core RCU API is small: every update) until reaching a data structure of interest, and then read from there. - RCU read-side critical sections must use atomic_rcu_read() to + RCU read-side critical sections must use qatomic_rcu_read() to read data, unless concurrent writes are prevented by another synchronization mechanism.
@@ -152,18 +152,18 @@ The core RCU API is small: data structure in a single direction, opposite to the direction in which the updater initializes it. - void atomic_rcu_set(p, typeof(*p) v); + void qatomic_rcu_set(p, typeof(*p) v); - atomic_rcu_set() is similar to atomic_store_release(), though it also + qatomic_rcu_set() is similar to qatomic_store_release(), though it also makes assumptions on the code that calls it in order to allow a more optimized implementation. - In particular, atomic_rcu_set() suffices for synchronization + In particular, qatomic_rcu_set() suffices for synchronization with readers, if the updater never mutates a field within a data item that is already accessible to readers. This is the case when initializing a new copy of the RCU-protected data structure; just ensure that initialization of *p is carried out - before atomic_rcu_set() makes the data item visible to readers. + before qatomic_rcu_set() makes the data item visible to readers. If this rule is observed, writes will happen in the opposite order as reads in the RCU read-side critical sections (or if there is just one update), and there will be no need for other
@@ -212,7 +212,7 @@ DIFFERENCES WITH LINUX programming; not allowing this would prevent upgrading an RCU read-side critical section to become an updater. -- atomic_rcu_read and atomic_rcu_set replace rcu_dereference and +- qatomic_rcu_read and qatomic_rcu_set replace rcu_dereference and rcu_assign_pointer. They take a _pointer_ to the variable being accessed. - call_rcu is a macro that has an extra argument (the name of the first
@@ -257,7 +257,7 @@ may be used as a restricted reference-counting mechanism. For example, consider the following code fragment: rcu_read_lock(); - p = atomic_rcu_read(&foo); + p = qatomic_rcu_read(&foo); /* do something with p. */ rcu_read_unlock();
@@ -268,7 +268,7 @@ The write side looks simply like this (with appropriate locking): qemu_mutex_lock(&foo_mutex); old = foo; - atomic_rcu_set(&foo, new); + qatomic_rcu_set(&foo, new); qemu_mutex_unlock(&foo_mutex); synchronize_rcu(); free(old);
@@ -277,7 +277,7 @@ If the processing cannot be done purely within the critical section, it is possible to combine this idiom with a "real" reference count: rcu_read_lock(); - p = atomic_rcu_read(&foo); + p = qatomic_rcu_read(&foo); foo_ref(p); rcu_read_unlock(); /* do something with p. */
@@ -287,7 +287,7 @@ The write side can be like this: qemu_mutex_lock(&foo_mutex); old = foo; - atomic_rcu_set(&foo, new); + qatomic_rcu_set(&foo, new); qemu_mutex_unlock(&foo_mutex); synchronize_rcu(); foo_unref(old);
@@ -296,7 +296,7 @@ or with call_rcu: qemu_mutex_lock(&foo_mutex); old = foo; - atomic_rcu_set(&foo, new); + qatomic_rcu_set(&foo, new); qemu_mutex_unlock(&foo_mutex); call_rcu(foo_unref, old, rcu);
@@ -307,7 +307,7 @@ last reference may be dropped on the read side. Hence you can use call_rcu() instead: foo_unref(struct foo *p) { - if (atomic_fetch_dec(&p->refcount) == 1) { + if (qatomic_fetch_dec(&p->refcount) == 1) { call_rcu(foo_destroy, p, rcu); } }
@@ -375,7 +375,7 @@ Instead, we store the size of the array with the array itself: read side: rcu_read_lock(); - struct arr *array = atomic_rcu_read(&global_array); + struct arr *array = qatomic_rcu_read(&global_array); x = i < array->size ? array->data[i] : -1; rcu_read_unlock(); return x;
@@ -392,7 +392,7 @@ Instead, we store the size of the array with the array itself: /* Removal phase. */ old_array = global_array; - atomic_rcu_set(&new_array->data, new_array); + qatomic_rcu_set(&new_array->data, new_array); synchronize_rcu(); /* Reclamation phase. */
accel/tcg/atomic_template.h +10 -10
@@ -83,7 +83,7 @@ ABI_TYPE ATOMIC_NAME(cmpxchg)(CPUArchState *env, target_ulong addr,#if DATA_SIZE ==16 ret =atomic16_cmpxchg (haddr, cmpv, newv);#else - ret =atomic_cmpxchg__nocheck (haddr, cmpv, newv); + ret =qatomic_cmpxchg__nocheck (haddr, cmpv, newv);#endif ATOMIC_MMU_CLEANUP ;atomic_trace_rmw_post (env, addr, info);
@@ -131,7 +131,7 @@ ABI_TYPE ATOMIC_NAME(xchg)(CPUArchState *env, target_ulong addr, ATOMIC_MMU_IDX);atomic_trace_rmw_pre (env, addr, info); - ret =atomic_xchg__nocheck (haddr, val); + ret =qatomic_xchg__nocheck (haddr, val);ATOMIC_MMU_CLEANUP ;atomic_trace_rmw_post (env, addr, info);return ret;
@@ -147,7 +147,7 @@ ABI_TYPE ATOMIC_NAME(X)(CPUArchState *env, target_ulong addr, \uint16_t info =trace_mem_build_info (SHIFT , false,0 , false, \ATOMIC_MMU_IDX ); \atomic_trace_rmw_pre (env, addr, info); \ - ret = atomic_##X(haddr, val); \ + ret = qatomic_##X(haddr, val); \ ATOMIC_MMU_CLEANUP; \ atomic_trace_rmw_post(env, addr, info); \ return ret; \
@@ -182,10 +182,10 @@ ABI_TYPE ATOMIC_NAME(X)(CPUArchState *env, target_ulong addr, \ ATOMIC_MMU_IDX); \atomic_trace_rmw_pre (env, addr, info); \smp_mb (); \ - cmp =atomic_read__nocheck (haddr); \ + cmp =qatomic_read__nocheck (haddr); \do { \ old = cmp; new =FN (old, val); \ - cmp =atomic_cmpxchg__nocheck (haddr, old, new); \ + cmp =qatomic_cmpxchg__nocheck (haddr, old, new); \ }while (cmp != old); \ATOMIC_MMU_CLEANUP ; \atomic_trace_rmw_post (env, addr, info); \
@@ -230,7 +230,7 @@ ABI_TYPE ATOMIC_NAME(cmpxchg)(CPUArchState *env, target_ulong addr,#if DATA_SIZE ==16 ret =atomic16_cmpxchg (haddr,BSWAP (cmpv),BSWAP (newv));#else - ret =atomic_cmpxchg__nocheck (haddr,BSWAP (cmpv),BSWAP (newv)); + ret =qatomic_cmpxchg__nocheck (haddr,BSWAP (cmpv),BSWAP (newv));#endif ATOMIC_MMU_CLEANUP ;atomic_trace_rmw_post (env, addr, info);
@@ -280,7 +280,7 @@ ABI_TYPE ATOMIC_NAME(xchg)(CPUArchState *env, target_ulong addr, ATOMIC_MMU_IDX);atomic_trace_rmw_pre (env, addr, info); - ret =atomic_xchg__nocheck (haddr,BSWAP (val)); + ret =qatomic_xchg__nocheck (haddr,BSWAP (val));ATOMIC_MMU_CLEANUP ;atomic_trace_rmw_post (env, addr, info);return BSWAP (ret);
@@ -296,7 +296,7 @@ ABI_TYPE ATOMIC_NAME(X)(CPUArchState *env, target_ulong addr, \uint16_t info =trace_mem_build_info (SHIFT , false,MO_BSWAP , \ false,ATOMIC_MMU_IDX ); \atomic_trace_rmw_pre (env, addr, info); \ - ret = atomic_##X(haddr, BSWAP(val)); \ + ret = qatomic_##X(haddr, BSWAP(val)); \ ATOMIC_MMU_CLEANUP; \ atomic_trace_rmw_post(env, addr, info); \ return BSWAP(ret); \
@@ -329,10 +329,10 @@ ABI_TYPE ATOMIC_NAME(X)(CPUArchState *env, target_ulong addr, \ false, ATOMIC_MMU_IDX); \atomic_trace_rmw_pre (env, addr, info); \smp_mb (); \ - ldn =atomic_read__nocheck (haddr); \ + ldn =qatomic_read__nocheck (haddr); \do { \ ldo = ldn; old =BSWAP (ldo); new =FN (old, val); \ - ldn =atomic_cmpxchg__nocheck (haddr, ldo,BSWAP (new)); \ + ldn =qatomic_cmpxchg__nocheck (haddr, ldo,BSWAP (new)); \ }while (ldo != ldn); \ATOMIC_MMU_CLEANUP ; \atomic_trace_rmw_post (env, addr, info); \
include/block/aio-wait.h +2 -2
@@ -80,7 +80,7 @@ extern AioWait global_aio_wait;AioWait *wait_ = &global_aio_wait; \AioContext *ctx_ = (ctx); \/* Increment wait_->num_waiters before evaluating cond. */ \ -atomic_inc (&wait_->num_waiters); \ +qatomic_inc (&wait_->num_waiters); \if (ctx_ &&in_aio_context_home_thread (ctx_)) { \while ((cond)) { \aio_poll (ctx_, true); \
@@ -100,7 +100,7 @@ extern AioWait global_aio_wait; waited_ = true; \ } \ } \ -atomic_dec (&wait_->num_waiters); \ +qatomic_dec (&wait_->num_waiters); \ waited_; })/**
include/block/aio.h +4 -4
@@ -595,7 +595,7 @@ int64_t aio_compute_timeout(AioContext *ctx);*/ static inline void aio_disable_external (AioContext *ctx) { -atomic_inc (&ctx->external_disable_cnt); +qatomic_inc (&ctx->external_disable_cnt); }/**
@@ -608,7 +608,7 @@ static inline void aio_enable_external(AioContext *ctx) {int old; - old =atomic_fetch_dec (&ctx->external_disable_cnt); + old =qatomic_fetch_dec (&ctx->external_disable_cnt);assert (old >0 );if (old ==1 ) {/* Kick event loop so it re-arms file descriptors */
@@ -624,7 +624,7 @@ static inline void aio_enable_external(AioContext *ctx)*/ static inline bool aio_external_disabled (AioContext *ctx) { -return atomic_read (&ctx->external_disable_cnt); +return qatomic_read (&ctx->external_disable_cnt); }/**
@@ -637,7 +637,7 @@ static inline bool aio_external_disabled(AioContext *ctx)*/ static inline bool aio_node_check (AioContext *ctx,bool is_external) { -return !is_external || !atomic_read (&ctx->external_disable_cnt); +return !is_external || !qatomic_read (&ctx->external_disable_cnt); }/**
include/exec/cpu_ldst.h +1 -1
@@ -299,7 +299,7 @@ static inline target_ulong tlb_addr_write(const CPUTLBEntry *entry)#if TCG_OVERSIZED_GUEST return entry->addr_write;#else -return atomic_read (&entry->addr_write); +return qatomic_read (&entry->addr_write);#endif }
include/exec/exec-all.h +3 -3
@@ -89,7 +89,7 @@ void QEMU_NORETURN cpu_loop_exit_atomic(CPUState *cpu, uintptr_t pc);*/ static inline bool cpu_loop_exit_requested (CPUState *cpu) { -return (int32_t )atomic_read (&cpu_neg (cpu)->icount_decr.u32) <0 ; +return (int32_t )qatomic_read (&cpu_neg (cpu)->icount_decr.u32) <0 ; }#if !defined(CONFIG_USER_ONLY )
@@ -487,10 +487,10 @@ struct TranslationBlock {extern bool parallel_cpus; -/* Hide the atomic_read to make code a little easier on the eyes */ +/* Hide the qatomic_read to make code a little easier on the eyes */ static inline uint32_t tb_cflags (const TranslationBlock *tb) { -return atomic_read (&tb->cflags); +return qatomic_read (&tb->cflags); }/* current cflags for hashing/comparison */
include/exec/log.h +3 -3
@@ -19,7 +19,7 @@ static inline void log_cpu_state(CPUState *cpu, int flags)if (qemu_log_enabled ()) {rcu_read_lock (); - logfile =atomic_rcu_read (&qemu_logfile); + logfile =qatomic_rcu_read (&qemu_logfile);if (logfile) {cpu_dump_state (cpu, logfile->fd, flags); }
@@ -49,7 +49,7 @@ static inline void log_target_disas(CPUState *cpu, target_ulong start, {QemuLogFile *logfile;rcu_read_lock (); - logfile =atomic_rcu_read (&qemu_logfile); + logfile =qatomic_rcu_read (&qemu_logfile);if (logfile) {target_disas (logfile->fd, cpu, start, len); }
@@ -60,7 +60,7 @@ static inline void log_disas(void *code, unsigned long size, const char *note) {QemuLogFile *logfile;rcu_read_lock (); - logfile =atomic_rcu_read (&qemu_logfile); + logfile =qatomic_rcu_read (&qemu_logfile);if (logfile) {disas (logfile->fd, code, size, note); }
include/exec/memory.h +1 -1
@@ -685,7 +685,7 @@ struct FlatView {static inline FlatView *address_space_to_flatview (AddressSpace *as) { -return atomic_rcu_read (&as->current_map); +return qatomic_rcu_read (&as->current_map); }
include/exec/ram_addr.h +14 -12
@@ -164,7 +164,7 @@ static inline bool cpu_physical_memory_get_dirty(ram_addr_t start, page = start >>TARGET_PAGE_BITS ; WITH_RCU_READ_LOCK_GUARD() { - blocks =atomic_rcu_read (&ram_list.dirty_memory[client]); + blocks =qatomic_rcu_read (&ram_list.dirty_memory[client]); idx = page /DIRTY_MEMORY_BLOCK_SIZE ; offset = page %DIRTY_MEMORY_BLOCK_SIZE ;
@@ -205,7 +205,7 @@ static inline bool cpu_physical_memory_all_dirty(ram_addr_t start,RCU_READ_LOCK_GUARD (); - blocks =atomic_rcu_read (&ram_list.dirty_memory[client]); + blocks =qatomic_rcu_read (&ram_list.dirty_memory[client]); idx = page /DIRTY_MEMORY_BLOCK_SIZE ; offset = page %DIRTY_MEMORY_BLOCK_SIZE ;
@@ -278,7 +278,7 @@ static inline void cpu_physical_memory_set_dirty_flag(ram_addr_t addr,RCU_READ_LOCK_GUARD (); - blocks =atomic_rcu_read (&ram_list.dirty_memory[client]); + blocks =qatomic_rcu_read (&ram_list.dirty_memory[client]);set_bit_atomic (offset, blocks->blocks[idx]); }
@@ -301,7 +301,7 @@ static inline void cpu_physical_memory_set_dirty_range(ram_addr_t start, WITH_RCU_READ_LOCK_GUARD() {for (i =0 ; i <DIRTY_MEMORY_NUM ; i++) { - blocks[i] =atomic_rcu_read (&ram_list.dirty_memory[i]); + blocks[i] =qatomic_rcu_read (&ram_list.dirty_memory[i]); } idx = page /DIRTY_MEMORY_BLOCK_SIZE ;
@@ -361,23 +361,25 @@ static inline void cpu_physical_memory_set_dirty_lebitmap(unsigned long *bitmap, WITH_RCU_READ_LOCK_GUARD() {for (i =0 ; i <DIRTY_MEMORY_NUM ; i++) { - blocks[i] =atomic_rcu_read (&ram_list.dirty_memory[i])->blocks; + blocks[i] = +qatomic_rcu_read (&ram_list.dirty_memory[i])->blocks; }for (k =0 ; k < nr; k++) {if (bitmap[k]) {unsigned long temp =leul_to_cpu (bitmap[k]); -atomic_or (&blocks[DIRTY_MEMORY_VGA ][idx][offset], temp); +qatomic_or (&blocks[DIRTY_MEMORY_VGA ][idx][offset], temp);if (global_dirty_log) { -atomic_or (&blocks[DIRTY_MEMORY_MIGRATION ][idx][offset], - temp); +qatomic_or ( + &blocks[DIRTY_MEMORY_MIGRATION ][idx][offset], + temp); }if (tcg_enabled ()) { -atomic_or (&blocks[DIRTY_MEMORY_CODE ][idx][offset], - temp); +qatomic_or (&blocks[DIRTY_MEMORY_CODE ][idx][offset], + temp); } }
@@ -461,12 +463,12 @@ uint64_t cpu_physical_memory_sync_dirty_bitmap(RAMBlock *rb, DIRTY_MEMORY_BLOCK_SIZE);unsigned long page =BIT_WORD (start >>TARGET_PAGE_BITS ); - src =atomic_rcu_read ( + src =qatomic_rcu_read ( &ram_list.dirty_memory[DIRTY_MEMORY_MIGRATION ])->blocks;for (k = page; k < page + nr; k++) {if (src[idx][offset]) { -unsigned long bits =atomic_xchg (&src[idx][offset],0 ); +unsigned long bits =qatomic_xchg (&src[idx][offset],0 );unsigned long new_dirty; new_dirty = ~dest[k]; dest[k] |= bits;
include/exec/ramlist.h +1 -1
@@ -19,7 +19,7 @@ typedef struct RAMBlockNotifier RAMBlockNotifier;* rcu_read_lock(); * * DirtyMemoryBlocks *blocks = -* atomic_rcu_read(&ram_list.dirty_memory[DIRTY_MEMORY_MIGRATION]); +* qatomic_rcu_read(&ram_list.dirty_memory[DIRTY_MEMORY_MIGRATION]); * * ram_addr_t idx = (addr >> TARGET_PAGE_BITS) / DIRTY_MEMORY_BLOCK_SIZE; * unsigned long *block = blocks.blocks[idx];
include/exec/tb-lookup.h +2 -2
@@ -27,7 +27,7 @@ tb_lookup__cpu_state(CPUState *cpu, target_ulong *pc, target_ulong *cs_base,cpu_get_tb_cpu_state (env, pc, cs_base, flags); hash =tb_jmp_cache_hash_func (*pc); - tb =atomic_rcu_read (&cpu->tb_jmp_cache[hash]); + tb =qatomic_rcu_read (&cpu->tb_jmp_cache[hash]); cf_mask &= ~CF_CLUSTER_MASK ; cf_mask |= cpu->cluster_index <<CF_CLUSTER_SHIFT ;
@@ -44,7 +44,7 @@ tb_lookup__cpu_state(CPUState *cpu, target_ulong *pc, target_ulong *cs_base,if (tb ==NULL ) {return NULL ; } -atomic_set (&cpu->tb_jmp_cache[hash], tb); +qatomic_set (&cpu->tb_jmp_cache[hash], tb);return tb; }
include/hw/core/cpu.h +1 -1
@@ -482,7 +482,7 @@ static inline void cpu_tb_jmp_cache_clear(CPUState *cpu)unsigned int i;for (i =0 ; i <TB_JMP_CACHE_SIZE ; i++) { -atomic_set (&cpu->tb_jmp_cache[i],NULL ); +qatomic_set (&cpu->tb_jmp_cache[i],NULL ); } }
include/qemu/atomic.h +126 -122
415 lines not on this page · raw message
include/qemu/atomic128.h +3 -3
@@ -44,7 +44,7 @@#if defined(CONFIG_ATOMIC128 )static inline Int128 atomic16_cmpxchg (Int128 *ptr,Int128 cmp,Int128 new) { -return atomic_cmpxchg__nocheck (ptr, cmp, new); +return qatomic_cmpxchg__nocheck (ptr, cmp, new); }# define HAVE_CMPXCHG128 1#elif defined(CONFIG_CMPXCHG128 )
@@ -89,12 +89,12 @@ Int128 QEMU_ERROR("unsupported atomic")#if defined(CONFIG_ATOMIC128 )static inline Int128 atomic16_read (Int128 *ptr) { -return atomic_read__nocheck (ptr); +return qatomic_read__nocheck (ptr); }static inline void atomic16_set (Int128 *ptr,Int128 val) { -atomic_set__nocheck (ptr, val); +qatomic_set__nocheck (ptr, val); }# define HAVE_ATOMIC128 1
include/qemu/bitops.h +1 -1
@@ -51,7 +51,7 @@ static inline void set_bit_atomic(long nr, unsigned long *addr)unsigned long mask =BIT_MASK (nr);unsigned long *p = addr +BIT_WORD (nr); -atomic_or (p, mask); +qatomic_or (p, mask); }/**
include/qemu/coroutine.h +1 -1
@@ -179,7 +179,7 @@ static inline coroutine_fn void qemu_co_mutex_assert_locked(CoMutex *mutex)* because the condition will be false no matter whether we read NULL or * the pointer for any other coroutine. */ -assert (atomic_read (&mutex->locked) && +assert (qatomic_read (&mutex->locked) && mutex->holder ==qemu_coroutine_self ()); }
include/qemu/log.h +3 -3
@@ -36,7 +36,7 @@ static inline bool qemu_log_separate(void)bool res = false;rcu_read_lock (); - logfile =atomic_rcu_read (&qemu_logfile); + logfile =qatomic_rcu_read (&qemu_logfile);if (logfile && logfile->fd != stderr) { res = true; }
@@ -75,7 +75,7 @@ static inline FILE *qemu_log_lock(void) {QemuLogFile *logfile;rcu_read_lock (); - logfile =atomic_rcu_read (&qemu_logfile); + logfile =qatomic_rcu_read (&qemu_logfile);if (logfile) {qemu_flockfile (logfile->fd);return logfile->fd;
@@ -102,7 +102,7 @@ qemu_log_vprintf(const char *fmt, va_list va)QemuLogFile *logfile;rcu_read_lock (); - logfile =atomic_rcu_read (&qemu_logfile); + logfile =qatomic_rcu_read (&qemu_logfile);if (logfile) {vfprintf (logfile->fd, fmt, va); }
include/qemu/queue.h +4 -3
@@ -218,12 +218,12 @@ struct { \typeof (elm) save_sle_next; \do { \ save_sle_next = (elm)->field.sle_next = (head)->slh_first; \ - }while (atomic_cmpxchg (&(head)->slh_first, save_sle_next, (elm)) != \ + }while (qatomic_cmpxchg (&(head)->slh_first, save_sle_next, (elm)) !=\ save_sle_next); \ } while (/*CONSTCOND*/0) #define QSLIST_MOVE_ATOMIC(dest, src) do { \ - (dest)->slh_first = atomic_xchg(&(src)->slh_first, NULL); \ + (dest)->slh_first = qatomic_xchg(&(src)->slh_first, NULL); \ } while (/*CONSTCOND*/0)#define QSLIST_REMOVE_HEAD (head, field) do { \
@@ -376,7 +376,8 @@ struct { \/* * Simple queue access methods. */ -#define QSIMPLEQ_EMPTY_ATOMIC (head) (atomic_read(&((head)->sqh_first)) == NULL) +#define QSIMPLEQ_EMPTY_ATOMIC (head) \ + (qatomic_read(&((head)->sqh_first)) == NULL)#define QSIMPLEQ_EMPTY (head) ((head)->sqh_first == NULL)#define QSIMPLEQ_FIRST (head) ((head)->sqh_first)#define QSIMPLEQ_NEXT (elm, field) ((elm)->field.sqe_next)
include/qemu/rcu.h +5 -5
@@ -79,8 +79,8 @@ static inline void rcu_read_lock(void)return ; } - ctr =atomic_read (&rcu_gp_ctr); -atomic_set (&p_rcu_reader->ctr, ctr); + ctr =qatomic_read (&rcu_gp_ctr); +qatomic_set (&p_rcu_reader->ctr, ctr);/* Write p_rcu_reader->ctr before reading RCU-protected pointers. */ smp_mb_placeholder ();
@@ -100,12 +100,12 @@ static inline void rcu_read_unlock(void)* smp_mb_placeholder(), this ensures writes to p_rcu_reader->ctr * are sequentially consistent. */ -atomic_store_release (&p_rcu_reader->ctr,0 ); +qatomic_store_release (&p_rcu_reader->ctr,0 );/* Write p_rcu_reader->ctr before reading p_rcu_reader->waiting. */ smp_mb_placeholder (); -if (unlikely (atomic_read (&p_rcu_reader->waiting))) { -atomic_set (&p_rcu_reader->waiting, false); +if (unlikely (qatomic_read (&p_rcu_reader->waiting))) { +qatomic_set (&p_rcu_reader->waiting, false);qemu_event_set (&rcu_gp_event); } }
include/qemu/rcu_queue.h +51 -49
257 lines not on this page · raw message
include/qemu/seqlock.h +4 -4
@@ -32,7 +32,7 @@ static inline void seqlock_init(QemuSeqLock *sl)/* Lock out other writers and update the count. */ static inline void seqlock_write_begin (QemuSeqLock *sl) { -atomic_set (&sl->sequence, sl->sequence +1 ); +qatomic_set (&sl->sequence, sl->sequence +1 );/* Write sequence before updating other fields. */ smp_wmb ();
@@ -43,7 +43,7 @@ static inline void seqlock_write_end(QemuSeqLock *sl)/* Write other fields before finalizing sequence. */ smp_wmb (); -atomic_set (&sl->sequence, sl->sequence +1 ); +qatomic_set (&sl->sequence, sl->sequence +1 ); }/* Lock out other writers and update the count. */
@@ -68,7 +68,7 @@ static inline void seqlock_write_unlock_impl(QemuSeqLock *sl, QemuLockable *lockstatic inline unsigned seqlock_read_begin (const QemuSeqLock *sl) {/* Always fail if a write is in progress. */ -unsigned ret =atomic_read (&sl->sequence); +unsigned ret =qatomic_read (&sl->sequence);/* Read sequence before reading other fields. */ smp_rmb ();
@@ -79,7 +79,7 @@ static inline int seqlock_read_retry(const QemuSeqLock *sl, unsigned start) {/* Read other fields before reading final sequence. */ smp_rmb (); -return unlikely (atomic_read (&sl->sequence) != start); +return unlikely (qatomic_read (&sl->sequence) != start); }#endif
include/qemu/stats64.h +14 -14
@@ -37,27 +37,27 @@ static inline void stat64_init(Stat64 *s, uint64_t value)static inline uint64_t stat64_get (const Stat64 *s) { -return atomic_read__nocheck (&s->value); +return qatomic_read__nocheck (&s->value); }static inline void stat64_add (Stat64 *s,uint64_t value) { -atomic_add (&s->value, value); +qatomic_add (&s->value, value); }static inline void stat64_min (Stat64 *s,uint64_t value) { -uint64_t orig =atomic_read__nocheck (&s->value); +uint64_t orig =qatomic_read__nocheck (&s->value);while (orig > value) { - orig =atomic_cmpxchg__nocheck (&s->value, orig, value); + orig =qatomic_cmpxchg__nocheck (&s->value, orig, value); } }static inline void stat64_max (Stat64 *s,uint64_t value) { -uint64_t orig =atomic_read__nocheck (&s->value); +uint64_t orig =qatomic_read__nocheck (&s->value);while (orig < value) { - orig =atomic_cmpxchg__nocheck (&s->value, orig, value); + orig =qatomic_cmpxchg__nocheck (&s->value, orig, value); } }#else
@@ -79,7 +79,7 @@ static inline void stat64_add(Stat64 *s, uint64_t value) low = (uint32_t ) value;if (!low) {if (high) { -atomic_add (&s->high, high); +qatomic_add (&s->high, high); }return ; }
@@ -101,7 +101,7 @@ static inline void stat64_add(Stat64 *s, uint64_t value)* the high 32 bits, so it can race just fine with stat64_add32_carry * and even stat64_get! */ - old =atomic_cmpxchg (&s->low, orig, result); + old =qatomic_cmpxchg (&s->low, orig, result);if (orig == old) {return ; }
@@ -116,7 +116,7 @@ static inline void stat64_min(Stat64 *s, uint64_t value) high = value >>32 ; low = (uint32_t ) value; do { - orig_high = atomic_read(&s->high); + orig_high = qatomic_read(&s->high); if (orig_high < high) { return; }
@@ -128,7 +128,7 @@ static inline void stat64_min(Stat64 *s, uint64_t value)* the write barrier in stat64_min_slow. */ smp_rmb (); - orig_low =atomic_read (&s->low); + orig_low =qatomic_read (&s->low);if (orig_low <= low) {return ; }
@@ -138,7 +138,7 @@ static inline void stat64_min(Stat64 *s, uint64_t value)* we may miss being lucky. */ smp_rmb (); - orig_high =atomic_read (&s->high); + orig_high =qatomic_read (&s->high);if (orig_high < high) {return ; }
@@ -156,7 +156,7 @@ static inline void stat64_max(Stat64 *s, uint64_t value) high = value >>32 ; low = (uint32_t ) value; do { - orig_high = atomic_read(&s->high); + orig_high = qatomic_read(&s->high); if (orig_high > high) { return; }
@@ -168,7 +168,7 @@ static inline void stat64_max(Stat64 *s, uint64_t value)* the write barrier in stat64_max_slow. */ smp_rmb (); - orig_low =atomic_read (&s->low); + orig_low =qatomic_read (&s->low);if (orig_low >= low) {return ; }
@@ -178,7 +178,7 @@ static inline void stat64_max(Stat64 *s, uint64_t value)* we may miss being lucky. */ smp_rmb (); - orig_high =atomic_read (&s->high); + orig_high =qatomic_read (&s->high);if (orig_high > high) {return ; }
include/qemu/thread.h +12 -12
@@ -70,33 +70,33 @@ extern QemuCondTimedWaitFunc qemu_cond_timedwait_func; qemu_cond_timedwait_impl(c, m, ms, __FILE__, __LINE__)#else #define qemu_mutex_lock (m) ({ \ - QemuMutexLockFunc _f = atomic_read(&qemu_mutex_lock_func); \ + QemuMutexLockFunc _f = qatomic_read(&qemu_mutex_lock_func); \ _f(m, __FILE__, __LINE__); \ }) -#define qemu_mutex_trylock (m) ({ \ - QemuMutexTrylockFunc _f = atomic_read(&qemu_mutex_trylock_func); \ - _f(m, __FILE__, __LINE__); \ +#define qemu_mutex_trylock (m) ({ \ + QemuMutexTrylockFunc _f = qatomic_read(&qemu_mutex_trylock_func); \ + _f(m, __FILE__, __LINE__); \ }) -#define qemu_rec_mutex_lock (m) ({ \ - QemuRecMutexLockFunc _f = atomic_read(&qemu_rec_mutex_lock_func); \ - _f(m, __FILE__, __LINE__); \ +#define qemu_rec_mutex_lock (m) ({ \ + QemuRecMutexLockFunc _f = qatomic_read(&qemu_rec_mutex_lock_func);\ + _f(m, __FILE__, __LINE__); \ })#define qemu_rec_mutex_trylock (m) ({ \ QemuRecMutexTrylockFunc _f; \ - _f = atomic_read(&qemu_rec_mutex_trylock_func); \ + _f = qatomic_read(&qemu_rec_mutex_trylock_func); \ _f(m, __FILE__, __LINE__); \ })#define qemu_cond_wait (c, m) ({ \ - QemuCondWaitFunc _f = atomic_read(&qemu_cond_wait_func); \ + QemuCondWaitFunc _f = qatomic_read(&qemu_cond_wait_func); \ _f(c, m, __FILE__, __LINE__); \ })#define qemu_cond_timedwait (c, m, ms) ({ \ - QemuCondTimedWaitFunc _f = atomic_read(&qemu_cond_timedwait_func); \ + QemuCondTimedWaitFunc _f = qatomic_read(&qemu_cond_timedwait_func);\ _f(c, m, ms, __FILE__, __LINE__); \ })#endif
@@ -236,7 +236,7 @@ static inline void qemu_spin_lock(QemuSpin *spin)__tsan_mutex_pre_lock (spin,0 );#endif while (unlikely (__sync_lock_test_and_set (&spin->value, true))) { -while (atomic_read (&spin->value)) { +while (qatomic_read (&spin->value)) {cpu_relax (); } }
@@ -261,7 +261,7 @@ static inline bool qemu_spin_trylock(QemuSpin *spin)static inline bool qemu_spin_locked (QemuSpin *spin) { -return atomic_read (&spin->value); +return qatomic_read (&spin->value); }static inline void qemu_spin_unlock (QemuSpin *spin)
include/standard-headers/drivers/infiniband/hw/vmw_pvrdma/pvrdma_ring.h +7 -7
@@ -68,7 +68,7 @@ static inline int pvrdma_idx_valid(uint32_t idx, uint32_t max_elems)static inline int32_t pvrdma_idx (int *var,uint32_t max_elems) { -const unsigned int idx =atomic_read (var); +const unsigned int idx =qatomic_read (var);if (pvrdma_idx_valid (idx, max_elems))return idx & (max_elems -1 );
@@ -77,17 +77,17 @@ static inline int32_t pvrdma_idx(int *var, uint32_t max_elems)static inline void pvrdma_idx_ring_inc (int *var,uint32_t max_elems) { -uint32_t idx =atomic_read (var) +1 ;/* Increment. */ +uint32_t idx =qatomic_read (var) +1 ;/* Increment. */ idx &= (max_elems <<1 ) -1 ;/* Modulo size, flip gen. */ -atomic_set (var, idx); +qatomic_set (var, idx); }static inline int32_t pvrdma_idx_ring_has_space (const struct pvrdma_ring *r,uint32_t max_elems,uint32_t *out_tail) { -const uint32_t tail =atomic_read (&r->prod_tail); -const uint32_t head =atomic_read (&r->cons_head); +const uint32_t tail =qatomic_read (&r->prod_tail); +const uint32_t head =qatomic_read (&r->cons_head);if (pvrdma_idx_valid (tail, max_elems) &&pvrdma_idx_valid (head, max_elems)) {
@@ -100,8 +100,8 @@ static inline int32_t pvrdma_idx_ring_has_space(const struct pvrdma_ring *r,static inline int32_t pvrdma_idx_ring_has_data (const struct pvrdma_ring *r,uint32_t max_elems,uint32_t *out_head) { -const uint32_t tail =atomic_read (&r->prod_tail); -const uint32_t head =atomic_read (&r->cons_head); +const uint32_t tail =qatomic_read (&r->prod_tail); +const uint32_t head =qatomic_read (&r->cons_head);if (pvrdma_idx_valid (tail, max_elems) &&pvrdma_idx_valid (head, max_elems)) {
linux-user/qemu.h +1 -1
@@ -146,7 +146,7 @@ typedef struct TaskState {/* Nonzero if process_pending_signals() needs to do something (either * handle a pending signal or unblock signals). * This flag is written from a signal handler so should be accessed via -* the atomic_read() and atomic_set() functions. (It is not accessed +* the qatomic_read() and qatomic_set() functions. (It is not accessed * from multiple threads.) */ int signal_pending;
tcg/i386/tcg-target.h +1 -1
@@ -215,7 +215,7 @@ static inline void tb_target_set_jmp_target(uintptr_t tc_ptr, uintptr_t jmp_addr, uintptr_t addr) {/* patch the branch destination */ -atomic_set ((int32_t *)jmp_addr, addr - (jmp_addr +4 )); +qatomic_set ((int32_t *)jmp_addr, addr - (jmp_addr +4 ));/* no need to flush icache explicitly */ }
tcg/s390/tcg-target.h +1 -1
@@ -154,7 +154,7 @@ static inline void tb_target_set_jmp_target(uintptr_t tc_ptr, {/* patch the branch destination */ intptr_t disp = addr - (jmp_addr -2 ); -atomic_set ((int32_t *)jmp_addr, disp /2 ); +qatomic_set ((int32_t *)jmp_addr, disp /2 );/* no need to flush icache explicitly */ }
tcg/tci/tcg-target.h +1 -1
@@ -206,7 +206,7 @@ static inline void tb_target_set_jmp_target(uintptr_t tc_ptr, uintptr_t jmp_addr, uintptr_t addr) {/* patch the branch destination */ -atomic_set ((int32_t *)jmp_addr, addr - (jmp_addr +4 )); +qatomic_set ((int32_t *)jmp_addr, addr - (jmp_addr +4 ));/* no need to flush icache explicitly */ }
accel/kvm/kvm-all.c +6 -6
@@ -2379,7 +2379,7 @@ static __thread bool have_sigbus_pending;static void kvm_cpu_kick (CPUState *cpu) { -atomic_set (&cpu->kvm_run->immediate_exit,1 ); +qatomic_set (&cpu->kvm_run->immediate_exit,1 ); }static void kvm_cpu_kick_self (void )
@@ -2400,7 +2400,7 @@ static void kvm_eat_signals(CPUState *cpu)int r;if (kvm_immediate_exit) { -atomic_set (&cpu->kvm_run->immediate_exit,0 ); +qatomic_set (&cpu->kvm_run->immediate_exit,0 );/* Write kvm_run->immediate_exit before the cpu->exit_request * write in kvm_cpu_exec. */
@@ -2434,7 +2434,7 @@ int kvm_cpu_exec(CPUState *cpu)DPRINTF ("kvm_cpu_exec()\n" );if (kvm_arch_process_async_events (cpu)) { -atomic_set (&cpu->exit_request,0 ); +qatomic_set (&cpu->exit_request,0 );return EXCP_HLT ; }
@@ -2450,7 +2450,7 @@ int kvm_cpu_exec(CPUState *cpu) }kvm_arch_pre_run (cpu, run); -if (atomic_read (&cpu->exit_request)) { +if (qatomic_read (&cpu->exit_request)) {DPRINTF ("interrupt exit requested\n" );/* * KVM requires us to reenter the kernel after IO exits to complete
@@ -2577,7 +2577,7 @@ int kvm_cpu_exec(CPUState *cpu)vm_stop (RUN_STATE_INTERNAL_ERROR ); } -atomic_set (&cpu->exit_request,0 ); +qatomic_set (&cpu->exit_request,0 );return ret; }
@@ -2994,7 +2994,7 @@ int kvm_on_sigbus_vcpu(CPUState *cpu, int code, void *addr) have_sigbus_pending = true; pending_sigbus_addr = addr; pending_sigbus_code = code; -atomic_set (&cpu->exit_request,1 ); +qatomic_set (&cpu->exit_request,1 );return 0 ;#else return 1 ;
accel/tcg/cpu-exec.c +8 -7
@@ -367,7 +367,8 @@ static inline void tb_add_jump(TranslationBlock *tb, int n, goto out_unlock_next; }/* Atomically claim the jump destination slot only if it was NULL */ - old =atomic_cmpxchg (&tb->jmp_dest[n], (uintptr_t )NULL , (uintptr_t )tb_next); + old =qatomic_cmpxchg (&tb->jmp_dest[n], (uintptr_t )NULL , + (uintptr_t )tb_next);if (old) { goto out_unlock_next; }
@@ -407,7 +408,7 @@ static inline TranslationBlock *tb_find(CPUState *cpu, tb =tb_gen_code (cpu, pc, cs_base, flags, cf_mask);mmap_unlock ();/* We add the TB in the virtual pc hash table for the fast lookup */ -atomic_set (&cpu->tb_jmp_cache[tb_jmp_cache_hash_func (pc)], tb); +qatomic_set (&cpu->tb_jmp_cache[tb_jmp_cache_hash_func (pc)], tb); }#ifndef CONFIG_USER_ONLY /* We don't take care of direct jumps when address mapping changes in
@@ -536,9 +537,9 @@ static inline bool cpu_handle_interrupt(CPUState *cpu,* Ensure zeroing happens before reading cpu->exit_request or * cpu->interrupt_request (see also smp_wmb in cpu_exit()) */ -atomic_mb_set (&cpu_neg (cpu)->icount_decr.u16.high,0 ); +qatomic_mb_set (&cpu_neg (cpu)->icount_decr.u16.high,0 ); -if (unlikely (atomic_read (&cpu->interrupt_request))) { +if (unlikely (qatomic_read (&cpu->interrupt_request))) {int interrupt_request;qemu_mutex_lock_iothread (); interrupt_request = cpu->interrupt_request;
@@ -613,10 +614,10 @@ static inline bool cpu_handle_interrupt(CPUState *cpu, }/* Finally, check if we need to exit to the main loop. */ -if (unlikely (atomic_read (&cpu->exit_request)) +if (unlikely (qatomic_read (&cpu->exit_request)) || (use_icount &&cpu_neg (cpu)->icount_decr.u16.low + cpu->icount_extra ==0 )) { -atomic_set (&cpu->exit_request,0 ); +qatomic_set (&cpu->exit_request,0 );if (cpu->exception_index ==-1 ) { cpu->exception_index =EXCP_INTERRUPT ; }
@@ -642,7 +643,7 @@ static inline void cpu_loop_exec_tb(CPUState *cpu, TranslationBlock *tb, } *last_tb =NULL ; - insns_left =atomic_read (&cpu_neg (cpu)->icount_decr.u32); + insns_left =qatomic_read (&cpu_neg (cpu)->icount_decr.u32);if (insns_left <0 ) {/* Something asked us to stop executing chained TBs; just * continue round the main loop. Whatever requested the exit
accel/tcg/cputlb.c +12 -12
@@ -312,9 +312,9 @@ void tlb_flush_counts(size_t *pfull, size_t *ppart, size_t *pelide)CPU_FOREACH (cpu) {CPUArchState *env = cpu->env_ptr; - full +=atomic_read (&env_tlb (env)->c.full_flush_count); - part +=atomic_read (&env_tlb (env)->c.part_flush_count); - elide +=atomic_read (&env_tlb (env)->c.elide_flush_count); + full +=qatomic_read (&env_tlb (env)->c.full_flush_count); + part +=qatomic_read (&env_tlb (env)->c.part_flush_count); + elide +=qatomic_read (&env_tlb (env)->c.elide_flush_count); } *pfull = full; *ppart = part;
@@ -349,13 +349,13 @@ static void tlb_flush_by_mmuidx_async_work(CPUState *cpu, run_on_cpu_data data)cpu_tb_jmp_cache_clear (cpu);if (to_clean ==ALL_MMUIDX_BITS ) { -atomic_set (&env_tlb (env)->c.full_flush_count, +qatomic_set (&env_tlb (env)->c.full_flush_count,env_tlb (env)->c.full_flush_count +1 ); }else { -atomic_set (&env_tlb (env)->c.part_flush_count, +qatomic_set (&env_tlb (env)->c.part_flush_count,env_tlb (env)->c.part_flush_count +ctpop16 (to_clean));if (to_clean != asked) { -atomic_set (&env_tlb (env)->c.elide_flush_count, +qatomic_set (&env_tlb (env)->c.elide_flush_count,env_tlb (env)->c.elide_flush_count +ctpop16 (asked & ~to_clean)); }
@@ -693,7 +693,7 @@ void tlb_unprotect_code(ram_addr_t ram_addr)* generated code. * * Other vCPUs might be reading their TLBs during guest execution, so we update -* te->addr_write with atomic_set. We don't need to worry about this for +* te->addr_write with qatomic_set. We don't need to worry about this for * oversized guests as MTTCG is disabled for them. * * Called with tlb_c.lock held.
@@ -711,7 +711,7 @@ static void tlb_reset_dirty_range_locked(CPUTLBEntry *tlb_entry,#if TCG_OVERSIZED_GUEST tlb_entry->addr_write |=TLB_NOTDIRTY ;#else -atomic_set (&tlb_entry->addr_write, +qatomic_set (&tlb_entry->addr_write, tlb_entry->addr_write |TLB_NOTDIRTY );#endif }
@@ -1138,8 +1138,8 @@ static inline target_ulong tlb_read_ofs(CPUTLBEntry *entry, size_t ofs)#if TCG_OVERSIZED_GUEST return *(target_ulong *)((uintptr_t )entry + ofs);#else -/* ofs might correspond to .addr_write, so use atomic_read */ -return atomic_read ((target_ulong *)((uintptr_t )entry + ofs)); +/* ofs might correspond to .addr_write, so use qatomic_read */ +return qatomic_read ((target_ulong *)((uintptr_t )entry + ofs));#endif }
@@ -1155,11 +1155,11 @@ static bool victim_tlb_hit(CPUArchState *env, size_t mmu_idx, size_t index,CPUTLBEntry *vtlb = &env_tlb (env)->d[mmu_idx].vtable[vidx];target_ulong cmp; -/* elt_ofs might correspond to .addr_write, so use atomic_read */ +/* elt_ofs might correspond to .addr_write, so use qatomic_read */ #if TCG_OVERSIZED_GUEST cmp = *(target_ulong *)((uintptr_t )vtlb + elt_ofs);#else - cmp =atomic_read ((target_ulong *)((uintptr_t )vtlb + elt_ofs)); + cmp =qatomic_read ((target_ulong *)((uintptr_t )vtlb + elt_ofs));#endif if (cmp == page) {
accel/tcg/tcg-all.c +1 -1
@@ -65,7 +65,7 @@ static void tcg_handle_interrupt(CPUState *cpu, int mask)if (!qemu_cpu_is_self (cpu)) {qemu_cpu_kick (cpu); }else { -atomic_set (&cpu_neg (cpu)->icount_decr.u16.high,-1 ); +qatomic_set (&cpu_neg (cpu)->icount_decr.u16.high,-1 );if (use_icount && !cpu->can_do_io && (mask & ~old_mask) !=0 ) {
accel/tcg/translate-all.c +28 -27
182 lines not on this page · raw message
audio/jackaudio.c +9 -9
@@ -104,7 +104,7 @@ static void qjack_buffer_create(QJackBuffer *buffer, int channels, int frames)static void qjack_buffer_clear (QJackBuffer *buffer) {assert (buffer->data); -atomic_store_release (&buffer->used,0 ); +qatomic_store_release (&buffer->used,0 ); buffer->rptr =0 ; buffer->wptr =0 ; }
@@ -129,7 +129,7 @@ static int qjack_buffer_write(QJackBuffer *buffer, float *data, int size)assert (buffer->data);const int samples = size /sizeof (float );int frames = samples / buffer->channels; -const int avail = buffer->frames -atomic_load_acquire (&buffer->used); +const int avail = buffer->frames -qatomic_load_acquire (&buffer->used);if (frames > avail) { frames = avail;
@@ -153,7 +153,7 @@ static int qjack_buffer_write(QJackBuffer *buffer, float *data, int size) buffer->wptr = wptr; -atomic_add (&buffer->used, frames); +qatomic_add (&buffer->used, frames);return frames * buffer->channels *sizeof (float ); };
@@ -161,7 +161,7 @@ static int qjack_buffer_write(QJackBuffer *buffer, float *data, int size)static int qjack_buffer_write_l (QJackBuffer *buffer,float **dest,int frames) {assert (buffer->data); -const int avail = buffer->frames -atomic_load_acquire (&buffer->used); +const int avail = buffer->frames -qatomic_load_acquire (&buffer->used);int wptr = buffer->wptr;if (frames > avail) {
@@ -185,7 +185,7 @@ static int qjack_buffer_write_l(QJackBuffer *buffer, float **dest, int frames) } buffer->wptr = wptr; -atomic_add (&buffer->used, frames); +qatomic_add (&buffer->used, frames);return frames; }
@@ -195,7 +195,7 @@ static int qjack_buffer_read(QJackBuffer *buffer, float *dest, int size)assert (buffer->data);const int samples = size /sizeof (float );int frames = samples / buffer->channels; -const int avail =atomic_load_acquire (&buffer->used); +const int avail =qatomic_load_acquire (&buffer->used);if (frames > avail) { frames = avail;
@@ -219,7 +219,7 @@ static int qjack_buffer_read(QJackBuffer *buffer, float *dest, int size) buffer->rptr = rptr; -atomic_sub (&buffer->used, frames); +qatomic_sub (&buffer->used, frames);return frames * buffer->channels *sizeof (float ); }
@@ -228,7 +228,7 @@ static int qjack_buffer_read_l(QJackBuffer *buffer, float **dest, int frames) {assert (buffer->data);int copy = frames; -const int used =atomic_load_acquire (&buffer->used); +const int used =qatomic_load_acquire (&buffer->used);int rptr = buffer->rptr;if (copy > used) {
@@ -252,7 +252,7 @@ static int qjack_buffer_read_l(QJackBuffer *buffer, float **dest, int frames) } buffer->rptr = rptr; -atomic_sub (&buffer->used, copy); +qatomic_sub (&buffer->used, copy);return copy; }
block.c +2 -2
@@ -1694,7 +1694,7 @@ static int bdrv_open_common(BlockDriverState *bs, BlockBackend *file, }/* bdrv_new() and bdrv_close() make it so */ -assert (atomic_read (&bs->copy_on_read) ==0 ); +assert (qatomic_read (&bs->copy_on_read) ==0 );if (bs->open_flags &BDRV_O_COPY_ON_READ ) {if (!bs->read_only) {
@@ -4436,7 +4436,7 @@ static void bdrv_close(BlockDriverState *bs) bs->file =NULL ;g_free (bs->opaque); bs->opaque =NULL ; -atomic_set (&bs->copy_on_read,0 ); +qatomic_set (&bs->copy_on_read,0 ); bs->backing_file[0 ] ='\0' ; bs->backing_format[0 ] ='\0' ; bs->total_sectors =0 ;
block/block-backend.c +8 -7
@@ -1353,12 +1353,12 @@ int blk_make_zero(BlockBackend *blk, BdrvRequestFlags flags)void blk_inc_in_flight (BlockBackend *blk) { -atomic_inc (&blk->in_flight); +qatomic_inc (&blk->in_flight); }void blk_dec_in_flight (BlockBackend *blk) { -atomic_dec (&blk->in_flight); +qatomic_dec (&blk->in_flight);aio_wait_kick (); }
@@ -1720,7 +1720,7 @@ void blk_drain(BlockBackend *blk)/* We may have -ENOMEDIUM completions in flight */ AIO_WAIT_WHILE (blk_get_aio_context (blk), -atomic_mb_read (&blk->in_flight) >0 ); +qatomic_mb_read (&blk->in_flight) >0 );if (bs) {bdrv_drained_end (bs);
@@ -1739,7 +1739,7 @@ void blk_drain_all(void)aio_context_acquire (ctx);/* We may have -ENOMEDIUM completions in flight */ -AIO_WAIT_WHILE (ctx,atomic_mb_read (&blk->in_flight) >0 ); +AIO_WAIT_WHILE (ctx,qatomic_mb_read (&blk->in_flight) >0 );aio_context_release (ctx); }
@@ -2346,6 +2346,7 @@ void blk_io_limits_update_group(BlockBackend *blk, const char *group)static void blk_root_drained_begin (BdrvChild *child) {BlockBackend *blk = child->opaque; +ThrottleGroupMember *tgm = &blk->public.throttle_group_member;if (++blk->quiesce_counter ==1 ) {if (blk->dev_ops && blk->dev_ops->drained_begin) {
@@ -2356,8 +2357,8 @@ static void blk_root_drained_begin(BdrvChild *child)/* Note that blk->root may not be accessible here yet if we are just * attaching to a BlockDriverState that is drained. Use child instead. */ -if (atomic_fetch_inc (&blk->public.throttle_group_member.io_limits_disabled) ==0 ) { -throttle_group_restart_tgm (&blk->public.throttle_group_member); +if (qatomic_fetch_inc (&tgm->io_limits_disabled) ==0 ) { +throttle_group_restart_tgm (tgm); } }
@@ -2374,7 +2375,7 @@ static void blk_root_drained_end(BdrvChild *child, int *drained_end_counter)assert (blk->quiesce_counter);assert (blk->public.throttle_group_member.io_limits_disabled); -atomic_dec (&blk->public.throttle_group_member.io_limits_disabled); +qatomic_dec (&blk->public.throttle_group_member.io_limits_disabled);if (--blk->quiesce_counter ==0 ) {if (blk->dev_ops && blk->dev_ops->drained_end) {
block/io.c +24 -24
185 lines not on this page · raw message
block/nfs.c +1 -1
@@ -721,7 +721,7 @@ nfs_get_allocated_file_size_cb(int ret, struct nfs_context *nfs, void *data, }/* Set task->complete before reading bs->wakeup. */ -atomic_mb_set (&task->complete,1 ); +qatomic_mb_set (&task->complete,1 );bdrv_wakeup (task->bs); }
block/sheepdog.c +1 -1
@@ -665,7 +665,7 @@ out: srco->co =NULL ; srco->ret = ret;/* Set srco->finished before reading bs->wakeup. */ -atomic_mb_set (&srco->finished, true); +qatomic_mb_set (&srco->finished, true);if (srco->bs) {bdrv_wakeup (srco->bs); }
block/throttle-groups.c +6 -6
@@ -228,7 +228,7 @@ static ThrottleGroupMember *next_throttle_token(ThrottleGroupMember *tgm,* immediately if it has pending requests. Otherwise we could be * forcing it to wait for other member's throttled requests. */ if (tgm_has_pending_reqs (tgm, is_write) && -atomic_read (&tgm->io_limits_disabled)) { +qatomic_read (&tgm->io_limits_disabled)) {return tgm; }
@@ -272,7 +272,7 @@ static bool throttle_group_schedule_timer(ThrottleGroupMember *tgm,ThrottleTimers *tt = &tgm->throttle_timers;bool must_wait; -if (atomic_read (&tgm->io_limits_disabled)) { +if (qatomic_read (&tgm->io_limits_disabled)) {return false; }
@@ -417,7 +417,7 @@ static void coroutine_fn throttle_group_restart_queue_entry(void *opaque)g_free (data); -atomic_dec (&tgm->restart_pending); +qatomic_dec (&tgm->restart_pending);aio_wait_kick (); }
@@ -434,7 +434,7 @@ static void throttle_group_restart_queue(ThrottleGroupMember *tgm, bool is_write* be no timer pending on this tgm at this point */ assert (!timer_pending (tgm->throttle_timers.timers[is_write])); -atomic_inc (&tgm->restart_pending); +qatomic_inc (&tgm->restart_pending); co =qemu_coroutine_create (throttle_group_restart_queue_entry, rd);aio_co_enter (tgm->aio_context, co);
@@ -544,7 +544,7 @@ void throttle_group_register_tgm(ThrottleGroupMember *tgm, tgm->throttle_state = ts; tgm->aio_context = ctx; -atomic_set (&tgm->restart_pending,0 ); +qatomic_set (&tgm->restart_pending,0 );qemu_mutex_lock (&tg->lock);/* If the ThrottleGroup is new set this ThrottleGroupMember as the token */
@@ -592,7 +592,7 @@ void throttle_group_unregister_tgm(ThrottleGroupMember *tgm) }/* Wait for throttle_group_restart_queue_entry() coroutines to finish */ -AIO_WAIT_WHILE (tgm->aio_context,atomic_read (&tgm->restart_pending) >0 ); +AIO_WAIT_WHILE (tgm->aio_context,qatomic_read (&tgm->restart_pending) >0 );qemu_mutex_lock (&tg->lock);for (i =0 ; i <2 ; i++) {
block/throttle.c +2 -2
@@ -217,7 +217,7 @@ static void throttle_reopen_abort(BDRVReopenState *reopen_state) static void coroutine_fn throttle_co_drain_begin(BlockDriverState *bs) {ThrottleGroupMember *tgm = bs->opaque; -if (atomic_fetch_inc (&tgm->io_limits_disabled) ==0 ) { +if (qatomic_fetch_inc (&tgm->io_limits_disabled) ==0 ) {throttle_group_restart_tgm (tgm); } }
@@ -226,7 +226,7 @@ static void coroutine_fn throttle_co_drain_end(BlockDriverState *bs) {ThrottleGroupMember *tgm = bs->opaque;assert (tgm->io_limits_disabled); -atomic_dec (&tgm->io_limits_disabled); +qatomic_dec (&tgm->io_limits_disabled); }static const char *const throttle_strong_runtime_opts[] = {
blockdev.c +1 -1
@@ -1604,7 +1604,7 @@ static void external_snapshot_commit(BlkActionState *common)/* We don't need (or want) to use the transactional * bdrv_reopen_multiple() across all the entries at once, because we * don't want to abort all of them if one of them fails the reopen */ -if (!atomic_read (&state->old_bs->copy_on_read)) { +if (!qatomic_read (&state->old_bs->copy_on_read)) {bdrv_reopen_set_read_only (state->old_bs, true,NULL ); }
blockjob.c +1 -1
@@ -298,7 +298,7 @@ BlockJobInfo *block_job_query(BlockJob *job, Error **errp) info =g_new0 (BlockJobInfo,1 ); info->type =g_strdup (job_type_str (&job->job)); info->device =g_strdup (job->job.id); - info->busy =atomic_read (&job->job.busy); + info->busy =qatomic_read (&job->job.busy); info->paused = job->job.pause_count >0 ; info->offset = job->job.progress.current; info->len = job->job.progress.total;
contrib/libvhost-user/libvhost-user.c +1 -1
@@ -448,7 +448,7 @@ static void vu_log_page(uint8_t *log_table, uint64_t page) {DPRINT ("Logged dirty guest page: %" PRId64"\n" , page); -atomic_or (&log_table[page /8 ],1 << (page %8 )); +qatomic_or (&log_table[page /8 ],1 << (page %8 )); } static void
cpus-common.c +13 -13
@@ -148,7 +148,7 @@ void do_run_on_cpu(CPUState *cpu, run_on_cpu_func func, run_on_cpu_data data, wi.exclusive = false;queue_work_on_cpu (cpu, &wi); -while (!atomic_mb_read (&wi.done)) { +while (!qatomic_mb_read (&wi.done)) {CPUState *self_cpu = current_cpu;qemu_cond_wait (&qemu_work_cond, mutex);
@@ -188,20 +188,20 @@ void start_exclusive(void)exclusive_idle ();/* Make all other cpus stop executing. */ -atomic_set (&pending_cpus,1 ); +qatomic_set (&pending_cpus,1 );/* Write pending_cpus before reading other_cpu->running. */ smp_mb (); running_cpus =0 ;CPU_FOREACH (other_cpu) { -if (atomic_read (&other_cpu->running)) { +if (qatomic_read (&other_cpu->running)) { other_cpu->has_waiter = true; running_cpus++;qemu_cpu_kick (other_cpu); } } -atomic_set (&pending_cpus, running_cpus +1 ); +qatomic_set (&pending_cpus, running_cpus +1 );while (pending_cpus >1 ) {qemu_cond_wait (&exclusive_cond, &qemu_cpu_list_lock); }
@@ -220,7 +220,7 @@ void end_exclusive(void) current_cpu->in_exclusive_context = false;qemu_mutex_lock (&qemu_cpu_list_lock); -atomic_set (&pending_cpus,0 ); +qatomic_set (&pending_cpus,0 );qemu_cond_broadcast (&exclusive_resume);qemu_mutex_unlock (&qemu_cpu_list_lock); }
@@ -228,7 +228,7 @@ void end_exclusive(void)/* Wait for exclusive ops to finish, and begin cpu execution. */ void cpu_exec_start (CPUState *cpu) { -atomic_set (&cpu->running, true); +qatomic_set (&cpu->running, true);/* Write cpu->running before reading pending_cpus. */ smp_mb ();
@@ -246,17 +246,17 @@ void cpu_exec_start(CPUState *cpu)* 3. pending_cpus == 0. Then start_exclusive is definitely going to * see cpu->running == true, and it will kick the CPU. */ -if (unlikely (atomic_read (&pending_cpus))) { +if (unlikely (qatomic_read (&pending_cpus))) {QEMU_LOCK_GUARD (&qemu_cpu_list_lock);if (!cpu->has_waiter) {/* Not counted in pending_cpus, let the exclusive item * run. Since we have the lock, just set cpu->running to true * while holding it; no need to check pending_cpus again. */ -atomic_set (&cpu->running, false); +qatomic_set (&cpu->running, false);exclusive_idle ();/* Now pending_cpus is zero. */ -atomic_set (&cpu->running, true); +qatomic_set (&cpu->running, true); }else {/* Counted in pending_cpus, go ahead and release the * waiter at cpu_exec_end.
@@ -268,7 +268,7 @@ void cpu_exec_start(CPUState *cpu)/* Mark cpu as not executing, and release pending exclusive ops. */ void cpu_exec_end (CPUState *cpu) { -atomic_set (&cpu->running, false); +qatomic_set (&cpu->running, false);/* Write cpu->running before reading pending_cpus. */ smp_mb ();
@@ -288,11 +288,11 @@ void cpu_exec_end(CPUState *cpu)* see cpu->running == false, and it can ignore this CPU until the * next cpu_exec_start. */ -if (unlikely (atomic_read (&pending_cpus))) { +if (unlikely (qatomic_read (&pending_cpus))) {QEMU_LOCK_GUARD (&qemu_cpu_list_lock);if (cpu->has_waiter) { cpu->has_waiter = false; -atomic_set (&pending_cpus, pending_cpus -1 ); +qatomic_set (&pending_cpus, pending_cpus -1 );if (pending_cpus ==1 ) {qemu_cond_signal (&exclusive_cond); }
@@ -346,7 +346,7 @@ void process_queued_cpu_work(CPUState *cpu)if (wi->free) {g_free (wi); }else { -atomic_mb_set (&wi->done, true); +qatomic_mb_set (&wi->done, true); } }qemu_mutex_unlock (&cpu->work_mutex);
dump/dump.c +4 -4
@@ -1572,7 +1572,7 @@ static void dump_state_prepare(DumpState *s)bool dump_in_progress (void ) {DumpState *state = &dump_state_global; -return (atomic_read (&state->status) ==DUMP_STATUS_ACTIVE ); +return (qatomic_read (&state->status) ==DUMP_STATUS_ACTIVE ); }/* calculate total size of memory to be dumped (taking filter into
@@ -1882,7 +1882,7 @@ static void dump_process(DumpState *s, Error **errp)/* make sure status is written after written_size updates */ smp_wmb (); -atomic_set (&s->status, +qatomic_set (&s->status, (local_err ?DUMP_STATUS_FAILED :DUMP_STATUS_COMPLETED ));/* send DUMP_COMPLETED message (unconditionally) */
@@ -1908,7 +1908,7 @@ DumpQueryResult *qmp_query_dump(Error **errp) {DumpQueryResult *result =g_new (DumpQueryResult,1 );DumpState *state = &dump_state_global; - result->status =atomic_read (&state->status); + result->status =qatomic_read (&state->status);/* make sure we are reading status and written_size in order */ smp_rmb (); result->completed = state->written_size;
@@ -2013,7 +2013,7 @@ void qmp_dump_guest_memory(bool paging, const char *file, begin, length, &local_err);if (local_err) {error_propagate (errp, local_err); -atomic_set (&s->status,DUMP_STATUS_FAILED ); +qatomic_set (&s->status,DUMP_STATUS_FAILED );return ; }
exec.c +26 -23
173 lines not on this page · raw message
hw/core/cpu.c +3 -3
@@ -111,10 +111,10 @@ void cpu_reset_interrupt(CPUState *cpu, int mask)void cpu_exit (CPUState *cpu) { -atomic_set (&cpu->exit_request,1 ); +qatomic_set (&cpu->exit_request,1 );/* Ensure cpu_exec will see the exit request after TCG has exited. */ smp_wmb (); -atomic_set (&cpu->icount_decr_ptr->u16.high,-1 ); +qatomic_set (&cpu->icount_decr_ptr->u16.high,-1 ); } int cpu_write_elf32_qemunote(WriteCoreDumpFunction f, CPUState *cpu,
@@ -261,7 +261,7 @@ static void cpu_common_reset(DeviceState *dev) cpu->halted = cpu->start_powered_off; cpu->mem_io_pc =0 ; cpu->icount_extra =0 ; -atomic_set (&cpu->icount_decr_ptr->u32,0 ); +qatomic_set (&cpu->icount_decr_ptr->u32,0 ); cpu->can_do_io =1 ; cpu->exception_index =-1 ; cpu->crash_occurred = false;
hw/display/qxl.c +2 -2
@@ -1908,7 +1908,7 @@ static void qxl_send_events(PCIQXLDevice *d, uint32_t events)/* * Older versions of Spice forgot to define the QXLRam struct * with the '__aligned__(4)' attribute. clang 7 and newer will -* thus warn that atomic_fetch_or(&d->ram->int_pending, ...) +* thus warn that qatomic_fetch_or(&d->ram->int_pending, ...) * might be a misaligned atomic access, and will generate an * out-of-line call for it, which results in a link error since * we don't currently link against libatomic.
@@ -1928,7 +1928,7 @@ static void qxl_send_events(PCIQXLDevice *d, uint32_t events)#define ALIGNED_UINT32_PTR (P ) ((uint32_t *)P)#endif - old_pending =atomic_fetch_or (ALIGNED_UINT32_PTR (&d->ram->int_pending), + old_pending =qatomic_fetch_or (ALIGNED_UINT32_PTR (&d->ram->int_pending), le_events);if ((old_pending & le_events) == le_events) {return ;
hw/hyperv/hyperv.c +5 -5
@@ -231,7 +231,7 @@ static void sint_msg_bh(void *opaque)HvSintRoute *sint_route = opaque;HvSintStagedMessage *staged_msg = sint_route->staged_msg; -if (atomic_read (&staged_msg->state) !=HV_STAGED_MSG_POSTED ) { +if (qatomic_read (&staged_msg->state) !=HV_STAGED_MSG_POSTED ) {/* status nor ready yet (spurious ack from guest?), ignore */ return ; }
@@ -240,7 +240,7 @@ static void sint_msg_bh(void *opaque) staged_msg->status =0 ;/* staged message processing finished, ready to start over */ -atomic_set (&staged_msg->state,HV_STAGED_MSG_FREE ); +qatomic_set (&staged_msg->state,HV_STAGED_MSG_FREE );/* drop the reference taken in hyperv_post_msg */ hyperv_sint_route_unref (sint_route); }
@@ -278,7 +278,7 @@ static void cpu_post_msg(CPUState *cs, run_on_cpu_data data)memory_region_set_dirty (&synic->msg_page_mr,0 ,sizeof (*synic->msg_page)); posted: -atomic_set (&staged_msg->state,HV_STAGED_MSG_POSTED ); +qatomic_set (&staged_msg->state,HV_STAGED_MSG_POSTED );/* * Notify the msg originator of the progress made; if the slot was busy we * set msg_pending flag in it so it will be the guest who will do EOM and
@@ -301,7 +301,7 @@ int hyperv_post_msg(HvSintRoute *sint_route, struct hyperv_message *src_msg)assert (staged_msg);/* grab the staging area */ -if (atomic_cmpxchg (&staged_msg->state,HV_STAGED_MSG_FREE , +if (qatomic_cmpxchg (&staged_msg->state,HV_STAGED_MSG_FREE ,HV_STAGED_MSG_BUSY ) !=HV_STAGED_MSG_FREE ) {return -EAGAIN ; }
@@ -351,7 +351,7 @@ int hyperv_set_event_flag(HvSintRoute *sint_route, unsigned eventno) set_mask =BIT_MASK (eventno); flags = synic->event_page->slot[sint_route->sint].flags; -if ((atomic_fetch_or (&flags[set_idx], set_mask) & set_mask) != set_mask) { +if ((qatomic_fetch_or (&flags[set_idx], set_mask) & set_mask) != set_mask) {memory_region_set_dirty (&synic->event_page_mr,0 ,sizeof (*synic->event_page)); ret =hyperv_sint_route_set_sint (sint_route);
hw/hyperv/vmbus.c +1 -1
@@ -747,7 +747,7 @@ static int vmbus_channel_notify_guest(VMBusChannel *chan) idx =BIT_WORD (chan->id); mask =BIT_MASK (chan->id); -if ((atomic_fetch_or (&int_map[idx], mask) & mask) != mask) { +if ((qatomic_fetch_or (&int_map[idx], mask) & mask) != mask) { res =hyperv_sint_route_set_sint (chan->notify_route); dirty = len; }
hw/i386/xen/xen-hvm.c +1 -1
@@ -1140,7 +1140,7 @@ static int handle_buffered_iopage(XenIOState *state)assert (req.dir ==IOREQ_WRITE );assert (!req.data_is_ptr); -atomic_add (&buf_page->read_pointer, qw +1 ); +qatomic_add (&buf_page->read_pointer, qw +1 ); }return req.count;
hw/intc/rx_icu.c +6 -6
@@ -81,8 +81,8 @@ static void rxicu_request(RXICUState *icu, int n_IRQ)int enable; enable = icu->ier[n_IRQ /8 ] & (1 << (n_IRQ &7 )); -if (n_IRQ >0 && enable !=0 &&atomic_read (&icu->req_irq) <0 ) { -atomic_set (&icu->req_irq, n_IRQ); +if (n_IRQ >0 && enable !=0 &&qatomic_read (&icu->req_irq) <0 ) { +qatomic_set (&icu->req_irq, n_IRQ);set_irq (icu, n_IRQ,rxicu_level (icu, n_IRQ)); } }
@@ -124,10 +124,10 @@ static void rxicu_set_irq(void *opaque, int n_IRQ, int level) }if (issue ==0 && src->sense ==TRG_LEVEL ) { icu->ir[n_IRQ] =0 ; -if (atomic_read (&icu->req_irq) == n_IRQ) { +if (qatomic_read (&icu->req_irq) == n_IRQ) {/* clear request */ set_irq (icu, n_IRQ,0 ); -atomic_set (&icu->req_irq,-1 ); +qatomic_set (&icu->req_irq,-1 ); }return ; }
@@ -144,11 +144,11 @@ static void rxicu_ack_irq(void *opaque, int no, int level)int n_IRQ;int max_pri; - n_IRQ =atomic_read (&icu->req_irq); + n_IRQ =qatomic_read (&icu->req_irq);if (n_IRQ <0 ) {return ; } -atomic_set (&icu->req_irq,-1 ); +qatomic_set (&icu->req_irq,-1 );if (icu->src[n_IRQ].sense !=TRG_LEVEL ) { icu->ir[n_IRQ] =0 ; }
hw/intc/sifive_plic.c +2 -2
@@ -89,12 +89,12 @@ static void sifive_plic_print_state(SiFivePLICState *plic)static uint32_t atomic_set_masked (uint32_t *a,uint32_t mask,uint32_t value) { -uint32_t old, new, cmp =atomic_read (a); +uint32_t old, new, cmp =qatomic_read (a);do { old = cmp; new = (old & ~mask) | (value & mask); - cmp =atomic_cmpxchg (a, old, new); + cmp =qatomic_cmpxchg (a, old, new); }while (old != cmp);return old;
hw/misc/edu.c +8 -8
@@ -212,7 +212,7 @@ static uint64_t edu_mmio_read(void *opaque, hwaddr addr, unsigned size)qemu_mutex_unlock (&edu->thr_mutex);break ;
Lines of this file are not shown. View the raw message.
softmmu/cpus.c +21 -21
42 lines not on this page · raw message
tcg/tcg.c +29 -29
58 lines not on this page · raw message
tests/test-aio-multithread.c +26 -26
52 lines not on this page · raw message
util/lockcnt.c +27 -25
52 lines not on this page · raw message
util/qht.c +29 -28
57 lines not on this page · raw message
util/qsp.c +25 -25
50 lines not on this page · raw message
The rest of this diff is not shown. View the raw message.
Signature · 1 line
2.26.2
Part of the diff is not shown here. View the raw message.
Patchew URL: https://patchew.org/QEMU/[email protected]/
Patchew URL: https://patchew.org/QEMU/[email protected]/
Hi,
This series seems to have some coding style problems. See output below for more information:
Type: series
Message-id: [email protected]
Subject: [PATCH v4 0/2] qemu/atomic.h: rename atomic_ to qatomic_
=== TEST SCRIPT BEGIN ===
#!/bin/bash
git rev-parse base > /dev/null || exit 0
git config --local diff.renamelimit 0
git config --local diff.renames True
git config --local diff.algorithm histogram./scripts/checkpatch.pl --mailback base..
=== TEST SCRIPT END ===
From https://github.com/patchew-project/qemu
* [new tag] patchew/[email protected] -> patchew/[email protected]
Switched to a new branch 'test'
1661a2c qemu/atomic.h: rename atomic_ to qatomic_
b27980b qemu/atomic: Update coding style to make checkpatch.pl happier
=== OUTPUT BEGIN ===
1/2 Checking commit b27980bf1db5 (qemu/atomic: Update coding style to make checkpatch.pl happier)
ERROR: Use of volatile is usually wrong, please add a comment
#23: FILE: include/qemu/atomic.h:328:
+#define atomic_read__nocheck(p) (*(__typeof__(*(p)) volatile *) (p))
ERROR: Use of volatile is usually wrong, please add a comment
#24: FILE: include/qemu/atomic.h:329:
+#define atomic_set__nocheck(p, i) ((*(__typeof__(*(p)) volatile *) (p)) = (i))
total: 2 errors, 0 warnings, 50 lines checked
Patch 1/2 has style problems, please review. If any of these errors are false positives report them to the maintainer, see CHECKPATCH in MAINTAINERS.
2/2 Checking commit 1661a2c48e6c (qemu/atomic.h: rename atomic_ to qatomic_)
ERROR: Macros with multiple statements should be enclosed in a do - while loop #2801: FILE: include/qemu/atomic.h:152:
+#define qatomic_rcu_read__nocheck(ptr, valptr) \
+ __atomic_load(ptr, valptr, __ATOMIC_RELAXED); \
smp_read_barrier_depends();ERROR: Use of volatile is usually wrong, please add a comment #2946: FILE: include/qemu/atomic.h:333:
+#define qatomic_read__nocheck(p) (*(__typeof__(*(p)) volatile *) (p))
ERROR: Use of volatile is usually wrong, please add a comment #2947: FILE: include/qemu/atomic.h:334:
+#define qatomic_set__nocheck(p, i) ((*(__typeof__(*(p)) volatile *) (p)) = (i))
ERROR: memory barrier without comment
#3024: FILE: include/qemu/atomic.h:395:
+#define qatomic_xchg(ptr, i) (smp_mb(), __sync_lock_test_and_set(ptr, i))
total: 4 errors, 0 warnings, 6269 lines checked
Patch 2/2 has style problems, please review. If any of these errors are false positives report them to the maintainer, see CHECKPATCH in MAINTAINERS.
=== OUTPUT END ===
Test command exited with code: 1
The full log is available at
http://patchew.org/logs/[email protected]/testing.checkpatch/?type=message.
---
Email generated automatically by Patchew [https://patchew.org/].
Please send your feedback to [email protected]
Patchew URL: https://patchew.org/QEMU/[email protected]/
Patchew URL: https://patchew.org/QEMU/[email protected]/
Hi,
This series seems to have some coding style problems. See output below for more information:
Type: series
Message-id: [email protected]
Subject: [PATCH v4 0/2] qemu/atomic.h: rename atomic_ to qatomic_
=== TEST SCRIPT BEGIN ===
#!/bin/bash
git rev-parse base > /dev/null || exit 0
git config --local diff.renamelimit 0
git config --local diff.renames True
git config --local diff.algorithm histogram./scripts/checkpatch.pl --mailback base..
=== TEST SCRIPT END ===
From https://github.com/patchew-project/qemu
- [tag update] patchew/[email protected] -> patchew/[email protected]
Switched to a new branch 'test'
424f21a qemu/atomic.h: rename atomic_ to qatomic_
90bd4fa qemu/atomic: Update coding style to make checkpatch.pl happier
=== OUTPUT BEGIN ===
1/2 Checking commit 90bd4facd2bb (qemu/atomic: Update coding style to make checkpatch.pl happier)
ERROR: Use of volatile is usually wrong, please add a comment
#23: FILE: include/qemu/atomic.h:328:
+#define atomic_read__nocheck(p) (*(__typeof__(*(p)) volatile *) (p))
ERROR: Use of volatile is usually wrong, please add a comment
#24: FILE: include/qemu/atomic.h:329:
+#define atomic_set__nocheck(p, i) ((*(__typeof__(*(p)) volatile *) (p)) = (i))
total: 2 errors, 0 warnings, 50 lines checked
Patch 1/2 has style problems, please review. If any of these errors are false positives report them to the maintainer, see CHECKPATCH in MAINTAINERS.
2/2 Checking commit 424f21a3295e (qemu/atomic.h: rename atomic_ to qatomic_)
ERROR: Macros with multiple statements should be enclosed in a do - while loop #2801: FILE: include/qemu/atomic.h:152:
+#define qatomic_rcu_read__nocheck(ptr, valptr) \
+ __atomic_load(ptr, valptr, __ATOMIC_RELAXED); \
smp_read_barrier_depends();ERROR: Use of volatile is usually wrong, please add a comment #2946: FILE: include/qemu/atomic.h:333:
+#define qatomic_read__nocheck(p) (*(__typeof__(*(p)) volatile *) (p))
ERROR: Use of volatile is usually wrong, please add a comment #2947: FILE: include/qemu/atomic.h:334:
+#define qatomic_set__nocheck(p, i) ((*(__typeof__(*(p)) volatile *) (p)) = (i))
ERROR: memory barrier without comment
#3024: FILE: include/qemu/atomic.h:395:
+#define qatomic_xchg(ptr, i) (smp_mb(), __sync_lock_test_and_set(ptr, i))
total: 4 errors, 0 warnings, 6269 lines checked
Patch 2/2 has style problems, please review. If any of these errors are false positives report them to the maintainer, see CHECKPATCH in MAINTAINERS.
=== OUTPUT END ===
Test command exited with code: 1
The full log is available at
http://patchew.org/logs/[email protected]/testing.checkpatch/?type=message.
---
Email generated automatically by Patchew [https://patchew.org/].
Please send your feedback to [email protected]