X-Git-Url: http://git.liburcu.org/?p=urcu.git;a=blobdiff_plain;f=src%2Furcu-bp.c;h=38f867e7b46347dd8da6b74a2fd18f2ea8505129;hp=81bb91a9f07ebbcea661dd159bc726851ae2f041;hb=HEAD;hpb=d8d9a3405ce46af6d34d2e80e260ad50f3d211a0 diff --git a/src/urcu-bp.c b/src/urcu-bp.c index 81bb91a..38f867e 100644 --- a/src/urcu-bp.c +++ b/src/urcu-bp.c @@ -1,52 +1,44 @@ +// SPDX-FileCopyrightText: 2009 Mathieu Desnoyers +// SPDX-FileCopyrightText: 2009 Paul E. McKenney, IBM Corporation. +// +// SPDX-License-Identifier: LGPL-2.1-or-later + /* - * urcu-bp.c - * * Userspace RCU library, "bulletproof" version. * - * Copyright (c) 2009 Mathieu Desnoyers - * Copyright (c) 2009 Paul E. McKenney, IBM Corporation. - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA - * * IBM's contributions to this file may be relicensed under LGPLv2 or later. */ +#define URCU_NO_COMPAT_IDENTIFIERS #define _LGPL_SOURCE #include #include #include -#include #include #include #include #include #include +#include #include -#include "urcu/arch.h" -#include "urcu/wfcqueue.h" -#include "urcu/map/urcu-bp.h" -#include "urcu/static/urcu-bp.h" -#include "urcu-pointer.h" -#include "urcu/tls-compat.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include #include "urcu-die.h" +#include "urcu-utils.h" +#define URCU_API_MAP /* Do not #define _LGPL_SOURCE to ensure we can emit the wrapper symbols */ #undef _LGPL_SOURCE -#include "urcu-bp.h" +#include #define _LGPL_SOURCE #ifndef MAP_ANONYMOUS @@ -70,10 +62,12 @@ void *mremap_wrapper(void *old_address, size_t old_size, * This is not generic. */ static -void *mremap_wrapper(void *old_address, size_t old_size, - size_t new_size, int flags) +void *mremap_wrapper(void *old_address __attribute__((unused)), + size_t old_size __attribute__((unused)), + size_t new_size __attribute__((unused)), + int flags) { - assert(!(flags & MREMAP_MAYMOVE)); + urcu_posix_assert(!(flags & MREMAP_MAYMOVE)); return MAP_FAILED; } @@ -81,10 +75,7 @@ void *mremap_wrapper(void *old_address, size_t old_size, /* Sleep delay in ms */ #define RCU_SLEEP_DELAY_MS 10 -#define INIT_NR_THREADS 8 -#define ARENA_INIT_ALLOC \ - sizeof(struct registry_chunk) \ - + INIT_NR_THREADS * sizeof(struct rcu_reader) +#define INIT_READER_COUNT 8 /* * Active attempts to check for reader Q.S. before calling sleep(). @@ -92,7 +83,7 @@ void *mremap_wrapper(void *old_address, size_t old_size, #define RCU_QS_ACTIVE_ATTEMPTS 100 static -int rcu_bp_refcount; +int urcu_bp_refcount; /* If the headers do not support membarrier system call, fall back smp_mb. */ #ifdef __NR_membarrier @@ -102,14 +93,21 @@ int rcu_bp_refcount; #endif enum membarrier_cmd { - MEMBARRIER_CMD_QUERY = 0, - MEMBARRIER_CMD_SHARED = (1 << 0), + MEMBARRIER_CMD_QUERY = 0, + MEMBARRIER_CMD_SHARED = (1 << 0), + /* reserved for MEMBARRIER_CMD_SHARED_EXPEDITED (1 << 1) */ + /* reserved for MEMBARRIER_CMD_PRIVATE (1 << 2) */ + MEMBARRIER_CMD_PRIVATE_EXPEDITED = (1 << 3), + MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED = (1 << 4), }; static -void __attribute__((constructor)) rcu_bp_init(void); +void __attribute__((constructor)) _urcu_bp_init(void); +static +void urcu_bp_exit(void); static -void __attribute__((destructor)) rcu_bp_exit(void); +void __attribute__((destructor)) urcu_bp_exit_destructor(void); +static void urcu_call_rcu_exit(void); #ifndef CONFIG_RCU_FORCE_SYS_MEMBARRIER int urcu_bp_has_sys_membarrier; @@ -136,21 +134,21 @@ static int initialized; static pthread_key_t urcu_bp_key; -struct rcu_gp rcu_gp = { .ctr = RCU_GP_COUNT }; +struct urcu_bp_gp urcu_bp_gp = { .ctr = URCU_BP_GP_COUNT }; /* * Pointer to registry elements. Written to only by each individual reader. Read * by both the reader and the writers. */ -DEFINE_URCU_TLS(struct rcu_reader *, rcu_reader); +DEFINE_URCU_TLS(struct urcu_bp_reader *, urcu_bp_reader); static CDS_LIST_HEAD(registry); struct registry_chunk { - size_t data_len; /* data length */ - size_t used; /* amount of data used */ + size_t capacity; /* capacity of this chunk (in elements) */ + size_t used; /* count of elements used */ struct cds_list_head node; /* chunk_list node */ - char data[]; + struct urcu_bp_reader readers[]; }; struct registry_arena { @@ -192,10 +190,19 @@ static void mutex_unlock(pthread_mutex_t *mutex) static void smp_mb_master(void) { - if (caa_likely(urcu_bp_has_sys_membarrier)) - (void) membarrier(MEMBARRIER_CMD_SHARED, 0); - else + if (caa_likely(urcu_bp_has_sys_membarrier)) { + if (membarrier(MEMBARRIER_CMD_PRIVATE_EXPEDITED, 0)) + urcu_die(errno); + } else { cmm_smp_mb(); + } +} + +/* Get the size of a chunk's allocation from its capacity (an element count). */ +static size_t chunk_allocation_size(size_t capacity) +{ + return (capacity * sizeof(struct urcu_bp_reader)) + + sizeof(struct registry_chunk); } /* @@ -204,13 +211,14 @@ static void smp_mb_master(void) */ static void wait_for_readers(struct cds_list_head *input_readers, struct cds_list_head *cur_snap_readers, - struct cds_list_head *qsreaders) + struct cds_list_head *qsreaders, + cmm_annotate_t *group) { unsigned int wait_loops = 0; - struct rcu_reader *index, *tmp; + struct urcu_bp_reader *index, *tmp; /* - * Wait for each thread URCU_TLS(rcu_reader).ctr to either + * Wait for each thread URCU_TLS(urcu_bp_reader).ctr to either * indicate quiescence (not nested), or observe the current * rcu_gp.ctr value. */ @@ -219,18 +227,18 @@ static void wait_for_readers(struct cds_list_head *input_readers, wait_loops++; cds_list_for_each_entry_safe(index, tmp, input_readers, node) { - switch (rcu_reader_state(&index->ctr)) { - case RCU_READER_ACTIVE_CURRENT: + switch (urcu_bp_reader_state(&index->ctr, group)) { + case URCU_BP_READER_ACTIVE_CURRENT: if (cur_snap_readers) { cds_list_move(&index->node, cur_snap_readers); break; } /* Fall-through */ - case RCU_READER_INACTIVE: + case URCU_BP_READER_INACTIVE: cds_list_move(&index->node, qsreaders); break; - case RCU_READER_ACTIVE_OLD: + case URCU_BP_READER_ACTIVE_OLD: /* * Old snapshot. Leaving node in * input_readers will make us busy-loop @@ -256,17 +264,19 @@ static void wait_for_readers(struct cds_list_head *input_readers, } } -void synchronize_rcu(void) +void urcu_bp_synchronize_rcu(void) { + cmm_annotate_define(acquire_group); + cmm_annotate_define(release_group); CDS_LIST_HEAD(cur_snap_readers); CDS_LIST_HEAD(qsreaders); sigset_t newmask, oldmask; int ret; ret = sigfillset(&newmask); - assert(!ret); + urcu_posix_assert(!ret); ret = pthread_sigmask(SIG_BLOCK, &newmask, &oldmask); - assert(!ret); + urcu_posix_assert(!ret); mutex_lock(&rcu_gp_lock); @@ -279,13 +289,14 @@ void synchronize_rcu(void) * where new ptr points to. */ /* Write new ptr before changing the qparity */ smp_mb_master(); + cmm_annotate_group_mb_release(&release_group); /* * Wait for readers to observe original parity or be quiescent. * wait_for_readers() can release and grab again rcu_registry_lock - * interally. + * internally. */ - wait_for_readers(®istry, &cur_snap_readers, &qsreaders); + wait_for_readers(®istry, &cur_snap_readers, &qsreaders, &acquire_group); /* * Adding a cmm_smp_mb() which is _not_ formally required, but makes the @@ -295,7 +306,8 @@ void synchronize_rcu(void) cmm_smp_mb(); /* Switch parity: 0 -> 1, 1 -> 0 */ - CMM_STORE_SHARED(rcu_gp.ctr, rcu_gp.ctr ^ RCU_GP_CTR_PHASE); + cmm_annotate_group_mem_release(&release_group, &rcu_gp.ctr); + uatomic_store(&rcu_gp.ctr, rcu_gp.ctr ^ URCU_BP_GP_CTR_PHASE, CMM_RELAXED); /* * Must commit qparity update to memory before waiting for other parity @@ -314,9 +326,9 @@ void synchronize_rcu(void) /* * Wait for readers to observe new parity or be quiescent. * wait_for_readers() can release and grab again rcu_registry_lock - * interally. + * internally. */ - wait_for_readers(&cur_snap_readers, NULL, &qsreaders); + wait_for_readers(&cur_snap_readers, NULL, &qsreaders, &acquire_group); /* * Put quiescent reader list back into registry. @@ -328,30 +340,31 @@ void synchronize_rcu(void) * freed. */ smp_mb_master(); + cmm_annotate_group_mb_acquire(&acquire_group); out: mutex_unlock(&rcu_registry_lock); mutex_unlock(&rcu_gp_lock); ret = pthread_sigmask(SIG_SETMASK, &oldmask, NULL); - assert(!ret); + urcu_posix_assert(!ret); } /* * library wrappers to be used by non-LGPL compatible source code. */ -void rcu_read_lock(void) +void urcu_bp_read_lock(void) { - _rcu_read_lock(); + _urcu_bp_read_lock(); } -void rcu_read_unlock(void) +void urcu_bp_read_unlock(void) { - _rcu_read_unlock(); + _urcu_bp_read_unlock(); } -int rcu_read_ongoing(void) +int urcu_bp_read_ongoing(void) { - return _rcu_read_ongoing(); + return _urcu_bp_read_ongoing(); } /* @@ -366,23 +379,20 @@ static void expand_arena(struct registry_arena *arena) { struct registry_chunk *new_chunk, *last_chunk; - size_t old_chunk_len, new_chunk_len; + size_t old_chunk_size_bytes, new_chunk_size_bytes, new_capacity; /* No chunk. */ if (cds_list_empty(&arena->chunk_list)) { - assert(ARENA_INIT_ALLOC >= - sizeof(struct registry_chunk) - + sizeof(struct rcu_reader)); - new_chunk_len = ARENA_INIT_ALLOC; - new_chunk = mmap(NULL, new_chunk_len, + new_chunk_size_bytes = chunk_allocation_size(INIT_READER_COUNT); + new_chunk = (struct registry_chunk *) mmap(NULL, + new_chunk_size_bytes, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0); if (new_chunk == MAP_FAILED) abort(); - memset(new_chunk, 0, new_chunk_len); - new_chunk->data_len = - new_chunk_len - sizeof(struct registry_chunk); + memset(new_chunk, 0, new_chunk_size_bytes); + new_chunk->capacity = INIT_READER_COUNT; cds_list_add_tail(&new_chunk->node, &arena->chunk_list); return; /* We're done. */ } @@ -390,33 +400,32 @@ void expand_arena(struct registry_arena *arena) /* Try expanding last chunk. */ last_chunk = cds_list_entry(arena->chunk_list.prev, struct registry_chunk, node); - old_chunk_len = - last_chunk->data_len + sizeof(struct registry_chunk); - new_chunk_len = old_chunk_len << 1; + old_chunk_size_bytes = chunk_allocation_size(last_chunk->capacity); + new_capacity = last_chunk->capacity << 1; + new_chunk_size_bytes = chunk_allocation_size(new_capacity); /* Don't allow memory mapping to move, just expand. */ - new_chunk = mremap_wrapper(last_chunk, old_chunk_len, - new_chunk_len, 0); + new_chunk = mremap_wrapper(last_chunk, old_chunk_size_bytes, + new_chunk_size_bytes, 0); if (new_chunk != MAP_FAILED) { /* Should not have moved. */ assert(new_chunk == last_chunk); - memset((char *) last_chunk + old_chunk_len, 0, - new_chunk_len - old_chunk_len); - last_chunk->data_len = - new_chunk_len - sizeof(struct registry_chunk); + memset((char *) last_chunk + old_chunk_size_bytes, 0, + new_chunk_size_bytes - old_chunk_size_bytes); + last_chunk->capacity = new_capacity; return; /* We're done. */ } /* Remap did not succeed, we need to add a new chunk. */ - new_chunk = mmap(NULL, new_chunk_len, + new_chunk = (struct registry_chunk *) mmap(NULL, + new_chunk_size_bytes, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0); if (new_chunk == MAP_FAILED) abort(); - memset(new_chunk, 0, new_chunk_len); - new_chunk->data_len = - new_chunk_len - sizeof(struct registry_chunk); + memset(new_chunk, 0, new_chunk_size_bytes); + new_chunk->capacity = new_capacity; cds_list_add_tail(&new_chunk->node, &arena->chunk_list); } @@ -424,22 +433,23 @@ static struct rcu_reader *arena_alloc(struct registry_arena *arena) { struct registry_chunk *chunk; - struct rcu_reader *rcu_reader_reg; int expand_done = 0; /* Only allow to expand once per alloc */ - size_t len = sizeof(struct rcu_reader); retry: cds_list_for_each_entry(chunk, &arena->chunk_list, node) { - if (chunk->data_len - chunk->used < len) + size_t spot_idx; + + /* Skip fully used chunks. */ + if (chunk->used == chunk->capacity) { continue; - /* Find spot */ - for (rcu_reader_reg = (struct rcu_reader *) &chunk->data[0]; - rcu_reader_reg < (struct rcu_reader *) &chunk->data[chunk->data_len]; - rcu_reader_reg++) { - if (!rcu_reader_reg->alloc) { - rcu_reader_reg->alloc = 1; - chunk->used += len; - return rcu_reader_reg; + } + + /* Find a spot. */ + for (spot_idx = 0; spot_idx < chunk->capacity; spot_idx++) { + if (!chunk->readers[spot_idx].alloc) { + chunk->readers[spot_idx].alloc = 1; + chunk->used++; + return &chunk->readers[spot_idx]; } } } @@ -469,13 +479,13 @@ void add_thread(void) /* Add to registry */ rcu_reader_reg->tid = pthread_self(); - assert(rcu_reader_reg->ctr == 0); + urcu_posix_assert(rcu_reader_reg->ctr == 0); cds_list_add(&rcu_reader_reg->node, ®istry); /* * Reader threads are pointing to the reader registry. This is * why its memory should never be relocated. */ - URCU_TLS(rcu_reader) = rcu_reader_reg; + URCU_TLS(urcu_bp_reader) = rcu_reader_reg; } /* Called with mutex locked */ @@ -487,7 +497,7 @@ void cleanup_thread(struct registry_chunk *chunk, cds_list_del(&rcu_reader_reg->node); rcu_reader_reg->tid = 0; rcu_reader_reg->alloc = 0; - chunk->used -= sizeof(struct rcu_reader); + chunk->used--; } static @@ -496,9 +506,9 @@ struct registry_chunk *find_chunk(struct rcu_reader *rcu_reader_reg) struct registry_chunk *chunk; cds_list_for_each_entry(chunk, ®istry_arena.chunk_list, node) { - if (rcu_reader_reg < (struct rcu_reader *) &chunk->data[0]) + if (rcu_reader_reg < (struct urcu_bp_reader *) &chunk->readers[0]) continue; - if (rcu_reader_reg >= (struct rcu_reader *) &chunk->data[chunk->data_len]) + if (rcu_reader_reg >= (struct urcu_bp_reader *) &chunk->readers[chunk->capacity]) continue; return chunk; } @@ -510,11 +520,11 @@ static void remove_thread(struct rcu_reader *rcu_reader_reg) { cleanup_thread(find_chunk(rcu_reader_reg), rcu_reader_reg); - URCU_TLS(rcu_reader) = NULL; + URCU_TLS(urcu_bp_reader) = NULL; } /* Disable signals, take mutex, add to registry */ -void rcu_bp_register(void) +void urcu_bp_register(void) { sigset_t newmask, oldmask; int ret; @@ -530,13 +540,13 @@ void rcu_bp_register(void) * Check if a signal concurrently registered our thread since * the check in rcu_read_lock(). */ - if (URCU_TLS(rcu_reader)) + if (URCU_TLS(urcu_bp_reader)) goto end; /* * Take care of early registration before urcu_bp constructor. */ - rcu_bp_init(); + _urcu_bp_init(); mutex_lock(&rcu_registry_lock); add_thread(); @@ -547,9 +557,15 @@ end: abort(); } +void urcu_bp_register_thread(void) +{ + if (caa_unlikely(!URCU_TLS(urcu_bp_reader))) + urcu_bp_register(); /* If not yet registered. */ +} + /* Disable signals, take mutex, remove from registry */ static -void rcu_bp_unregister(struct rcu_reader *rcu_reader_reg) +void urcu_bp_unregister(struct rcu_reader *rcu_reader_reg) { sigset_t newmask, oldmask; int ret; @@ -567,7 +583,7 @@ void rcu_bp_unregister(struct rcu_reader *rcu_reader_reg) ret = pthread_sigmask(SIG_SETMASK, &oldmask, NULL); if (ret) abort(); - rcu_bp_exit(); + urcu_bp_exit(); } /* @@ -577,56 +593,71 @@ void rcu_bp_unregister(struct rcu_reader *rcu_reader_reg) static void urcu_bp_thread_exit_notifier(void *rcu_key) { - rcu_bp_unregister(rcu_key); + urcu_bp_unregister(rcu_key); } #ifdef CONFIG_RCU_FORCE_SYS_MEMBARRIER static -void rcu_sys_membarrier_status(int available) +void urcu_bp_sys_membarrier_status(bool available) { if (!available) abort(); } #else static -void rcu_sys_membarrier_status(int available) +void urcu_bp_sys_membarrier_status(bool available) { - if (available) - urcu_bp_has_sys_membarrier = 1; + if (!available) + return; + urcu_bp_has_sys_membarrier = 1; } #endif static -void rcu_bp_init(void) +void urcu_bp_sys_membarrier_init(void) +{ + bool available = false; + int mask; + + mask = membarrier(MEMBARRIER_CMD_QUERY, 0); + if (mask >= 0) { + if (mask & MEMBARRIER_CMD_PRIVATE_EXPEDITED) { + if (membarrier(MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED, 0)) + urcu_die(errno); + available = true; + } + } + urcu_bp_sys_membarrier_status(available); +} + +static +void _urcu_bp_init(void) { mutex_lock(&init_lock); - if (!rcu_bp_refcount++) { + if (!urcu_bp_refcount++) { int ret; ret = pthread_key_create(&urcu_bp_key, urcu_bp_thread_exit_notifier); if (ret) abort(); - ret = membarrier(MEMBARRIER_CMD_QUERY, 0); - rcu_sys_membarrier_status(ret >= 0 - && (ret & MEMBARRIER_CMD_SHARED)); + urcu_bp_sys_membarrier_init(); initialized = 1; } mutex_unlock(&init_lock); } static -void rcu_bp_exit(void) +void urcu_bp_exit(void) { mutex_lock(&init_lock); - if (!--rcu_bp_refcount) { + if (!--urcu_bp_refcount) { struct registry_chunk *chunk, *tmp; int ret; cds_list_for_each_entry_safe(chunk, tmp, ®istry_arena.chunk_list, node) { - munmap(chunk, chunk->data_len - + sizeof(struct registry_chunk)); + munmap((void *) chunk, chunk_allocation_size(chunk->capacity)); } CDS_INIT_LIST_HEAD(®istry_arena.chunk_list); ret = pthread_key_delete(urcu_bp_key); @@ -636,27 +667,34 @@ void rcu_bp_exit(void) mutex_unlock(&init_lock); } +static +void urcu_bp_exit_destructor(void) +{ + urcu_call_rcu_exit(); + urcu_bp_exit(); +} + /* * Holding the rcu_gp_lock and rcu_registry_lock across fork will make * sure we fork() don't race with a concurrent thread executing with * any of those locks held. This ensures that the registry and data * protected by rcu_gp_lock are in a coherent state in the child. */ -void rcu_bp_before_fork(void) +void urcu_bp_before_fork(void) { sigset_t newmask, oldmask; int ret; ret = sigfillset(&newmask); - assert(!ret); + urcu_posix_assert(!ret); ret = pthread_sigmask(SIG_BLOCK, &newmask, &oldmask); - assert(!ret); + urcu_posix_assert(!ret); mutex_lock(&rcu_gp_lock); mutex_lock(&rcu_registry_lock); saved_fork_signal_mask = oldmask; } -void rcu_bp_after_fork_parent(void) +void urcu_bp_after_fork_parent(void) { sigset_t oldmask; int ret; @@ -665,7 +703,7 @@ void rcu_bp_after_fork_parent(void) mutex_unlock(&rcu_registry_lock); mutex_unlock(&rcu_gp_lock); ret = pthread_sigmask(SIG_SETMASK, &oldmask, NULL); - assert(!ret); + urcu_posix_assert(!ret); } /* @@ -676,22 +714,23 @@ static void urcu_bp_prune_registry(void) { struct registry_chunk *chunk; - struct rcu_reader *rcu_reader_reg; cds_list_for_each_entry(chunk, ®istry_arena.chunk_list, node) { - for (rcu_reader_reg = (struct rcu_reader *) &chunk->data[0]; - rcu_reader_reg < (struct rcu_reader *) &chunk->data[chunk->data_len]; - rcu_reader_reg++) { - if (!rcu_reader_reg->alloc) + size_t spot_idx; + + for (spot_idx = 0; spot_idx < chunk->capacity; spot_idx++) { + struct urcu_bp_reader *reader = &chunk->readers[spot_idx]; + + if (!reader->alloc) continue; - if (rcu_reader_reg->tid == pthread_self()) + if (reader->tid == pthread_self()) continue; - cleanup_thread(chunk, rcu_reader_reg); + cleanup_thread(chunk, reader); } } } -void rcu_bp_after_fork_child(void) +void urcu_bp_after_fork_child(void) { sigset_t oldmask; int ret; @@ -701,28 +740,28 @@ void rcu_bp_after_fork_child(void) mutex_unlock(&rcu_registry_lock); mutex_unlock(&rcu_gp_lock); ret = pthread_sigmask(SIG_SETMASK, &oldmask, NULL); - assert(!ret); + urcu_posix_assert(!ret); } -void *rcu_dereference_sym_bp(void *p) +void *urcu_bp_dereference_sym(void *p) { return _rcu_dereference(p); } -void *rcu_set_pointer_sym_bp(void **p, void *v) +void *urcu_bp_set_pointer_sym(void **p, void *v) { cmm_wmb(); uatomic_set(p, v); return v; } -void *rcu_xchg_pointer_sym_bp(void **p, void *v) +void *urcu_bp_xchg_pointer_sym(void **p, void *v) { cmm_wmb(); return uatomic_xchg(p, v); } -void *rcu_cmpxchg_pointer_sym_bp(void **p, void *old, void *_new) +void *urcu_bp_cmpxchg_pointer_sym(void **p, void *old, void *_new) { cmm_wmb(); return uatomic_cmpxchg(p, old, _new); @@ -732,3 +771,4 @@ DEFINE_RCU_FLAVOR(rcu_flavor); #include "urcu-call-rcu-impl.h" #include "urcu-defer-impl.h" +#include "urcu-poll-impl.h"