1N/A/*-
1N/A * See the file LICENSE for redistribution information.
1N/A *
1N/A * Copyright (c) 1996, 1997
1N/A * Sleepycat Software. All rights reserved.
1N/A *
1N/A * @(#)shqueue.h 8.12 (Sleepycat) 9/10/97
1N/A * %W% (Sun) %G%
1N/A */
1N/A/*
1N/A * Copyright (c) 1998 by Sun Microsystems, Inc.
1N/A * All rights reserved.
1N/A */
1N/A
1N/A#pragma ident "%Z%%M% %I% %E% SMI"
1N/A
1N/A#ifndef _SYS_SHQUEUE_H_
1N/A#define _SYS_SHQUEUE_H_
1N/A
1N/A/*
1N/A * This file defines three types of data structures: lists, tail queues, and
1N/A * circular queues, similarly to the include file <sys/queue.h>.
1N/A *
1N/A * The difference is that this set of macros can be used for structures that
1N/A * reside in shared memory that may be mapped at different addresses in each
1N/A * process. In most cases, the macros for shared structures exactly mirror
1N/A * the normal macros, although the macro calls require an additional type
1N/A * parameter, only used by the HEAD and ENTRY macros of the standard macros.
1N/A *
1N/A * For details on the use of these macros, see the queue(3) manual page.
1N/A */
1N/A
1N/A/*
1N/A * Shared list definitions.
1N/A */
1N/A#define SH_LIST_HEAD(name) \
1N/Astruct name { \
1N/A ssize_t slh_first; /* first element */ \
1N/A}
1N/A
1N/A#define SH_LIST_ENTRY \
1N/Astruct { \
1N/A ssize_t sle_next; /* relative offset next element */ \
1N/A ssize_t sle_prev; /* relative offset of prev element */ \
1N/A}
1N/A
1N/A/*
1N/A * Shared list functions. Since we use relative offsets for pointers,
1N/A * 0 is a valid offset. Therefore, we use -1 to indicate end of list.
1N/A * The macros ending in "P" return pointers without checking for end
1N/A * of list, the others check for end of list and evaluate to either a
1N/A * pointer or NULL.
1N/A */
1N/A
1N/A#define SH_LIST_FIRSTP(head, type) \
1N/A ((struct type *)(((u_int8_t *)(head)) + (head)->slh_first))
1N/A
1N/A#define SH_LIST_FIRST(head, type) \
1N/A ((head)->slh_first == -1 ? NULL : \
1N/A ((struct type *)(((u_int8_t *)(head)) + (head)->slh_first)))
1N/A
1N/A#define SH_LIST_NEXTP(elm, field, type) \
1N/A ((struct type *)(((u_int8_t *)(elm)) + (elm)->field.sle_next))
1N/A
1N/A#define SH_LIST_NEXT(elm, field, type) \
1N/A ((elm)->field.sle_next == -1 ? NULL : \
1N/A ((struct type *)(((u_int8_t *)(elm)) + (elm)->field.sle_next)))
1N/A
1N/A#define SH_LIST_PREV(elm, field) \
1N/A ((ssize_t *)(((u_int8_t *)(elm)) + (elm)->field.sle_prev))
1N/A
1N/A#define SH_PTR_TO_OFF(src, dest) \
1N/A ((ssize_t)(((u_int8_t *)(dest)) - ((u_int8_t *)(src))))
1N/A
1N/A#define SH_LIST_END(head) NULL
1N/A
1N/A/*
1N/A * Take the element's next pointer and calculate what the corresponding
1N/A * Prev pointer should be -- basically it is the negation plus the offset
1N/A * of the next field in the structure.
1N/A */
1N/A#define SH_LIST_NEXT_TO_PREV(elm, field) \
1N/A (-(elm)->field.sle_next + SH_PTR_TO_OFF(elm, &(elm)->field.sle_next))
1N/A
1N/A#define SH_LIST_INIT(head) (head)->slh_first = -1
1N/A
1N/A#define SH_LIST_INSERT_AFTER(listelm, elm, field, type) do { \
1N/A if ((listelm)->field.sle_next != -1) { \
1N/A (elm)->field.sle_next = SH_PTR_TO_OFF(elm, \
1N/A SH_LIST_NEXTP(listelm, field, type)); \
1N/A SH_LIST_NEXTP(listelm, field, type)->field.sle_prev = \
1N/A SH_LIST_NEXT_TO_PREV(elm, field); \
1N/A } else \
1N/A (elm)->field.sle_next = -1; \
1N/A (listelm)->field.sle_next = SH_PTR_TO_OFF(listelm, elm); \
1N/A (elm)->field.sle_prev = SH_LIST_NEXT_TO_PREV(listelm, field); \
1N/A} while (0)
1N/A
1N/A#define SH_LIST_INSERT_HEAD(head, elm, field, type) do { \
1N/A if ((head)->slh_first != -1) { \
1N/A (elm)->field.sle_next = \
1N/A (head)->slh_first - SH_PTR_TO_OFF(head, elm); \
1N/A SH_LIST_FIRSTP(head, type)->field.sle_prev = \
1N/A SH_LIST_NEXT_TO_PREV(elm, field); \
1N/A } else \
1N/A (elm)->field.sle_next = -1; \
1N/A (head)->slh_first = SH_PTR_TO_OFF(head, elm); \
1N/A (elm)->field.sle_prev = SH_PTR_TO_OFF(elm, &(head)->slh_first); \
1N/A} while (0)
1N/A
1N/A#define SH_LIST_REMOVE(elm, field, type) do { \
1N/A if ((elm)->field.sle_next != -1) { \
1N/A SH_LIST_NEXTP(elm, field, type)->field.sle_prev = \
1N/A (elm)->field.sle_prev - (elm)->field.sle_next; \
1N/A *SH_LIST_PREV(elm, field) += (elm)->field.sle_next; \
1N/A } else \
1N/A *SH_LIST_PREV(elm, field) = -1; \
1N/A} while (0)
1N/A
1N/A/*
1N/A * Shared tail queue definitions.
1N/A */
1N/A#define SH_TAILQ_HEAD(name) \
1N/Astruct name { \
1N/A ssize_t stqh_first; /* relative offset of first element */ \
1N/A ssize_t stqh_last; /* relative offset of last's next */ \
1N/A}
1N/A
1N/A#define SH_TAILQ_ENTRY \
1N/Astruct { \
1N/A ssize_t stqe_next; /* relative offset of next element */ \
1N/A ssize_t stqe_prev; /* relative offset of prev's next */ \
1N/A}
1N/A
1N/A/*
1N/A * Shared tail queue functions.
1N/A */
1N/A#define SH_TAILQ_FIRSTP(head, type) \
1N/A ((struct type *)((u_int8_t *)(head) + (head)->stqh_first))
1N/A
1N/A#define SH_TAILQ_FIRST(head, type) \
1N/A ((head)->stqh_first == -1 ? NULL : SH_TAILQ_FIRSTP(head, type))
1N/A
1N/A#define SH_TAILQ_NEXTP(elm, field, type) \
1N/A ((struct type *)((u_int8_t *)(elm) + (elm)->field.stqe_next))
1N/A
1N/A#define SH_TAILQ_NEXT(elm, field, type) \
1N/A ((elm)->field.stqe_next == -1 ? NULL : SH_TAILQ_NEXTP(elm, field, type))
1N/A
1N/A#define SH_TAILQ_PREVP(elm, field) \
1N/A ((ssize_t *)((u_int8_t *)(elm) + (elm)->field.stqe_prev))
1N/A
1N/A#define SH_TAILQ_LAST(head) \
1N/A ((ssize_t *)(((u_int8_t *)(head)) + (head)->stqh_last))
1N/A
1N/A#define SH_TAILQ_NEXT_TO_PREV(elm, field) \
1N/A (-(elm)->field.stqe_next + SH_PTR_TO_OFF(elm, &(elm)->field.stqe_next))
1N/A
1N/A#define SH_TAILQ_END(head) NULL
1N/A
1N/A#define SH_TAILQ_INIT(head) { \
1N/A (head)->stqh_first = -1; \
1N/A (head)->stqh_last = SH_PTR_TO_OFF(head, &(head)->stqh_first); \
1N/A}
1N/A
1N/A#define SH_TAILQ_INSERT_HEAD(head, elm, field, type) do { \
1N/A if ((head)->stqh_first != -1) { \
1N/A (elm)->field.stqe_next = \
1N/A (head)->stqh_first - SH_PTR_TO_OFF(head, elm); \
1N/A SH_TAILQ_FIRSTP(head, type)->field.stqe_prev = \
1N/A SH_TAILQ_NEXT_TO_PREV(elm, field); \
1N/A } else { \
1N/A (elm)->field.stqe_next = -1; \
1N/A (head)->stqh_last = \
1N/A SH_PTR_TO_OFF(head, &(elm)->field.stqe_next); \
1N/A } \
1N/A (head)->stqh_first = SH_PTR_TO_OFF(head, elm); \
1N/A (elm)->field.stqe_prev = \
1N/A SH_PTR_TO_OFF(elm, &(head)->stqh_first); \
1N/A} while (0)
1N/A
1N/A#define SH_TAILQ_INSERT_TAIL(head, elm, field) do { \
1N/A (elm)->field.stqe_next = -1; \
1N/A (elm)->field.stqe_prev = \
1N/A -SH_PTR_TO_OFF(head, elm) + (head)->stqh_last; \
1N/A if ((head)->stqh_last == \
1N/A SH_PTR_TO_OFF((head), &(head)->stqh_first)) \
1N/A (head)->stqh_first = SH_PTR_TO_OFF(head, elm); \
1N/A else \
1N/A *SH_TAILQ_LAST(head) = -(head)->stqh_last + \
1N/A SH_PTR_TO_OFF((elm), &(elm)->field.stqe_next) + \
1N/A SH_PTR_TO_OFF(head, elm); \
1N/A (head)->stqh_last = \
1N/A SH_PTR_TO_OFF(head, &((elm)->field.stqe_next)); \
1N/A} while (0)
1N/A
1N/A#define SH_TAILQ_INSERT_AFTER(head, listelm, elm, field, type) do { \
1N/A if ((listelm)->field.stqe_next != -1) { \
1N/A (elm)->field.stqe_next = (listelm)->field.stqe_next - \
1N/A SH_PTR_TO_OFF(listelm, elm); \
1N/A SH_TAILQ_NEXTP(listelm, field, type)->field.stqe_prev = \
1N/A SH_TAILQ_NEXT_TO_PREV(elm, field); \
1N/A } else { \
1N/A (elm)->field.stqe_next = -1; \
1N/A (head)->stqh_last = \
1N/A SH_PTR_TO_OFF(head, &elm->field.stqe_next); \
1N/A } \
1N/A (listelm)->field.stqe_next = SH_PTR_TO_OFF(listelm, elm); \
1N/A (elm)->field.stqe_prev = SH_TAILQ_NEXT_TO_PREV(listelm, field); \
1N/A} while (0)
1N/A
1N/A#define SH_TAILQ_REMOVE(head, elm, field, type) do { \
1N/A if ((elm)->field.stqe_next != -1) { \
1N/A SH_TAILQ_NEXTP(elm, field, type)->field.stqe_prev = \
1N/A (elm)->field.stqe_prev + \
1N/A SH_PTR_TO_OFF(SH_TAILQ_NEXTP(elm, \
1N/A field, type), elm); \
1N/A *SH_TAILQ_PREVP(elm, field) += elm->field.stqe_next; \
1N/A } else { \
1N/A (head)->stqh_last = (elm)->field.stqe_prev + \
1N/A SH_PTR_TO_OFF(head, elm); \
1N/A *SH_TAILQ_PREVP(elm, field) = -1; \
1N/A } \
1N/A} while (0)
1N/A
1N/A/*
1N/A * Shared circular queue definitions.
1N/A */
1N/A#define SH_CIRCLEQ_HEAD(name) \
1N/Astruct name { \
1N/A ssize_t scqh_first; /* first element */ \
1N/A ssize_t scqh_last; /* last element */ \
1N/A}
1N/A
1N/A#define SH_CIRCLEQ_ENTRY \
1N/Astruct { \
1N/A ssize_t scqe_next; /* next element */ \
1N/A ssize_t scqe_prev; /* previous element */ \
1N/A}
1N/A
1N/A/*
1N/A * Shared circular queue functions.
1N/A */
1N/A#define SH_CIRCLEQ_FIRSTP(head, type) \
1N/A ((struct type *)(((u_int8_t *)(head)) + (head)->scqh_first))
1N/A
1N/A#define SH_CIRCLEQ_FIRST(head, type) \
1N/A ((head)->scqh_first == -1 ? \
1N/A (void *)head : SH_CIRCLEQ_FIRSTP(head, type))
1N/A
1N/A#define SH_CIRCLEQ_LASTP(head, type) \
1N/A ((struct type *)(((u_int8_t *)(head)) + (head)->scqh_last))
1N/A
1N/A#define SH_CIRCLEQ_LAST(head, type) \
1N/A ((head)->scqh_last == -1 ? (void *)head : SH_CIRCLEQ_LASTP(head, type))
1N/A
1N/A#define SH_CIRCLEQ_NEXTP(elm, field, type) \
1N/A ((struct type *)(((u_int8_t *)(elm)) + (elm)->field.scqe_next))
1N/A
1N/A#define SH_CIRCLEQ_NEXT(head, elm, field, type) \
1N/A ((elm)->field.scqe_next == SH_PTR_TO_OFF(elm, head) ? \
1N/A (void *)head : SH_CIRCLEQ_NEXTP(elm, field, type))
1N/A
1N/A#define SH_CIRCLEQ_PREVP(elm, field, type) \
1N/A ((struct type *)(((u_int8_t *)(elm)) + (elm)->field.scqe_prev))
1N/A
1N/A#define SH_CIRCLEQ_PREV(head, elm, field, type) \
1N/A ((elm)->field.scqe_prev == SH_PTR_TO_OFF(elm, head) ? \
1N/A (void *)head : SH_CIRCLEQ_PREVP(elm, field, type))
1N/A
1N/A#define SH_CIRCLEQ_END(head) ((void *)(head))
1N/A
1N/A#define SH_CIRCLEQ_INIT(head) { \
1N/A (head)->scqh_first = 0; \
1N/A (head)->scqh_last = 0; \
1N/A}
1N/A
1N/A#define SH_CIRCLEQ_INSERT_AFTER(head, listelm, elm, field, type) do { \
1N/A (elm)->field.scqe_prev = SH_PTR_TO_OFF(elm, listelm); \
1N/A (elm)->field.scqe_next = (listelm)->field.scqe_next + \
1N/A (elm)->field.scqe_prev; \
1N/A if (SH_CIRCLEQ_NEXTP(listelm, field, type) == (void *)head) \
1N/A (head)->scqh_last = SH_PTR_TO_OFF(head, elm); \
1N/A else \
1N/A SH_CIRCLEQ_NEXTP(listelm, \
1N/A field, type)->field.scqe_prev = \
1N/A SH_PTR_TO_OFF(SH_CIRCLEQ_NEXTP(listelm, \
1N/A field, type), elm); \
1N/A (listelm)->field.scqe_next = -(elm)->field.scqe_prev; \
1N/A} while (0)
1N/A
1N/A#define SH_CIRCLEQ_INSERT_BEFORE(head, listelm, elm, field, type) do { \
1N/A (elm)->field.scqe_next = SH_PTR_TO_OFF(elm, listelm); \
1N/A (elm)->field.scqe_prev = (elm)->field.scqe_next - \
1N/A SH_CIRCLEQ_PREVP(listelm, field, type)->field.scqe_next;\
1N/A if (SH_CIRCLEQ_PREVP(listelm, field, type) == (void *)(head)) \
1N/A (head)->scqh_first = SH_PTR_TO_OFF(head, elm); \
1N/A else \
1N/A SH_CIRCLEQ_PREVP(listelm, \
1N/A field, type)->field.scqe_next = \
1N/A SH_PTR_TO_OFF(SH_CIRCLEQ_PREVP(listelm, \
1N/A field, type), elm); \
1N/A (listelm)->field.scqe_prev = -(elm)->field.scqe_next; \
1N/A} while (0)
1N/A
1N/A#define SH_CIRCLEQ_INSERT_HEAD(head, elm, field, type) do { \
1N/A (elm)->field.scqe_prev = SH_PTR_TO_OFF(elm, head); \
1N/A (elm)->field.scqe_next = (head)->scqh_first + \
1N/A (elm)->field.scqe_prev; \
1N/A if ((head)->scqh_last == 0) \
1N/A (head)->scqh_last = -(elm)->field.scqe_prev; \
1N/A else \
1N/A SH_CIRCLEQ_FIRSTP(head, type)->field.scqe_prev = \
1N/A SH_PTR_TO_OFF(SH_CIRCLEQ_FIRSTP(head, type), elm); \
1N/A (head)->scqh_first = -(elm)->field.scqe_prev; \
1N/A} while (0)
1N/A
1N/A#define SH_CIRCLEQ_INSERT_TAIL(head, elm, field, type) do { \
1N/A (elm)->field.scqe_next = SH_PTR_TO_OFF(elm, head); \
1N/A (elm)->field.scqe_prev = (head)->scqh_last + \
1N/A (elm)->field.scqe_next; \
1N/A if ((head)->scqh_first == 0) \
1N/A (head)->scqh_first = -(elm)->field.scqe_next; \
1N/A else \
1N/A SH_CIRCLEQ_LASTP(head, type)->field.scqe_next = \
1N/A SH_PTR_TO_OFF(SH_CIRCLEQ_LASTP(head, type), elm); \
1N/A (head)->scqh_last = -(elm)->field.scqe_next; \
1N/A} while (0)
1N/A
1N/A#define SH_CIRCLEQ_REMOVE(head, elm, field, type) do { \
1N/A if (SH_CIRCLEQ_NEXTP(elm, field, type) == (void *)(head)) \
1N/A (head)->scqh_last += (elm)->field.scqe_prev; \
1N/A else \
1N/A SH_CIRCLEQ_NEXTP(elm, field, type)->field.scqe_prev += \
1N/A (elm)->field.scqe_prev; \
1N/A if (SH_CIRCLEQ_PREVP(elm, field, type) == (void *)(head)) \
1N/A (head)->scqh_first += (elm)->field.scqe_next; \
1N/A else \
1N/A SH_CIRCLEQ_PREVP(elm, field, type)->field.scqe_next += \
1N/A (elm)->field.scqe_next; \
1N/A} while (0)
1N/A#endif /* !_SYS_SHQUEUE_H_ */