X-Git-Url: http://git.liburcu.org/?p=urcu.git;a=blobdiff_plain;f=urcu.h;h=af7d75cb7bc9e389ba9896a9207695d4feea9540;hp=bee7715270794c3e83cede4acb1741a98d361ac6;hb=7abf2d0da3b328572a17c9457b33c3890b0ba58b;hpb=41718ff94c4a07cb5f56d68084267798e471d1b1 diff --git a/urcu.h b/urcu.h index bee7715..af7d75c 100644 --- a/urcu.h +++ b/urcu.h @@ -1,102 +1,96 @@ #ifndef _URCU_H #define _URCU_H -/* The "volatile" is due to gcc bugs */ -#define barrier() __asm__ __volatile__("": : :"memory") - -/* x86 32/64 specific */ -#define mb() asm volatile("mfence":::"memory") -#define rmb() asm volatile("lfence":::"memory") -#define wmb() asm volatile("sfence" ::: "memory") +/* + * urcu.h + * + * Userspace RCU header + * + * Copyright (c) 2009 Mathieu Desnoyers + * Copyright (c) 2009 Paul E. McKenney, IBM Corporation. + * + * LGPL-compatible code should include this header with : + * + * #define _LGPL_SOURCE + * #include + * + * 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. + */ +#include +#include +/* + * Important ! + * + * Each thread containing read-side critical sections must be registered + * with rcu_register_thread() before calling rcu_read_lock(). + * rcu_unregister_thread() should be called before the thread exits. + */ -/* x86 32 */ -static inline void atomic_inc(int *v) -{ - asm volatile("lock; incl %0" - : "+m" (*v)); -} +#ifdef _LGPL_SOURCE -/* Nop everywhere except on alpha. */ -#define smp_read_barrier_depends() +#include /* - * Prevent the compiler from merging or refetching accesses. The compiler - * is also forbidden from reordering successive instances of ACCESS_ONCE(), - * but only when the compiler is aware of some particular ordering. One way - * to make the compiler aware of ordering is to put the two invocations of - * ACCESS_ONCE() in different C statements. - * - * This macro does absolutely -nothing- to prevent the CPU from reordering, - * merging, or refetching absolutely anything at any time. Its main intended - * use is to mediate communication between process-level code and irq/NMI - * handlers, all running on the same CPU. + * Mappings for static use of the userspace RCU library. + * Should only be used in LGPL-compatible code. */ -#define ACCESS_ONCE(x) (*(volatile typeof(x) *)&(x)) -/** - * rcu_dereference - fetch an RCU-protected pointer in an - * RCU read-side critical section. This pointer may later - * be safely dereferenced. - * - * Inserts memory barriers on architectures that require them - * (currently only the Alpha), and, more importantly, documents - * exactly which pointers are protected by RCU. +#define rcu_dereference _rcu_dereference +#define rcu_read_lock _rcu_read_lock +#define rcu_read_unlock _rcu_read_unlock + +#define rcu_assign_pointer _rcu_assign_pointer +#define rcu_xchg_pointer _rcu_xchg_pointer +#define rcu_publish_content _rcu_publish_content + +#else /* !_LGPL_SOURCE */ + +/* + * library wrappers to be used by non-LGPL compatible source code. */ -#define rcu_dereference(p) ({ \ - typeof(p) _________p1 = ACCESS_ONCE(p); \ - smp_read_barrier_depends(); \ - (_________p1); \ - }) +extern void rcu_read_lock(void); +extern void rcu_read_unlock(void); -#define SIGURCU SIGUSR1 +extern void *rcu_dereference(void *p); -/* Global quiescent period parity */ -extern int urcu_qparity; +extern void *rcu_assign_pointer_sym(void **p, void *v); -extern int __thread urcu_active_readers[2]; +#define rcu_assign_pointer(p, v) \ + rcu_assign_pointer_sym((void **)(p), (v)) -static inline int get_urcu_qparity(void) -{ - return urcu_qparity; -} +extern void *rcu_xchg_pointer_sym(void **p, void *v); +#define rcu_xchg_pointer(p, v) \ + rcu_xchg_pointer_sym((void **)(p), (v)) -/* - * returns urcu_parity. - */ -static inline int rcu_read_lock(void) -{ - int urcu_parity = get_urcu_qparity(); - urcu_active_readers[urcu_parity]++; - /* - * Increment active readers count before accessing the pointer. - * See force_mb_all_threads(). - */ - barrier(); - return urcu_parity; -} - -static inline void rcu_read_unlock(int urcu_parity) -{ - barrier(); - /* - * Finish using rcu before decrementing the pointer. - * See force_mb_all_threads(). - */ - urcu_active_readers[urcu_parity]--; -} - -extern void rcu_write_lock(void); -extern void rcu_write_unlock(void); - -extern void *urcu_publish_content(void **ptr, void *new); +extern void *rcu_publish_content_sym(void **p, void *v); +#define rcu_publish_content(p, v) \ + rcu_publish_content_sym((void **)(p), (v)) + +#endif /* !_LGPL_SOURCE */ + +extern void synchronize_rcu(void); /* * Reader thread registration. */ -extern void urcu_register_thread(void); -extern void urcu_register_thread(void); +extern void rcu_register_thread(void); +extern void rcu_unregister_thread(void); #endif /* _URCU_H */