mirror of
http://git.haproxy.org/git/haproxy.git/
synced 2024-12-21 03:00:35 +00:00
5775d0964a
A few files were including it while not needing it (anymore). Some only required access to the atomic ops and got haproxy/atomic.h in exchange. Others didn't need it at all. A significant number of files still include it only for THREAD_LOCAL definition.
85 lines
1.9 KiB
C
85 lines
1.9 KiB
C
#ifndef __XREF_H__
|
|
#define __XREF_H__
|
|
|
|
#include <haproxy/atomic.h>
|
|
|
|
/* xref is used to create relation between two elements.
|
|
* Once an element is released, it breaks the relation. If the
|
|
* relation is already broken, it frees the xref struct.
|
|
* The pointer between two elements is sort of a refcount with
|
|
* max value 1. The relation is only between two elements.
|
|
* The pointer and the type of elements a and b are conventional.
|
|
*/
|
|
|
|
struct xref {
|
|
struct xref *peer;
|
|
};
|
|
|
|
#define XREF_BUSY ((struct xref *)1)
|
|
|
|
static inline void xref_create(struct xref *xref_a, struct xref *xref_b)
|
|
{
|
|
xref_a->peer = xref_b;
|
|
xref_b->peer = xref_a;
|
|
}
|
|
|
|
static inline struct xref *xref_get_peer_and_lock(struct xref *xref)
|
|
{
|
|
struct xref *local;
|
|
struct xref *remote;
|
|
|
|
while (1) {
|
|
|
|
/* Get the local pointer to the peer. */
|
|
local = _HA_ATOMIC_XCHG(&xref->peer, XREF_BUSY);
|
|
__ha_barrier_atomic_store();
|
|
|
|
/* If the local pointer is NULL, the peer no longer exists. */
|
|
if (local == NULL) {
|
|
xref->peer = NULL;
|
|
return NULL;
|
|
}
|
|
|
|
/* If the local pointeru is BUSY, the peer try to acquire the
|
|
* lock. We retry the process.
|
|
*/
|
|
if (local == XREF_BUSY)
|
|
continue;
|
|
|
|
/* We are locked, the peer can't disappear, try to acquire
|
|
* the pper's lock. Note that remote can't be NULL.
|
|
*/
|
|
remote = _HA_ATOMIC_XCHG(&local->peer, XREF_BUSY);
|
|
|
|
/* The remote lock is BUSY, We retry the process. */
|
|
if (remote == XREF_BUSY) {
|
|
xref->peer = local;
|
|
__ha_barrier_store();
|
|
continue;
|
|
}
|
|
|
|
/* We have the lock, we return the value of the xref. */
|
|
return local;
|
|
}
|
|
}
|
|
|
|
static inline void xref_unlock(struct xref *xref, struct xref *peer)
|
|
{
|
|
/* Release the peer. */
|
|
peer->peer = xref;
|
|
|
|
__ha_barrier_store();
|
|
|
|
/* Release myself. */
|
|
xref->peer = peer;
|
|
}
|
|
|
|
static inline void xref_disconnect(struct xref *xref, struct xref *peer)
|
|
{
|
|
peer->peer = NULL;
|
|
__ha_barrier_store();
|
|
xref->peer = NULL;
|
|
}
|
|
|
|
#endif /* __XREF_H__ */
|