Ticket #12617: bsd.patch

new file headers/compatibility/bsd/sys/queue.h

@@ +1 @@
+/*-
+ * Copyright (c) 1991, 1993
+ *  The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *  @(#)queue.h 8.5 (Berkeley) 8/20/94
+ * $FreeBSD: src/sys/sys/queue.h,v 1.68 2006/10/24 11:20:29 ru Exp $
+ */
+
+#ifndef _SYS_QUEUE_H_
+#define _SYS_QUEUE_H_
+
+#include <sys/cdefs.h>
+
+/*
+ * This file defines four types of data structures: singly-linked lists,
+ * singly-linked tail queues, lists and tail queues.
+ *
+ * A singly-linked list is headed by a single forward pointer. The elements
+ * are singly linked for minimum space and pointer manipulation overhead at
+ * the expense of O(n) removal for arbitrary elements. New elements can be
+ * added to the list after an existing element or at the head of the list.
+ * Elements being removed from the head of the list should use the explicit
+ * macro for this purpose for optimum efficiency. A singly-linked list may
+ * only be traversed in the forward direction.  Singly-linked lists are ideal
+ * for applications with large datasets and few or no removals or for
+ * implementing a LIFO queue.
+ *
+ * A singly-linked tail queue is headed by a pair of pointers, one to the
+ * head of the list and the other to the tail of the list. The elements are
+ * singly linked for minimum space and pointer manipulation overhead at the
+ * expense of O(n) removal for arbitrary elements. New elements can be added
+ * to the list after an existing element, at the head of the list, or at the
+ * end of the list. Elements being removed from the head of the tail queue
+ * should use the explicit macro for this purpose for optimum efficiency.
+ * A singly-linked tail queue may only be traversed in the forward direction.
+ * Singly-linked tail queues are ideal for applications with large datasets
+ * and few or no removals or for implementing a FIFO queue.
+ *
+ * A list is headed by a single forward pointer (or an array of forward
+ * pointers for a hash table header). The elements are doubly linked
+ * so that an arbitrary element can be removed without a need to
+ * traverse the list. New elements can be added to the list before
+ * or after an existing element or at the head of the list. A list
+ * may only be traversed in the forward direction.
+ *
+ * A tail queue is headed by a pair of pointers, one to the head of the
+ * list and the other to the tail of the list. The elements are doubly
+ * linked so that an arbitrary element can be removed without a need to
+ * traverse the list. New elements can be added to the list before or
+ * after an existing element, at the head of the list, or at the end of
+ * the list. A tail queue may be traversed in either direction.
+ *
+ * For details on the use of these macros, see the queue(3) manual page.
+ *
+ *
+ *              SLIST   LIST    STAILQ  TAILQ
+ * _HEAD            +   +   +   +
+ * _HEAD_INITIALIZER        +   +   +   +
+ * _ENTRY           +   +   +   +
+ * _INIT            +   +   +   +
+ * _EMPTY           +   +   +   +
+ * _FIRST           +   +   +   +
+ * _NEXT            +   +   +   +
+ * _PREV            -   -   -   +
+ * _LAST            -   -   +   +
+ * _FOREACH         +   +   +   +
+ * _FOREACH_SAFE        +   +   +   +
+ * _FOREACH_REVERSE     -   -   -   +
+ * _FOREACH_REVERSE_SAFE    -   -   -   +
+ * _INSERT_HEAD         +   +   +   +
+ * _INSERT_BEFORE       -   +   -   +
+ * _INSERT_AFTER        +   +   +   +
+ * _INSERT_TAIL         -   -   +   +
+ * _CONCAT          -   -   +   +
+ * _REMOVE_HEAD         +   -   +   -
+ * _REMOVE          +   +   +   +
+ *
+ */
+#ifdef QUEUE_MACRO_DEBUG
+/* Store the last 2 places the queue element or head was altered */
+struct qm_trace {
+    char * lastfile;
+    int lastline;
+    char * prevfile;
+    int prevline;
+};
+
+#define TRACEBUF    struct qm_trace trace;
+#define TRASHIT(x)  do {(x) = (void *)-1;} while (0)
+
+#define QMD_TRACE_HEAD(head) do {                   \
+    (head)->trace.prevline = (head)->trace.lastline;        \
+    (head)->trace.prevfile = (head)->trace.lastfile;        \
+    (head)->trace.lastline = __LINE__;              \
+    (head)->trace.lastfile = __FILE__;              \
+} while (0)
+
+#define QMD_TRACE_ELEM(elem) do {                   \
+    (elem)->trace.prevline = (elem)->trace.lastline;        \
+    (elem)->trace.prevfile = (elem)->trace.lastfile;        \
+    (elem)->trace.lastline = __LINE__;              \
+    (elem)->trace.lastfile = __FILE__;              \
+} while (0)
+
+#else
+#define QMD_TRACE_ELEM(elem)
+#define QMD_TRACE_HEAD(head)
+#define TRACEBUF
+#define TRASHIT(x)
+#endif  /* QUEUE_MACRO_DEBUG */
+
+/*
+ * Singly-linked List declarations.
+ */
+#define SLIST_HEAD(name, type)                      \
+struct name {                               \
+    struct type *slh_first; /* first element */         \
+}
+
+#define SLIST_HEAD_INITIALIZER(head)                    \
+    { NULL }
+
+#define SLIST_ENTRY(type)                       \
+struct {                                \
+    struct type *sle_next;  /* next element */          \
+}
+
+/*
+ * Singly-linked List functions.
+ */
+#define SLIST_EMPTY(head)   ((head)->slh_first == NULL)
+
+#define SLIST_FIRST(head)   ((head)->slh_first)
+
+#define SLIST_FOREACH(var, head, field)                 \
+    for ((var) = SLIST_FIRST((head));               \
+        (var);                          \
+        (var) = SLIST_NEXT((var), field))
+
+#define SLIST_FOREACH_SAFE(var, head, field, tvar)          \
+    for ((var) = SLIST_FIRST((head));               \
+        (var) && ((tvar) = SLIST_NEXT((var), field), 1);        \
+        (var) = (tvar))
+
+#define SLIST_FOREACH_PREVPTR(var, varp, head, field)           \
+    for ((varp) = &SLIST_FIRST((head));             \
+        ((var) = *(varp)) != NULL;                  \
+        (varp) = &SLIST_NEXT((var), field))
+
+#define SLIST_INIT(head) do {                       \
+    SLIST_FIRST((head)) = NULL;                 \
+} while (0)
+
+#define SLIST_INSERT_AFTER(slistelm, elm, field) do {           \
+    SLIST_NEXT((elm), field) = SLIST_NEXT((slistelm), field);   \
+    SLIST_NEXT((slistelm), field) = (elm);              \
+} while (0)
+
+#define SLIST_INSERT_HEAD(head, elm, field) do {            \
+    SLIST_NEXT((elm), field) = SLIST_FIRST((head));         \
+    SLIST_FIRST((head)) = (elm);                    \
+} while (0)
+
+#define SLIST_NEXT(elm, field)  ((elm)->field.sle_next)
+
+#define SLIST_REMOVE(head, elm, type, field) do {           \
+    if (SLIST_FIRST((head)) == (elm)) {             \
+        SLIST_REMOVE_HEAD((head), field);           \
+    }                               \
+    else {                              \
+        struct type *curelm = SLIST_FIRST((head));      \
+        while (SLIST_NEXT(curelm, field) != (elm))      \
+            curelm = SLIST_NEXT(curelm, field);     \
+        SLIST_NEXT(curelm, field) =             \
+            SLIST_NEXT(SLIST_NEXT(curelm, field), field);   \
+    }                               \
+    TRASHIT((elm)->field.sle_next);                 \
+} while (0)
+
+#define SLIST_REMOVE_HEAD(head, field) do {             \
+    SLIST_FIRST((head)) = SLIST_NEXT(SLIST_FIRST((head)), field);   \
+} while (0)
+
+/*
+ * Singly-linked Tail queue declarations.
+ */
+#define STAILQ_HEAD(name, type)                     \
+struct name {                               \
+    struct type *stqh_first;/* first element */         \
+    struct type **stqh_last;/* addr of last next element */     \
+}
+
+#define STAILQ_HEAD_INITIALIZER(head)                   \
+    { NULL, &(head).stqh_first }
+
+#define STAILQ_ENTRY(type)                      \
+struct {                                \
+    struct type *stqe_next; /* next element */          \
+}
+
+/*
+ * Singly-linked Tail queue functions.
+ */
+#define STAILQ_CONCAT(head1, head2) do {                \
+    if (!STAILQ_EMPTY((head2))) {                   \
+        *(head1)->stqh_last = (head2)->stqh_first;      \
+        (head1)->stqh_last = (head2)->stqh_last;        \
+        STAILQ_INIT((head2));                   \
+    }                               \
+} while (0)
+
+#define STAILQ_EMPTY(head)  ((head)->stqh_first == NULL)
+
+#define STAILQ_FIRST(head)  ((head)->stqh_first)
+
+#define STAILQ_FOREACH(var, head, field)                \
+    for((var) = STAILQ_FIRST((head));               \
+       (var);                           \
+       (var) = STAILQ_NEXT((var), field))
+
+
+#define STAILQ_FOREACH_SAFE(var, head, field, tvar)         \
+    for ((var) = STAILQ_FIRST((head));              \
+        (var) && ((tvar) = STAILQ_NEXT((var), field), 1);       \
+        (var) = (tvar))
+
+#define STAILQ_INIT(head) do {                      \
+    STAILQ_FIRST((head)) = NULL;                    \
+    (head)->stqh_last = &STAILQ_FIRST((head));          \
+} while (0)
+
+#define STAILQ_INSERT_AFTER(head, tqelm, elm, field) do {       \
+    if ((STAILQ_NEXT((elm), field) = STAILQ_NEXT((tqelm), field)) == NULL)\
+        (head)->stqh_last = &STAILQ_NEXT((elm), field);     \
+    STAILQ_NEXT((tqelm), field) = (elm);                \
+} while (0)
+
+#define STAILQ_INSERT_HEAD(head, elm, field) do {           \
+    if ((STAILQ_NEXT((elm), field) = STAILQ_FIRST((head))) == NULL) \
+        (head)->stqh_last = &STAILQ_NEXT((elm), field);     \
+    STAILQ_FIRST((head)) = (elm);                   \
+} while (0)
+
+#define STAILQ_INSERT_TAIL(head, elm, field) do {           \
+    STAILQ_NEXT((elm), field) = NULL;               \
+    *(head)->stqh_last = (elm);                 \
+    (head)->stqh_last = &STAILQ_NEXT((elm), field);         \
+} while (0)
+
+#define STAILQ_LAST(head, type, field)                  \
+    (STAILQ_EMPTY((head)) ?                     \
+        NULL :                          \
+            ((struct type *)(void *)                \
+        ((char *)((head)->stqh_last) - __offsetof(struct type, field))))
+
+#define STAILQ_NEXT(elm, field) ((elm)->field.stqe_next)
+
+#define STAILQ_REMOVE(head, elm, type, field) do {          \
+    if (STAILQ_FIRST((head)) == (elm)) {                \
+        STAILQ_REMOVE_HEAD((head), field);          \
+    }                               \
+    else {                              \
+        struct type *curelm = STAILQ_FIRST((head));     \
+        while (STAILQ_NEXT(curelm, field) != (elm))     \
+            curelm = STAILQ_NEXT(curelm, field);        \
+        if ((STAILQ_NEXT(curelm, field) =           \
+             STAILQ_NEXT(STAILQ_NEXT(curelm, field), field)) == NULL)\
+            (head)->stqh_last = &STAILQ_NEXT((curelm), field);\
+    }                               \
+    TRASHIT((elm)->field.stqe_next);                \
+} while (0)
+
+#define STAILQ_REMOVE_HEAD(head, field) do {                \
+    if ((STAILQ_FIRST((head)) =                 \
+         STAILQ_NEXT(STAILQ_FIRST((head)), field)) == NULL)     \
+        (head)->stqh_last = &STAILQ_FIRST((head));      \
+} while (0)
+
+/*
+ * List declarations.
+ */
+#define LIST_HEAD(name, type)                       \
+struct name {                               \
+    struct type *lh_first;  /* first element */         \
+}
+
+#define LIST_HEAD_INITIALIZER(head)                 \
+    { NULL }
+
+#define LIST_ENTRY(type)                        \
+struct {                                \
+    struct type *le_next;   /* next element */          \
+    struct type **le_prev;  /* address of previous next element */  \
+}
+
+/*
+ * List functions.
+ */
+
+#if (defined(_KERNEL) && defined(INVARIANTS))
+#define QMD_LIST_CHECK_HEAD(head, field) do {               \
+    if (LIST_FIRST((head)) != NULL &&               \
+        LIST_FIRST((head))->field.le_prev !=            \
+         &LIST_FIRST((head)))                   \
+        panic("Bad list head %p first->prev != head", (head));  \
+} while (0)
+
+#define QMD_LIST_CHECK_NEXT(elm, field) do {                \
+    if (LIST_NEXT((elm), field) != NULL &&              \
+        LIST_NEXT((elm), field)->field.le_prev !=           \
+         &((elm)->field.le_next))                   \
+            panic("Bad link elm %p next->prev != elm", (elm));  \
+} while (0)
+
+#define QMD_LIST_CHECK_PREV(elm, field) do {                \
+    if (*(elm)->field.le_prev != (elm))             \
+        panic("Bad link elm %p prev->next != elm", (elm));  \
+} while (0)
+#else
+#define QMD_LIST_CHECK_HEAD(head, field)
+#define QMD_LIST_CHECK_NEXT(elm, field)
+#define QMD_LIST_CHECK_PREV(elm, field)
+#endif /* (_KERNEL && INVARIANTS) */
+
+#define LIST_EMPTY(head)    ((head)->lh_first == NULL)
+
+#define LIST_FIRST(head)    ((head)->lh_first)
+
+#define LIST_FOREACH(var, head, field)                  \
+    for ((var) = LIST_FIRST((head));                \
+        (var);                          \
+        (var) = LIST_NEXT((var), field))
+
+#define LIST_FOREACH_SAFE(var, head, field, tvar)           \
+    for ((var) = LIST_FIRST((head));                \
+        (var) && ((tvar) = LIST_NEXT((var), field), 1);     \
+        (var) = (tvar))
+
+#define LIST_INIT(head) do {                        \
+    LIST_FIRST((head)) = NULL;                  \
+} while (0)
+
+#define LIST_INSERT_AFTER(listelm, elm, field) do {         \
+    QMD_LIST_CHECK_NEXT(listelm, field);                \
+    if ((LIST_NEXT((elm), field) = LIST_NEXT((listelm), field)) != NULL)\
+        LIST_NEXT((listelm), field)->field.le_prev =        \
+            &LIST_NEXT((elm), field);               \
+    LIST_NEXT((listelm), field) = (elm);                \
+    (elm)->field.le_prev = &LIST_NEXT((listelm), field);        \
+} while (0)
+
+#define LIST_INSERT_BEFORE(listelm, elm, field) do {            \
+    QMD_LIST_CHECK_PREV(listelm, field);                \
+    (elm)->field.le_prev = (listelm)->field.le_prev;        \
+    LIST_NEXT((elm), field) = (listelm);                \
+    *(listelm)->field.le_prev = (elm);              \
+    (listelm)->field.le_prev = &LIST_NEXT((elm), field);        \
+} while (0)
+
+#define LIST_INSERT_HEAD(head, elm, field) do {             \
+    QMD_LIST_CHECK_HEAD((head), field);             \
+    if ((LIST_NEXT((elm), field) = LIST_FIRST((head))) != NULL) \
+        LIST_FIRST((head))->field.le_prev = &LIST_NEXT((elm), field);\
+    LIST_FIRST((head)) = (elm);                 \
+    (elm)->field.le_prev = &LIST_FIRST((head));         \
+} while (0)
+
+#define LIST_NEXT(elm, field)   ((elm)->field.le_next)
+
+#define LIST_REMOVE(elm, field) do {                    \
+    QMD_LIST_CHECK_NEXT(elm, field);                \
+    QMD_LIST_CHECK_PREV(elm, field);                \
+    if (LIST_NEXT((elm), field) != NULL)                \
+        LIST_NEXT((elm), field)->field.le_prev =        \
+            (elm)->field.le_prev;               \
+    *(elm)->field.le_prev = LIST_NEXT((elm), field);        \
+    TRASHIT((elm)->field.le_next);                  \
+    TRASHIT((elm)->field.le_prev);                  \
+} while (0)
+
+/*
+ * Tail queue declarations.
+ */
+#define TAILQ_HEAD(name, type)                      \
+struct name {                               \
+    struct type *tqh_first; /* first element */         \
+    struct type **tqh_last; /* addr of last next element */     \
+    TRACEBUF                            \
+}
+
+#define TAILQ_HEAD_INITIALIZER(head)                    \
+    { NULL, &(head).tqh_first }
+
+#define TAILQ_ENTRY(type)                       \
+struct {                                \
+    struct type *tqe_next;  /* next element */          \
+    struct type **tqe_prev; /* address of previous next element */  \
+    TRACEBUF                            \
+}
+
+/*
+ * Tail queue functions.
+ */
+#if (defined(_KERNEL) && defined(INVARIANTS))
+#define QMD_TAILQ_CHECK_HEAD(head, field) do {              \
+    if (!TAILQ_EMPTY(head) &&                   \
+        TAILQ_FIRST((head))->field.tqe_prev !=          \
+         &TAILQ_FIRST((head)))                  \
+        panic("Bad tailq head %p first->prev != head", (head)); \
+} while (0)
+
+#define QMD_TAILQ_CHECK_TAIL(head, field) do {              \
+    if (*(head)->tqh_last != NULL)                  \
+            panic("Bad tailq NEXT(%p->tqh_last) != NULL", (head));  \
+} while (0)
+
+#define QMD_TAILQ_CHECK_NEXT(elm, field) do {               \
+    if (TAILQ_NEXT((elm), field) != NULL &&             \
+        TAILQ_NEXT((elm), field)->field.tqe_prev !=         \
+         &((elm)->field.tqe_next))                  \
+        panic("Bad link elm %p next->prev != elm", (elm));  \
+} while (0)
+
+#define QMD_TAILQ_CHECK_PREV(elm, field) do {               \
+    if (*(elm)->field.tqe_prev != (elm))                \
+        panic("Bad link elm %p prev->next != elm", (elm));  \
+} while (0)
+#else
+#define QMD_TAILQ_CHECK_HEAD(head, field)
+#define QMD_TAILQ_CHECK_TAIL(head, headname)
+#define QMD_TAILQ_CHECK_NEXT(elm, field)
+#define QMD_TAILQ_CHECK_PREV(elm, field)
+#endif /* (_KERNEL && INVARIANTS) */
+
+#define TAILQ_CONCAT(head1, head2, field) do {              \
+    if (!TAILQ_EMPTY(head2)) {                  \
+        *(head1)->tqh_last = (head2)->tqh_first;        \
+        (head2)->tqh_first->field.tqe_prev = (head1)->tqh_last; \
+        (head1)->tqh_last = (head2)->tqh_last;          \
+        TAILQ_INIT((head2));                    \
+        QMD_TRACE_HEAD(head1);                  \
+        QMD_TRACE_HEAD(head2);                  \
+    }                               \
+} while (0)
+
+#define TAILQ_EMPTY(head)   ((head)->tqh_first == NULL)
+
+#define TAILQ_FIRST(head)   ((head)->tqh_first)
+
+#define TAILQ_FOREACH(var, head, field)                 \
+    for ((var) = TAILQ_FIRST((head));               \
+        (var);                          \
+        (var) = TAILQ_NEXT((var), field))
+
+#define TAILQ_FOREACH_SAFE(var, head, field, tvar)          \
+    for ((var) = TAILQ_FIRST((head));               \
+        (var) && ((tvar) = TAILQ_NEXT((var), field), 1);        \
+        (var) = (tvar))
+
+#define TAILQ_FOREACH_REVERSE(var, head, headname, field)       \
+    for ((var) = TAILQ_LAST((head), headname);          \
+        (var);                          \
+        (var) = TAILQ_PREV((var), headname, field))
+
+#define TAILQ_FOREACH_REVERSE_SAFE(var, head, headname, field, tvar)    \
+    for ((var) = TAILQ_LAST((head), headname);          \
+        (var) && ((tvar) = TAILQ_PREV((var), headname, field), 1);  \
+        (var) = (tvar))
+
+#define TAILQ_INIT(head) do {                       \
+    TAILQ_FIRST((head)) = NULL;                 \
+    (head)->tqh_last = &TAILQ_FIRST((head));            \
+    QMD_TRACE_HEAD(head);                       \
+} while (0)
+
+#define TAILQ_INSERT_AFTER(head, listelm, elm, field) do {      \
+    QMD_TAILQ_CHECK_NEXT(listelm, field);               \
+    if ((TAILQ_NEXT((elm), field) = TAILQ_NEXT((listelm), field)) != NULL)\
+        TAILQ_NEXT((elm), field)->field.tqe_prev =      \
+            &TAILQ_NEXT((elm), field);              \
+    else {                              \
+        (head)->tqh_last = &TAILQ_NEXT((elm), field);       \
+        QMD_TRACE_HEAD(head);                   \
+    }                               \
+    TAILQ_NEXT((listelm), field) = (elm);               \
+    (elm)->field.tqe_prev = &TAILQ_NEXT((listelm), field);      \
+    QMD_TRACE_ELEM(&(elm)->field);                  \
+    QMD_TRACE_ELEM(&listelm->field);                \
+} while (0)
+
+#define TAILQ_INSERT_BEFORE(listelm, elm, field) do {           \
+    QMD_TAILQ_CHECK_PREV(listelm, field);               \
+    (elm)->field.tqe_prev = (listelm)->field.tqe_prev;      \
+    TAILQ_NEXT((elm), field) = (listelm);               \
+    *(listelm)->field.tqe_prev = (elm);             \
+    (listelm)->field.tqe_prev = &TAILQ_NEXT((elm), field);      \
+    QMD_TRACE_ELEM(&(elm)->field);                  \
+    QMD_TRACE_ELEM(&listelm->field);                \
+} while (0)
+
+#define TAILQ_INSERT_HEAD(head, elm, field) do {            \
+    QMD_TAILQ_CHECK_HEAD(head, field);              \
+    if ((TAILQ_NEXT((elm), field) = TAILQ_FIRST((head))) != NULL)   \
+        TAILQ_FIRST((head))->field.tqe_prev =           \
+            &TAILQ_NEXT((elm), field);              \
+    else                                \
+        (head)->tqh_last = &TAILQ_NEXT((elm), field);       \
+    TAILQ_FIRST((head)) = (elm);                    \
+    (elm)->field.tqe_prev = &TAILQ_FIRST((head));           \
+    QMD_TRACE_HEAD(head);                       \
+    QMD_TRACE_ELEM(&(elm)->field);                  \
+} while (0)
+
+#define TAILQ_INSERT_TAIL(head, elm, field) do {            \
+    QMD_TAILQ_CHECK_TAIL(head, field);              \
+    TAILQ_NEXT((elm), field) = NULL;                \
+    (elm)->field.tqe_prev = (head)->tqh_last;           \
+    *(head)->tqh_last = (elm);                  \
+    (head)->tqh_last = &TAILQ_NEXT((elm), field);           \
+    QMD_TRACE_HEAD(head);                       \
+    QMD_TRACE_ELEM(&(elm)->field);                  \
+} while (0)
+
+#define TAILQ_LAST(head, headname)                  \
+    (*(((struct headname *)((head)->tqh_last))->tqh_last))
+
+#define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next)
+
+#define TAILQ_PREV(elm, headname, field)                \
+    (*(((struct headname *)((elm)->field.tqe_prev))->tqh_last))
+
+#define TAILQ_REMOVE(head, elm, field) do {             \
+    QMD_TAILQ_CHECK_NEXT(elm, field);               \
+    QMD_TAILQ_CHECK_PREV(elm, field);               \
+    if ((TAILQ_NEXT((elm), field)) != NULL)             \
+        TAILQ_NEXT((elm), field)->field.tqe_prev =      \
+            (elm)->field.tqe_prev;              \
+    else {                              \
+        (head)->tqh_last = (elm)->field.tqe_prev;       \
+        QMD_TRACE_HEAD(head);                   \
+    }                               \
+    *(elm)->field.tqe_prev = TAILQ_NEXT((elm), field);      \
+    TRASHIT((elm)->field.tqe_next);                 \
+    TRASHIT((elm)->field.tqe_prev);                 \
+    QMD_TRACE_ELEM(&(elm)->field);                  \
+} while (0)
+
+
+#ifdef _KERNEL
+
+/*
+ * XXX insque() and remque() are an old way of handling certain queues.
+ * They bogusly assumes that all queue heads look alike.
+ */
+
+struct quehead {
+    struct quehead *qh_link;
+    struct quehead *qh_rlink;
+};
+
+#ifdef __CC_SUPPORTS___INLINE
+
+static __inline void
+insque(void *a, void *b)
+{
+    struct quehead *element = (struct quehead *)a,
+         *head = (struct quehead *)b;
+
+    element->qh_link = head->qh_link;
+    element->qh_rlink = head;
+    head->qh_link = element;
+    element->qh_link->qh_rlink = element;
+}
+
+static __inline void
+remque(void *a)
+{
+    struct quehead *element = (struct quehead *)a;
+
+    element->qh_link->qh_rlink = element->qh_rlink;
+    element->qh_rlink->qh_link = element->qh_link;
+    element->qh_rlink = 0;
+}
+
+#else /* !__CC_SUPPORTS___INLINE */
+
+void    insque(void *a, void *b);
+void    remque(void *a);
+
+#endif /* __CC_SUPPORTS___INLINE */
+
+#endif /* _KERNEL */
+
+#endif /* !_SYS_QUEUE_H_ */

deleted file headers/private/firewire/queue.h

@@ -1 @@
-/*-
- * Copyright (c) 1991, 1993
- *  The Regents of the University of California.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *  @(#)queue.h 8.5 (Berkeley) 8/20/94
- * $FreeBSD: src/sys/sys/queue.h,v 1.68 2006/10/24 11:20:29 ru Exp $
- */
-
-#ifndef _SYS_QUEUE_H_
-#define _SYS_QUEUE_H_
-
-#include <sys/cdefs.h>
-
-/*
- * This file defines four types of data structures: singly-linked lists,
- * singly-linked tail queues, lists and tail queues.
- *
- * A singly-linked list is headed by a single forward pointer. The elements
- * are singly linked for minimum space and pointer manipulation overhead at
- * the expense of O(n) removal for arbitrary elements. New elements can be
- * added to the list after an existing element or at the head of the list.
- * Elements being removed from the head of the list should use the explicit
- * macro for this purpose for optimum efficiency. A singly-linked list may
- * only be traversed in the forward direction.  Singly-linked lists are ideal
- * for applications with large datasets and few or no removals or for
- * implementing a LIFO queue.
- *
- * A singly-linked tail queue is headed by a pair of pointers, one to the
- * head of the list and the other to the tail of the list. The elements are
- * singly linked for minimum space and pointer manipulation overhead at the
- * expense of O(n) removal for arbitrary elements. New elements can be added
- * to the list after an existing element, at the head of the list, or at the
- * end of the list. Elements being removed from the head of the tail queue
- * should use the explicit macro for this purpose for optimum efficiency.
- * A singly-linked tail queue may only be traversed in the forward direction.
- * Singly-linked tail queues are ideal for applications with large datasets
- * and few or no removals or for implementing a FIFO queue.
- *
- * A list is headed by a single forward pointer (or an array of forward
- * pointers for a hash table header). The elements are doubly linked
- * so that an arbitrary element can be removed without a need to
- * traverse the list. New elements can be added to the list before
- * or after an existing element or at the head of the list. A list
- * may only be traversed in the forward direction.
- *
- * A tail queue is headed by a pair of pointers, one to the head of the
- * list and the other to the tail of the list. The elements are doubly
- * linked so that an arbitrary element can be removed without a need to
- * traverse the list. New elements can be added to the list before or
- * after an existing element, at the head of the list, or at the end of
- * the list. A tail queue may be traversed in either direction.
- *
- * For details on the use of these macros, see the queue(3) manual page.
- *
- *
- *              SLIST   LIST    STAILQ  TAILQ
- * _HEAD            +   +   +   +
- * _HEAD_INITIALIZER        +   +   +   +
- * _ENTRY           +   +   +   +
- * _INIT            +   +   +   +
- * _EMPTY           +   +   +   +
- * _FIRST           +   +   +   +
- * _NEXT            +   +   +   +
- * _PREV            -   -   -   +
- * _LAST            -   -   +   +
- * _FOREACH         +   +   +   +
- * _FOREACH_SAFE        +   +   +   +
- * _FOREACH_REVERSE     -   -   -   +
- * _FOREACH_REVERSE_SAFE    -   -   -   +
- * _INSERT_HEAD         +   +   +   +
- * _INSERT_BEFORE       -   +   -   +
- * _INSERT_AFTER        +   +   +   +
- * _INSERT_TAIL         -   -   +   +
- * _CONCAT          -   -   +   +
- * _REMOVE_HEAD         +   -   +   -
- * _REMOVE          +   +   +   +
- *
- */
-#ifdef QUEUE_MACRO_DEBUG
-/* Store the last 2 places the queue element or head was altered */
-struct qm_trace {
-    char * lastfile;
-    int lastline;
-    char * prevfile;
-    int prevline;
-};
-
-#define TRACEBUF    struct qm_trace trace;
-#define TRASHIT(x)  do {(x) = (void *)-1;} while (0)
-
-#define QMD_TRACE_HEAD(head) do {                   \
-    (head)->trace.prevline = (head)->trace.lastline;        \
-    (head)->trace.prevfile = (head)->trace.lastfile;        \
-    (head)->trace.lastline = __LINE__;              \
-    (head)->trace.lastfile = __FILE__;              \
-} while (0)
-
-#define QMD_TRACE_ELEM(elem) do {                   \
-    (elem)->trace.prevline = (elem)->trace.lastline;        \
-    (elem)->trace.prevfile = (elem)->trace.lastfile;        \
-    (elem)->trace.lastline = __LINE__;              \
-    (elem)->trace.lastfile = __FILE__;              \
-} while (0)
-
-#else
-#define QMD_TRACE_ELEM(elem)
-#define QMD_TRACE_HEAD(head)
-#define TRACEBUF
-#define TRASHIT(x)
-#endif  /* QUEUE_MACRO_DEBUG */
-
-/*
- * Singly-linked List declarations.
- */
-#define SLIST_HEAD(name, type)                      \
-struct name {                               \
-    struct type *slh_first; /* first element */         \
-}
-
-#define SLIST_HEAD_INITIALIZER(head)                    \
-    { NULL }
-
-#define SLIST_ENTRY(type)                       \
-struct {                                \
-    struct type *sle_next;  /* next element */          \
-}
-
-/*
- * Singly-linked List functions.
- */
-#define SLIST_EMPTY(head)   ((head)->slh_first == NULL)
-
-#define SLIST_FIRST(head)   ((head)->slh_first)
-
-#define SLIST_FOREACH(var, head, field)                 \
-    for ((var) = SLIST_FIRST((head));               \
-        (var);                          \
-        (var) = SLIST_NEXT((var), field))
-
-#define SLIST_FOREACH_SAFE(var, head, field, tvar)          \
-    for ((var) = SLIST_FIRST((head));               \
-        (var) && ((tvar) = SLIST_NEXT((var), field), 1);        \
-        (var) = (tvar))
-
-#define SLIST_FOREACH_PREVPTR(var, varp, head, field)           \
-    for ((varp) = &SLIST_FIRST((head));             \
-        ((var) = *(varp)) != NULL;                  \
-        (varp) = &SLIST_NEXT((var), field))
-
-#define SLIST_INIT(head) do {                       \
-    SLIST_FIRST((head)) = NULL;                 \
-} while (0)
-
-#define SLIST_INSERT_AFTER(slistelm, elm, field) do {           \
-    SLIST_NEXT((elm), field) = SLIST_NEXT((slistelm), field);   \
-    SLIST_NEXT((slistelm), field) = (elm);              \
-} while (0)
-
-#define SLIST_INSERT_HEAD(head, elm, field) do {            \
-    SLIST_NEXT((elm), field) = SLIST_FIRST((head));         \
-    SLIST_FIRST((head)) = (elm);                    \
-} while (0)
-
-#define SLIST_NEXT(elm, field)  ((elm)->field.sle_next)
-
-#define SLIST_REMOVE(head, elm, type, field) do {           \
-    if (SLIST_FIRST((head)) == (elm)) {             \
-        SLIST_REMOVE_HEAD((head), field);           \
-    }                               \
-    else {                              \
-        struct type *curelm = SLIST_FIRST((head));      \
-        while (SLIST_NEXT(curelm, field) != (elm))      \
-            curelm = SLIST_NEXT(curelm, field);     \
-        SLIST_NEXT(curelm, field) =             \
-            SLIST_NEXT(SLIST_NEXT(curelm, field), field);   \
-    }                               \
-    TRASHIT((elm)->field.sle_next);                 \
-} while (0)
-
-#define SLIST_REMOVE_HEAD(head, field) do {             \
-    SLIST_FIRST((head)) = SLIST_NEXT(SLIST_FIRST((head)), field);   \
-} while (0)
-
-/*
- * Singly-linked Tail queue declarations.
- */
-#define STAILQ_HEAD(name, type)                     \
-struct name {                               \
-    struct type *stqh_first;/* first element */         \
-    struct type **stqh_last;/* addr of last next element */     \
-}
-
-#define STAILQ_HEAD_INITIALIZER(head)                   \
-    { NULL, &(head).stqh_first }
-
-#define STAILQ_ENTRY(type)                      \
-struct {                                \
-    struct type *stqe_next; /* next element */          \
-}
-
-/*
- * Singly-linked Tail queue functions.
- */
-#define STAILQ_CONCAT(head1, head2) do {                \
-    if (!STAILQ_EMPTY((head2))) {                   \
-        *(head1)->stqh_last = (head2)->stqh_first;      \
-        (head1)->stqh_last = (head2)->stqh_last;        \
-        STAILQ_INIT((head2));                   \
-    }                               \
-} while (0)
-
-#define STAILQ_EMPTY(head)  ((head)->stqh_first == NULL)
-
-#define STAILQ_FIRST(head)  ((head)->stqh_first)
-
-#define STAILQ_FOREACH(var, head, field)                \
-    for((var) = STAILQ_FIRST((head));               \
-       (var);                           \
-       (var) = STAILQ_NEXT((var), field))
-
-
-#define STAILQ_FOREACH_SAFE(var, head, field, tvar)         \
-    for ((var) = STAILQ_FIRST((head));              \
-        (var) && ((tvar) = STAILQ_NEXT((var), field), 1);       \
-        (var) = (tvar))
-
-#define STAILQ_INIT(head) do {                      \
-    STAILQ_FIRST((head)) = NULL;                    \
-    (head)->stqh_last = &STAILQ_FIRST((head));          \
-} while (0)
-
-#define STAILQ_INSERT_AFTER(head, tqelm, elm, field) do {       \
-    if ((STAILQ_NEXT((elm), field) = STAILQ_NEXT((tqelm), field)) == NULL)\
-        (head)->stqh_last = &STAILQ_NEXT((elm), field);     \
-    STAILQ_NEXT((tqelm), field) = (elm);                \
-} while (0)
-
-#define STAILQ_INSERT_HEAD(head, elm, field) do {           \
-    if ((STAILQ_NEXT((elm), field) = STAILQ_FIRST((head))) == NULL) \
-        (head)->stqh_last = &STAILQ_NEXT((elm), field);     \
-    STAILQ_FIRST((head)) = (elm);                   \
-} while (0)
-
-#define STAILQ_INSERT_TAIL(head, elm, field) do {           \
-    STAILQ_NEXT((elm), field) = NULL;               \
-    *(head)->stqh_last = (elm);                 \
-    (head)->stqh_last = &STAILQ_NEXT((elm), field);         \
-} while (0)
-
-#define STAILQ_LAST(head, type, field)                  \
-    (STAILQ_EMPTY((head)) ?                     \
-        NULL :                          \
-            ((struct type *)(void *)                \
-        ((char *)((head)->stqh_last) - __offsetof(struct type, field))))
-
-#define STAILQ_NEXT(elm, field) ((elm)->field.stqe_next)
-
-#define STAILQ_REMOVE(head, elm, type, field) do {          \
-    if (STAILQ_FIRST((head)) == (elm)) {                \
-        STAILQ_REMOVE_HEAD((head), field);          \
-    }                               \
-    else {                              \
-        struct type *curelm = STAILQ_FIRST((head));     \
-        while (STAILQ_NEXT(curelm, field) != (elm))     \
-            curelm = STAILQ_NEXT(curelm, field);        \
-        if ((STAILQ_NEXT(curelm, field) =           \
-             STAILQ_NEXT(STAILQ_NEXT(curelm, field), field)) == NULL)\
-            (head)->stqh_last = &STAILQ_NEXT((curelm), field);\
-    }                               \
-    TRASHIT((elm)->field.stqe_next);                \
-} while (0)
-
-#define STAILQ_REMOVE_HEAD(head, field) do {                \
-    if ((STAILQ_FIRST((head)) =                 \
-         STAILQ_NEXT(STAILQ_FIRST((head)), field)) == NULL)     \
-        (head)->stqh_last = &STAILQ_FIRST((head));      \
-} while (0)
-
-/*
- * List declarations.
- */
-#define LIST_HEAD(name, type)                       \
-struct name {                               \
-    struct type *lh_first;  /* first element */         \
-}
-
-#define LIST_HEAD_INITIALIZER(head)                 \
-    { NULL }
-
-#define LIST_ENTRY(type)                        \
-struct {                                \
-    struct type *le_next;   /* next element */          \
-    struct type **le_prev;  /* address of previous next element */  \
-}
-
-/*
- * List functions.
- */
-
-#if (defined(_KERNEL) && defined(INVARIANTS))
-#define QMD_LIST_CHECK_HEAD(head, field) do {               \
-    if (LIST_FIRST((head)) != NULL &&               \
-        LIST_FIRST((head))->field.le_prev !=            \
-         &LIST_FIRST((head)))                   \
-        panic("Bad list head %p first->prev != head", (head));  \
-} while (0)
-
-#define QMD_LIST_CHECK_NEXT(elm, field) do {                \
-    if (LIST_NEXT((elm), field) != NULL &&              \
-        LIST_NEXT((elm), field)->field.le_prev !=           \
-         &((elm)->field.le_next))                   \
-            panic("Bad link elm %p next->prev != elm", (elm));  \
-} while (0)
-
-#define QMD_LIST_CHECK_PREV(elm, field) do {                \
-    if (*(elm)->field.le_prev != (elm))             \
-        panic("Bad link elm %p prev->next != elm", (elm));  \
-} while (0)
-#else
-#define QMD_LIST_CHECK_HEAD(head, field)
-#define QMD_LIST_CHECK_NEXT(elm, field)
-#define QMD_LIST_CHECK_PREV(elm, field)
-#endif /* (_KERNEL && INVARIANTS) */
-
-#define LIST_EMPTY(head)    ((head)->lh_first == NULL)
-
-#define LIST_FIRST(head)    ((head)->lh_first)
-
-#define LIST_FOREACH(var, head, field)                  \
-    for ((var) = LIST_FIRST((head));                \
-        (var);                          \
-        (var) = LIST_NEXT((var), field))
-
-#define LIST_FOREACH_SAFE(var, head, field, tvar)           \
-    for ((var) = LIST_FIRST((head));                \
-        (var) && ((tvar) = LIST_NEXT((var), field), 1);     \
-        (var) = (tvar))
-
-#define LIST_INIT(head) do {                        \
-    LIST_FIRST((head)) = NULL;                  \
-} while (0)
-
-#define LIST_INSERT_AFTER(listelm, elm, field) do {         \
-    QMD_LIST_CHECK_NEXT(listelm, field);                \
-    if ((LIST_NEXT((elm), field) = LIST_NEXT((listelm), field)) != NULL)\
-        LIST_NEXT((listelm), field)->field.le_prev =        \
-            &LIST_NEXT((elm), field);               \
-    LIST_NEXT((listelm), field) = (elm);                \
-    (elm)->field.le_prev = &LIST_NEXT((listelm), field);        \
-} while (0)
-
-#define LIST_INSERT_BEFORE(listelm, elm, field) do {            \
-    QMD_LIST_CHECK_PREV(listelm, field);                \
-    (elm)->field.le_prev = (listelm)->field.le_prev;        \
-    LIST_NEXT((elm), field) = (listelm);                \
-    *(listelm)->field.le_prev = (elm);              \
-    (listelm)->field.le_prev = &LIST_NEXT((elm), field);        \
-} while (0)
-
-#define LIST_INSERT_HEAD(head, elm, field) do {             \
-    QMD_LIST_CHECK_HEAD((head), field);             \
-    if ((LIST_NEXT((elm), field) = LIST_FIRST((head))) != NULL) \
-        LIST_FIRST((head))->field.le_prev = &LIST_NEXT((elm), field);\
-    LIST_FIRST((head)) = (elm);                 \
-    (elm)->field.le_prev = &LIST_FIRST((head));         \
-} while (0)
-
-#define LIST_NEXT(elm, field)   ((elm)->field.le_next)
-
-#define LIST_REMOVE(elm, field) do {                    \
-    QMD_LIST_CHECK_NEXT(elm, field);                \
-    QMD_LIST_CHECK_PREV(elm, field);                \
-    if (LIST_NEXT((elm), field) != NULL)                \
-        LIST_NEXT((elm), field)->field.le_prev =        \
-            (elm)->field.le_prev;               \
-    *(elm)->field.le_prev = LIST_NEXT((elm), field);        \
-    TRASHIT((elm)->field.le_next);                  \
-    TRASHIT((elm)->field.le_prev);                  \
-} while (0)
-
-/*
- * Tail queue declarations.
- */
-#define TAILQ_HEAD(name, type)                      \
-struct name {                               \
-    struct type *tqh_first; /* first element */         \
-    struct type **tqh_last; /* addr of last next element */     \
-    TRACEBUF                            \
-}
-
-#define TAILQ_HEAD_INITIALIZER(head)                    \
-    { NULL, &(head).tqh_first }
-
-#define TAILQ_ENTRY(type)                       \
-struct {                                \
-    struct type *tqe_next;  /* next element */          \
-    struct type **tqe_prev; /* address of previous next element */  \
-    TRACEBUF                            \
-}
-
-/*
- * Tail queue functions.
- */
-#if (defined(_KERNEL) && defined(INVARIANTS))
-#define QMD_TAILQ_CHECK_HEAD(head, field) do {              \
-    if (!TAILQ_EMPTY(head) &&                   \
-        TAILQ_FIRST((head))->field.tqe_prev !=          \
-         &TAILQ_FIRST((head)))                  \
-        panic("Bad tailq head %p first->prev != head", (head)); \
-} while (0)
-
-#define QMD_TAILQ_CHECK_TAIL(head, field) do {              \
-    if (*(head)->tqh_last != NULL)                  \
-            panic("Bad tailq NEXT(%p->tqh_last) != NULL", (head));  \
-} while (0)
-
-#define QMD_TAILQ_CHECK_NEXT(elm, field) do {               \
-    if (TAILQ_NEXT((elm), field) != NULL &&             \
-        TAILQ_NEXT((elm), field)->field.tqe_prev !=         \
-         &((elm)->field.tqe_next))                  \
-        panic("Bad link elm %p next->prev != elm", (elm));  \
-} while (0)
-
-#define QMD_TAILQ_CHECK_PREV(elm, field) do {               \
-    if (*(elm)->field.tqe_prev != (elm))                \
-        panic("Bad link elm %p prev->next != elm", (elm));  \
-} while (0)
-#else
-#define QMD_TAILQ_CHECK_HEAD(head, field)
-#define QMD_TAILQ_CHECK_TAIL(head, headname)
-#define QMD_TAILQ_CHECK_NEXT(elm, field)
-#define QMD_TAILQ_CHECK_PREV(elm, field)
-#endif /* (_KERNEL && INVARIANTS) */
-
-#define TAILQ_CONCAT(head1, head2, field) do {              \
-    if (!TAILQ_EMPTY(head2)) {                  \
-        *(head1)->tqh_last = (head2)->tqh_first;        \
-        (head2)->tqh_first->field.tqe_prev = (head1)->tqh_last; \
-        (head1)->tqh_last = (head2)->tqh_last;          \
-        TAILQ_INIT((head2));                    \
-        QMD_TRACE_HEAD(head1);                  \
-        QMD_TRACE_HEAD(head2);                  \
-    }                               \
-} while (0)
-
-#define TAILQ_EMPTY(head)   ((head)->tqh_first == NULL)
-
-#define TAILQ_FIRST(head)   ((head)->tqh_first)
-
-#define TAILQ_FOREACH(var, head, field)                 \
-    for ((var) = TAILQ_FIRST((head));               \
-        (var);                          \
-        (var) = TAILQ_NEXT((var), field))
-
-#define TAILQ_FOREACH_SAFE(var, head, field, tvar)          \
-    for ((var) = TAILQ_FIRST((head));               \
-        (var) && ((tvar) = TAILQ_NEXT((var), field), 1);        \
-        (var) = (tvar))
-
-#define TAILQ_FOREACH_REVERSE(var, head, headname, field)       \
-    for ((var) = TAILQ_LAST((head), headname);          \
-        (var);                          \
-        (var) = TAILQ_PREV((var), headname, field))
-
-#define TAILQ_FOREACH_REVERSE_SAFE(var, head, headname, field, tvar)    \
-    for ((var) = TAILQ_LAST((head), headname);          \
-        (var) && ((tvar) = TAILQ_PREV((var), headname, field), 1);  \
-        (var) = (tvar))
-
-#define TAILQ_INIT(head) do {                       \
-    TAILQ_FIRST((head)) = NULL;                 \
-    (head)->tqh_last = &TAILQ_FIRST((head));            \
-    QMD_TRACE_HEAD(head);                       \
-} while (0)
-
-#define TAILQ_INSERT_AFTER(head, listelm, elm, field) do {      \
-    QMD_TAILQ_CHECK_NEXT(listelm, field);               \
-    if ((TAILQ_NEXT((elm), field) = TAILQ_NEXT((listelm), field)) != NULL)\
-        TAILQ_NEXT((elm), field)->field.tqe_prev =      \
-            &TAILQ_NEXT((elm), field);              \
-    else {                              \
-        (head)->tqh_last = &TAILQ_NEXT((elm), field);       \
-        QMD_TRACE_HEAD(head);                   \
-    }                               \
-    TAILQ_NEXT((listelm), field) = (elm);               \
-    (elm)->field.tqe_prev = &TAILQ_NEXT((listelm), field);      \
-    QMD_TRACE_ELEM(&(elm)->field);                  \
-    QMD_TRACE_ELEM(&listelm->field);                \
-} while (0)
-
-#define TAILQ_INSERT_BEFORE(listelm, elm, field) do {           \
-    QMD_TAILQ_CHECK_PREV(listelm, field);               \
-    (elm)->field.tqe_prev = (listelm)->field.tqe_prev;      \
-    TAILQ_NEXT((elm), field) = (listelm);               \
-    *(listelm)->field.tqe_prev = (elm);             \
-    (listelm)->field.tqe_prev = &TAILQ_NEXT((elm), field);      \
-    QMD_TRACE_ELEM(&(elm)->field);                  \
-    QMD_TRACE_ELEM(&listelm->field);                \
-} while (0)
-
-#define TAILQ_INSERT_HEAD(head, elm, field) do {            \
-    QMD_TAILQ_CHECK_HEAD(head, field);              \
-    if ((TAILQ_NEXT((elm), field) = TAILQ_FIRST((head))) != NULL)   \
-        TAILQ_FIRST((head))->field.tqe_prev =           \
-            &TAILQ_NEXT((elm), field);              \
-    else                                \
-        (head)->tqh_last = &TAILQ_NEXT((elm), field);       \
-    TAILQ_FIRST((head)) = (elm);                    \
-    (elm)->field.tqe_prev = &TAILQ_FIRST((head));           \
-    QMD_TRACE_HEAD(head);                       \
-    QMD_TRACE_ELEM(&(elm)->field);                  \
-} while (0)
-
-#define TAILQ_INSERT_TAIL(head, elm, field) do {            \
-    QMD_TAILQ_CHECK_TAIL(head, field);              \
-    TAILQ_NEXT((elm), field) = NULL;                \
-    (elm)->field.tqe_prev = (head)->tqh_last;           \
-    *(head)->tqh_last = (elm);                  \
-    (head)->tqh_last = &TAILQ_NEXT((elm), field);           \
-    QMD_TRACE_HEAD(head);                       \
-    QMD_TRACE_ELEM(&(elm)->field);                  \
-} while (0)
-
-#define TAILQ_LAST(head, headname)                  \
-    (*(((struct headname *)((head)->tqh_last))->tqh_last))
-
-#define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next)
-
-#define TAILQ_PREV(elm, headname, field)                \
-    (*(((struct headname *)((elm)->field.tqe_prev))->tqh_last))
-
-#define TAILQ_REMOVE(head, elm, field) do {             \
-    QMD_TAILQ_CHECK_NEXT(elm, field);               \
-    QMD_TAILQ_CHECK_PREV(elm, field);               \
-    if ((TAILQ_NEXT((elm), field)) != NULL)             \
-        TAILQ_NEXT((elm), field)->field.tqe_prev =      \
-            (elm)->field.tqe_prev;              \
-    else {                              \
-        (head)->tqh_last = (elm)->field.tqe_prev;       \
-        QMD_TRACE_HEAD(head);                   \
-    }                               \
-    *(elm)->field.tqe_prev = TAILQ_NEXT((elm), field);      \
-    TRASHIT((elm)->field.tqe_next);                 \
-    TRASHIT((elm)->field.tqe_prev);                 \
-    QMD_TRACE_ELEM(&(elm)->field);                  \
-} while (0)
-
-
-#ifdef _KERNEL
-
-/*
- * XXX insque() and remque() are an old way of handling certain queues.
- * They bogusly assumes that all queue heads look alike.
- */
-
-struct quehead {
-    struct quehead *qh_link;
-    struct quehead *qh_rlink;
-};
-
-#ifdef __CC_SUPPORTS___INLINE
-
-static __inline void
-insque(void *a, void *b)
-{
-    struct quehead *element = (struct quehead *)a,
-         *head = (struct quehead *)b;
-
-    element->qh_link = head->qh_link;
-    element->qh_rlink = head;
-    head->qh_link = element;
-    element->qh_link->qh_rlink = element;
-}
-
-static __inline void
-remque(void *a)
-{
-    struct quehead *element = (struct quehead *)a;
-
-    element->qh_link->qh_rlink = element->qh_rlink;
-    element->qh_rlink->qh_link = element->qh_link;
-    element->qh_rlink = 0;
-}
-
-#else /* !__CC_SUPPORTS___INLINE */
-
-void    insque(void *a, void *b);
-void    remque(void *a);
-
-#endif /* __CC_SUPPORTS___INLINE */
-
-#endif /* _KERNEL */
-
-#endif /* !_SYS_QUEUE_H_ */

deleted file src/libs/compat/freebsd_network/compat/sys/queue.h

@@ -1 @@
-/*-
- * Copyright (c) 1991, 1993
- *  The Regents of the University of California.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *  @(#)queue.h 8.5 (Berkeley) 8/20/94
- * $FreeBSD: src/sys/sys/queue.h,v 1.60.2.1 2005/08/16 22:41:39 phk Exp $
- */
-#ifndef _SYS_QUEUE_H_
-#define _SYS_QUEUE_H_
-
-#include <sys/cdefs.h>
-
-/*
- * This file defines four types of data structures: singly-linked lists,
- * singly-linked tail queues, lists and tail queues.
- *
- * A singly-linked list is headed by a single forward pointer. The elements
- * are singly linked for minimum space and pointer manipulation overhead at
- * the expense of O(n) removal for arbitrary elements. New elements can be
- * added to the list after an existing element or at the head of the list.
- * Elements being removed from the head of the list should use the explicit
- * macro for this purpose for optimum efficiency. A singly-linked list may
- * only be traversed in the forward direction.  Singly-linked lists are ideal
- * for applications with large datasets and few or no removals or for
- * implementing a LIFO queue.
- *
- * A singly-linked tail queue is headed by a pair of pointers, one to the
- * head of the list and the other to the tail of the list. The elements are
- * singly linked for minimum space and pointer manipulation overhead at the
- * expense of O(n) removal for arbitrary elements. New elements can be added
- * to the list after an existing element, at the head of the list, or at the
- * end of the list. Elements being removed from the head of the tail queue
- * should use the explicit macro for this purpose for optimum efficiency.
- * A singly-linked tail queue may only be traversed in the forward direction.
- * Singly-linked tail queues are ideal for applications with large datasets
- * and few or no removals or for implementing a FIFO queue.
- *
- * A list is headed by a single forward pointer (or an array of forward
- * pointers for a hash table header). The elements are doubly linked
- * so that an arbitrary element can be removed without a need to
- * traverse the list. New elements can be added to the list before
- * or after an existing element or at the head of the list. A list
- * may only be traversed in the forward direction.
- *
- * A tail queue is headed by a pair of pointers, one to the head of the
- * list and the other to the tail of the list. The elements are doubly
- * linked so that an arbitrary element can be removed without a need to
- * traverse the list. New elements can be added to the list before or
- * after an existing element, at the head of the list, or at the end of
- * the list. A tail queue may be traversed in either direction.
- *
- * For details on the use of these macros, see the queue(3) manual page.
- *
- *
- *              SLIST   LIST    STAILQ  TAILQ
- * _HEAD            +   +   +   +
- * _HEAD_INITIALIZER        +   +   +   +
- * _ENTRY           +   +   +   +
- * _INIT            +   +   +   +
- * _EMPTY           +   +   +   +
- * _FIRST           +   +   +   +
- * _NEXT            +   +   +   +
- * _PREV            -   -   -   +
- * _LAST            -   -   +   +
- * _FOREACH         +   +   +   +
- * _FOREACH_SAFE        +   +   +   +
- * _FOREACH_REVERSE     -   -   -   +
- * _FOREACH_REVERSE_SAFE    -   -   -   +
- * _INSERT_HEAD         +   +   +   +
- * _INSERT_BEFORE       -   +   -   +
- * _INSERT_AFTER        +   +   +   +
- * _INSERT_TAIL         -   -   +   +
- * _CONCAT          -   -   +   +
- * _REMOVE_HEAD         +   -   +   -
- * _REMOVE          +   +   +   +
- *
- */
-#define QUEUE_MACRO_DEBUG 0
-#if QUEUE_MACRO_DEBUG
-/* Store the last 2 places the queue element or head was altered */
-struct qm_trace {
-    char * lastfile;
-    int lastline;
-    char * prevfile;
-    int prevline;
-};
-
-#define TRACEBUF    struct qm_trace trace;
-#define TRASHIT(x)  do {(x) = (void *)-1;} while (0)
-
-#define QMD_TRACE_HEAD(head) do {                   \
-    (head)->trace.prevline = (head)->trace.lastline;        \
-    (head)->trace.prevfile = (head)->trace.lastfile;        \
-    (head)->trace.lastline = __LINE__;              \
-    (head)->trace.lastfile = __FILE__;              \
-} while (0)
-
-#define QMD_TRACE_ELEM(elem) do {                   \
-    (elem)->trace.prevline = (elem)->trace.lastline;        \
-    (elem)->trace.prevfile = (elem)->trace.lastfile;        \
-    (elem)->trace.lastline = __LINE__;              \
-    (elem)->trace.lastfile = __FILE__;              \
-} while (0)
-
-#else
-#define QMD_TRACE_ELEM(elem)
-#define QMD_TRACE_HEAD(head)
-#define TRACEBUF
-#define TRASHIT(x)
-#endif  /* QUEUE_MACRO_DEBUG */
-
-/*
- * Singly-linked List declarations.
- */
-#define SLIST_HEAD(name, type)                      \
-struct name {                               \
-    struct type *slh_first; /* first element */         \
-}
-
-#define SLIST_HEAD_INITIALIZER(head)                    \
-    { NULL }
-
-#define SLIST_ENTRY(type)                       \
-struct {                                \
-    struct type *sle_next;  /* next element */          \
-}
-
-/*
- * Singly-linked List functions.
- */
-#define SLIST_EMPTY(head)   ((head)->slh_first == NULL)
-
-#define SLIST_FIRST(head)   ((head)->slh_first)
-
-#define SLIST_FOREACH(var, head, field)                 \
-    for ((var) = SLIST_FIRST((head));               \
-        (var);                          \
-        (var) = SLIST_NEXT((var), field))
-
-#define SLIST_FOREACH_SAFE(var, head, field, tvar)          \
-    for ((var) = SLIST_FIRST((head));               \
-        (var) && ((tvar) = SLIST_NEXT((var), field), 1);        \
-        (var) = (tvar))
-
-#define SLIST_FOREACH_PREVPTR(var, varp, head, field)           \
-    for ((varp) = &SLIST_FIRST((head));             \
-        ((var) = *(varp)) != NULL;                  \
-        (varp) = &SLIST_NEXT((var), field))
-
-#define SLIST_INIT(head) do {                       \
-    SLIST_FIRST((head)) = NULL;                 \
-} while (0)
-
-#define SLIST_INSERT_AFTER(slistelm, elm, field) do {           \
-    SLIST_NEXT((elm), field) = SLIST_NEXT((slistelm), field);   \
-    SLIST_NEXT((slistelm), field) = (elm);              \
-} while (0)
-
-#define SLIST_INSERT_HEAD(head, elm, field) do {            \
-    SLIST_NEXT((elm), field) = SLIST_FIRST((head));         \
-    SLIST_FIRST((head)) = (elm);                    \
-} while (0)
-
-#define SLIST_NEXT(elm, field)  ((elm)->field.sle_next)
-
-#define SLIST_REMOVE(head, elm, type, field) do {           \
-    if (SLIST_FIRST((head)) == (elm)) {             \
-        SLIST_REMOVE_HEAD((head), field);           \
-    }                               \
-    else {                              \
-        struct type *curelm = SLIST_FIRST((head));      \
-        while (SLIST_NEXT(curelm, field) != (elm))      \
-            curelm = SLIST_NEXT(curelm, field);     \
-        SLIST_NEXT(curelm, field) =             \
-            SLIST_NEXT(SLIST_NEXT(curelm, field), field);   \
-    }                               \
-} while (0)
-
-#define SLIST_REMOVE_HEAD(head, field) do {             \
-    SLIST_FIRST((head)) = SLIST_NEXT(SLIST_FIRST((head)), field);   \
-} while (0)
-
-/*
- * Singly-linked Tail queue declarations.
- */
-#define STAILQ_HEAD(name, type)                     \
-struct name {                               \
-    struct type *stqh_first;/* first element */         \
-    struct type **stqh_last;/* addr of last next element */     \
-}
-
-#define STAILQ_HEAD_INITIALIZER(head)                   \
-    { NULL, &(head).stqh_first }
-
-#define STAILQ_ENTRY(type)                      \
-struct {                                \
-    struct type *stqe_next; /* next element */          \
-}
-
-/*
- * Singly-linked Tail queue functions.
- */
-#define STAILQ_CONCAT(head1, head2) do {                \
-    if (!STAILQ_EMPTY((head2))) {                   \
-        *(head1)->stqh_last = (head2)->stqh_first;      \
-        (head1)->stqh_last = (head2)->stqh_last;        \
-        STAILQ_INIT((head2));                   \
-    }                               \
-} while (0)
-
-#define STAILQ_EMPTY(head)  ((head)->stqh_first == NULL)
-
-#define STAILQ_FIRST(head)  ((head)->stqh_first)
-
-#define STAILQ_FOREACH(var, head, field)                \
-    for((var) = STAILQ_FIRST((head));               \
-       (var);                           \
-       (var) = STAILQ_NEXT((var), field))
-
-
-#define STAILQ_FOREACH_SAFE(var, head, field, tvar)         \
-    for ((var) = STAILQ_FIRST((head));              \
-        (var) && ((tvar) = STAILQ_NEXT((var), field), 1);       \
-        (var) = (tvar))
-
-#define STAILQ_INIT(head) do {                      \
-    STAILQ_FIRST((head)) = NULL;                    \
-    (head)->stqh_last = &STAILQ_FIRST((head));          \
-} while (0)
-
-#define STAILQ_INSERT_AFTER(head, tqelm, elm, field) do {       \
-    if ((STAILQ_NEXT((elm), field) = STAILQ_NEXT((tqelm), field)) == NULL)\
-        (head)->stqh_last = &STAILQ_NEXT((elm), field);     \
-    STAILQ_NEXT((tqelm), field) = (elm);                \
-} while (0)
-
-#define STAILQ_INSERT_HEAD(head, elm, field) do {           \
-    if ((STAILQ_NEXT((elm), field) = STAILQ_FIRST((head))) == NULL) \
-        (head)->stqh_last = &STAILQ_NEXT((elm), field);     \
-    STAILQ_FIRST((head)) = (elm);                   \
-} while (0)
-
-#define STAILQ_INSERT_TAIL(head, elm, field) do {           \
-    STAILQ_NEXT((elm), field) = NULL;               \
-    *(head)->stqh_last = (elm);                 \
-    (head)->stqh_last = &STAILQ_NEXT((elm), field);         \
-} while (0)
-
-#define STAILQ_LAST(head, type, field)                  \
-    (STAILQ_EMPTY((head)) ?                     \
-        NULL :                          \
-            ((struct type *)                    \
-        ((char *)((head)->stqh_last) - __offsetof(struct type, field))))
-
-#define STAILQ_NEXT(elm, field) ((elm)->field.stqe_next)
-
-#define STAILQ_REMOVE(head, elm, type, field) do {          \
-    if (STAILQ_FIRST((head)) == (elm)) {                \
-        STAILQ_REMOVE_HEAD((head), field);          \
-    }                               \
-    else {                              \
-        struct type *curelm = STAILQ_FIRST((head));     \
-        while (STAILQ_NEXT(curelm, field) != (elm))     \
-            curelm = STAILQ_NEXT(curelm, field);        \
-        if ((STAILQ_NEXT(curelm, field) =           \
-             STAILQ_NEXT(STAILQ_NEXT(curelm, field), field)) == NULL)\
-            (head)->stqh_last = &STAILQ_NEXT((curelm), field);\
-    }                               \
-} while (0)
-
-#define STAILQ_REMOVE_HEAD(head, field) do {                \
-    if ((STAILQ_FIRST((head)) =                 \
-         STAILQ_NEXT(STAILQ_FIRST((head)), field)) == NULL)     \
-        (head)->stqh_last = &STAILQ_FIRST((head));      \
-} while (0)
-
-#define STAILQ_REMOVE_HEAD_UNTIL(head, elm, field) do {         \
-    if ((STAILQ_FIRST((head)) = STAILQ_NEXT((elm), field)) == NULL) \
-        (head)->stqh_last = &STAILQ_FIRST((head));      \
-} while (0)
-
-/*
- * List declarations.
- */
-#define LIST_HEAD(name, type)                       \
-struct name {                               \
-    struct type *lh_first;  /* first element */         \
-}
-
-#define LIST_HEAD_INITIALIZER(head)                 \
-    { NULL }
-
-#define LIST_ENTRY(type)                        \
-struct {                                \
-    struct type *le_next;   /* next element */          \
-    struct type **le_prev;  /* address of previous next element */  \
-}
-
-/*
- * List functions.
- */
-
-#define LIST_EMPTY(head)    ((head)->lh_first == NULL)
-
-#define LIST_FIRST(head)    ((head)->lh_first)
-
-#define LIST_FOREACH(var, head, field)                  \
-    for ((var) = LIST_FIRST((head));                \
-        (var);                          \
-        (var) = LIST_NEXT((var), field))
-
-#define LIST_FOREACH_SAFE(var, head, field, tvar)           \
-    for ((var) = LIST_FIRST((head));                \
-        (var) && ((tvar) = LIST_NEXT((var), field), 1);     \
-        (var) = (tvar))
-
-#define LIST_INIT(head) do {                        \
-    LIST_FIRST((head)) = NULL;                  \
-} while (0)
-
-#define LIST_INSERT_AFTER(listelm, elm, field) do {         \
-    if ((LIST_NEXT((elm), field) = LIST_NEXT((listelm), field)) != NULL)\
-        LIST_NEXT((listelm), field)->field.le_prev =        \
-            &LIST_NEXT((elm), field);               \
-    LIST_NEXT((listelm), field) = (elm);                \
-    (elm)->field.le_prev = &LIST_NEXT((listelm), field);        \
-} while (0)
-
-#define LIST_INSERT_BEFORE(listelm, elm, field) do {            \
-    (elm)->field.le_prev = (listelm)->field.le_prev;        \
-    LIST_NEXT((elm), field) = (listelm);                \
-    *(listelm)->field.le_prev = (elm);              \
-    (listelm)->field.le_prev = &LIST_NEXT((elm), field);        \
-} while (0)
-
-#define LIST_INSERT_HEAD(head, elm, field) do {             \
-    if ((LIST_NEXT((elm), field) = LIST_FIRST((head))) != NULL) \
-        LIST_FIRST((head))->field.le_prev = &LIST_NEXT((elm), field);\
-    LIST_FIRST((head)) = (elm);                 \
-    (elm)->field.le_prev = &LIST_FIRST((head));         \
-} while (0)
-
-#define LIST_NEXT(elm, field)   ((elm)->field.le_next)
-
-#define LIST_REMOVE(elm, field) do {                    \
-    if (LIST_NEXT((elm), field) != NULL)                \
-        LIST_NEXT((elm), field)->field.le_prev =        \
-            (elm)->field.le_prev;               \
-    *(elm)->field.le_prev = LIST_NEXT((elm), field);        \
-} while (0)
-
-/*
- * Tail queue declarations.
- */
-#define TAILQ_HEAD(name, type)                      \
-struct name {                               \
-    struct type *tqh_first; /* first element */         \
-    struct type **tqh_last; /* addr of last next element */     \
-    TRACEBUF                            \
-}
-
-#define TAILQ_HEAD_INITIALIZER(head)                    \
-    { NULL, &(head).tqh_first }
-
-#define TAILQ_ENTRY(type)                       \
-struct {                                \
-    struct type *tqe_next;  /* next element */          \
-    struct type **tqe_prev; /* address of previous next element */  \
-    TRACEBUF                            \
-}
-
-/*
- * Tail queue functions.
- */
-#define TAILQ_CONCAT(head1, head2, field) do {              \
-    if (!TAILQ_EMPTY(head2)) {                  \
-        *(head1)->tqh_last = (head2)->tqh_first;        \
-        (head2)->tqh_first->field.tqe_prev = (head1)->tqh_last; \
-        (head1)->tqh_last = (head2)->tqh_last;          \
-        TAILQ_INIT((head2));                    \
-        QMD_TRACE_HEAD(head1);                  \
-        QMD_TRACE_HEAD(head2);                  \
-    }                               \
-} while (0)
-
-#define TAILQ_EMPTY(head)   ((head)->tqh_first == NULL)
-
-#define TAILQ_FIRST(head)   ((head)->tqh_first)
-
-#define TAILQ_FOREACH(var, head, field)                 \
-    for ((var) = TAILQ_FIRST((head));               \
-        (var);                          \
-        (var) = TAILQ_NEXT((var), field))
-
-#define TAILQ_FOREACH_SAFE(var, head, field, tvar)          \
-    for ((var) = TAILQ_FIRST((head));               \
-        (var) && ((tvar) = TAILQ_NEXT((var), field), 1);        \
-        (var) = (tvar))
-
-#define TAILQ_FOREACH_REVERSE(var, head, headname, field)       \
-    for ((var) = TAILQ_LAST((head), headname);          \
-        (var);                          \
-        (var) = TAILQ_PREV((var), headname, field))
-
-#define TAILQ_FOREACH_REVERSE_SAFE(var, head, headname, field, tvar)    \
-    for ((var) = TAILQ_LAST((head), headname);          \
-        (var) && ((tvar) = TAILQ_PREV((var), headname, field), 1);  \
-        (var) = (tvar))
-
-#define TAILQ_INIT(head) do {                       \
-    TAILQ_FIRST((head)) = NULL;                 \
-    (head)->tqh_last = &TAILQ_FIRST((head));            \
-    QMD_TRACE_HEAD(head);                       \
-} while (0)
-
-#define TAILQ_INSERT_AFTER(head, listelm, elm, field) do {      \
-    if ((TAILQ_NEXT((elm), field) = TAILQ_NEXT((listelm), field)) != NULL)\
-        TAILQ_NEXT((elm), field)->field.tqe_prev =      \
-            &TAILQ_NEXT((elm), field);              \
-    else {                              \
-        (head)->tqh_last = &TAILQ_NEXT((elm), field);       \
-        QMD_TRACE_HEAD(head);                   \
-    }                               \
-    TAILQ_NEXT((listelm), field) = (elm);               \
-    (elm)->field.tqe_prev = &TAILQ_NEXT((listelm), field);      \
-    QMD_TRACE_ELEM(&(elm)->field);                  \
-    QMD_TRACE_ELEM(&listelm->field);                \
-} while (0)
-
-#define TAILQ_INSERT_BEFORE(listelm, elm, field) do {           \
-    (elm)->field.tqe_prev = (listelm)->field.tqe_prev;      \
-    TAILQ_NEXT((elm), field) = (listelm);               \
-    *(listelm)->field.tqe_prev = (elm);             \
-    (listelm)->field.tqe_prev = &TAILQ_NEXT((elm), field);      \
-    QMD_TRACE_ELEM(&(elm)->field);                  \
-    QMD_TRACE_ELEM(&listelm->field);                \
-} while (0)
-
-#define TAILQ_INSERT_HEAD(head, elm, field) do {            \
-    if ((TAILQ_NEXT((elm), field) = TAILQ_FIRST((head))) != NULL)   \
-        TAILQ_FIRST((head))->field.tqe_prev =           \
-            &TAILQ_NEXT((elm), field);              \
-    else                                \
-        (head)->tqh_last = &TAILQ_NEXT((elm), field);       \
-    TAILQ_FIRST((head)) = (elm);                    \
-    (elm)->field.tqe_prev = &TAILQ_FIRST((head));           \
-    QMD_TRACE_HEAD(head);                       \
-    QMD_TRACE_ELEM(&(elm)->field);                  \
-} while (0)
-
-#define TAILQ_INSERT_TAIL(head, elm, field) do {            \
-    TAILQ_NEXT((elm), field) = NULL;                \
-    (elm)->field.tqe_prev = (head)->tqh_last;           \
-    *(head)->tqh_last = (elm);                  \
-    (head)->tqh_last = &TAILQ_NEXT((elm), field);           \
-    QMD_TRACE_HEAD(head);                       \
-    QMD_TRACE_ELEM(&(elm)->field);                  \
-} while (0)
-
-#define TAILQ_LAST(head, headname)                  \
-    (*(((struct headname *)((head)->tqh_last))->tqh_last))
-
-#define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next)
-
-#define TAILQ_PREV(elm, headname, field)                \
-    (*(((struct headname *)((elm)->field.tqe_prev))->tqh_last))
-
-#define TAILQ_REMOVE(head, elm, field) do {             \
-    if ((TAILQ_NEXT((elm), field)) != NULL)             \
-        TAILQ_NEXT((elm), field)->field.tqe_prev =      \
-            (elm)->field.tqe_prev;              \
-    else {                              \
-        (head)->tqh_last = (elm)->field.tqe_prev;       \
-        QMD_TRACE_HEAD(head);                   \
-    }                               \
-    *(elm)->field.tqe_prev = TAILQ_NEXT((elm), field);      \
-    TRASHIT((elm)->field.tqe_next);                 \
-    TRASHIT((elm)->field.tqe_prev);                 \
-    QMD_TRACE_ELEM(&(elm)->field);                  \
-} while (0)
-
-
-#ifdef _KERNEL
-
-/*
- * XXX insque() and remque() are an old way of handling certain queues.
- * They bogusly assumes that all queue heads look alike.
- */
-
-struct quehead {
-    struct quehead *qh_link;
-    struct quehead *qh_rlink;
-};
-
-#ifdef __CC_SUPPORTS___INLINE
-
-static __inline void
-insque(void *a, void *b)
-{
-    struct quehead *element = (struct quehead *)a,
-         *head = (struct quehead *)b;
-
-    element->qh_link = head->qh_link;
-    element->qh_rlink = head;
-    head->qh_link = element;
-    element->qh_link->qh_rlink = element;
-}
-
-static __inline void
-remque(void *a)
-{
-    struct quehead *element = (struct quehead *)a;
-
-    element->qh_link->qh_rlink = element->qh_rlink;
-    element->qh_rlink->qh_link = element->qh_link;
-    element->qh_rlink = 0;
-}
-
-#else /* !__CC_SUPPORTS___INLINE */
-
-void    insque(void *a, void *b);
-void    remque(void *a);
-
-#endif /* __CC_SUPPORTS___INLINE */
-
-#endif /* _KERNEL */
-
-#endif /* !_SYS_QUEUE_H_ */

new file headers/compatibility/bsd/ar.h

@@ +1 @@
+/*-
+ * Copyright (c) 1991, 1993
+ *  The Regents of the University of California.  All rights reserved.
+ * (c) UNIX System Laboratories, Inc.
+ * All or some portions of this file are derived from material licensed
+ * to the University of California by American Telephone and Telegraph
+ * Co. or Unix System Laboratories, Inc. and are reproduced herein with
+ * the permission of UNIX System Laboratories, Inc.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Hugh Smith at The University of Guelph.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *  @(#)ar.h    8.2 (Berkeley) 1/21/94
+ *
+ * $FreeBSD$
+ */
+
+#ifndef _AR_H_
+#define _AR_H_
+
+#include <sys/cdefs.h>
+
+/* Pre-4BSD archives had these magic numbers in them. */
+#define OARMAG1 0177555
+#define OARMAG2 0177545
+
+#define ARMAG       "!<arch>\n" /* ar "magic number" */
+#define SARMAG      8       /* strlen(ARMAG); */
+
+#define AR_EFMT1    "#1/"       /* extended format #1 */
+
+struct ar_hdr {
+    char ar_name[16];       /* name */
+    char ar_date[12];       /* modification time */
+    char ar_uid[6];         /* user id */
+    char ar_gid[6];         /* group id */
+    char ar_mode[8];        /* octal file permissions */
+    char ar_size[10];       /* size in bytes */
+#define ARFMAG  "`\n"
+    char ar_fmag[2];        /* consistency check */
+} __packed;
+
+#endif /* !_AR_H_ */

new file headers/compatibility/bsd/machine/_bus.h

@@ +1 @@
+/*
+ * Copyright 2009, Colin Günther. All Rights Reserved.
+ * Copyright 2007, Hugo Santos. All Rights Reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef _FBSD_COMPAT_MACHINE__BUS_H_
+#define _FBSD_COMPAT_MACHINE__BUS_H_
+
+
+#ifdef B_HAIKU_64_BIT
+
+
+typedef uint64_t bus_addr_t;
+typedef uint64_t bus_size_t;
+
+typedef uint64_t bus_space_tag_t;
+typedef uint64_t bus_space_handle_t;
+
+
+#else
+
+
+typedef uint32_t bus_addr_t;
+typedef uint32_t bus_size_t;
+
+typedef int bus_space_tag_t;
+typedef unsigned int bus_space_handle_t;
+
+
+#endif
+
+#endif /* _FBSD_COMPAT_MACHINE__BUS_H_ */

new file headers/compatibility/bsd/machine/atomic.h

@@ +1 @@
+/*
+ * Copyright 2007, Hugo Santos. All Rights Reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef _FBSD_COMPAT_MACHINE_ATOMIC_H_
+#define _FBSD_COMPAT_MACHINE_ATOMIC_H_
+
+
+#include <KernelExport.h>
+
+
+#define atomic_add_int(ptr, value) \
+    atomic_add((int32 *)(ptr), value)
+
+#define atomic_subtract_int(ptr, value) \
+    atomic_add((int32 *)(ptr), -value)
+
+#define atomic_set_acq_32(ptr, value) \
+    atomic_set_int(ptr, value)
+
+#define atomic_set_int(ptr, value) \
+    atomic_or((int32 *)(ptr), value)
+
+#define atomic_readandclear_int(ptr) \
+    atomic_set((int32 *)(ptr), 0)
+
+#endif  /* _FBSD_COMPAT_MACHINE_ATOMIC_H_ */

new file headers/compatibility/bsd/machine/bus.h

@@ +1 @@
+/*
+ * Copyright 2009, Colin Günther. All Rights Reserved.
+ * Copyright 2007, Hugo Santos. All Rights Reserved.
+ * Distributed under the terms of the MIT License.
+ */
+
+
+/*-
+ * Copyright (c) KATO Takenori, 1999.
+ *
+ * All rights reserved.  Unpublished rights reserved under the copyright
+ * laws of Japan.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer as
+ *    the first lines of this file unmodified.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+/*  $NetBSD: bus.h,v 1.12 1997/10/01 08:25:15 fvdl Exp $    */
+
+/*-
+ * Copyright (c) 1996, 1997 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
+ * NASA Ames Research Center.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *  This product includes software developed by the NetBSD
+ *  Foundation, Inc. and its contributors.
+ * 4. Neither the name of The NetBSD Foundation nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*-
+ * Copyright (c) 1996 Charles M. Hannum.  All rights reserved.
+ * Copyright (c) 1996 Christopher G. Demetriou.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by Christopher G. Demetriou
+ *  for the NetBSD Project.
+ * 4. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef _FBSD_COMPAT_MACHINE_BUS_H_
+#define _FBSD_COMPAT_MACHINE_BUS_H_
+
+
+#include <machine/_bus.h>
+#include <machine/cpufunc.h>
+
+
+struct resource;
+
+
+// TODO: x86 specific!
+#define I386_BUS_SPACE_IO           0
+#define I386_BUS_SPACE_MEM          1
+
+#define BUS_SPACE_MAXADDR_32BIT     0xffffffff
+#ifdef __x86_64__
+#   define BUS_SPACE_MAXADDR        0xffffffffffffffffull
+#else
+#   define BUS_SPACE_MAXADDR        0xffffffff
+#endif
+
+#define BUS_SPACE_MAXSIZE_32BIT     0xffffffff
+#define BUS_SPACE_MAXSIZE           0xffffffff
+
+#define BUS_SPACE_UNRESTRICTED  (~0)
+
+#define BUS_SPACE_BARRIER_READ      1
+#define BUS_SPACE_BARRIER_WRITE     2
+
+
+uint8_t bus_space_read_1(bus_space_tag_t tag, bus_space_handle_t handle,
+    bus_size_t offset);
+uint16_t bus_space_read_2(bus_space_tag_t tag, bus_space_handle_t handle,
+    bus_size_t offset);
+uint32_t bus_space_read_4(bus_space_tag_t tag, bus_space_handle_t handle,
+    bus_size_t offset);
+void bus_space_write_1(bus_space_tag_t tag, bus_space_handle_t handle,
+    bus_size_t offset, uint8_t value);
+void bus_space_write_2(bus_space_tag_t tag, bus_space_handle_t handle,
+    bus_size_t offset, uint16_t value);
+void bus_space_write_4(bus_space_tag_t tag, bus_space_handle_t handle,
+    bus_size_t offset, uint32_t value);
+
+
+static inline void
+bus_space_read_region_1(bus_space_tag_t tag, bus_space_handle_t bsh,
+            bus_size_t offset, u_int8_t *addr, size_t count)
+{
+    if (tag == I386_BUS_SPACE_IO) {
+        int _port_ = bsh + offset;
+        __asm __volatile("                          \n\
+            cld                                     \n\
+        1:  inb %w2,%%al                            \n\
+            stosb                                   \n\
+            incl %2                                 \n\
+            loop 1b"                                :
+            "=D" (addr), "=c" (count), "=d" (_port_):
+            "0" (addr), "1" (count), "2" (_port_)   :
+            "%eax", "memory", "cc");
+    } else {
+        void* _port_ = (void*) (bsh + offset);
+        memcpy(addr, _port_, count);
+    }
+}
+
+
+static inline void
+bus_space_read_region_4(bus_space_tag_t tag, bus_space_handle_t bsh,
+    bus_size_t offset, u_int32_t *addr, size_t count)
+{
+    if (tag == I386_BUS_SPACE_IO) {
+        int _port_ = bsh + offset;
+        __asm __volatile("                          \n\
+            cld                                     \n\
+        1:  inl %w2,%%eax                           \n\
+            stosl                                   \n\
+            addl $4,%2                              \n\
+            loop 1b"                                :
+            "=D" (addr), "=c" (count), "=d" (_port_):
+            "0" (addr), "1" (count), "2" (_port_)   :
+            "%eax", "memory", "cc");
+    } else {
+        void* _port_ = (void*) (bsh + offset);
+        memcpy(addr, _port_, count);
+    }
+}
+
+
+static inline void
+bus_space_write_region_1(bus_space_tag_t tag, bus_space_handle_t bsh,
+    bus_size_t offset, const u_int8_t *addr, size_t count)
+{
+    if (tag == I386_BUS_SPACE_IO) {
+        int _port_ = bsh + offset;
+        __asm __volatile("                          \n\
+            cld                                     \n\
+        1:  lodsb                                   \n\
+            outb %%al,%w0                           \n\
+            incl %0                                 \n\
+            loop 1b"                                :
+            "=d" (_port_), "=S" (addr), "=c" (count):
+            "0" (_port_), "1" (addr), "2" (count)   :
+            "%eax", "memory", "cc");
+    } else {
+        void* _port_ = (void*) (bsh + offset);
+        memcpy(_port_, addr, count);
+    }
+}
+
+
+static inline void
+bus_space_set_region_4(bus_space_tag_t tag, bus_space_handle_t bsh,
+               bus_size_t offset, u_int32_t value, size_t count)
+{
+    /* TODO implement */
+}
+
+
+static inline void
+bus_space_barrier(bus_space_tag_t tag, bus_space_handle_t handle,
+    bus_size_t offset, bus_size_t len, int flags)
+{
+    if (flags & BUS_SPACE_BARRIER_READ)
+#ifdef __x86_64__
+        __asm__ __volatile__ ("lock; addl $0,0(%%rsp)" : : : "memory");
+#else
+        __asm__ __volatile__ ("lock; addl $0,0(%%esp)" : : : "memory");
+#endif
+    else
+        __asm__ __volatile__ ("" : : : "memory");
+}
+
+
+static inline void
+bus_space_write_multi_1(bus_space_tag_t tag, bus_space_handle_t bsh,
+    bus_size_t offset, const u_int8_t *addr, size_t count)
+{
+
+    if (tag == I386_BUS_SPACE_IO)
+        outsb(bsh + offset, addr, count);
+    else {
+        __asm __volatile("                              \n\
+            cld                                         \n\
+        1:  lodsb                                       \n\
+            movb %%al,(%2)                              \n\
+            loop 1b"                                    :
+            "=S" (addr), "=c" (count)                   :
+            "r" (bsh + offset), "0" (addr), "1" (count) :
+            "%eax", "memory", "cc");
+    }
+}
+
+
+#include <machine/bus_dma.h>
+
+
+#define bus_space_write_stream_4(t, h, o, v) \
+    bus_space_write_4((t), (h), (o), (v))
+
+#endif /* _FBSD_COMPAT_MACHINE_BUS_H_ */

new file headers/compatibility/bsd/machine/bus_dma.h

@@ +1 @@
+/*
+ * Copyright 2009, Colin Günther, coling@gmx.de
+ * All Rights Reserved. Distributed under the terms of the MIT License.
+ */
+#ifndef _FBSD_COMPAT_MACHINE_BUS_DMA_H_
+#define _FBSD_COMPAT_MACHINE_BUS_DMA_H_
+
+
+#include <sys/bus_dma.h>
+
+#endif /* _FBSD_COMPAT_MACHINE_BUS_DMA_H_ */

new file headers/compatibility/bsd/machine/clock.h

@@ +1 @@
+/*
+ * Copyright 2009 Haiku Inc. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef _FBSD_COMPAT_SYS_CLOCK_H_
+#define _FBSD_COMPAT_SYS_CLOCK_H_
+
+
+#endif /* _FBSD_COMPAT_SYS_CLOCK_H_ */

new file headers/compatibility/bsd/machine/cpufunc.h

@@ +1 @@
+/*-
+ * Copyright (c) 1993 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+#ifndef _FBSD_COMPAT_MACHINE_CPUFUNC_H_
+#define _FBSD_COMPAT_MACHINE_CPUFUNC_H_
+
+
+static __inline void
+outsb(u_int port, const void *addr, size_t cnt)
+{
+    __asm __volatile("cld; rep; outsb"
+             : "+S" (addr), "+c" (cnt)
+             : "d" (port));
+}
+
+#endif /* _FBSD_COMPAT_MACHINE_CPUFUNC_H_ */

new file headers/compatibility/bsd/machine/endian.h

@@ +1 @@
+/*
+ * Copyright 2007 Haiku Inc. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef _FBSD_COMPAT_MACHINE_ENDIAN_H_
+#define _FBSD_COMPAT_MACHINE_ENDIAN_H_
+
+
+#include <sys/cdefs.h>
+#include <sys/_types.h>
+
+#endif

new file headers/compatibility/bsd/machine/in_cksum.h

@@ +1 @@
+/*
+ * Copyright 2007, Axel Dörfler, axeld@pinc-software.de. All Rights Reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef _FBSD_COMPAT_MACHINE_IN_CKSUM_H_
+#define _FBSD_COMPAT_MACHINE_IN_CKSUM_H_
+
+
+#include <stdint.h>
+
+
+#define in_cksum(m, len)    in_cksum_skip(m, len, 0)
+
+
+static inline u_short
+in_pseudo(u_int sum, u_int b, u_int c)
+{
+    // should never be called
+    panic("in_pseudo() called");
+    return 0;
+}
+
+
+static inline u_short
+in_cksum_skip(struct mbuf* m, int len, int skip)
+{
+    // should never be called
+    panic("in_cksum_skip() called");
+    return 0;
+}
+
+#endif  /* _FBSD_COMPAT_MACHINE_IN_CKSUM_H_ */

new file headers/compatibility/bsd/machine/resource.h

@@ +1 @@
+/*
+ * Copyright 2007 Haiku Inc. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef _FBSD_COMPAT_MACHINE_RESOURCE_H_
+#define _FBSD_COMPAT_MACHINE_RESOURCE_H_
+
+
+#define SYS_RES_IRQ     0x1
+#define SYS_RES_DRQ     0x2
+#define SYS_RES_MEMORY  0x3
+#define SYS_RES_IOPORT  0x4
+
+#endif

new file headers/compatibility/bsd/machine/stdarg.h

@@ +1 @@
+/*
+ * Copyright 2009 Haiku Inc. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef _FBSD_COMPAT_MACHINE_STDARG_H_
+#define _FBSD_COMPAT_MACHINE_STDARG_H_
+
+
+#include <sys/cdefs.h>
+#include <sys/_types.h>
+
+#endif /* _FBSD_COMPAT_MACHINE_STDARG_H_ */

new file headers/compatibility/bsd/sys/_bus_dma.h

@@ +1 @@
+/*-
+ * Copyright 2006 John-Mark Gurney.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * $FreeBSD: src/sys/sys/_bus_dma.h,v 1.1 2006/09/03 00:26:17 jmg Exp $
+ *
+ */
+#ifndef _SYS__BUS_DMA_H_
+#define _SYS__BUS_DMA_H_
+
+typedef int bus_dmasync_op_t;
+
+/*
+ *  bus_dma_tag_t
+ *
+ *  A machine-dependent opaque type describing the characteristics
+ *  of how to perform DMA mappings.  This structure encapsultes
+ *  information concerning address and alignment restrictions, number
+ *  of S/G segments, amount of data per S/G segment, etc.
+ */
+typedef struct bus_dma_tag  *bus_dma_tag_t;
+
+/*
+ *  bus_dmamap_t
+ *
+ *  DMA mapping instance information.
+ */
+typedef struct bus_dmamap   *bus_dmamap_t;
+
+/*
+ * A function that performs driver-specific synchronization on behalf of
+ * busdma.
+ */
+typedef enum {
+    BUS_DMA_LOCK    = 0x01,
+    BUS_DMA_UNLOCK  = 0x02,
+} bus_dma_lock_op_t;
+
+typedef void bus_dma_lock_t(void *, bus_dma_lock_op_t);
+
+#endif /* !_SYS__BUS_DMA_H_ */

new file headers/compatibility/bsd/sys/_mutex.h

@@ +1 @@
+/*
+ * Copyright 2009, Colin Günther, coling@gmx.de.
+ * Copyright 2007, Hugo Santos. All Rights Reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef _FBSD_COMPAT_SYS__MUTEX_H_
+#define _FBSD_COMPAT_SYS__MUTEX_H_
+
+
+#include <lock.h>
+
+
+struct mtx {
+    int                     type;
+    union {
+        struct {
+            mutex           lock;
+            thread_id       owner;
+        }                   mutex;
+        int32               spinlock;
+        recursive_lock      recursive;
+    } u;
+};
+
+
+#endif /* _FBSD_COMPAT_SYS__MUTEX_H_ */

new file headers/compatibility/bsd/sys/_task.h

@@ +1 @@
+/*
+ * Copyright 2007 Haiku Inc. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef _FBSD_COMPAT_SYS__TASK_H_
+#define _FBSD_COMPAT_SYS__TASK_H_
+
+
+/* Haiku's list management */
+#include <util/list.h>
+
+
+typedef void (*task_handler_t)(void *context, int pending);
+
+struct task {
+    int ta_priority;
+    task_handler_t ta_handler;
+    void *ta_argument;
+    int ta_pending;
+
+    struct list_link ta_link;
+};
+
+#endif

new file headers/compatibility/bsd/sys/_timeval.h

@@ +1 @@
+/*
+ * Copyright 2009 Haiku Inc. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef _FBSD_COMPAT_SYS__TIMEVAL_H_
+#define _FBSD_COMPAT_SYS__TIMEVAL_H_
+
+
+#include <sys/_types.h>
+
+#endif /* _FBSD_COMPAT_SYS__TIMEVAL_H_ */

new file headers/compatibility/bsd/sys/_types.h

@@ +1 @@
+/*
+ * Copyright 2007 Haiku Inc. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef _FBSD_COMPAT_SYS__TYPES_H_
+#define _FBSD_COMPAT_SYS__TYPES_H_
+
+
+#ifdef __GNUCLIKE_BUILTIN_VARARGS
+typedef __builtin_va_list   __va_list;  /* internally known to gcc */
+#else
+typedef char *          __va_list;
+#endif /* __GNUCLIKE_BUILTIN_VARARGS */
+#if defined(__GNUC_VA_LIST_COMPATIBILITY) && !defined(__GNUC_VA_LIST) \
+    && !defined(__NO_GNUC_VA_LIST)
+#define __GNUC_VA_LIST
+typedef __va_list       __gnuc_va_list; /* compatibility w/GNU headers*/
+#endif
+
+#endif /* _FBSD_COMPAT_SYS__TYPES_H_ */

new file headers/compatibility/bsd/sys/bus.h

@@ +1 @@
+/*
+ * Copyright 2009, Colin Günther. All Rights Reserved.
+ * Copyright 2007, Hugo Santos. All Rights Reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef _FBSD_COMPAT_SYS_BUS_H_
+#define _FBSD_COMPAT_SYS_BUS_H_
+
+
+#include <sys/haiku-module.h>
+
+#include <sys/_bus_dma.h>
+
+#include <sys/queue.h>
+
+
+// TODO per platform, these are 32-bit
+
+// oh you glorious world of macros
+#define bus_read_1(r, o) \
+    bus_space_read_1((r)->r_bustag, (r)->r_bushandle, (o))
+#define bus_read_2(r, o) \
+    bus_space_read_2((r)->r_bustag, (r)->r_bushandle, (o))
+#define bus_read_4(r, o) \
+    bus_space_read_4((r)->r_bustag, (r)->r_bushandle, (o))
+#define bus_write_1(r, o, v) \
+    bus_space_write_1((r)->r_bustag, (r)->r_bushandle, (o), (v))
+#define bus_write_2(r, o, v) \
+    bus_space_write_2((r)->r_bustag, (r)->r_bushandle, (o), (v))
+#define bus_write_4(r, o, v) \
+    bus_space_write_4((r)->r_bustag, (r)->r_bushandle, (o), (v))
+
+#define bus_barrier(r, o, l, f) \
+    bus_space_barrier((r)->r_bustag, (r)->r_bushandle, (o), (l), (f))
+
+#define bus_read_region_1(r, o, d, c) \
+    bus_space_read_region_1((r)->r_bustag, (r)->r_bushandle, (o), (d), (c))
+
+#define FILTER_STRAY            B_UNHANDLED_INTERRUPT
+#define FILTER_HANDLED          B_HANDLED_INTERRUPT
+#define FILTER_SCHEDULE_THREAD  B_INVOKE_SCHEDULER
+
+/* Note that we reversed the original order, so whenever actual (negative)
+   numbers are used in a driver, we have to change it. */
+#define BUS_PROBE_SPECIFIC      0
+#define BUS_PROBE_LOW_PRIORITY  10
+#define BUS_PROBE_DEFAULT       20
+#define BUS_PROBE_GENERIC       100
+
+#define __BUS_ACCESSOR(varp, var, ivarp, ivar, type)                        \
+                                                                            \
+static __inline type varp ## _get_ ## var(device_t dev)                 \
+{                                                                       \
+    return 0;                                                       \
+}                                                                       \
+                                                                            \
+static __inline void varp ## _set_ ## var(device_t dev, type t)             \
+{                                                                           \
+}
+
+
+struct resource;
+
+struct resource_spec {
+    int type;
+    int rid;
+    int flags;
+};
+
+enum intr_type {
+    INTR_TYPE_NET   = 4,
+    INTR_FAST       = 128,
+    INTR_MPSAFE     = 512,
+};
+
+
+int bus_generic_detach(device_t dev);
+int bus_generic_suspend(device_t dev);
+int bus_generic_resume(device_t dev);
+void bus_generic_shutdown(device_t dev);
+
+typedef int (*driver_filter_t)(void *);
+typedef void driver_intr_t(void *);
+
+
+int resource_int_value(const char *name, int unit, const char *resname,
+    int *result);
+
+struct resource *bus_alloc_resource(device_t dev, int type, int *rid,
+    unsigned long start, unsigned long end, unsigned long count, uint32 flags);
+int bus_release_resource(device_t dev, int type, int rid, struct resource *r);
+int bus_alloc_resources(device_t dev, struct resource_spec *resourceSpec,
+    struct resource **resources);
+void bus_release_resources(device_t dev,
+    const struct resource_spec *resourceSpec, struct resource **resources);
+
+int bus_child_present(device_t child);
+
+static inline struct resource *
+bus_alloc_resource_any(device_t dev, int type, int *rid, uint32 flags)
+{
+    return bus_alloc_resource(dev, type, rid, 0, ~0, 1, flags);
+}
+
+bus_dma_tag_t bus_get_dma_tag(device_t dev);
+
+int bus_setup_intr(device_t dev, struct resource *r, int flags,
+    driver_filter_t filter, driver_intr_t handler, void *arg, void **_cookie);
+int bus_teardown_intr(device_t dev, struct resource *r, void *cookie);
+
+const char *device_get_name(device_t dev);
+const char *device_get_nameunit(device_t dev);
+int device_get_unit(device_t dev);
+void *device_get_softc(device_t dev);
+int device_printf(device_t dev, const char *, ...) __printflike(2, 3);
+void device_set_desc(device_t dev, const char *desc);
+void device_set_desc_copy(device_t dev, const char *desc);
+const char *device_get_desc(device_t dev);
+device_t device_get_parent(device_t dev);
+u_int32_t device_get_flags(device_t dev);
+devclass_t device_get_devclass(device_t dev);
+int device_get_children(device_t dev, device_t **devlistp, int *devcountp);
+
+void device_set_ivars(device_t dev, void *);
+void *device_get_ivars(device_t dev);
+
+device_t device_add_child(device_t dev, const char *name, int unit);
+int device_delete_child(device_t dev, device_t child);
+int device_is_attached(device_t dev);
+int device_attach(device_t dev);
+int device_detach(device_t dev);
+int bus_print_child_header(device_t dev, device_t child);
+int bus_print_child_footer(device_t dev, device_t child);
+int bus_generic_print_child(device_t dev, device_t child);
+void bus_generic_driver_added(device_t dev, driver_t *driver);
+int bus_generic_attach(device_t dev);
+int device_set_driver(device_t dev, driver_t *driver);
+int device_is_alive(device_t dev);
+
+
+static inline struct sysctl_ctx_list *
+device_get_sysctl_ctx(device_t dev)
+{
+    return NULL;
+}
+
+
+static inline void *
+device_get_sysctl_tree(device_t dev)
+{
+    return NULL;
+}
+
+devclass_t devclass_find(const char *classname);
+device_t devclass_get_device(devclass_t dc, int unit);
+int devclass_get_maxunit(devclass_t dc);
+
+#endif  /* _FBSD_COMPAT_SYS_BUS_H_ */

new file headers/compatibility/bsd/sys/bus_dma.h

@@ +1 @@
+/*  $NetBSD: bus.h,v 1.12 1997/10/01 08:25:15 fvdl Exp $    */
+
+/*-
+ * Copyright (c) 1996, 1997 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
+ * NASA Ames Research Center.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *  This product includes software developed by the NetBSD
+ *  Foundation, Inc. and its contributors.
+ * 4. Neither the name of The NetBSD Foundation nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*-
+ * Copyright (c) 1996 Charles M. Hannum.  All rights reserved.
+ * Copyright (c) 1996 Christopher G. Demetriou.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by Christopher G. Demetriou
+ *  for the NetBSD Project.
+ * 4. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/* $FreeBSD: src/sys/sys/bus_dma.h,v 1.30 2006/09/03 00:26:17 jmg Exp $ */
+#ifndef _BUS_DMA_H_
+#define _BUS_DMA_H_
+
+#include <sys/_bus_dma.h>
+
+
+/*
+ * Machine independent interface for mapping physical addresses to peripheral
+ * bus 'physical' addresses, and assisting with DMA operations.
+ *
+ * XXX This file is always included from <machine/bus_dma.h> and should not
+ *     (yet) be included directly.
+ */
+
+/*
+ * Flags used in various bus DMA methods.
+ */
+#define BUS_DMA_WAITOK      0x00    /* safe to sleep (pseudo-flag) */
+#define BUS_DMA_NOWAIT      0x01    /* not safe to sleep */
+#define BUS_DMA_ALLOCNOW    0x02    /* perform resource allocation now */
+#define BUS_DMA_COHERENT    0x04    /* hint: map memory in a coherent way */
+#define BUS_DMA_ZERO        0x08    /* allocate zero'ed memory */
+#define BUS_DMA_BUS1        0x10    /* placeholders for bus functions... */
+#define BUS_DMA_BUS2        0x20
+#define BUS_DMA_BUS3        0x40
+#define BUS_DMA_BUS4        0x80
+
+/*
+ * The following two flags are non-standard or specific to only certain
+ * architectures
+ */
+#define BUS_DMA_NOWRITE     0x100
+#define BUS_DMA_NOCACHE     0x200
+#define BUS_DMA_ISA     0x400   /* map memory for AXP ISA dma */
+
+/* Forwards needed by prototypes below. */
+struct mbuf;
+struct uio;
+
+/*
+ * Operations performed by bus_dmamap_sync().
+ */
+#define BUS_DMASYNC_PREREAD 1
+#define BUS_DMASYNC_POSTREAD    2
+#define BUS_DMASYNC_PREWRITE    4
+#define BUS_DMASYNC_POSTWRITE   8
+
+/*
+ *  bus_dma_segment_t
+ *
+ *  Describes a single contiguous DMA transaction.  Values
+ *  are suitable for programming into DMA registers.
+ */
+typedef struct bus_dma_segment {
+    bus_addr_t  ds_addr;    /* DMA address */
+    bus_size_t  ds_len;     /* length of transfer */
+} bus_dma_segment_t;
+
+/*
+ * A function that returns 1 if the address cannot be accessed by
+ * a device and 0 if it can be.
+ */
+typedef int bus_dma_filter_t(void *, bus_addr_t);
+
+/*
+ * Generic helper function for manipulating mutexes.
+ */
+void busdma_lock_mutex(void *arg, bus_dma_lock_op_t op);
+
+/*
+ * Allocate a device specific dma_tag encapsulating the constraints of
+ * the parent tag in addition to other restrictions specified:
+ *
+ *  alignment:  Alignment for segments.
+ *  boundary:   Boundary that segments cannot cross.
+ *  lowaddr:    Low restricted address that cannot appear in a mapping.
+ *  highaddr:   High restricted address that cannot appear in a mapping.
+ *  filtfunc:   An optional function to further test if an address
+ *          within the range of lowaddr and highaddr cannot appear
+ *          in a mapping.
+ *  filtfuncarg:    An argument that will be passed to filtfunc in addition
+ *          to the address to test.
+ *  maxsize:    Maximum mapping size supported by this tag.
+ *  nsegments:  Number of discontinuities allowed in maps.
+ *  maxsegsz:   Maximum size of a segment in the map.
+ *  flags:      Bus DMA flags.
+ *  lockfunc:   An optional function to handle driver-defined lock
+ *          operations.
+ *  lockfuncarg:    An argument that will be passed to lockfunc in addition
+ *          to the lock operation.
+ *  dmat:       A pointer to set to a valid dma tag should the return
+ *          value of this function indicate success.
+ */
+/* XXX Should probably allow specification of alignment */
+int bus_dma_tag_create(bus_dma_tag_t parent, bus_size_t alignment,
+               bus_size_t boundary, bus_addr_t lowaddr,
+               bus_addr_t highaddr, bus_dma_filter_t *filtfunc,
+               void *filtfuncarg, bus_size_t maxsize, int nsegments,
+               bus_size_t maxsegsz, int flags, bus_dma_lock_t *lockfunc,
+               void *lockfuncarg, bus_dma_tag_t *dmat);
+
+int bus_dma_tag_destroy(bus_dma_tag_t dmat);
+
+/*
+ * A function that processes a successfully loaded dma map or an error
+ * from a delayed load map.
+ */
+typedef void bus_dmamap_callback_t(void *, bus_dma_segment_t *, int, int);
+
+/*
+ * Like bus_dmamap_callback but includes map size in bytes.  This is
+ * defined as a separate interface to maintain compatibility for users
+ * of bus_dmamap_callback_t--at some point these interfaces should be merged.
+ */
+typedef void bus_dmamap_callback2_t(void *, bus_dma_segment_t *, int, bus_size_t, int);
+
+/*
+ * XXX sparc64 uses the same interface, but a much different implementation.
+ *     <machine/bus_dma.h> for the sparc64 arch contains the equivalent
+ *     declarations.
+ */
+#if !defined(__sparc64__)
+
+/*
+ * Allocate a handle for mapping from kva/uva/physical
+ * address space into bus device space.
+ */
+int bus_dmamap_create(bus_dma_tag_t dmat, int flags, bus_dmamap_t *mapp);
+
+/*
+ * Destroy a handle for mapping from kva/uva/physical
+ * address space into bus device space.
+ */
+int bus_dmamap_destroy(bus_dma_tag_t dmat, bus_dmamap_t map);
+
+/*
+ * Allocate a piece of memory that can be efficiently mapped into
+ * bus device space based on the constraints listed in the dma tag.
+ * A dmamap to for use with dmamap_load is also allocated.
+ */
+int bus_dmamem_alloc(bus_dma_tag_t dmat, void** vaddr, int flags,
+             bus_dmamap_t *mapp);
+
+/*
+ * Free a piece of memory and its allocated dmamap, that was allocated
+ * via bus_dmamem_alloc.
+ */
+void bus_dmamem_free(bus_dma_tag_t dmat, void *vaddr, bus_dmamap_t map);
+
+/*
+ * Map the buffer buf into bus space using the dmamap map.
+ */
+int bus_dmamap_load(bus_dma_tag_t dmat, bus_dmamap_t map, void *buf,
+            bus_size_t buflen, bus_dmamap_callback_t *callback,
+            void *callback_arg, int flags);
+
+/*
+ * Like bus_dmamap_load but for mbufs.  Note the use of the
+ * bus_dmamap_callback2_t interface.
+ */
+int bus_dmamap_load_mbuf(bus_dma_tag_t dmat, bus_dmamap_t map,
+             struct mbuf *mbuf,
+             bus_dmamap_callback2_t *callback, void *callback_arg,
+             int flags);
+
+int bus_dmamap_load_mbuf_sg(bus_dma_tag_t dmat, bus_dmamap_t map,
+                struct mbuf *mbuf, bus_dma_segment_t *segs,
+                int *nsegs, int flags);
+
+/*
+ * Like bus_dmamap_load but for uios.  Note the use of the
+ * bus_dmamap_callback2_t interface.
+ */
+int bus_dmamap_load_uio(bus_dma_tag_t dmat, bus_dmamap_t map,
+            struct uio *ui,
+            bus_dmamap_callback2_t *callback, void *callback_arg,
+            int flags);
+
+/*
+ * Perform a synchronization operation on the given map.
+ */
+void _bus_dmamap_sync(bus_dma_tag_t, bus_dmamap_t, bus_dmasync_op_t);
+#define bus_dmamap_sync(dmat, dmamap, op)           \
+    do {                            \
+        if ((dmamap) != NULL)               \
+            _bus_dmamap_sync(dmat, dmamap, op); \
+    } while (0)
+
+/*
+ * Release the mapping held by map.
+ */
+void _bus_dmamap_unload(bus_dma_tag_t dmat, bus_dmamap_t map);
+#define bus_dmamap_unload(dmat, dmamap)             \
+    do {                            \
+        if ((dmamap) != NULL)               \
+            _bus_dmamap_unload(dmat, dmamap);   \
+    } while (0)
+
+#endif /* __sparc64__ */
+
+#endif /* _BUS_DMA_H_ */

new file headers/compatibility/bsd/sys/callout.h

@@ +1 @@
+/*
+ * Copyright 2010, Axel Dörfler, axeld@pinc-software.de.
+ * Copyright 2009, Colin Günther, coling@gmx.de.
+ * Copyright 2007, Hugo Santos. All Rights Reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef _FBSD_COMPAT_SYS_CALLOUT_H_
+#define _FBSD_COMPAT_SYS_CALLOUT_H_
+
+
+#include <sys/haiku-module.h>
+
+#include <sys/queue.h>
+
+
+struct callout {
+    struct list_link    link;
+    bigtime_t           due;
+    uint32              flags;
+
+    void *              c_arg;
+    void                (*c_func)(void *);
+    struct mtx *        c_mtx;
+    int                 c_flags;
+};
+
+
+#define CALLOUT_MPSAFE  0x0001
+
+
+void callout_init(struct callout *c, int mpsafe);
+void callout_init_mtx(struct callout *c, struct mtx *mutex, int flags);
+/* Time values are in ticks, see compat/sys/kernel.h for its definition */
+int callout_schedule(struct callout *c, int ticks);
+int callout_reset(struct callout *c, int ticks, void (*func)(void *), void *arg);
+int callout_pending(struct callout *c);
+int callout_active(struct callout *c);
+
+#define callout_drain(c)    _callout_stop_safe(c, 1)
+#define callout_stop(c)     _callout_stop_safe(c, 0)
+int _callout_stop_safe(struct callout *c, int safe);
+
+
+
+#endif  /* _FBSD_COMPAT_SYS_CALLOUT_H_ */

headers/compatibility/bsd/sys/cdefs.h

@@ +1 @@
+/*-
+ * Copyright (c) 1991, 1993
+ *  The Regents of the University of California.  All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Berkeley Software Design, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *  @(#)cdefs.h 8.8 (Berkeley) 1/9/95
+ * $FreeBSD$
+ */
+#ifndef _FBSD_COMPAT_SYS_CDEFS_H_
+#define _FBSD_COMPAT_SYS_CDEFS_H_
+
+
+#include <posix/sys/cdefs.h>
+
+
+#define __FBSDID(str)   static const char __fbsdid[] = str
+
 /*
- * Copyright 2006-2012 Haiku Inc. All Rights Reserved.
- * Distributed under the terms of the MIT License.
+ * This code has been put in place to help reduce the addition of
+ * compiler specific defines in FreeBSD code.  It helps to aid in
+ * having a compiler-agnostic source tree.
  */
-#ifndef _BSD_SYS_CDEFS_H_
-#define _BSD_SYS_CDEFS_H_
 
+#if defined(__GNUC__) || defined(__INTEL_COMPILER)
+
+#if __GNUC__ >= 3 || defined(__INTEL_COMPILER)
+#define __GNUCLIKE_ASM 3
+#define __GNUCLIKE_MATH_BUILTIN_CONSTANTS
+#else
+#define __GNUCLIKE_ASM 2
+#endif
+#define __GNUCLIKE___TYPEOF 1
+#define __GNUCLIKE___OFFSETOF 1
+#define __GNUCLIKE___SECTION 1
+
+#define __GNUCLIKE_ATTRIBUTE_MODE_DI 1
+
+#ifndef __INTEL_COMPILER
+# define __GNUCLIKE_CTOR_SECTION_HANDLING 1
+#endif
+
+#define __GNUCLIKE_BUILTIN_CONSTANT_P 1
+# if defined(__INTEL_COMPILER) && defined(__cplusplus) \
+    && __INTEL_COMPILER < 800
+#  undef __GNUCLIKE_BUILTIN_CONSTANT_P
+# endif
 
-#include_next <sys/cdefs.h>
+#if (__GNUC_MINOR__ > 95 || __GNUC__ >= 3) && !defined(__INTEL_COMPILER)
+# define __GNUCLIKE_BUILTIN_VARARGS 1
+# define __GNUCLIKE_BUILTIN_STDARG 1
+# define __GNUCLIKE_BUILTIN_VAALIST 1
+#endif
+
+#if defined(__GNUC__)
+# define __GNUC_VA_LIST_COMPATIBILITY 1
+#endif
 
+#ifndef __INTEL_COMPILER
+# define __GNUCLIKE_BUILTIN_NEXT_ARG 1
+# define __GNUCLIKE_MATH_BUILTIN_RELOPS
+#endif
 
-#ifdef _BSD_SOURCE
+#define __GNUCLIKE_BUILTIN_MEMCPY 1
 
+/* XXX: if __GNUC__ >= 2: not tested everywhere originally, where replaced */
+#define __CC_SUPPORTS_INLINE 1
+#define __CC_SUPPORTS___INLINE 1
+#define __CC_SUPPORTS___INLINE__ 1
 
-#define __FBSDID(x)
-#define __unused
+#define __CC_SUPPORTS___FUNC__ 1
+#define __CC_SUPPORTS_WARNING 1
+
+#define __CC_SUPPORTS_VARADIC_XXX 1 /* see varargs.h */
+
+#define __CC_SUPPORTS_DYNAMIC_ARRAY_INIT 1
+
+#endif /* __GNUC__ || __INTEL_COMPILER */
+
+
+/*
+ * Macro to test if we're using a specific version of gcc or later.
+ */
+#if defined(__GNUC__) && !defined(__INTEL_COMPILER)
+#define __GNUC_PREREQ__(ma, mi) \
+    (__GNUC__ > (ma) || __GNUC__ == (ma) && __GNUC_MINOR__ >= (mi))
+#else
+#define __GNUC_PREREQ__(ma, mi) 0
+#endif
+
+/*
+ * GNU C version 2.96 adds explicit branch prediction so that
+ * the CPU back-end can hint the processor and also so that
+ * code blocks can be reordered such that the predicted path
+ * sees a more linear flow, thus improving cache behavior, etc.
+ *
+ * The following two macros provide us with a way to utilize this
+ * compiler feature.  Use __predict_true() if you expect the expression
+ * to evaluate to true, and __predict_false() if you expect the
+ * expression to evaluate to false.
+ *
+ * A few notes about usage:
+ *
+ *  * Generally, __predict_false() error condition checks (unless
+ *    you have some _strong_ reason to do otherwise, in which case
+ *    document it), and/or __predict_true() `no-error' condition
+ *    checks, assuming you want to optimize for the no-error case.
+ *
+ *  * Other than that, if you don't know the likelihood of a test
+ *    succeeding from empirical or other `hard' evidence, don't
+ *    make predictions.
+ *
+ *  * These are meant to be used in places that are run `a lot'.
+ *    It is wasteful to make predictions in code that is run
+ *    seldomly (e.g. at subsystem initialization time) as the
+ *    basic block reordering that this affects can often generate
+ *    larger code.
+ */
+#if __GNUC_PREREQ__(2, 96)
+#define __predict_true(exp)     __builtin_expect((exp), 1)
+#define __predict_false(exp)    __builtin_expect((exp), 0)
+#else
+#define __predict_true(exp)     (exp)
+#define __predict_false(exp)    (exp)
+#endif
+
+/*
+ * We define this here since <stddef.h>, <sys/queue.h>, and <sys/types.h>
+ * require it.
+ */
+#define __offsetof offsetof
 
-#define __printflike(a, b)  __attribute__ ((format (__printf__, (a), (b))))
+/*
+ * Compiler-dependent macros to help declare dead (non-returning) and
+ * pure (no side effects) functions, and unused variables.  They are
+ * null except for versions of gcc that are known to support the features
+ * properly (old versions of gcc-2 supported the dead and pure features
+ * in a different (wrong) way).  If we do not provide an implementation
+ * for a given compiler, let the compile fail if it is told to use
+ * a feature that we cannot live without.
+ */
+#ifdef lint
+#define __pure2
+#define __unused
+#define __packed
+#define __aligned(x)
+#define __section(x)
+#else
+#if !__GNUC_PREREQ__(2, 5) && !defined(__INTEL_COMPILER)
+#define __pure2
+#define __unused
+#endif
+#if __GNUC__ == 2 && __GNUC_MINOR__ >= 5 && __GNUC_MINOR__ < 7 && !defined(__INTEL_COMPILER)
+#define __pure2     __attribute__((__const__))
+#define __unused
+/* XXX Find out what to do for __packed, __aligned and __section */
+#endif
+#if __GNUC_PREREQ__(2, 7)
+#define __pure2     __attribute__((__const__))
+#define __unused    __attribute__((__unused__))
+#define __packed    __attribute__((__packed__))
+#define __aligned(x)    __attribute__((__aligned__(x)))
+#define __section(x)    __attribute__((__section__(x)))
+#endif
+
+#if __GNUC_PREREQ__(3, 1)
+#define __used      __attribute__((__used__))
+#else
+#if __GNUC_PREREQ__(2, 7)
+#define __used
+#endif
+#endif
+
+#if defined(__INTEL_COMPILER)
+#define __pure2     __attribute__((__const__))
+#define __unused    __attribute__((__unused__))
+#define __used      __attribute__((__used__))
+#define __packed    __attribute__((__packed__))
+#define __aligned(x)    __attribute__((__aligned__(x)))
+#define __section(x)    __attribute__((__section__(x)))
+#endif
+#endif
+
+/*
+ * Compiler-dependent macros to declare that functions take printf-like
+ * or scanf-like arguments.  They are null except for versions of gcc
+ * that are known to support the features properly (old versions of gcc-2
+ * didn't permit keeping the keywords out of the application namespace).
+ */
+#if !__GNUC_PREREQ__(2, 7) && !defined(__INTEL_COMPILER)
+#define __printflike(fmtarg, firstvararg)
+#define __scanflike(fmtarg, firstvararg)
+#define __format_arg(fmtarg)
+#else
+#define __printflike(fmtarg, firstvararg) \
+        __attribute__((__format__ (__printf__, fmtarg, firstvararg)))
+#define __scanflike(fmtarg, firstvararg) \
+        __attribute__((__format__ (__scanf__, fmtarg, firstvararg)))
+#define __format_arg(fmtarg)    __attribute__((__format_arg__ (fmtarg)))
+#endif
 #define __printf0like(a, b)
 
+#if __GNUC_PREREQ__(3, 1)
+#define __noinline  __attribute__ ((__noinline__))
+#else
+#define __noinline
+#endif
 
+#if __GNUC_PREREQ__(3, 3)
+#define __nonnull(x)    __attribute__((__nonnull__(x)))
+#else
+#define __nonnull(x)
 #endif
 
+/*
+ * The __CONCAT macro is used to concatenate parts of symbol names, e.g.
+ * with "#define OLD(foo) __CONCAT(old,foo)", OLD(foo) produces oldfoo.
+ * The __CONCAT macro is a bit tricky to use if it must work in non-ANSI
+ * mode -- there must be no spaces between its arguments, and for nested
+ * __CONCAT's, all the __CONCAT's must be at the left.  __CONCAT can also
+ * concatenate double-quoted strings produced by the __STRING macro, but
+ * this only works with ANSI C.
+ *
+ * __XSTRING is like __STRING, but it expands any macros in its argument
+ * first.  It is only available with ANSI C.
+ */
+#if defined(__STDC__) || defined(__cplusplus)
+#define __XSTRING(x)    __STRING(x) /* expand x, then stringify */
+
+#define __const     const       /* define reserved names to standard */
+#define __signed    signed
+#define __volatile  volatile
+#if defined(__cplusplus)
+#define __inline    inline      /* convert to C++ keyword */
+#else
+#if !(defined(__CC_SUPPORTS___INLINE))
+#define __inline            /* delete GCC keyword */
+#endif /* ! __CC_SUPPORTS___INLINE */
+#endif /* !__cplusplus */
+
+#else   /* !(__STDC__ || __cplusplus) */
+
+#if !defined(__CC_SUPPORTS___INLINE)
+#define __const             /* delete pseudo-ANSI C keywords */
+#define __inline
+#define __signed
+#define __volatile
+/*
+ * In non-ANSI C environments, new programs will want ANSI-only C keywords
+ * deleted from the program and old programs will want them left alone.
+ * When using a compiler other than gcc, programs using the ANSI C keywords
+ * const, inline etc. as normal identifiers should define -DNO_ANSI_KEYWORDS.
+ * When using "gcc -traditional", we assume that this is the intent; if
+ * __GNUC__ is defined but __STDC__ is not, we leave the new keywords alone.
+ */
+#ifndef NO_ANSI_KEYWORDS
+#define const               /* delete ANSI C keywords */
+#define inline
+#define signed
+#define volatile
+#endif  /* !NO_ANSI_KEYWORDS */
+#endif  /* !__CC_SUPPORTS___INLINE */
+#endif  /* !(__STDC__ || __cplusplus) */
+
+#ifndef __DECONST
+#define __DECONST(type, var)    ((type)(uintptr_t)(const void *)(var))
+#endif
+
+#ifndef __UNCONST
+#define __UNCONST(var)  ((void*)(uintptr_t)(const void *)(var))
+#endif
+
+
+#endif
 
-#endif  /* _BSD_SYS_CDEFS_H_ */

new file headers/compatibility/bsd/sys/condvar.h

@@ +1 @@
+/*
+ * Copyright 2009, Colin Günther, coling@gmx.de.
+ * All rights reserved. Distributed under the terms of the MIT License.
+ */
+#ifndef _FBSD_COMPAT_SYS_CONDVAR_H_
+#define _FBSD_COMPAT_SYS_CONDVAR_H_
+
+
+#include <sys/queue.h>
+
+#ifdef __cplusplus
+} /* extern "C" */
+#include <kernel_c++_structs.h>
+extern "C" {
+#else
+#include <kernel_c++_structs.h>
+#endif
+
+
+struct cv {
+    struct ConditionVariable condition;
+};
+
+
+void cv_init(struct cv*, const char*);
+void cv_destroy(struct cv*);
+void cv_wait(struct cv*, struct mtx*);
+int cv_timedwait(struct cv*, struct mtx*, int);
+void cv_signal(struct cv*);
+
+#endif /* _FBSD_COMPAT_SYS_CONDVAR_H_ */

new file headers/compatibility/bsd/sys/ctype.h

@@ +1 @@
+/*
+ * Copyright 2009 Haiku Inc. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef _FBSD_COMPAT_SYS_CTYPE_H_
+#define _FBSD_COMPAT_SYS_CTYPE_H_
+
+
+#define isprint(c) ((c) >= ' ' && (c) <= '~')
+
+#endif /* _FBSD_COMPAT_SYS_CTYPE_H_ */

new file headers/compatibility/bsd/sys/endian.h

@@ +1 @@
+/*-
+ * Copyright (c) 2002 Thomas Moestl <tmm@FreeBSD.org>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * $FreeBSD: src/sys/sys/endian.h,v 1.6 2003/10/15 20:05:57 obrien Exp $
+ */
+#ifndef _FBSD_COMPAT_SYS_ENDIAN_H_
+#define _FBSD_COMPAT_SYS_ENDIAN_H_
+
+#include <stdint.h>
+#include <posix/endian.h>
+
+#include <support/ByteOrder.h>
+
+#include <sys/cdefs.h>
+#include <sys/_types.h>
+#include <machine/endian.h>
+
+#define _BYTE_ORDER     BYTE_ORDER
+#define _LITTLE_ENDIAN  LITTLE_ENDIAN
+#define _BIG_ENDIAN     BIG_ENDIAN
+
+#define __bswap16(x)    __swap_int16(x)
+#define __bswap32(x)    __swap_int32(x)
+#define __bswap64(x)    __swap_int64(x)
+
+/*
+ * General byte order swapping functions.
+ */
+#define bswap16(x)  __bswap16(x)
+#define bswap32(x)  __bswap32(x)
+#define bswap64(x)  __bswap64(x)
+
+/*
+ * Host to big endian, host to little endian, big endian to host, and little
+ * endian to host byte order functions as detailed in byteorder(9).
+ */
+#if _BYTE_ORDER == _LITTLE_ENDIAN
+#define htobe16(x)  bswap16((x))
+#define htobe32(x)  bswap32((x))
+#define htobe64(x)  bswap64((x))
+#define htole16(x)  ((uint16_t)(x))
+#define htole32(x)  ((uint32_t)(x))
+#define htole64(x)  ((uint64_t)(x))
+
+#define be16toh(x)  bswap16((x))
+#define be32toh(x)  bswap32((x))
+#define be64toh(x)  bswap64((x))
+#define le16toh(x)  ((uint16_t)(x))
+#define le32toh(x)  ((uint32_t)(x))
+#define le64toh(x)  ((uint64_t)(x))
+#else /* _BYTE_ORDER != _LITTLE_ENDIAN */
+#define htobe16(x)  ((uint16_t)(x))
+#define htobe32(x)  ((uint32_t)(x))
+#define htobe64(x)  ((uint64_t)(x))
+#define htole16(x)  bswap16((x))
+#define htole32(x)  bswap32((x))
+#define htole64(x)  bswap64((x))
+
+#define be16toh(x)  ((uint16_t)(x))
+#define be32toh(x)  ((uint32_t)(x))
+#define be64toh(x)  ((uint64_t)(x))
+#define le16toh(x)  bswap16((x))
+#define le32toh(x)  bswap32((x))
+#define le64toh(x)  bswap64((x))
+#endif /* _BYTE_ORDER == _LITTLE_ENDIAN */
+
+/* Alignment-agnostic encode/decode bytestream to/from little/big endian. */
+
+static __inline uint16_t
+be16dec(const void *pp)
+{
+    unsigned char const *p = (unsigned char const *)pp;
+
+    return ((p[0] << 8) | p[1]);
+}
+
+static __inline uint32_t
+be32dec(const void *pp)
+{
+    unsigned char const *p = (unsigned char const *)pp;
+
+    return ((p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3]);
+}
+
+static __inline uint64_t
+be64dec(const void *pp)
+{
+    unsigned char const *p = (unsigned char const *)pp;
+
+    return (((uint64_t)be32dec(p) << 32) | be32dec(p + 4));
+}
+
+static __inline uint16_t
+le16dec(const void *pp)
+{
+    unsigned char const *p = (unsigned char const *)pp;
+
+    return ((p[1] << 8) | p[0]);
+}
+
+static __inline uint32_t
+le32dec(const void *pp)
+{
+    unsigned char const *p = (unsigned char const *)pp;
+
+    return ((p[3] << 24) | (p[2] << 16) | (p[1] << 8) | p[0]);
+}
+
+static __inline uint64_t
+le64dec(const void *pp)
+{
+    unsigned char const *p = (unsigned char const *)pp;
+
+    return (((uint64_t)le32dec(p + 4) << 32) | le32dec(p));
+}
+
+static __inline void
+be16enc(void *pp, uint16_t u)
+{
+    unsigned char *p = (unsigned char *)pp;
+
+    p[0] = (u >> 8) & 0xff;
+    p[1] = u & 0xff;
+}
+
+static __inline void
+be32enc(void *pp, uint32_t u)
+{
+    unsigned char *p = (unsigned char *)pp;
+
+    p[0] = (u >> 24) & 0xff;
+    p[1] = (u >> 16) & 0xff;
+    p[2] = (u >> 8) & 0xff;
+    p[3] = u & 0xff;
+}
+
+static __inline void
+be64enc(void *pp, uint64_t u)
+{
+    unsigned char *p = (unsigned char *)pp;
+
+    be32enc(p, u >> 32);
+    be32enc(p + 4, u & 0xffffffff);
+}
+
+static __inline void
+le16enc(void *pp, uint16_t u)
+{
+    unsigned char *p = (unsigned char *)pp;
+
+    p[0] = u & 0xff;
+    p[1] = (u >> 8) & 0xff;
+}
+
+static __inline void
+le32enc(void *pp, uint32_t u)
+{
+    unsigned char *p = (unsigned char *)pp;
+
+    p[0] = u & 0xff;
+    p[1] = (u >> 8) & 0xff;
+    p[2] = (u >> 16) & 0xff;
+    p[3] = (u >> 24) & 0xff;
+}
+
+static __inline void
+le64enc(void *pp, uint64_t u)
+{
+    unsigned char *p = (unsigned char *)pp;
+
+    le32enc(p, u & 0xffffffff);
+    le32enc(p + 4, u >> 32);
+}
+
+#endif  /* _SYS_ENDIAN_H_ */

new file headers/compatibility/bsd/sys/errno.h

@@ +1 @@
+/*
+ * Copyright 2007 Haiku Inc. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef _FBSD_COMPAT_SYS_ERRNO_H_
+#define _FBSD_COMPAT_SYS_ERRNO_H_
+
+
+#include <posix/errno.h>
+
+
+/* pseudo-errors returned inside freebsd compat layer to modify return to process */
+#define ERESTART        (B_ERRORS_END + 1)      /* restart syscall */
+#define EJUSTRETURN     (B_ERRORS_END + 2)      /* don't modify regs, just return */
+
+#endif

new file headers/compatibility/bsd/sys/event.h

@@ +1 @@
+/*
+ * Copyright 2007 Haiku Inc. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef _FBSD_COMPAT_SYS_EVENT_H_
+#define _FBSD_COMPAT_SYS_EVENT_H_
+
+
+struct knlist {
+    int _dummy;
+};
+
+#endif

new file headers/compatibility/bsd/sys/eventhandler.h

@@ +1 @@
+/*-
+ * Copyright (c) 1999 Michael Smith <msmith@freebsd.org>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * $FreeBSD: src/sys/sys/eventhandler.h,v 1.33.2.1 2006/05/16 07:27:49 ps Exp $
+ */
+#ifndef SYS_EVENTHANDLER_H
+#define SYS_EVENTHANDLER_H
+
+#include <sys/lock.h>
+#include <sys/ktr.h>
+#include <sys/mutex.h>
+#include <sys/queue.h>
+
+struct eventhandler_entry {
+    TAILQ_ENTRY(eventhandler_entry) ee_link;
+    int             ee_priority;
+#define EHE_DEAD_PRIORITY   (-1)
+    void                *ee_arg;
+};
+
+struct eventhandler_list {
+    char                *el_name;
+    int             el_flags;
+#define EHL_INITTED (1<<0)
+    u_int               el_runcount;
+    struct mtx          el_lock;
+    TAILQ_ENTRY(eventhandler_list)  el_link;
+    TAILQ_HEAD(,eventhandler_entry) el_entries;
+};
+
+typedef struct eventhandler_entry   *eventhandler_tag;
+
+#define EHL_LOCK(p)     mtx_lock(&(p)->el_lock)
+#define EHL_UNLOCK(p)       mtx_unlock(&(p)->el_lock)
+#define EHL_LOCK_ASSERT(p, x)   mtx_assert(&(p)->el_lock, x)
+
+/*
+ * Macro to invoke the handlers for a given event.
+ */
+#define _EVENTHANDLER_INVOKE(name, list, ...) do {          \
+    struct eventhandler_entry *_ep;                 \
+    struct eventhandler_entry_ ## name *_t;             \
+                                    \
+    KASSERT((list)->el_flags & EHL_INITTED,             \
+       ("eventhandler_invoke: running non-inited list"));       \
+    EHL_LOCK_ASSERT((list), MA_OWNED);              \
+    (list)->el_runcount++;                      \
+    KASSERT((list)->el_runcount > 0,                \
+        ("eventhandler_invoke: runcount overflow"));        \
+    CTR0(KTR_EVH, "eventhandler_invoke(\"" __STRING(name) "\")");   \
+    TAILQ_FOREACH(_ep, &((list)->el_entries), ee_link) {        \
+        if (_ep->ee_priority != EHE_DEAD_PRIORITY) {        \
+            EHL_UNLOCK((list));             \
+            _t = (struct eventhandler_entry_ ## name *)_ep; \
+            CTR1(KTR_EVH, "eventhandler_invoke: executing %p", \
+                (void *)_t->eh_func);           \
+            _t->eh_func(_ep->ee_arg , ## __VA_ARGS__);  \
+            EHL_LOCK((list));               \
+        }                           \
+    }                               \
+    KASSERT((list)->el_runcount > 0,                \
+        ("eventhandler_invoke: runcount underflow"));       \
+    (list)->el_runcount--;                      \
+    if ((list)->el_runcount == 0)                   \
+        eventhandler_prune_list(list);              \
+    EHL_UNLOCK((list));                     \
+} while (0)
+
+/*
+ * Slow handlers are entirely dynamic; lists are created
+ * when entries are added to them, and thus have no concept of "owner",
+ *
+ * Slow handlers need to be declared, but do not need to be defined. The
+ * declaration must be in scope wherever the handler is to be invoked.
+ */
+#define EVENTHANDLER_DECLARE(name, type)                \
+struct eventhandler_entry_ ## name                  \
+{                                   \
+    struct eventhandler_entry   ee;             \
+    type                eh_func;            \
+};                                  \
+struct __hack
+
+#define EVENTHANDLER_INVOKE(name, ...)                  \
+do {                                    \
+    struct eventhandler_list *_el;                  \
+                                    \
+    if ((_el = eventhandler_find_list(#name)) != NULL)      \
+        _EVENTHANDLER_INVOKE(name, _el , ## __VA_ARGS__);   \
+} while (0)
+
+#define EVENTHANDLER_REGISTER(name, func, arg, priority)        \
+    eventhandler_register(NULL, #name, func, arg, priority)
+
+#define EVENTHANDLER_DEREGISTER(name, tag)              \
+do {                                    \
+    struct eventhandler_list *_el;                  \
+                                    \
+    if ((_el = eventhandler_find_list(#name)) != NULL)      \
+        eventhandler_deregister(_el, tag);          \
+} while(0)
+    
+
+eventhandler_tag eventhandler_register(struct eventhandler_list *list, 
+        const char *name, void *func, void *arg, int priority);
+void    eventhandler_deregister(struct eventhandler_list *list,
+        eventhandler_tag tag);
+struct eventhandler_list *eventhandler_find_list(const char *name);
+void    eventhandler_prune_list(struct eventhandler_list *list);
+
+/*
+ * Standard system event queues.
+ */
+
+/* Generic priority levels */
+#define EVENTHANDLER_PRI_FIRST  0
+#define EVENTHANDLER_PRI_ANY    10000
+#define EVENTHANDLER_PRI_LAST   20000
+
+/* Shutdown events */
+typedef void (*shutdown_fn)(void *, int);
+
+#define SHUTDOWN_PRI_FIRST  EVENTHANDLER_PRI_FIRST
+#define SHUTDOWN_PRI_DEFAULT    EVENTHANDLER_PRI_ANY
+#define SHUTDOWN_PRI_LAST   EVENTHANDLER_PRI_LAST
+
+EVENTHANDLER_DECLARE(shutdown_pre_sync, shutdown_fn);   /* before fs sync */
+EVENTHANDLER_DECLARE(shutdown_post_sync, shutdown_fn);  /* after fs sync */
+EVENTHANDLER_DECLARE(shutdown_final, shutdown_fn);
+
+/* Low memory event */
+typedef void (*vm_lowmem_handler_t)(void *, int);
+#define LOWMEM_PRI_DEFAULT  EVENTHANDLER_PRI_FIRST
+EVENTHANDLER_DECLARE(vm_lowmem, vm_lowmem_handler_t);
+
+/*
+ * Process events
+ * process_fork and exit handlers are called without Giant.
+ * exec handlers are called with Giant, but that is by accident.
+ */
+struct proc;
+
+typedef void (*exitlist_fn)(void *, struct proc *);
+typedef void (*forklist_fn)(void *, struct proc *, struct proc *, int);
+typedef void (*execlist_fn)(void *, struct proc *);
+
+EVENTHANDLER_DECLARE(process_exit, exitlist_fn);
+EVENTHANDLER_DECLARE(process_fork, forklist_fn);
+EVENTHANDLER_DECLARE(process_exec, execlist_fn);
+
+typedef void (*uma_zone_chfn)(void *);
+EVENTHANDLER_DECLARE(nmbclusters_change, uma_zone_chfn);
+EVENTHANDLER_DECLARE(maxsockets_change, uma_zone_chfn);
+#endif /* SYS_EVENTHANDLER_H */

new file headers/compatibility/bsd/sys/firmware.h

@@ +1 @@
+/*
+ * Copyright 2009 Haiku Inc. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef _FBSD_COMPAT_SYS_FIRMWARE_H_
+#define _FBSD_COMPAT_SYS_FIRMWARE_H_
+
+
+#define FIRMWARE_UNLOAD 0x0001
+
+
+struct firmware {
+    const char*     name;       // system-wide name
+    const void*     data;       // location of image
+    size_t          datasize;   // size of image in bytes
+    unsigned int    version;    // version of the image
+};
+
+
+const struct firmware* firmware_get(const char*);
+void firmware_put(const struct firmware*, int);
+
+#endif /* _FBSD_COMPAT_SYS_FIRMWARE_H_ */

new file headers/compatibility/bsd/sys/haiku-module.h

@@ +1 @@
+/*
+ * Copyright 2009, Colin Günther. All Rights Reserved.
+ * Copyright 2007, Hugo Santos. All Rights Reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef _FBSD_COMPAT_SYS_HAIKU_MODULE_H_
+#define _FBSD_COMPAT_SYS_HAIKU_MODULE_H_
+
+
+#include <Drivers.h>
+#include <KernelExport.h>
+
+#include <kernel/lock.h>
+#include <net_stack.h>
+
+
+#undef ASSERT
+    /* private/kernel/debug.h sets it */
+
+typedef struct device *device_t;
+typedef struct devclass *devclass_t;
+
+typedef int (*device_method_signature_t)(device_t dev);
+
+typedef int device_probe_t(device_t dev);
+typedef int device_attach_t(device_t dev);
+typedef int device_detach_t(device_t dev);
+typedef int device_resume_t(device_t dev);
+typedef int device_suspend_t(device_t dev);
+
+struct device_method {
+    const char *name;
+    device_method_signature_t method;
+};
+
+typedef struct device_method device_method_t;
+
+#define DEVMETHOD(name, func)   { #name, (device_method_signature_t)&func }
+#define DEVMETHOD_END   { 0, 0 }
+
+typedef struct {
+    const char *name;
+    device_method_t *methods;
+    size_t softc_size;
+} driver_t;
+
+#define DRIVER_MODULE_NAME(name, busname) \
+    __fbsd_ ## name ## _ ## busname
+
+status_t _fbsd_init_hardware(driver_t *driver[]);
+status_t _fbsd_init_drivers(driver_t *driver[]);
+status_t _fbsd_uninit_drivers(driver_t *driver[]);
+
+extern const char *gDriverName;
+driver_t *__haiku_select_miibus_driver(device_t dev);
+driver_t *__haiku_probe_miibus(device_t dev, driver_t *drivers[]);
+status_t __haiku_handle_fbsd_drivers_list(status_t (*handler)(driver_t *[]));
+
+status_t init_wlan_stack(void);
+void uninit_wlan_stack(void);
+status_t start_wlan(device_t);
+status_t stop_wlan(device_t);
+status_t wlan_control(void*, uint32, void*, size_t);
+status_t wlan_close(void*);
+status_t wlan_if_l2com_alloc(void*);
+
+/* we define the driver methods with HAIKU_FBSD_DRIVERS_GLUE to
+ * force the rest of the stuff to be linked back with the driver.
+ * While gcc 2.95 packs everything from the static library onto
+ * the final binary, gcc 4.x rightfuly doesn't. */
+
+#define HAIKU_FBSD_DRIVERS_GLUE(publicname)                             \
+    extern const char *gDeviceNameList[];                               \
+    extern device_hooks gDeviceHooks;                                   \
+    const char *gDriverName = #publicname;                              \
+    int32 api_version = B_CUR_DRIVER_API_VERSION;                       \
+    status_t init_hardware()                                            \
+    {                                                                   \
+        return __haiku_handle_fbsd_drivers_list(_fbsd_init_hardware);   \
+    }                                                                   \
+    status_t init_driver()                                              \
+    {                                                                   \
+        return __haiku_handle_fbsd_drivers_list(_fbsd_init_drivers);    \
+    }                                                                   \
+    void uninit_driver()                                                \
+    {                                                                   \
+        __haiku_handle_fbsd_drivers_list(_fbsd_uninit_drivers);         \
+    }                                                                   \
+    const char **publish_devices()                                      \
+        { return gDeviceNameList; }                                     \
+    device_hooks *find_device(const char *name)                         \
+        { return &gDeviceHooks; }                                       \
+    status_t init_wlan_stack(void)                                      \
+        { return B_OK; }                                                \
+    void uninit_wlan_stack(void) {}                                     \
+    status_t start_wlan(device_t dev)                                   \
+        { return B_OK; }                                                \
+    status_t stop_wlan(device_t dev)                                    \
+        { return B_OK; }                                                \
+    status_t wlan_control(void *cookie, uint32 op, void *arg,           \
+        size_t length)                                                  \
+        { return B_BAD_VALUE; }                                         \
+    status_t wlan_close(void* cookie)                                   \
+        { return B_OK; }                                                \
+    status_t wlan_if_l2com_alloc(void* ifp)                             \
+        { return B_OK; }
+
+#define HAIKU_FBSD_DRIVER_GLUE(publicname, name, busname)               \
+    extern driver_t *DRIVER_MODULE_NAME(name, busname);                 \
+    status_t __haiku_handle_fbsd_drivers_list(status_t (*proc)(driver_t *[])) {\
+        driver_t *drivers[] = {                                         \
+            DRIVER_MODULE_NAME(name, busname),                          \
+            NULL                                                        \
+        };                                                              \
+        return (*proc)(drivers);                                        \
+    }                                                                   \
+    HAIKU_FBSD_DRIVERS_GLUE(publicname);
+
+#define HAIKU_FBSD_WLAN_DRIVERS_GLUE(publicname)                        \
+    extern const char *gDeviceNameList[];                               \
+    extern device_hooks gDeviceHooks;                                   \
+    const char *gDriverName = #publicname;                              \
+    int32 api_version = B_CUR_DRIVER_API_VERSION;                       \
+    status_t init_hardware()                                            \
+    {                                                                   \
+        return __haiku_handle_fbsd_drivers_list(_fbsd_init_hardware);   \
+    }                                                                   \
+    status_t init_driver()                                              \
+    {                                                                   \
+        return __haiku_handle_fbsd_drivers_list(_fbsd_init_drivers);    \
+    }                                                                   \
+    void uninit_driver()                                                \
+    {                                                                   \
+        __haiku_handle_fbsd_drivers_list(_fbsd_uninit_drivers);         \
+    }                                                                   \
+    const char **publish_devices()                                      \
+        { return gDeviceNameList; }                                     \
+    device_hooks *find_device(const char *name)                         \
+        { return &gDeviceHooks; }
+
+#define HAIKU_FBSD_WLAN_DRIVER_GLUE(publicname, name, busname)          \
+    extern driver_t *DRIVER_MODULE_NAME(name, busname);                 \
+    status_t __haiku_handle_fbsd_drivers_list(status_t (*proc)(driver_t *[])) {\
+        driver_t *drivers[] = {                                         \
+            DRIVER_MODULE_NAME(name, busname),                          \
+            NULL                                                        \
+        };                                                              \
+        return (*proc)(drivers);                                        \
+    }                                                                   \
+    HAIKU_FBSD_WLAN_DRIVERS_GLUE(publicname);
+
+#define HAIKU_FBSD_RETURN_MII_DRIVER(drivers)                   \
+    driver_t *__haiku_select_miibus_driver(device_t dev)        \
+    {                                                           \
+        return __haiku_probe_miibus(dev, drivers);              \
+    }
+
+#define HAIKU_FBSD_MII_DRIVER(name)                             \
+    extern driver_t *DRIVER_MODULE_NAME(name, miibus);          \
+    driver_t *__haiku_select_miibus_driver(device_t dev)        \
+    {                                                           \
+        driver_t *drivers[] = {                                 \
+            DRIVER_MODULE_NAME(name, miibus),                   \
+            NULL                                                \
+        };                                                      \
+        return __haiku_probe_miibus(dev, drivers);              \
+    }
+
+#define NO_HAIKU_FBSD_MII_DRIVER()                              \
+    HAIKU_FBSD_RETURN_MII_DRIVER(NULL)
+
+extern spinlock __haiku_intr_spinlock;
+extern int __haiku_disable_interrupts(device_t dev);
+extern void __haiku_reenable_interrupts(device_t dev);
+
+#define HAIKU_CHECK_DISABLE_INTERRUPTS      __haiku_disable_interrupts
+#define HAIKU_REENABLE_INTERRUPTS           __haiku_reenable_interrupts
+
+#define NO_HAIKU_CHECK_DISABLE_INTERRUPTS()             \
+    int HAIKU_CHECK_DISABLE_INTERRUPTS(device_t dev) {  \
+        panic("should never be called.");               \
+        return -1; \
+    }
+
+#define NO_HAIKU_REENABLE_INTERRUPTS() \
+    void HAIKU_REENABLE_INTERRUPTS(device_t dev) {}
+
+extern int __haiku_driver_requirements;
+
+enum {
+    FBSD_TASKQUEUES     = 1 << 0,
+    FBSD_FAST_TASKQUEUE = 1 << 1,
+    FBSD_SWI_TASKQUEUE  = 1 << 2,
+    FBSD_WLAN           = 1 << 3,
+};
+
+#define HAIKU_DRIVER_REQUIREMENTS(flags) \
+    int __haiku_driver_requirements = (flags)
+
+#define HAIKU_DRIVER_REQUIRES(flag) (__haiku_driver_requirements & (flag))
+
+
+/* #pragma mark - firmware loading */
+
+
+/*
+ * Only needed to be specified in the glue code of drivers which actually need
+ * to load firmware. See iprowifi2100 for an example.
+ */
+
+extern const uint __haiku_firmware_version;
+
+/* Use 0 if driver doesn't care about firmware version. */
+#define HAIKU_FIRMWARE_VERSION(version) \
+    const uint __haiku_firmware_version = (version)
+
+extern const uint __haiku_firmware_parts_count;
+extern const char* __haiku_firmware_name_map[][2];
+
+#define HAIKU_FIRMWARE_NAME_MAP(firmwarePartsCount) \
+    const uint __haiku_firmware_parts_count = firmwarePartsCount; \
+    const char* __haiku_firmware_name_map[firmwarePartsCount][2]
+
+#define NO_HAIKU_FIRMWARE_NAME_MAP() \
+    const uint __haiku_firmware_parts_count = 0; \
+    const char* __haiku_firmware_name_map[0][2] = {}
+
+
+/* #pragma mark - synchronization */
+
+
+#define HAIKU_INTR_REGISTER_STATE \
+    cpu_status __haiku_cpu_state = 0
+
+#define HAIKU_INTR_REGISTER_ENTER() do {        \
+    __haiku_cpu_state = disable_interrupts();   \
+    acquire_spinlock(&__haiku_intr_spinlock);   \
+} while (0)
+
+#define HAIKU_INTR_REGISTER_LEAVE() do {        \
+    release_spinlock(&__haiku_intr_spinlock);   \
+    restore_interrupts(__haiku_cpu_state);      \
+} while (0)
+
+#define HAIKU_PROTECT_INTR_REGISTER(x) do {     \
+    HAIKU_INTR_REGISTER_STATE;                  \
+    HAIKU_INTR_REGISTER_ENTER();                \
+    x;                                          \
+    HAIKU_INTR_REGISTER_LEAVE();                \
+} while (0)
+
+#define DEFINE_CLASS_0(name, driver, methods, size) \
+    driver_t driver = { #name, methods, size }
+
+#define DRIVER_MODULE(name, busname, driver, devclass, evh, arg) \
+    driver_t *DRIVER_MODULE_NAME(name, busname) = &(driver); \
+    devclass_t *__class_ ## name ## _ ## busname ## _ ## devclass = &(devclass)
+
+#define DRIVER_MODULE_ORDERED(name, busname, driver, devclass, evh, arg, order) \
+    DRIVER_MODULE(name, busname, driver, devclass, evh, arg)
+
+#define nitems(_a)     (sizeof((_a)) / sizeof((_a)[0]))
+
+#endif  /* _FBSD_COMPAT_SYS_HAIKU_MODULE_H_ */

headers/compatibility/bsd/sys/ioccom.h

@@ -86 +86 @@
 
 
 #endif /* _SYS_IOCCOM_H */
+

new file headers/compatibility/bsd/sys/kernel.h

@@ +1 @@
+/*
+ * Copyright 2007-2009 Haiku Inc. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef _FBSD_COMPAT_SYS_KERNEL_H_
+#define _FBSD_COMPAT_SYS_KERNEL_H_
+
+
+#include <stddef.h>
+
+#include <sys/haiku-module.h>
+
+#include <sys/linker_set.h>
+#include <sys/queue.h>
+
+
+/*
+ *
+ * The rate at which FreeBSD can generate callouts (kind of timeout mechanism).
+ * For FreeBSD 8 this is typically 1000 times per second (100 for ARM).
+ * This value is defined in a file called subr_param.c
+ *
+ * WHile Haiku can have a much higher granularity, it is not a good idea to have
+ * this since FreeBSD tries to do certain tasks based on ticks, for instance
+ * autonegotiation and wlan scanning.
+ * Suffixing LL prevents integer overflows during calculations.
+ * as it defines a long long constant.*/
+#define hz  1000LL
+
+#define ticks_to_usecs(t) (1000000*((bigtime_t)t) / hz)
+
+typedef void (*system_init_func_t)(void *);
+
+
+struct __system_init {
+    system_init_func_t func;
+};
+
+/* TODO implement SYSINIT/SYSUNINIT subsystem */
+#define SYSINIT(uniquifier, subsystem, order, func, ident) \
+    struct __system_init __init_##uniquifier = { (system_init_func_t) func }
+
+#define SYSUNINIT(uniquifier, subsystem, order, func, ident) \
+    struct __system_init __uninit_##uniquifier = { (system_init_func_t) func }
+
+#define TUNABLE_INT(path, var)
+#define TUNABLE_INT_FETCH(path, var)
+
+extern int ticks;
+
+#endif

new file headers/compatibility/bsd/sys/ktr.h

@@ +1 @@
+/*-
+ * Copyright (c) 1996 Berkeley Software Design, Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Berkeley Software Design Inc's name may not be used to endorse or
+ *    promote products derived from this software without specific prior
+ *    written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY BERKELEY SOFTWARE DESIGN INC ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL BERKELEY SOFTWARE DESIGN INC BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *  from BSDI $Id: ktr.h,v 1.10.2.7 2000/03/16 21:44:42 cp Exp $
+ * $FreeBSD: src/sys/sys/ktr.h,v 1.32.2.2 2006/01/23 14:56:33 marius Exp $
+ */
+
+/*
+ *  Wraparound kernel trace buffer support.
+ */
+#ifndef _SYS_KTR_H_
+#define _SYS_KTR_H_
+
+/*
+ * Trace classes
+ */
+#define KTR_GEN     0x00000001      /* General (TR) */
+#define KTR_NET     0x00000002      /* Network */
+#define KTR_DEV     0x00000004      /* Device driver */
+#define KTR_LOCK    0x00000008      /* MP locking */
+#define KTR_SMP     0x00000010      /* MP general */
+#define KTR_FS      0x00000020      /* Filesystem */
+#define KTR_PMAP    0x00000040      /* Pmap tracing */
+#define KTR_MALLOC  0x00000080      /* Malloc tracing */
+#define KTR_TRAP    0x00000100      /* Trap processing */
+#define KTR_INTR    0x00000200      /* Interrupt tracing */
+#define KTR_SIG     0x00000400      /* Signal processing */
+#define KTR_CLK     0x00000800      /* hardclock verbose */
+#define KTR_PROC    0x00001000      /* Process scheduling */
+#define KTR_SYSC    0x00002000      /* System call */
+#define KTR_INIT    0x00004000      /* System initialization */
+#define KTR_KGDB    0x00008000      /* Trace kgdb internals */
+#define KTR_IO      0x00010000      /* Upper I/O  */
+#define KTR_EVH     0x00020000      /* Eventhandler */
+#define KTR_VFS     0x00040000      /* VFS events */
+#define KTR_VOP     0x00080000      /* Auto-generated vop events */
+#define KTR_VM      0x00100000      /* The virtual memory system */
+#define KTR_WITNESS 0x00200000
+#define KTR_RUNQ    0x00400000      /* Run queue */
+#define KTR_CONTENTION  0x00800000      /* Lock contention */
+#define KTR_UMA     0x01000000      /* UMA slab allocator */
+#define KTR_CALLOUT 0x02000000      /* Callouts and timeouts */
+#define KTR_GEOM    0x04000000      /* GEOM I/O events */
+#define KTR_BUSDMA  0x08000000      /* busdma(9) events */
+#define KTR_CRITICAL    0x10000000      /* Critical sections */
+#define KTR_SCHED   0x20000000      /* Machine parsed sched info. */
+#define KTR_BUF     0x40000000      /* Buffer cache */
+#define KTR_ALL     0x7fffffff
+
+/*
+ * Trace classes which can be assigned to particular use at compile time
+ * These must remain in high 22 as some assembly code counts on it
+ */
+#define KTR_CT1     0x01000000
+#define KTR_CT2     0x02000000
+#define KTR_CT3     0x04000000
+#define KTR_CT4     0x08000000
+#define KTR_CT5     0x10000000
+#define KTR_CT6     0x20000000
+#define KTR_CT7     0x40000000
+#define KTR_CT8     0x80000000
+
+/* Trace classes to compile in */
+#ifdef KTR
+#ifndef KTR_COMPILE
+#define KTR_COMPILE (KTR_ALL)
+#endif
+#else   /* !KTR */
+#undef KTR_COMPILE
+#define KTR_COMPILE 0
+#endif  /* KTR */
+
+/* Trace classes that can not be used with KTR_ALQ */
+#define KTR_ALQ_MASK    (KTR_WITNESS)
+
+/*
+ * Version number for ktr_entry struct.  Increment this when you break binary
+ * compatibility.
+ */
+#define KTR_VERSION 2
+
+#define KTR_PARMS   6
+
+#ifndef LOCORE
+
+struct ktr_entry {
+    u_int64_t ktr_timestamp;
+    int ktr_cpu;
+    int ktr_line;
+    const   char *ktr_file;
+    const   char *ktr_desc;
+    struct  thread *ktr_thread;
+    u_long  ktr_parms[KTR_PARMS];
+};
+
+extern int ktr_cpumask;
+extern int ktr_mask;
+extern int ktr_entries;
+extern int ktr_verbose;
+
+extern volatile int ktr_idx;
+extern struct ktr_entry ktr_buf[];
+
+#ifdef KTR
+
+#if 0
+void    ktr_tracepoint(u_int mask, const char *file, int line,
+        const char *format, u_long arg1, u_long arg2, u_long arg3,
+        u_long arg4, u_long arg5, u_long arg6);
+#else
+extern void driver_printf(const char *format, ...);
+#define ktr_tracepoint(mask, file, line, format, arg1, arg2, arg3, arg4, arg5, arg6) \
+    driver_printf("(%s:%i) " format "\n", file, line, arg1, arg2, arg3, arg4, arg5, arg6)
+#endif
+
+#define CTR6(m, format, p1, p2, p3, p4, p5, p6) do {            \
+    if (KTR_COMPILE & (m))                      \
+        ktr_tracepoint((m), __FILE__, __LINE__, format,     \
+            (u_long)(p1), (u_long)(p2), (u_long)(p3),       \
+            (u_long)(p4), (u_long)(p5), (u_long)(p6));      \
+    } while(0)
+#define CTR0(m, format)         CTR6(m, format, 0, 0, 0, 0, 0, 0)
+#define CTR1(m, format, p1)     CTR6(m, format, p1, 0, 0, 0, 0, 0)
+#define CTR2(m, format, p1, p2)     CTR6(m, format, p1, p2, 0, 0, 0, 0)
+#define CTR3(m, format, p1, p2, p3) CTR6(m, format, p1, p2, p3, 0, 0, 0)
+#define CTR4(m, format, p1, p2, p3, p4) CTR6(m, format, p1, p2, p3, p4, 0, 0)
+#define CTR5(m, format, p1, p2, p3, p4, p5) CTR6(m, format, p1, p2, p3, p4, p5, 0)
+#else   /* KTR */
+#define CTR0(m, d)
+#define CTR1(m, d, p1)
+#define CTR2(m, d, p1, p2)
+#define CTR3(m, d, p1, p2, p3)
+#define CTR4(m, d, p1, p2, p3, p4)
+#define CTR5(m, d, p1, p2, p3, p4, p5)
+#define CTR6(m, d, p1, p2, p3, p4, p5, p6)
+#endif  /* KTR */
+
+#define TR0(d)              CTR0(KTR_GEN, d)
+#define TR1(d, p1)          CTR1(KTR_GEN, d, p1)
+#define TR2(d, p1, p2)          CTR2(KTR_GEN, d, p1, p2)
+#define TR3(d, p1, p2, p3)      CTR3(KTR_GEN, d, p1, p2, p3)
+#define TR4(d, p1, p2, p3, p4)      CTR4(KTR_GEN, d, p1, p2, p3, p4)
+#define TR5(d, p1, p2, p3, p4, p5)  CTR5(KTR_GEN, d, p1, p2, p3, p4, p5)
+#define TR6(d, p1, p2, p3, p4, p5, p6)  CTR6(KTR_GEN, d, p1, p2, p3, p4, p5, p6)
+
+/*
+ * Trace initialization events, similar to CTR with KTR_INIT, but
+ * completely ifdef'ed out if KTR_INIT isn't in KTR_COMPILE (to
+ * save string space, the compiler doesn't optimize out strings
+ * for the conditional ones above).
+ */
+#if (KTR_COMPILE & KTR_INIT) != 0
+#define ITR0(d)             CTR0(KTR_INIT, d)
+#define ITR1(d, p1)         CTR1(KTR_INIT, d, p1)
+#define ITR2(d, p1, p2)         CTR2(KTR_INIT, d, p1, p2)
+#define ITR3(d, p1, p2, p3)     CTR3(KTR_INIT, d, p1, p2, p3)
+#define ITR4(d, p1, p2, p3, p4)     CTR4(KTR_INIT, d, p1, p2, p3, p4)
+#define ITR5(d, p1, p2, p3, p4, p5) CTR5(KTR_INIT, d, p1, p2, p3, p4, p5)
+#define ITR6(d, p1, p2, p3, p4, p5, p6) CTR6(KTR_INIT, d, p1, p2, p3, p4, p5, p6)
+#else
+#define ITR0(d)
+#define ITR1(d, p1)
+#define ITR2(d, p1, p2)
+#define ITR3(d, p1, p2, p3)
+#define ITR4(d, p1, p2, p3, p4)
+#define ITR5(d, p1, p2, p3, p4, p5)
+#define ITR6(d, p1, p2, p3, p4, p5, p6)
+#endif
+
+#endif /* !LOCORE */
+
+#endif /* !_SYS_KTR_H_ */

new file headers/compatibility/bsd/sys/libkern.h

@@ +1 @@
+/*
+ * Copyright 2009, Colin Günther, coling@gmx.de.
+ * All rights reserved. Distributed under the terms of the MIT License.
+ */
+#ifndef _FBSD_COMPAT_SYS_LIBKERN_H_
+#define _FBSD_COMPAT_SYS_LIBKERN_H_
+
+
+#include <sys/cdefs.h>
+#include <sys/types.h>
+
+
+extern int random(void);
+uint32_t arc4random(void);
+
+static __inline int imax(int a, int b) { return (a > b ? a : b); }
+
+extern int abs(int a);
+
+#endif /* _FBSD_COMPAT_SYS_LIBKERN_H_ */

new file headers/compatibility/bsd/sys/limits.h

@@ +1 @@
+/*
+ * Copyright 2009 Haiku Inc. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef _FBSD_COMPAT_SYS_LIMITS_H_
+#define _FBSD_COMPAT_SYS_LIMITS_H_
+
+
+#endif /* _FBSD_COMPAT_SYS_LIMITS_H_ */

new file headers/compatibility/bsd/sys/linker.h

@@ +1 @@
+/*
+ * Copyright 2009 Haiku Inc. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef _FBSD_COMPAT_SYS_LINKER_H_
+#define _FBSD_COMPAT_SYS_LINKER_H_
+
+
+#endif /* _FBSD_COMPAT_SYS_LINKER_H_ */

new file headers/compatibility/bsd/sys/linker_set.h

@@ +1 @@
+/*
+ * Copyright 2009 Haiku Inc. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef _FBSD_COMPAT_SYS_LINKER_SET_H_
+#define _FBSD_COMPAT_SYS_LINKER_SET_H_
+
+
+#ifndef _FBSD_COMPAT_SYS_CDEFS_H_
+#error this file needs sys/cdefs.h as a prerequisite
+#endif
+
+/*
+ * The following macros are used to declare global sets of objects, which
+ * are collected by the linker into a `linker_set' as defined below.
+ * For ELF, this is done by constructing a separate segment for each set.
+ */
+
+/*
+ * Private macros, not to be used outside this header file.
+ */
+#ifdef __GNUCLIKE___SECTION
+#define __MAKE_SET(set, sym)                        \
+    static void const * const __set_##set##_sym_##sym       \
+    __section("set_" #set) __used = &sym
+#else /* !__GNUCLIKE___SECTION */
+#ifndef lint
+#error this file needs to be ported to your compiler
+#endif /* lint */
+#define __MAKE_SET(set, sym)    extern void const * const (__set_##set##_sym_##sym)
+#endif /* __GNUCLIKE___SECTION */
+
+/*
+ * Public macros.
+ */
+#define TEXT_SET(set, sym)  __MAKE_SET(set, sym)
+#define DATA_SET(set, sym)  __MAKE_SET(set, sym)
+#define BSS_SET(set, sym)   __MAKE_SET(set, sym)
+#define ABS_SET(set, sym)   __MAKE_SET(set, sym)
+#define SET_ENTRY(set, sym) __MAKE_SET(set, sym)
+
+/*
+ * Initialize before referring to a given linker set.
+ */
+#define SET_DECLARE(set, ptype)                     \
+    extern ptype *__CONCAT(__start_set_,set);           \
+    extern ptype *__CONCAT(__stop_set_,set)
+
+#define SET_BEGIN(set)                          \
+    (&__CONCAT(__start_set_,set))
+#define SET_LIMIT(set)                          \
+    (&__CONCAT(__stop_set_,set))
+
+/*
+ * Iterate over all the elements of a set.
+ *
+ * Sets always contain addresses of things, and "pvar" points to words
+ * containing those addresses.  Thus is must be declared as "type **pvar",
+ * and the address of each set item is obtained inside the loop by "*pvar".
+ */
+#define SET_FOREACH(pvar, set)                      \
+    for (pvar = SET_BEGIN(set); pvar < SET_LIMIT(set); pvar++)
+
+#endif /* _FBSD_COMPAT_SYS_LINKER_SET_H_ */

new file headers/compatibility/bsd/sys/malloc.h

@@ +1 @@
+/*
+ * Copyright 2009, Colin Günther, coling@gmx.de.
+ * Copyright 2007, Hugo Santos. All Rights Reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef _FBSD_COMPAT_SYS_MALLOC_H_
+#define _FBSD_COMPAT_SYS_MALLOC_H_
+
+
+#include <malloc.h>
+
+#include <vm/vm.h>
+
+#include <sys/param.h>
+#include <sys/queue.h>
+#include <sys/_mutex.h>
+
+
+/*
+ * flags to malloc.
+ */
+#define M_NOWAIT        0x0001
+#define M_WAITOK        0x0002
+#define M_ZERO          0x0100
+
+#define M_MAGIC         877983977   /* time when first defined :-) */
+
+#define M_DEVBUF
+
+
+void *_kernel_malloc(size_t size, int flags);
+void _kernel_free(void *ptr);
+
+void *_kernel_contigmalloc(const char *file, int line, size_t size, int flags,
+    vm_paddr_t low, vm_paddr_t high, unsigned long alignment,
+    unsigned long boundary);
+void _kernel_contigfree(void *addr, unsigned long size);
+
+#define kernel_malloc(size, base, flags) \
+    _kernel_malloc(size, flags)
+
+#define kernel_free(ptr, base) \
+    _kernel_free(ptr)
+
+#define kernel_contigmalloc(size, type, flags, low, high, alignment, boundary) \
+    _kernel_contigmalloc(__FILE__, __LINE__, size, flags, low, high, \
+        alignment, boundary)
+
+#define kernel_contigfree(addr, size, base) \
+    _kernel_contigfree(addr, size)
+
+#ifdef FBSD_DRIVER
+#   define malloc(size, tag, flags) kernel_malloc(size, tag, flags)
+#   define free(pointer, tag)       kernel_free(pointer, tag)
+#   define contigmalloc(size, type, flags, low, high, alignment, boundary) \
+        _kernel_contigmalloc(__FILE__, __LINE__, size, flags, low, high, \
+            alignment, boundary)
+#   define contigfree(addr, size, base) \
+        _kernel_contigfree(addr, size)
+#endif
+
+#define MALLOC_DEFINE(type, shortdesc, longdesc)    int type[1]
+
+#define MALLOC_DECLARE(type) \
+        extern int type[1]
+
+#endif  /* _FBSD_COMPAT_SYS_MALLOC_H_ */

new file headers/compatibility/bsd/sys/mbuf-fbsd.h

@@ +1 @@
+/*-
+ * Copyright (c) 1982, 1986, 1988, 1993
+ *  The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *  @(#)mbuf.h  8.5 (Berkeley) 2/19/95
+ * $FreeBSD: src/sys/sys/mbuf.h,v 1.170.2.6 2006/03/23 23:24:32 sam Exp $
+ */
+#ifndef _FBSD_COMPAT_SYS_MBUF_FBSD_H_
+#define _FBSD_COMPAT_SYS_MBUF_FBSD_H_
+
+/*
+ * Set the m_data pointer of a newly-allocated mbuf (m_get/MGET) to place
+ * an object of the specified size at the end of the mbuf, longword aligned.
+ */
+#define M_ALIGN(m, len) do {                        \
+    (m)->m_data += (MLEN - (len)) & ~(sizeof(long) - 1);        \
+} while (0)
+
+/*
+ * As above, for mbufs allocated with m_gethdr/MGETHDR
+ * or initialized by M_COPY_PKTHDR.
+ */
+#define MH_ALIGN(m, len) do {                       \
+    (m)->m_data += (MHLEN - (len)) & ~(sizeof(long) - 1);       \
+} while (0)
+
+/*
+#define MEXT_IS_REF(m)  (((m)->m_ext.ref_cnt != NULL)           \
+    && (*((m)->m_ext.ref_cnt) > 1))
+ */
+#define MEXT_IS_REF(m)  0
+
+/*
+ * Evaluate TRUE if it's safe to write to the mbuf m's data region (this
+ * can be both the local data payload, or an external buffer area,
+ * depending on whether M_EXT is set).
+ */
+
+/*
+#define M_WRITABLE(m)   (!((m)->m_flags & M_RDONLY) && (!((m)->m_flags  \
+                & M_EXT) || !MEXT_IS_REF(m)))
+ */
+#define M_WRITABLE(m)   (!((m)->m_flags & M_EXT) || !MEXT_IS_REF(m))
+
+/*
+ * Compute the amount of space available
+ * before the current start of data in an mbuf.
+ *
+ * The M_WRITABLE() is a temporary, conservative safety measure: the burden
+ * of checking writability of the mbuf data area rests solely with the caller.
+ */
+#define M_LEADINGSPACE(m)                       \
+    ((m)->m_flags & M_EXT ?                     \
+        (M_WRITABLE(m) ? (m)->m_data - (m)->m_ext.ext_buf : 0): \
+        (m)->m_flags & M_PKTHDR ? (m)->m_data - (m)->m_pktdat : \
+        (m)->m_data - (m)->m_dat)
+
+/*
+ * Compute the amount of space available after the end of data in an mbuf.
+ *
+ * The M_WRITABLE() is a temporary, conservative safety measure: the burden
+ * of checking writability of the mbuf data area rests solely with the caller.
+ */
+#define M_TRAILINGSPACE(m)                      \
+    ((m)->m_flags & M_EXT ?                     \
+        (M_WRITABLE(m) ? (m)->m_ext.ext_buf + (m)->m_ext.ext_size   \
+        - ((m)->m_data + (m)->m_len) : 0) :         \
+        &(m)->m_dat[MLEN] - ((m)->m_data + (m)->m_len))
+
+/*
+ * Arrange to prepend space of size plen to mbuf m.
+ * If a new mbuf must be allocated, how specifies whether to wait.
+ * If the allocation fails, the original mbuf chain is freed and m is
+ * set to NULL.
+ */
+#define M_PREPEND(m, plen, how) do {                    \
+    struct mbuf **_mmp = &(m);                  \
+    struct mbuf *_mm = *_mmp;                   \
+    int _mplen = (plen);                        \
+    int __mhow = (how);                     \
+                                    \
+    MBUF_CHECKSLEEP(how);                       \
+    if (M_LEADINGSPACE(_mm) >= _mplen) {                \
+        _mm->m_data -= _mplen;                  \
+        _mm->m_len += _mplen;                   \
+    } else                              \
+        _mm = m_prepend(_mm, _mplen, __mhow);           \
+    if (_mm != NULL && _mm->m_flags & M_PKTHDR)         \
+        _mm->m_pkthdr.len += _mplen;                \
+    *_mmp = _mm;                            \
+} while (0)
+
+#endif

new file headers/compatibility/bsd/sys/mbuf.h

@@ +1 @@
+/*
+ * Copyright 2009, Colin Günther, coling@gmx.de.
+ * Copyright 2007, Hugo Santos. All Rights Reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef _FBSD_COMPAT_SYS_MBUF_H_
+#define _FBSD_COMPAT_SYS_MBUF_H_
+
+
+#include <sys/queue.h>
+#include <sys/systm.h>
+#include <vm/uma.h>
+
+
+#define MLEN        ((int)(MSIZE - sizeof(struct m_hdr)))
+#define MHLEN       ((int)(MLEN - sizeof(struct pkthdr)))
+
+#define MINCLSIZE   (MHLEN + 1)
+
+#define MBTOM(how)  (how)
+#define M_DONTWAIT  M_NOWAIT
+#define M_TRYWAIT   M_WAITOK
+#define M_WAIT      M_WAITOK
+
+#define MT_DATA     1
+
+#define M_EXT       0x00000001
+#define M_PKTHDR    0x00000002
+#define M_RDONLY    0x00000008
+#define M_PROTO1    0x00000010
+#define M_PROTO2    0x00000020
+#define M_PROTO3    0x00000040
+#define M_PROTO4    0x00000080
+#define M_PROTO5    0x00000100
+#define M_BCAST     0x00000200
+#define M_MCAST     0x00000400
+#define M_FRAG      0x00000800
+#define M_FIRSTFRAG 0x00001000
+#define M_LASTFRAG  0x00002000
+#define M_VLANTAG   0x00010000
+#define M_PROTO6    0x00080000
+#define M_PROTO7    0x00100000
+#define M_PROTO8    0x00200000
+
+#define M_COPYFLAGS (M_PKTHDR | M_RDONLY | M_BCAST | M_MCAST | M_FRAG \
+    | M_FIRSTFRAG | M_LASTFRAG | M_VLANTAG)
+    // Flags preserved when copying m_pkthdr
+
+#define M_MOVE_PKTHDR(to, from) m_move_pkthdr((to), (from))
+#define MGET(m, how, type)      ((m) = m_get((how), (type)))
+#define MGETHDR(m, how, type)   ((m) = m_gethdr((how), (type)))
+#define MCLGET(m, how)          m_clget((m), (how))
+
+#define mtod(m, type)   ((type)((m)->m_data))
+
+// Check if the supplied mbuf has a packet header, or else panic.
+#define M_ASSERTPKTHDR(m) KASSERT(m != NULL && m->m_flags & M_PKTHDR, \
+    ("%s: no mbuf packet header!", __func__))
+
+#define MBUF_CHECKSLEEP(how) do { } while (0)
+
+#define MTAG_PERSISTENT 0x800
+
+#define EXT_CLUSTER     1       // 2048 bytes
+#define EXT_JUMBOP      4       // Page size
+#define EXT_JUMBO9      5       // 9 * 1024 bytes
+#define EXT_NET_DRV     100     // custom ext_buf provided by net driver
+
+#define CSUM_IP         0x0001
+#define CSUM_TCP        0x0002
+#define CSUM_UDP        0x0004
+#define CSUM_TSO        0x0020
+#define CSUM_IP_CHECKED 0x0100
+#define CSUM_IP_VALID   0x0200
+#define CSUM_DATA_VALID 0x0400
+#define CSUM_PSEUDO_HDR 0x0800
+#define CSUM_DELAY_DATA (CSUM_TCP | CSUM_UDP)
+
+// TODO After all network driver are updated to the FreeBSD 8 version this can
+// changed
+#if __FreeBSD_version__ >= 8
+#define MEXTADD(m, buf, size, free, arg1, arg2, flags, type) \
+    m_extadd((m), (caddr_t)(buf), (size), (free),(arg1),(arg2),(flags), (type))
+#else
+#define MEXTADD(m, buf, size, free, args, flags, type) \
+    m_extadd((m), (caddr_t)(buf), (size), (free),(args),(flags), (type))
+#endif
+
+
+extern int max_linkhdr;
+extern int max_protohdr;
+extern int max_hdr;
+extern int max_datalen;     // MHLEN - max_hdr
+
+
+struct m_hdr {
+    struct mbuf*    mh_next;
+    struct mbuf*    mh_nextpkt;
+    caddr_t         mh_data;
+    int             mh_len;
+    int             mh_flags;
+    short           mh_type;
+};
+
+struct pkthdr {
+    struct ifnet*                   rcvif;
+    int                             len;
+    int                             csum_flags;
+    int                             csum_data;
+    uint16_t                        tso_segsz;
+    uint16_t                        ether_vtag;
+    SLIST_HEAD(packet_tags, m_tag)  tags;
+};
+
+struct m_tag {
+    SLIST_ENTRY(m_tag)  m_tag_link;     // List of packet tags
+    u_int16_t           m_tag_id;       // Tag ID
+    u_int16_t           m_tag_len;      // Length of data
+    u_int32_t           m_tag_cookie;   // ABI/Module ID
+    void                (*m_tag_free)(struct m_tag*);
+};
+
+struct m_ext {
+    caddr_t         ext_buf;
+    unsigned int    ext_size;
+    int             ext_type;
+};
+
+struct mbuf {
+    struct m_hdr m_hdr;
+    union {
+        struct {
+            struct pkthdr   MH_pkthdr;
+            union {
+                struct m_ext    MH_ext;
+                char            MH_databuf[MHLEN];
+            } MH_dat;
+        } MH;
+        char M_databuf[MLEN];
+    } M_dat;
+};
+
+
+#define m_next      m_hdr.mh_next
+#define m_len       m_hdr.mh_len
+#define m_data      m_hdr.mh_data
+#define m_type      m_hdr.mh_type
+#define m_flags     m_hdr.mh_flags
+#define m_nextpkt   m_hdr.mh_nextpkt
+#define m_act       m_nextpkt
+#define m_pkthdr    M_dat.MH.MH_pkthdr
+#define m_ext       M_dat.MH.MH_dat.MH_ext
+#define m_pktdat    M_dat.MH.MH_dat.MH_databuf
+#define m_dat       M_dat.M_databuf
+
+
+void            m_adj(struct mbuf*, int);
+void            m_align(struct mbuf*, int);
+int             m_append(struct mbuf*, int, c_caddr_t);
+void            m_cat(struct mbuf*, struct mbuf*);
+void            m_clget(struct mbuf*, int);
+void*           m_cljget(struct mbuf*, int, int);
+struct mbuf*    m_collapse(struct mbuf*, int, int);
+void            m_copyback(struct mbuf*, int, int, caddr_t);
+void            m_copydata(const struct mbuf*, int, int, caddr_t);
+struct mbuf*    m_copypacket(struct mbuf*, int);
+struct mbuf*    m_defrag(struct mbuf*, int);
+struct mbuf*    m_devget(char*, int, int, struct ifnet*,
+    void(*) (char*, caddr_t, u_int));
+
+struct mbuf*    m_dup(struct mbuf*, int);
+int             m_dup_pkthdr(struct mbuf*, struct mbuf*, int);
+
+// TODO After all network driver are updated to the FreeBSD 8 version this can
+// changed
+#if __FreeBSD_version__ >= 8
+void            m_extadd(struct mbuf*, caddr_t, u_int, void(*) (void*, void*),
+    void*, void*, int, int);
+#else
+void            m_extadd(struct mbuf*, caddr_t, u_int, void(*) (void*, void*),
+    void*, int, int);
+#endif
+
+u_int           m_fixhdr(struct mbuf*);
+struct mbuf*    m_free(struct mbuf*);
+void            m_freem(struct mbuf*);
+struct mbuf*    m_get(int, short);
+struct mbuf*    m_gethdr(int, short);
+struct mbuf*    m_getjcl(int, short, int, int);
+u_int           m_length(struct mbuf*, struct mbuf**);
+struct mbuf*    m_getcl(int, short, int);
+void            m_move_pkthdr(struct mbuf*, struct mbuf*);
+struct mbuf*    m_prepend(struct mbuf*, int, int);
+struct mbuf*    m_pulldown(struct mbuf*, int, int, int*);
+struct mbuf*    m_pullup(struct mbuf*, int);
+struct mbuf*    m_split(struct mbuf*, int, int);
+struct mbuf*    m_unshare(struct mbuf*, int);
+
+struct m_tag*   m_tag_alloc(u_int32_t, int, int, int);
+void            m_tag_delete(struct mbuf*, struct m_tag*);
+void            m_tag_delete_chain(struct mbuf*, struct m_tag*);
+void            m_tag_free_default(struct m_tag*);
+struct m_tag*   m_tag_locate(struct mbuf*, u_int32_t, int, struct m_tag*);
+struct m_tag*   m_tag_copy(struct m_tag*, int);
+int             m_tag_copy_chain(struct mbuf*, struct mbuf*, int);
+void            m_tag_delete_nonpersistent(struct mbuf*);
+
+
+static inline void
+m_tag_setup(struct m_tag* tagPointer, u_int32_t cookie, int type, int length)
+{
+    tagPointer->m_tag_id = type;
+    tagPointer->m_tag_len = length;
+    tagPointer->m_tag_cookie = cookie;
+}
+
+
+static inline void
+m_tag_free(struct m_tag* tag)
+{
+    (*tag->m_tag_free)(tag);
+}
+
+
+static inline void
+m_tag_prepend(struct mbuf* memoryBuffer, struct m_tag* tag)
+{
+    SLIST_INSERT_HEAD(&memoryBuffer->m_pkthdr.tags, tag, m_tag_link);
+}
+
+
+static inline void
+m_tag_unlink(struct mbuf* memoryBuffer, struct m_tag* tag)
+{
+    SLIST_REMOVE(&memoryBuffer->m_pkthdr.tags, tag, m_tag, m_tag_link);
+}
+
+
+#include <sys/mbuf-fbsd.h>
+
+#endif  /* _FBSD_COMPAT_SYS_MBUF_H_ */

new file headers/compatibility/bsd/sys/module.h

@@ +1 @@
+#ifndef _FBSD_COMPAT_SYS_MODULE_H_
+#define _FBSD_COMPAT_SYS_MODULE_H_
+
+
+#include <sys/linker_set.h>
+
+
+typedef struct module* module_t;
+
+typedef enum modeventtype {
+    MOD_LOAD,
+    MOD_UNLOAD,
+    MOD_SHUTDOWN,
+    MOD_QUIESCE
+} modeventtype_t;
+
+
+#define DECLARE_MODULE(name, data, sub, order)
+
+#define MODULE_VERSION(name, version)
+#define MODULE_DEPEND(module, mdepend, vmin, vpref, vmax)
+
+#endif

new file headers/compatibility/bsd/sys/mount.h

@@ +1 @@
+/*
+ * Copyright 2009 Haiku Inc. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef _FBSD_COMPAT_SYS_MOUNT_H_
+#define _FBSD_COMPAT_SYS_MOUNT_H_
+
+
+#endif /* _FBSD_COMPAT_SYS_MOUNT_H_ */

new file headers/compatibility/bsd/sys/mutex.h

@@ +1 @@
+/*
+ * Copyright 2009, Colin Günther, coling@gmx.de.
+ * Copyright 2007, Hugo Santos. All Rights Reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef _FBSD_COMPAT_SYS_MUTEX_H_
+#define _FBSD_COMPAT_SYS_MUTEX_H_
+
+
+#include <sys/haiku-module.h>
+
+#include <sys/queue.h>
+#include <sys/_mutex.h>
+#include <sys/pcpu.h>
+#include <machine/atomic.h>
+#include <machine/cpufunc.h>
+
+
+#define MA_OWNED        0x1
+#define MA_NOTOWNED     0x2
+#define MA_RECURSED     0x4
+#define MA_NOTRECURSED  0x8
+
+#define mtx_assert(mtx, what)
+
+#define MTX_DEF             0x0000
+#define MTX_RECURSE         0x0004
+#define MTX_QUIET           0x40000
+#define MTX_DUPOK           0x400000
+
+
+#define MTX_NETWORK_LOCK    "network driver"
+
+#define NET_LOCK_GIANT()
+#define NET_UNLOCK_GIANT()
+
+
+extern struct mtx Giant;
+
+
+void mtx_init(struct mtx*, const char*, const char*, int);
+void mtx_destroy(struct mtx*);
+
+
+static inline void
+mtx_lock(struct mtx* mutex)
+{
+    if (mutex->type == MTX_DEF) {
+        mutex_lock(&mutex->u.mutex.lock);
+        mutex->u.mutex.owner = find_thread(NULL);
+    } else if (mutex->type == MTX_RECURSE)
+        recursive_lock_lock(&mutex->u.recursive);
+}
+
+
+static inline void
+mtx_unlock(struct mtx* mutex)
+{
+    if (mutex->type == MTX_DEF) {
+        mutex->u.mutex.owner = -1;
+        mutex_unlock(&mutex->u.mutex.lock);
+    } else if (mutex->type == MTX_RECURSE)
+        recursive_lock_unlock(&mutex->u.recursive);
+}
+
+
+static inline int
+mtx_initialized(struct mtx* mutex)
+{
+    /* TODO */
+    return 1;
+}
+
+
+static inline int
+mtx_owned(struct mtx* mutex)
+{
+    if (mutex->type == MTX_DEF)
+        return mutex->u.mutex.owner == find_thread(NULL);
+    if (mutex->type == MTX_RECURSE) {
+#if KDEBUG
+        return mutex->u.recursive.lock.holder == find_thread(NULL);
+#else
+        return mutex->u.recursive.holder == find_thread(NULL);
+#endif
+    }
+
+    return 0;
+}
+
+
+#endif  /* _FBSD_COMPAT_SYS_MUTEX_H_ */

new file headers/compatibility/bsd/sys/namei.h

@@ +1 @@
+/*
+ * Copyright 2009 Haiku Inc. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef _FBSD_COMPAT_SYS_NAMEI_H_
+#define _FBSD_COMPAT_SYS_NAMEI_H_
+
+
+#endif /* _FBSD_COMPAT_SYS_NAMEI_H_ */

headers/compatibility/bsd/sys/param.h

@@ -1 +1 @@
 /*
- * Copyright 2006-2010 Haiku Inc. All Rights Reserved.
+<<<<<<< HEAD
+ * Copyright 2009, Colin Günther, coling@gmx.de.
+ * Copyright 2007, Hugo Santos. All Rights Reserved.
  * Distributed under the terms of the MIT License.
  */
-#ifndef _BSD_SYS_PARAM_H_
-#define _BSD_SYS_PARAM_H_
+#ifndef _FBSD_COMPAT_SYS_PARAM_H_
+#define _FBSD_COMPAT_SYS_PARAM_H_
 
 
-#include_next <sys/param.h>
+#include <posix/sys/param.h>
 
+#include <sys/types.h>
+#include <sys/cdefs.h>
+#include <sys/errno.h>
+#include <sys/time.h>
+#include <sys/priority.h>
+
+
+/* The version this compatibility layer is based on */
+#define __FreeBSD_version 800107
+
+#define MAXBSIZE    0x10000
+
+#define PAGE_SHIFT  12
+#define PAGE_MASK   (PAGE_SIZE - 1)
+
+#define trunc_page(x)   ((x) & ~PAGE_MASK)
+
+#define ptoa(x)         ((unsigned long)((x) << PAGE_SHIFT))
+#define atop(x)         ((unsigned long)((x) >> PAGE_SHIFT))
+
+/* MAJOR FIXME */
+#define Maxmem          (32768)
+
+#ifndef MSIZE
+#define MSIZE 256
+#endif
+
+#ifndef MCLSHIFT
+#define MCLSHIFT 11
+#endif
+
+#define MCLBYTES        (1 << MCLSHIFT)
+
+#define MJUMPAGESIZE    PAGE_SIZE
+#define MJUM9BYTES      (9 * 1024)
+#define MJUM16BYTES     (16 * 1024)
+
+#define ALIGN_BYTES     (sizeof(unsigned long) - 1)
+#define ALIGN(x)        ((((unsigned long)x) + ALIGN_BYTES) & ~ALIGN_BYTES)
+
+/* Macros for counting and rounding. */
+#ifndef howmany
+#define howmany(x, y)   (((x)+((y)-1))/(y))
+#endif
+#define roundup(x, y)   ((((x)+((y)-1))/(y))*(y))  /* to any y */
+#define roundup2(x, y)  (((x) + ((y) - 1)) & (~((y) - 1)))
+#define rounddown(x, y)  (((x) / (y)) * (y))
+
+#define PRIMASK 0x0ff
+#define PCATCH  0x100
+#define PDROP   0x200
+#define PBDRY   0x400
+
+#define NBBY    8       /* number of bits in a byte */
+
+/* Bit map related macros. */
+#define setbit(a,i) (((unsigned char *)(a))[(i)/NBBY] |= 1<<((i)%NBBY))
+#define clrbit(a,i) (((unsigned char *)(a))[(i)/NBBY] &= ~(1<<((i)%NBBY)))
+#define isset(a,i)                          \
+    (((const unsigned char *)(a))[(i)/NBBY] & (1<<((i)%NBBY)))
+#define isclr(a,i)                          \
+    ((((const unsigned char *)(a))[(i)/NBBY] & (1<<((i)%NBBY))) == 0)
 
 #ifdef _BSD_SOURCE
 
@@ -38 +102 @@
 #endif
 
 
-#endif  /* _BSD_SYS_PARAM_H_ */
+#endif  /* _FBSD_COMPAT_SYS_PARAM_H_ */
+

new file headers/compatibility/bsd/sys/pcpu.h

@@ +1 @@
+/*
+ * Copyright 2009, Colin Günther, coling@gmx.de.
+ * All rights reserved. Distributed under the terms of the MIT License.
+ */
+#ifndef _FBSD_COMPAT_SYS_PCPU_H_
+#define _FBSD_COMPAT_SYS_PCPU_H_
+
+
+#include <OS.h>
+
+
+struct thread;
+
+#define curthread ((struct thread*)NULL)
+    /* NOTE: Dereferencing curthread will crash, which is intentional. There is
+       no FreeBSD compatible struct thread and Haiku's should not be used as it
+       is only valid for the current thread or with proper locking. Currently
+       only priv_check() expects a struct thread parameter and ignores it. Using
+       NULL will show us when other uses appear. */
+
+
+#endif /* _FBSD_COMPAT_SYS_PCPU_H_ */

new file headers/compatibility/bsd/sys/priority.h

@@ +1 @@
+/*
+ * Copyright 2009 Haiku Inc. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef _FBSD_COMPAT_SYS_PRIORITY_H_
+#define _FBSD_COMPAT_SYS_PRIORITY_H_
+
+
+#define PRI_MIN_KERN    (64)
+#define PZERO           (PRI_MIN_KERN + 20)
+
+#endif /* _FBSD_COMPAT_SYS_PRIORITY_H_ */

new file headers/compatibility/bsd/sys/priv.h

@@ +1 @@
+/*
+ * Copyright 2009, Colin Günther, coling@gmx.de.
+ * All rights reserved. Distributed under the terms of the MIT License.
+ */
+#ifndef _FBSD_COMPAT_SYS_PRIV_H_
+#define _FBSD_COMPAT_SYS_PRIV_H_
+
+
+#include <sys/cdefs.h>
+
+
+/*
+ * 802.11-related privileges.
+ */
+#define PRIV_NET80211_GETKEY    440 /* Query 802.11 keys. */
+#define PRIV_NET80211_MANAGE    441 /* Administer 802.11. */
+
+#define PRIV_DRIVER     14  /* Low-level driver privilege. */
+
+
+/*
+ * Privilege check interfaces, modeled after historic suser() interfacs, but
+ * with the addition of a specific privilege name.  No flags are currently
+ * defined for the API.  Historically, flags specified using the real uid
+ * instead of the effective uid, and whether or not the check should be
+ * allowed in jail.
+ */
+struct thread;
+
+
+__BEGIN_DECLS
+
+int priv_check(struct thread*, int);
+
+__END_DECLS
+
+
+#endif /* _FBSD_COMPAT_SYS_PRIV_H_ */

new file headers/compatibility/bsd/sys/proc.h

@@ +1 @@
+/*
+ * Copyright 2009 Haiku Inc. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef _FBSD_COMPAT_SYS_PROC_H_
+#define _FBSD_COMPAT_SYS_PROC_H_
+
+
+#endif /* _FBSD_COMPAT_SYS_PROC_H_ */

new file headers/compatibility/bsd/sys/rman.h

@@ +1 @@
+/*
+ * Copyright 2007, Hugo Santos. All Rights Reserved.
+ * Distributed under the terms of the MIT License.
+ */
+
+
+/*-
+ * Copyright 1998 Massachusetts Institute of Technology
+ *
+ * Permission to use, copy, modify, and distribute this software and
+ * its documentation for any purpose and without fee is hereby
+ * granted, provided that both the above copyright notice and this
+ * permission notice appear in all copies, that both the above
+ * copyright notice and this permission notice appear in all
+ * supporting documentation, and that the name of M.I.T. not be used
+ * in advertising or publicity pertaining to distribution of the
+ * software without specific, written prior permission.  M.I.T. makes
+ * no representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied
+ * warranty.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY M.I.T. ``AS IS''.  M.I.T. DISCLAIMS
+ * ALL EXPRESS OR IMPLIED WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT
+ * SHALL M.I.T. BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+ * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+#ifndef _FBSD_COMPAT_SYS_RMAN_H_
+#define _FBSD_COMPAT_SYS_RMAN_H_
+
+
+#include <machine/_bus.h>
+#include <machine/resource.h>
+
+
+#define RF_ACTIVE       0x0002
+#define RF_SHAREABLE    0x0004
+#define RF_OPTIONAL     0x0080
+
+#define RF_ALIGNMENT_SHIFT      10 /* alignment size bit starts bit 10 */
+#define RF_ALIGNMENT_LOG2(x)    ((x) << RF_ALIGNMENT_SHIFT)
+
+struct resource {
+    int                 r_type;
+    bus_space_tag_t     r_bustag;       /* bus_space tag */
+    bus_space_handle_t  r_bushandle;    /* bus_space handle */
+    area_id             r_mapped_area;
+};
+
+
+bus_space_handle_t rman_get_bushandle(struct resource *);
+bus_space_tag_t rman_get_bustag(struct resource *);
+int rman_get_rid(struct resource *);
+
+
+static inline u_long
+rman_get_start(struct resource *resourcePointer)
+{
+    return resourcePointer->r_bushandle;
+}
+
+
+static inline uint32_t
+rman_make_alignment_flags(uint32_t size)
+{
+    int i;
+
+    /*
+     * Find the hightest bit set, and add one if more than one bit
+     * set.  We're effectively computing the ceil(log2(size)) here.
+     */
+    for (i = 31; i > 0; i--)
+        if ((1 << i) & size)
+            break;
+    if (~(1 << i) & size)
+        i++;
+
+    return RF_ALIGNMENT_LOG2(i);
+}
+#endif /* _FBSD_COMPAT_SYS_RMAN_H_ */

new file headers/compatibility/bsd/sys/socket.h

@@ +1 @@
+/*
+ * Copyright 2009, Colin Günther, coling@gmx.de.
+ * All rights reserved. Distributed under the terms of the MIT License.
+ */
+#ifndef _FBSD_COMPAT_SYS_SOCKET_H_
+#define _FBSD_COMPAT_SYS_SOCKET_H_
+
+
+#include <posix/sys/socket.h>
+
+#include <sys/cdefs.h>
+#include <sys/_types.h>
+
+
+// TODO Should be incorporated into Haikus socket.h with a number below AF_MAX
+#define AF_IEEE80211    AF_MAX + 1  /* IEEE 802.11 protocol */
+
+#endif /* _FBSD_COMPAT_SYS_SOCKET_H_ */

new file headers/compatibility/bsd/sys/sockio.h

@@ +1 @@
+/*
+ * Copyright 2007-2009 Haiku Inc. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef _FBSD_COMPAT_SYS_SOCKIO_H_
+#define _FBSD_COMPAT_SYS_SOCKIO_H_
+
+
+#include <posix/sys/sockio.h>
+
+#include <sys/ioccom.h>
+
+
+#define SIOCSIFCAP  SIOCSPACKETCAP
+
+#endif

new file headers/compatibility/bsd/sys/sysctl.h

@@ +1 @@
+/*
+ * Copyright 2009 Haiku Inc. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef _FBSD_COMPAT_SYS_SYSCTL_H_
+#define _FBSD_COMPAT_SYS_SYSCTL_H_
+
+
+#include <sys/queue.h>
+
+
+#ifdef _KERNEL
+
+struct sysctl_req {
+    void *newptr;
+};
+
+struct sysctl_ctx_list {
+};
+
+struct sysctl_oid_list {
+};
+
+
+#define SYSCTL_HANDLER_ARGS void *oidp, void *arg1, int arg2, \
+    struct sysctl_req *req
+
+#define OID_AUTO    (-1)
+
+#define CTLTYPE     0xf /* Mask for the type */
+#define CTLTYPE_NODE    1   /* name is a node */
+#define CTLTYPE_INT 2   /* name describes an integer */
+#define CTLTYPE_STRING  3   /* name describes a string */
+#define CTLTYPE_QUAD    4   /* name describes a 64-bit number */
+#define CTLTYPE_OPAQUE  5   /* name describes a structure */
+#define CTLTYPE_STRUCT  CTLTYPE_OPAQUE  /* name describes a structure */
+#define CTLTYPE_UINT    6   /* name describes an unsigned integer */
+#define CTLTYPE_LONG    7   /* name describes a long */
+#define CTLTYPE_ULONG   8   /* name describes an unsigned long */
+#define CTLTYPE_U64     9   /* name describes an unsigned 64-bit number */
+
+#define CTLFLAG_RD  0x80000000  /* Allow reads of variable */
+#define CTLFLAG_WR  0x40000000  /* Allow writes to the variable */
+#define CTLFLAG_RW  (CTLFLAG_RD|CTLFLAG_WR)
+#define CTLFLAG_NOLOCK  0x20000000  /* XXX Don't Lock */
+#define CTLFLAG_ANYBODY 0x10000000  /* All users can set this var */
+#define CTLFLAG_SECURE  0x08000000  /* Permit set only if securelevel<=0 */
+#define CTLFLAG_PRISON  0x04000000  /* Prisoned roots can fiddle */
+#define CTLFLAG_DYN 0x02000000  /* Dynamic oid - can be freed */
+#define CTLFLAG_SKIP    0x01000000  /* Skip this sysctl when listing */
+#define CTLMASK_SECURE  0x00F00000  /* Secure level */
+#define CTLFLAG_TUN 0x00080000  /* Tunable variable */
+#define CTLFLAG_MPSAFE  0x00040000  /* Handler is MP safe */
+#define CTLFLAG_RDTUN   (CTLFLAG_RD|CTLFLAG_TUN)
+
+
+static inline int
+sysctl_ctx_init(struct sysctl_ctx_list *clist)
+{
+    return -1;
+}
+
+
+static inline int
+sysctl_ctx_free(struct sysctl_ctx_list *clist)
+{
+    return -1;
+}
+
+
+static inline void *
+sysctl_add_oid(struct sysctl_ctx_list *clist, void *parent, int nbr, 
+    const char *name, int kind, void *arg1, int arg2,
+    int (*handler) (SYSCTL_HANDLER_ARGS), const char *fmt, const char *descr)
+{
+    return NULL;
+}
+
+
+static inline int sysctl_handle_long(SYSCTL_HANDLER_ARGS) { return -1; }
+static inline int sysctl_handle_opaque(SYSCTL_HANDLER_ARGS) { return -1; }
+static inline int sysctl_handle_quad(SYSCTL_HANDLER_ARGS) { return -1; }
+static inline int sysctl_handle_int(SYSCTL_HANDLER_ARGS) { return -1; }
+static inline int sysctl_handle_64(SYSCTL_HANDLER_ARGS) { return -1; }
+static inline int sysctl_handle_string(SYSCTL_HANDLER_ARGS) { return -1; }
+
+
+#define SYSCTL_OUT(r, p, l) -1
+
+#define __DESCR(x) ""
+
+#define SYSCTL_ADD_OID(ctx, parent, nbr, name, kind, a1, a2, handler, fmt, descr) \
+    sysctl_add_oid(ctx, parent, nbr, name, kind, a1, a2, handler, fmt, \
+    __DESCR(descr))
+
+#define SYSCTL_ADD_NODE(ctx, parent, nbr, name, access, handler, descr) \
+    sysctl_add_oid(ctx, parent, nbr, name, CTLTYPE_NODE|(access),       \
+    0, 0, handler, "N", __DESCR(descr))
+
+#define SYSCTL_ADD_STRING(ctx, parent, nbr, name, access, arg, len, descr)  \
+    sysctl_add_oid(ctx, parent, nbr, name, CTLTYPE_STRING|(access),         \
+    arg, len, sysctl_handle_string, "A", __DESCR(descr))
+
+#define SYSCTL_ADD_INT(ctx, parent, nbr, name, access, ptr, val, descr) \
+    sysctl_add_oid(ctx, parent, nbr, name, CTLTYPE_INT|(access),        \
+    ptr, val, sysctl_handle_int, "I", __DESCR(descr))
+
+#define SYSCTL_ADD_UINT(ctx, parent, nbr, name, access, ptr, val, descr)    \
+    sysctl_add_oid(ctx, parent, nbr, name, CTLTYPE_UINT|(access),           \
+    ptr, val, sysctl_handle_int, "IU", __DESCR(descr))
+
+#define SYSCTL_ADD_XINT(ctx, parent, nbr, name, access, ptr, val, descr)    \
+    sysctl_add_oid(ctx, parent, nbr, name, CTLTYPE_UINT|(access),           \
+    ptr, val, sysctl_handle_int, "IX", __DESCR(descr))
+
+#define SYSCTL_ADD_LONG(ctx, parent, nbr, name, access, ptr, descr) \
+    sysctl_add_oid(ctx, parent, nbr, name, CTLTYPE_LONG|(access),   \
+    ptr, 0, sysctl_handle_long, "L", __DESCR(descr))
+
+#define SYSCTL_ADD_ULONG(ctx, parent, nbr, name, access, ptr, descr)    \
+    sysctl_add_oid(ctx, parent, nbr, name, CTLTYPE_ULONG|(access),      \
+    ptr, 0, sysctl_handle_long, "LU", __DESCR(descr))
+
+#define SYSCTL_ADD_QUAD(ctx, parent, nbr, name, access, ptr, descr) \
+    sysctl_add_oid(ctx, parent, nbr, name, CTLTYPE_QUAD|(access),   \
+    ptr, 0, sysctl_handle_quad, "Q", __DESCR(descr))
+
+#define SYSCTL_ADD_UQUAD(ctx, parent, nbr, name, access, ptr, descr)    \
+    sysctl_add_oid(ctx, parent, nbr, name,                              \
+    CTLTYPE_U64 | CTLFLAG_MPSAFE | (access),                            \
+    ptr, 0, sysctl_handle_64, "QU", __DESCR(descr))
+
+#define SYSCTL_ADD_OPAQUE(ctx, parent, nbr, name, access, ptr, len, fmt, descr) \
+    sysctl_add_oid(ctx, parent, nbr, name, CTLTYPE_OPAQUE|(access), \
+    ptr, len, sysctl_handle_opaque, fmt, __DESCR(descr))
+
+#define SYSCTL_ADD_STRUCT(ctx, parent, nbr, name, access, ptr, type, descr) \
+    sysctl_add_oid(ctx, parent, nbr, name, CTLTYPE_OPAQUE|(access),         \
+    ptr, sizeof(struct type), sysctl_handle_opaque, "S," #type, __DESCR(descr))
+
+#define SYSCTL_ADD_PROC(ctx, parent, nbr, name, access, ptr, arg, handler, fmt, descr) \
+    sysctl_add_oid(ctx, parent, nbr, name, (access), ptr, arg, handler, fmt, \
+    __DESCR(descr))
+
+
+static inline void *
+SYSCTL_CHILDREN(void *ptr)
+{
+    return NULL;
+}
+
+
+#define SYSCTL_STATIC_CHILDREN(...) NULL
+
+#define SYSCTL_DECL(name) \
+    extern struct sysctl_oid_list sysctl_##name##_children
+
+#define SYSCTL_NODE(...)
+#define SYSCTL_INT(...)
+#define SYSCTL_UINT(...)
+#define SYSCTL_PROC(...)
+
+#endif
+
+#endif

new file headers/compatibility/bsd/sys/syslog.h

@@ +1 @@
+/*
+ * Copyright 2009 Haiku Inc. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef _FBSD_COMPAT_SYS_SYSLOG_H_
+#define _FBSD_COMPAT_SYS_SYSLOG_H_
+
+
+#define LOG_ERR 3 /* error conditions */
+
+#endif /* _FBSD_COMPAT_SYS_SYSLOG_H_ */

new file headers/compatibility/bsd/sys/systm.h

@@ +1 @@
+/*
+ * Copyright 2009, Colin Günther, coling@gmx.de.
+ * Copyright 2007, Hugo Santos. All Rights Reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef _FBSD_COMPAT_SYS_SYSTM_H_
+#define _FBSD_COMPAT_SYS_SYSTM_H_
+
+
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <strings.h>
+
+#include <machine/atomic.h>
+#include <machine/cpufunc.h>
+
+#include <sys/callout.h>
+#include <sys/cdefs.h>
+#include <sys/queue.h>
+
+#include <sys/libkern.h>
+
+
+#define printf freebsd_printf
+int printf(const char *format, ...) __printflike(1, 2);
+
+
+#define ovbcopy(f, t, l) bcopy((f), (t), (l))
+
+#define bootverbose 1
+
+#ifdef INVARIANTS
+#define KASSERT(cond,msg) do {  \
+    if (!(cond))                \
+        panic msg;              \
+} while (0)
+#else
+#define KASSERT(exp,msg) do { \
+} while (0)
+#endif
+
+#define DELAY(n) \
+    do {                \
+        if (n < 1000)   \
+            spin(n);    \
+        else            \
+            snooze(n);  \
+    } while (0)
+
+void wakeup(void *);
+
+#ifndef CTASSERT /* Allow lint to override */
+#define CTASSERT(x)         _CTASSERT(x, __LINE__)
+#define _CTASSERT(x, y)     __CTASSERT(x, y)
+#define __CTASSERT(x, y)    typedef char __assert ## y[(x) ? 1 : -1]
+#endif
+
+
+static inline int
+copyin(const void * __restrict udaddr, void * __restrict kaddr,
+    size_t len)
+{
+    return user_memcpy(kaddr, udaddr, len);
+}
+
+
+static inline int
+copyout(const void * __restrict kaddr, void * __restrict udaddr,
+    size_t len)
+{
+    return user_memcpy(udaddr, kaddr, len);
+}
+
+
+static inline void log(int level, const char *fmt, ...) { }
+
+
+int snprintf(char *, size_t, const char *, ...) __printflike(3, 4);
+extern int sprintf(char *buf, const char *, ...);
+
+extern void driver_vprintf(const char *format, va_list vl);
+#define vprintf(fmt, vl) driver_vprintf(fmt, vl)
+
+extern int vsnprintf(char *, size_t, const char *, __va_list)
+    __printflike(3, 0);
+
+int msleep(void *, struct mtx *, int, const char *, int);
+int _pause(const char *, int);
+#define pause(waitMessage, timeout) _pause((waitMessage), (timeout))
+#define tsleep(channel, priority, waitMessage, timeout) \
+    msleep((channel), NULL, (priority), (waitMessage), (timeout))
+
+struct unrhdr;
+struct unrhdr *new_unrhdr(int low, int high, struct mtx *mutex);
+void delete_unrhdr(struct unrhdr *);
+int alloc_unr(struct unrhdr *);
+void free_unr(struct unrhdr *, u_int);
+
+extern char *getenv(const char *name);
+extern void    freeenv(char *env);
+
+#endif  /* _FBSD_COMPAT_SYS_SYSTM_H_ */

new file headers/compatibility/bsd/sys/taskqueue.h

@@ +1 @@
+/*
+ * Copyright 2007 Haiku Inc. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef _FBSD_COMPAT_SYS_TASKQUEUE_H_
+#define _FBSD_COMPAT_SYS_TASKQUEUE_H_
+
+
+#include <sys/queue.h>
+#include <sys/_task.h>
+
+
+#define PI_NET  (B_REAL_TIME_DISPLAY_PRIORITY - 1)
+
+#define TASK_INIT(taskp, prio, hand, arg) task_init(taskp, prio, hand, arg)
+
+
+typedef void (*taskqueue_enqueue_fn)(void *context);
+
+
+struct taskqueue;
+struct taskqueue *taskqueue_create(const char *name, int mflags,
+    taskqueue_enqueue_fn enqueue, void *context);
+int taskqueue_start_threads(struct taskqueue **tq, int count, int pri,
+    const char *name, ...) __printflike(4, 5);
+void taskqueue_free(struct taskqueue *tq);
+void taskqueue_drain(struct taskqueue *tq, struct task *task);
+void taskqueue_block(struct taskqueue *queue);
+void taskqueue_unblock(struct taskqueue *queue);
+int taskqueue_enqueue(struct taskqueue *tq, struct task *task);
+
+void taskqueue_thread_enqueue(void *context);
+
+extern struct taskqueue *taskqueue_fast;
+extern struct taskqueue *taskqueue_swi;
+
+int taskqueue_enqueue_fast(struct taskqueue *queue, struct task *task);
+struct taskqueue *taskqueue_create_fast(const char *name, int mflags,
+    taskqueue_enqueue_fn enqueue, void *context);
+
+void task_init(struct task *, int prio, task_handler_t handler, void *arg);
+
+#endif

new file headers/compatibility/bsd/sys/time.h

@@ +1 @@
+/*
+ * Copyright 2009, Colin Günther, coling@gmx.de.
+ * All rights reserved. Distributed under the terms of the MIT License.
+ */
+#ifndef _FBSD_COMPAT_SYS_TIME_H_
+#define _FBSD_COMPAT_SYS_TIME_H_
+
+
+#include <posix/sys/time.h>
+
+#include <sys/_timeval.h>
+#include <sys/types.h>
+
+
+#define time_uptime (system_time() / 1000000)
+
+
+int ppsratecheck(struct timeval*, int*, int);
+
+#endif /* _FBSD_COMPAT_SYS_TIME_H_ */

new file headers/compatibility/bsd/sys/types.h

@@ +1 @@
+/*
+ * Copyright 2007 Haiku Inc. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef _FBSD_COMPAT_SYS_TYPES_H_
+#define _FBSD_COMPAT_SYS_TYPES_H_
+
+
+#include <posix/stdint.h>
+#include <posix/sys/types.h>
+
+#include <sys/cdefs.h>
+
+#include <machine/endian.h>
+#include <sys/_types.h>
+
+
+typedef int boolean_t;
+typedef __const char* c_caddr_t;
+typedef uint64_t u_quad_t;
+
+#endif

headers/private/firewire/fwglue.h

@@ -24 +24 @@
 #ifndef howmany
 #define howmany(x, y)   (((x)+((y)-1))/(y)) // x/y的上界
 #endif
-#define rounddown(x, y) (((x)/(y))*(y)) // 比x小，y的最大的倍数
 #define roundup(x, y)   ((((x)+((y)-1))/(y))*(y))  /* to any y */ // 比x大，y的最小倍数
-#define roundup2(x, y)  (((x)+((y)-1))&(~((y)-1))) /* if y is powers of two */
 #define powerof2(x)     ((((x)-1)&(x))==0) // 是否是2的次方
 
 typedef uint32_t bus_addr_t;
@@ -55 +53 @@
 #define MAX_CARDS 4
 extern dpc_module_info *gDpc;
 
-#define __offsetof(type, field) ((size_t)(&((type *)0)->field))
-
 #endif /*_FW_GLUE_H*/

src/add-ons/kernel/bus_managers/firewire/firewire.cpp

@@ -43 +43 @@
 #include <string.h>
 #include <stdio.h>
 #include <sys/param.h>
+#include <sys/queue.h>
 #include <sys/types.h>
 #include <sys/uio.h>
 #include <dpc.h>
 
 #include "fwdebug.h"
 #include "fwglue.h"
-#include "queue.h"
 #include "firewire.h"
 #include "iec13213.h"
 #include "firewirereg.h"

src/add-ons/kernel/bus_managers/firewire/firewire_module.cpp

@@ -15 +15 @@
 #include <string.h>
 #include <malloc.h>
 #include <dpc.h>
+#include <sys/queue.h>
 
 #include "fwdebug.h"
-#include "queue.h"
 #include "fwglue.h"
 #include "firewire.h"
 #include "iec13213.h"

src/add-ons/kernel/bus_managers/firewire/fwdma.cpp

@@ -35 +35 @@
 
 #include <OS.h>
 #include <malloc.h>
+#include <sys/queue.h>
 
-#include "queue.h"
 #include "fwglue.h"
 #include "firewire.h"
 #include "iec13213.h"

src/add-ons/kernel/bus_managers/firewire/fwmem.cpp

@@ -34 +34 @@
  */
 
 #include <sys/param.h>
+#include <sys/queue.h>
 #include <sys/types.h>
 #include <endian.h>
 
 #include <sys/ioccom.h>
-#include "queue.h"
 #include "fwglue.h"
 #include "firewire.h"
 #include "iec13213.h"

src/add-ons/kernel/bus_managers/firewire/fwohci.cpp

@@ -52 +52 @@
 #include <string.h>
 #include <dpc.h>
 #include <sys/param.h>
+#include <sys/queue.h>
 
 #include "fwglue.h"
-#include "queue.h"
 #include "firewire.h"
 #include "iec13213.h"
 #include "firewirereg.h"

src/add-ons/kernel/bus_managers/firewire/fwohci_pci.cpp

@@ -40 +40 @@
 #include <SupportDefs.h>
 #include <PCI.h>
 
+#include <sys/queue.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
@@ -48 +49 @@
 #include "util.h"
 #include "fwdebug.h"
 #include "fwglue.h"
-#include "queue.h"
 #include "firewire.h"
 #include "iec13213.h"
 #include "firewirereg.h"

src/add-ons/kernel/drivers/bus/firewire/fw_raw.c

@@ -44 +44 @@
  */
 
 #include <sys/param.h>
+#include <sys/queue.h>
 #include <sys/types.h>
 
 #include <Drivers.h>
@@ -56 +57 @@
 #include <string.h>
 #include <sys/ioccom.h>
 
-#include "queue.h"
 #include "firewire.h"
 #include "iec13213.h"
 #include "firewirereg.h"

src/add-ons/kernel/drivers/network/3com/dev/xl/Jamfile

@@ -1 +1 @@
 SubDir HAIKU_TOP src add-ons kernel drivers network 3com dev xl ;
 
 UseHeaders [ FDirName $(SUBDIR) .. .. ] : true ;
+UseHeaders [ FDirName $(HAIKU_TOP) headers compatibility bsd ] : true ;
 UseHeaders [ FDirName $(HAIKU_TOP) src libs compat freebsd_network compat ] : true ;
 
 UsePrivateHeaders net system ;

src/bin/fwcontrol/fwcrom.c

@@ -44 +44 @@
 #include <bootstrap.h>
 #else
 #if defined(_KERNEL) || defined(TEST)
-#ifdef __HAIKU__
-#include "queue.h"
-#else
 #include <sys/queue.h>
 #endif
-#endif
 #ifdef _KERNEL
 #ifndef __HAIKU__
 #include <sys/systm.h>

src/kits/network/libnetapi/Jamfile

@@ -3 +3 @@
 UsePrivateHeaders app net shared storage support ;
 UsePrivateHeaders locale shared ;
 
+
+UseHeaders [ FDirName $(HAIKU_TOP) headers compatibility bsd ] : true ;
 UseHeaders [ FDirName $(HAIKU_TOP) src libs compat freebsd_network compat ]
     : true ;
 UseHeaders [ FDirName $(HAIKU_TOP) src libs compat freebsd_wlan ] : true ;

deleted file src/libs/compat/freebsd_network/compat/machine/_bus.h

@@ -1 @@
-/*
- * Copyright 2009, Colin Günther. All Rights Reserved.
- * Copyright 2007, Hugo Santos. All Rights Reserved.
- * Distributed under the terms of the MIT License.
- */
-#ifndef _FBSD_COMPAT_MACHINE__BUS_H_
-#define _FBSD_COMPAT_MACHINE__BUS_H_
-
-
-#ifdef B_HAIKU_64_BIT
-
-
-typedef uint64_t bus_addr_t;
-typedef uint64_t bus_size_t;
-
-typedef uint64_t bus_space_tag_t;
-typedef uint64_t bus_space_handle_t;
-
-
-#else
-
-
-typedef uint32_t bus_addr_t;
-typedef uint32_t bus_size_t;
-
-typedef int bus_space_tag_t;
-typedef unsigned int bus_space_handle_t;
-
-
-#endif
-
-#endif /* _FBSD_COMPAT_MACHINE__BUS_H_ */

deleted file src/libs/compat/freebsd_network/compat/machine/atomic.h

@@ -1 @@
-/*
- * Copyright 2007, Hugo Santos. All Rights Reserved.
- * Distributed under the terms of the MIT License.
- */
-#ifndef _FBSD_COMPAT_MACHINE_ATOMIC_H_
-#define _FBSD_COMPAT_MACHINE_ATOMIC_H_
-
-
-#include <KernelExport.h>
-
-
-#define atomic_add_int(ptr, value) \
-    atomic_add((int32 *)(ptr), value)
-
-#define atomic_subtract_int(ptr, value) \
-    atomic_add((int32 *)(ptr), -value)
-
-#define atomic_set_acq_32(ptr, value) \
-    atomic_set_int(ptr, value)
-
-#define atomic_set_int(ptr, value) \
-    atomic_or((int32 *)(ptr), value)
-
-#define atomic_readandclear_int(ptr) \
-    atomic_set((int32 *)(ptr), 0)
-
-#endif  /* _FBSD_COMPAT_MACHINE_ATOMIC_H_ */

deleted file src/libs/compat/freebsd_network/compat/machine/bus.h

@@ -1 @@
-/*
- * Copyright 2009, Colin Günther. All Rights Reserved.
- * Copyright 2007, Hugo Santos. All Rights Reserved.
- * Distributed under the terms of the MIT License.
- */
-
-
-/*-
- * Copyright (c) KATO Takenori, 1999.
- *
- * All rights reserved.  Unpublished rights reserved under the copyright
- * laws of Japan.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer as
- *    the first lines of this file unmodified.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. The name of the author may not be used to endorse or promote products
- *    derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
- * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
- * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * $FreeBSD$
- */
-
-/*  $NetBSD: bus.h,v 1.12 1997/10/01 08:25:15 fvdl Exp $    */
-
-/*-
- * Copyright (c) 1996, 1997 The NetBSD Foundation, Inc.
- * All rights reserved.
- *
- * This code is derived from software contributed to The NetBSD Foundation
- * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
- * NASA Ames Research Center.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *  This product includes software developed by the NetBSD
- *  Foundation, Inc. and its contributors.
- * 4. Neither the name of The NetBSD Foundation nor the names of its
- *    contributors may be used to endorse or promote products derived
- *    from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
- * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- */
-
-/*-
- * Copyright (c) 1996 Charles M. Hannum.  All rights reserved.
- * Copyright (c) 1996 Christopher G. Demetriou.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *      This product includes software developed by Christopher G. Demetriou
- *  for the NetBSD Project.
- * 4. The name of the author may not be used to endorse or promote products
- *    derived from this software without specific prior written permission
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
- * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
- * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-#ifndef _FBSD_COMPAT_MACHINE_BUS_H_
-#define _FBSD_COMPAT_MACHINE_BUS_H_
-
-
-#include <machine/_bus.h>
-#include <machine/cpufunc.h>
-
-
-struct resource;
-
-
-// TODO: x86 specific!
-#define I386_BUS_SPACE_IO           0
-#define I386_BUS_SPACE_MEM          1
-
-#define BUS_SPACE_MAXADDR_32BIT     0xffffffff
-#ifdef __x86_64__
-#   define BUS_SPACE_MAXADDR        0xffffffffffffffffull
-#else
-#   define BUS_SPACE_MAXADDR        0xffffffff
-#endif
-
-#define BUS_SPACE_MAXSIZE_32BIT     0xffffffff
-#define BUS_SPACE_MAXSIZE           0xffffffff
-
-#define BUS_SPACE_UNRESTRICTED  (~0)
-
-#define BUS_SPACE_BARRIER_READ      1
-#define BUS_SPACE_BARRIER_WRITE     2
-
-
-uint8_t bus_space_read_1(bus_space_tag_t tag, bus_space_handle_t handle,
-    bus_size_t offset);
-uint16_t bus_space_read_2(bus_space_tag_t tag, bus_space_handle_t handle,
-    bus_size_t offset);
-uint32_t bus_space_read_4(bus_space_tag_t tag, bus_space_handle_t handle,
-    bus_size_t offset);
-void bus_space_write_1(bus_space_tag_t tag, bus_space_handle_t handle,
-    bus_size_t offset, uint8_t value);
-void bus_space_write_2(bus_space_tag_t tag, bus_space_handle_t handle,
-    bus_size_t offset, uint16_t value);
-void bus_space_write_4(bus_space_tag_t tag, bus_space_handle_t handle,
-    bus_size_t offset, uint32_t value);
-
-
-static inline void
-bus_space_read_region_1(bus_space_tag_t tag, bus_space_handle_t bsh,
-            bus_size_t offset, u_int8_t *addr, size_t count)
-{
-    if (tag == I386_BUS_SPACE_IO) {
-        int _port_ = bsh + offset;
-        __asm __volatile("                          \n\
-            cld                                     \n\
-        1:  inb %w2,%%al                            \n\
-            stosb                                   \n\
-            incl %2                                 \n\
-            loop 1b"                                :
-            "=D" (addr), "=c" (count), "=d" (_port_):
-            "0" (addr), "1" (count), "2" (_port_)   :
-            "%eax", "memory", "cc");
-    } else {
-        void* _port_ = (void*) (bsh + offset);
-        memcpy(addr, _port_, count);
-    }
-}
-
-
-static inline void
-bus_space_read_region_4(bus_space_tag_t tag, bus_space_handle_t bsh,
-    bus_size_t offset, u_int32_t *addr, size_t count)
-{
-    if (tag == I386_BUS_SPACE_IO) {
-        int _port_ = bsh + offset;
-        __asm __volatile("                          \n\
-            cld                                     \n\
-        1:  inl %w2,%%eax                           \n\
-            stosl                                   \n\
-            addl $4,%2                              \n\
-            loop 1b"                                :
-            "=D" (addr), "=c" (count), "=d" (_port_):
-            "0" (addr), "1" (count), "2" (_port_)   :
-            "%eax", "memory", "cc");
-    } else {
-        void* _port_ = (void*) (bsh + offset);
-        memcpy(addr, _port_, count);
-    }
-}
-
-
-static inline void
-bus_space_write_region_1(bus_space_tag_t tag, bus_space_handle_t bsh,
-    bus_size_t offset, const u_int8_t *addr, size_t count)
-{
-    if (tag == I386_BUS_SPACE_IO) {
-        int _port_ = bsh + offset;
-        __asm __volatile("                          \n\
-            cld                                     \n\
-        1:  lodsb                                   \n\
-            outb %%al,%w0                           \n\
-            incl %0                                 \n\
-            loop 1b"                                :
-            "=d" (_port_), "=S" (addr), "=c" (count):
-            "0" (_port_), "1" (addr), "2" (count)   :
-            "%eax", "memory", "cc");
-    } else {
-        void* _port_ = (void*) (bsh + offset);
-        memcpy(_port_, addr, count);
-    }
-}
-
-
-static inline void
-bus_space_set_region_4(bus_space_tag_t tag, bus_space_handle_t bsh,
-               bus_size_t offset, u_int32_t value, size_t count)
-{
-    /* TODO implement */
-}
-
-
-static inline void
-bus_space_barrier(bus_space_tag_t tag, bus_space_handle_t handle,
-    bus_size_t offset, bus_size_t len, int flags)
-{
-    if (flags & BUS_SPACE_BARRIER_READ)
-#ifdef __x86_64__
-        __asm__ __volatile__ ("lock; addl $0,0(%%rsp)" : : : "memory");
-#else
-        __asm__ __volatile__ ("lock; addl $0,0(%%esp)" : : : "memory");
-#endif
-    else
-        __asm__ __volatile__ ("" : : : "memory");
-}
-
-
-static inline void
-bus_space_write_multi_1(bus_space_tag_t tag, bus_space_handle_t bsh,
-    bus_size_t offset, const u_int8_t *addr, size_t count)
-{
-
-    if (tag == I386_BUS_SPACE_IO)
-        outsb(bsh + offset, addr, count);
-    else {
-        __asm __volatile("                              \n\
-            cld                                         \n\
-        1:  lodsb                                       \n\
-            movb %%al,(%2)                              \n\
-            loop 1b"                                    :
-            "=S" (addr), "=c" (count)                   :
-            "r" (bsh + offset), "0" (addr), "1" (count) :
-            "%eax", "memory", "cc");
-    }
-}
-
-
-#include <machine/bus_dma.h>
-
-
-#define bus_space_write_stream_4(t, h, o, v) \
-    bus_space_write_4((t), (h), (o), (v))
-
-#endif /* _FBSD_COMPAT_MACHINE_BUS_H_ */

deleted file src/libs/compat/freebsd_network/compat/machine/bus_dma.h

@@ -1 @@
-/*
- * Copyright 2009, Colin Günther, coling@gmx.de
- * All Rights Reserved. Distributed under the terms of the MIT License.
- */
-#ifndef _FBSD_COMPAT_MACHINE_BUS_DMA_H_
-#define _FBSD_COMPAT_MACHINE_BUS_DMA_H_
-
-
-#include <sys/bus_dma.h>
-
-#endif /* _FBSD_COMPAT_MACHINE_BUS_DMA_H_ */

deleted file src/libs/compat/freebsd_network/compat/machine/clock.h

@@ -1 @@
-/*
- * Copyright 2009 Haiku Inc. All rights reserved.
- * Distributed under the terms of the MIT License.
- */
-#ifndef _FBSD_COMPAT_SYS_CLOCK_H_
-#define _FBSD_COMPAT_SYS_CLOCK_H_
-
-
-#endif /* _FBSD_COMPAT_SYS_CLOCK_H_ */

deleted file src/libs/compat/freebsd_network/compat/machine/cpufunc.h

@@ -1 @@
-/*-
- * Copyright (c) 1993 The Regents of the University of California.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * $FreeBSD$
- */
-#ifndef _FBSD_COMPAT_MACHINE_CPUFUNC_H_
-#define _FBSD_COMPAT_MACHINE_CPUFUNC_H_
-
-
-static __inline void
-outsb(u_int port, const void *addr, size_t cnt)
-{
-    __asm __volatile("cld; rep; outsb"
-             : "+S" (addr), "+c" (cnt)
-             : "d" (port));
-}
-
-#endif /* _FBSD_COMPAT_MACHINE_CPUFUNC_H_ */

deleted file src/libs/compat/freebsd_network/compat/machine/endian.h

@@ -1 @@
-/*
- * Copyright 2007 Haiku Inc. All rights reserved.
- * Distributed under the terms of the MIT License.
- */
-#ifndef _FBSD_COMPAT_MACHINE_ENDIAN_H_
-#define _FBSD_COMPAT_MACHINE_ENDIAN_H_
-
-
-#include <sys/cdefs.h>
-#include <sys/_types.h>
-
-#endif

deleted file src/libs/compat/freebsd_network/compat/machine/in_cksum.h

@@ -1 @@
-/*
- * Copyright 2007, Axel Dörfler, axeld@pinc-software.de. All Rights Reserved.
- * Distributed under the terms of the MIT License.
- */
-#ifndef _FBSD_COMPAT_MACHINE_IN_CKSUM_H_
-#define _FBSD_COMPAT_MACHINE_IN_CKSUM_H_
-
-
-#include <stdint.h>
-
-
-#define in_cksum(m, len)    in_cksum_skip(m, len, 0)
-
-
-static inline u_short
-in_pseudo(u_int sum, u_int b, u_int c)
-{
-    // should never be called
-    panic("in_pseudo() called");
-    return 0;
-}
-
-
-static inline u_short
-in_cksum_skip(struct mbuf* m, int len, int skip)
-{
-    // should never be called
-    panic("in_cksum_skip() called");
-    return 0;
-}
-
-#endif  /* _FBSD_COMPAT_MACHINE_IN_CKSUM_H_ */

deleted file src/libs/compat/freebsd_network/compat/machine/resource.h

@@ -1 @@
-/*
- * Copyright 2007 Haiku Inc. All rights reserved.
- * Distributed under the terms of the MIT License.
- */
-#ifndef _FBSD_COMPAT_MACHINE_RESOURCE_H_
-#define _FBSD_COMPAT_MACHINE_RESOURCE_H_
-
-
-#define SYS_RES_IRQ     0x1
-#define SYS_RES_DRQ     0x2
-#define SYS_RES_MEMORY  0x3
-#define SYS_RES_IOPORT  0x4
-
-#endif

deleted file src/libs/compat/freebsd_network/compat/machine/stdarg.h

@@ -1 @@
-/*
- * Copyright 2009 Haiku Inc. All rights reserved.
- * Distributed under the terms of the MIT License.
- */
-#ifndef _FBSD_COMPAT_MACHINE_STDARG_H_
-#define _FBSD_COMPAT_MACHINE_STDARG_H_
-
-
-#include <sys/cdefs.h>
-#include <sys/_types.h>
-
-#endif /* _FBSD_COMPAT_MACHINE_STDARG_H_ */

deleted file src/libs/compat/freebsd_network/compat/sys/_bus_dma.h

@@ -1 @@
-/*-
- * Copyright 2006 John-Mark Gurney.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * $FreeBSD: src/sys/sys/_bus_dma.h,v 1.1 2006/09/03 00:26:17 jmg Exp $
- *
- */
-#ifndef _SYS__BUS_DMA_H_
-#define _SYS__BUS_DMA_H_
-
-typedef int bus_dmasync_op_t;
-
-/*
- *  bus_dma_tag_t
- *
- *  A machine-dependent opaque type describing the characteristics
- *  of how to perform DMA mappings.  This structure encapsultes
- *  information concerning address and alignment restrictions, number
- *  of S/G segments, amount of data per S/G segment, etc.
- */
-typedef struct bus_dma_tag  *bus_dma_tag_t;
-
-/*
- *  bus_dmamap_t
- *
- *  DMA mapping instance information.
- */
-typedef struct bus_dmamap   *bus_dmamap_t;
-
-/*
- * A function that performs driver-specific synchronization on behalf of
- * busdma.
- */
-typedef enum {
-    BUS_DMA_LOCK    = 0x01,
-    BUS_DMA_UNLOCK  = 0x02,
-} bus_dma_lock_op_t;
-
-typedef void bus_dma_lock_t(void *, bus_dma_lock_op_t);
-
-#endif /* !_SYS__BUS_DMA_H_ */

deleted file src/libs/compat/freebsd_network/compat/sys/_mutex.h

@@ -1 @@
-/*
- * Copyright 2009, Colin Günther, coling@gmx.de.
- * Copyright 2007, Hugo Santos. All Rights Reserved.
- * Distributed under the terms of the MIT License.
- */
-#ifndef _FBSD_COMPAT_SYS__MUTEX_H_
-#define _FBSD_COMPAT_SYS__MUTEX_H_
-
-
-#include <lock.h>
-
-
-struct mtx {
-    int                     type;
-    union {
-        struct {
-            mutex           lock;
-            thread_id       owner;
-        }                   mutex;
-        int32               spinlock;
-        recursive_lock      recursive;
-    } u;
-};
-
-
-#endif /* _FBSD_COMPAT_SYS__MUTEX_H_ */

deleted file src/libs/compat/freebsd_network/compat/sys/_task.h

@@ -1 @@
-/*
- * Copyright 2007 Haiku Inc. All rights reserved.
- * Distributed under the terms of the MIT License.
- */
-#ifndef _FBSD_COMPAT_SYS__TASK_H_
-#define _FBSD_COMPAT_SYS__TASK_H_
-
-
-/* Haiku's list management */
-#include <util/list.h>
-
-
-typedef void (*task_handler_t)(void *context, int pending);
-
-struct task {
-    int ta_priority;
-    task_handler_t ta_handler;
-    void *ta_argument;
-    int ta_pending;
-
-    struct list_link ta_link;
-};
-
-#endif

deleted file src/libs/compat/freebsd_network/compat/sys/_timeval.h

@@ -1 @@
-/*
- * Copyright 2009 Haiku Inc. All rights reserved.
- * Distributed under the terms of the MIT License.
- */
-#ifndef _FBSD_COMPAT_SYS__TIMEVAL_H_
-#define _FBSD_COMPAT_SYS__TIMEVAL_H_
-
-
-#include <sys/_types.h>
-
-#endif /* _FBSD_COMPAT_SYS__TIMEVAL_H_ */

deleted file src/libs/compat/freebsd_network/compat/sys/_types.h

@@ -1 @@
-/*
- * Copyright 2007 Haiku Inc. All rights reserved.
- * Distributed under the terms of the MIT License.
- */
-#ifndef _FBSD_COMPAT_SYS__TYPES_H_
-#define _FBSD_COMPAT_SYS__TYPES_H_
-
-
-#ifdef __GNUCLIKE_BUILTIN_VARARGS
-typedef __builtin_va_list   __va_list;  /* internally known to gcc */
-#else
-typedef char *          __va_list;
-#endif /* __GNUCLIKE_BUILTIN_VARARGS */
-#if defined(__GNUC_VA_LIST_COMPATIBILITY) && !defined(__GNUC_VA_LIST) \
-    && !defined(__NO_GNUC_VA_LIST)
-#define __GNUC_VA_LIST
-typedef __va_list       __gnuc_va_list; /* compatibility w/GNU headers*/
-#endif
-
-#endif /* _FBSD_COMPAT_SYS__TYPES_H_ */

deleted file src/libs/compat/freebsd_network/compat/sys/bus.h

@@ -1 @@
-/*
- * Copyright 2009, Colin Günther. All Rights Reserved.
- * Copyright 2007, Hugo Santos. All Rights Reserved.
- * Distributed under the terms of the MIT License.
- */
-#ifndef _FBSD_COMPAT_SYS_BUS_H_
-#define _FBSD_COMPAT_SYS_BUS_H_
-
-
-#include <sys/haiku-module.h>
-
-#include <sys/_bus_dma.h>
-
-#include <sys/queue.h>
-
-
-// TODO per platform, these are 32-bit
-
-// oh you glorious world of macros
-#define bus_read_1(r, o) \
-    bus_space_read_1((r)->r_bustag, (r)->r_bushandle, (o))
-#define bus_read_2(r, o) \
-    bus_space_read_2((r)->r_bustag, (r)->r_bushandle, (o))
-#define bus_read_4(r, o) \
-    bus_space_read_4((r)->r_bustag, (r)->r_bushandle, (o))
-#define bus_write_1(r, o, v) \
-    bus_space_write_1((r)->r_bustag, (r)->r_bushandle, (o), (v))
-#define bus_write_2(r, o, v) \
-    bus_space_write_2((r)->r_bustag, (r)->r_bushandle, (o), (v))
-#define bus_write_4(r, o, v) \
-    bus_space_write_4((r)->r_bustag, (r)->r_bushandle, (o), (v))
-
-#define bus_barrier(r, o, l, f) \
-    bus_space_barrier((r)->r_bustag, (r)->r_bushandle, (o), (l), (f))
-
-#define bus_read_region_1(r, o, d, c) \
-    bus_space_read_region_1((r)->r_bustag, (r)->r_bushandle, (o), (d), (c))
-
-#define FILTER_STRAY            B_UNHANDLED_INTERRUPT
-#define FILTER_HANDLED          B_HANDLED_INTERRUPT
-#define FILTER_SCHEDULE_THREAD  B_INVOKE_SCHEDULER
-
-/* Note that we reversed the original order, so whenever actual (negative)
-   numbers are used in a driver, we have to change it. */
-#define BUS_PROBE_SPECIFIC      0
-#define BUS_PROBE_LOW_PRIORITY  10
-#define BUS_PROBE_DEFAULT       20
-#define BUS_PROBE_GENERIC       100
-
-#define __BUS_ACCESSOR(varp, var, ivarp, ivar, type)                        \
-                                                                            \
-static __inline type varp ## _get_ ## var(device_t dev)                 \
-{                                                                       \
-    return 0;                                                       \
-}                                                                       \
-                                                                            \
-static __inline void varp ## _set_ ## var(device_t dev, type t)             \
-{                                                                           \
-}
-
-
-struct resource;
-
-struct resource_spec {
-    int type;
-    int rid;
-    int flags;
-};
-
-enum intr_type {
-    INTR_TYPE_NET   = 4,
-    INTR_FAST       = 128,
-    INTR_MPSAFE     = 512,
-};
-
-
-int bus_generic_detach(device_t dev);
-int bus_generic_suspend(device_t dev);
-int bus_generic_resume(device_t dev);
-void bus_generic_shutdown(device_t dev);
-
-typedef int (*driver_filter_t)(void *);
-typedef void driver_intr_t(void *);
-
-
-int resource_int_value(const char *name, int unit, const char *resname,
-    int *result);
-
-struct resource *bus_alloc_resource(device_t dev, int type, int *rid,
-    unsigned long start, unsigned long end, unsigned long count, uint32 flags);
-int bus_release_resource(device_t dev, int type, int rid, struct resource *r);
-int bus_alloc_resources(device_t dev, struct resource_spec *resourceSpec,
-    struct resource **resources);
-void bus_release_resources(device_t dev,
-    const struct resource_spec *resourceSpec, struct resource **resources);
-
-int bus_child_present(device_t child);
-
-static inline struct resource *
-bus_alloc_resource_any(device_t dev, int type, int *rid, uint32 flags)
-{
-    return bus_alloc_resource(dev, type, rid, 0, ~0, 1, flags);
-}
-
-bus_dma_tag_t bus_get_dma_tag(device_t dev);
-
-int bus_setup_intr(device_t dev, struct resource *r, int flags,
-    driver_filter_t filter, driver_intr_t handler, void *arg, void **_cookie);
-int bus_teardown_intr(device_t dev, struct resource *r, void *cookie);
-
-const char *device_get_name(device_t dev);
-const char *device_get_nameunit(device_t dev);
-int device_get_unit(device_t dev);
-void *device_get_softc(device_t dev);
-int device_printf(device_t dev, const char *, ...) __printflike(2, 3);
-void device_set_desc(device_t dev, const char *desc);
-void device_set_desc_copy(device_t dev, const char *desc);
-const char *device_get_desc(device_t dev);
-device_t device_get_parent(device_t dev);
-u_int32_t device_get_flags(device_t dev);
-devclass_t device_get_devclass(device_t dev);
-int device_get_children(device_t dev, device_t **devlistp, int *devcountp);
-
-void device_set_ivars(device_t dev, void *);
-void *device_get_ivars(device_t dev);
-
-device_t device_add_child(device_t dev, const char *name, int unit);
-int device_delete_child(device_t dev, device_t child);
-int device_is_attached(device_t dev);
-int device_attach(device_t dev);
-int device_detach(device_t dev);
-int bus_print_child_header(device_t dev, device_t child);
-int bus_print_child_footer(device_t dev, device_t child);
-int bus_generic_print_child(device_t dev, device_t child);
-void bus_generic_driver_added(device_t dev, driver_t *driver);
-int bus_generic_attach(device_t dev);
-int device_set_driver(device_t dev, driver_t *driver);
-int device_is_alive(device_t dev);
-
-
-static inline struct sysctl_ctx_list *
-device_get_sysctl_ctx(device_t dev)
-{
-    return NULL;
-}
-
-
-static inline void *
-device_get_sysctl_tree(device_t dev)
-{
-    return NULL;
-}
-
-devclass_t devclass_find(const char *classname);
-device_t devclass_get_device(devclass_t dc, int unit);
-int devclass_get_maxunit(devclass_t dc);
-
-#endif  /* _FBSD_COMPAT_SYS_BUS_H_ */

deleted file src/libs/compat/freebsd_network/compat/sys/bus_dma.h

@@ -1 @@
-/*  $NetBSD: bus.h,v 1.12 1997/10/01 08:25:15 fvdl Exp $    */
-
-/*-
- * Copyright (c) 1996, 1997 The NetBSD Foundation, Inc.
- * All rights reserved.
- *
- * This code is derived from software contributed to The NetBSD Foundation
- * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
- * NASA Ames Research Center.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *  This product includes software developed by the NetBSD
- *  Foundation, Inc. and its contributors.
- * 4. Neither the name of The NetBSD Foundation nor the names of its
- *    contributors may be used to endorse or promote products derived
- *    from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
- * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- */
-
-/*-
- * Copyright (c) 1996 Charles M. Hannum.  All rights reserved.
- * Copyright (c) 1996 Christopher G. Demetriou.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *      This product includes software developed by Christopher G. Demetriou
- *  for the NetBSD Project.
- * 4. The name of the author may not be used to endorse or promote products
- *    derived from this software without specific prior written permission
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
- * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
- * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-/* $FreeBSD: src/sys/sys/bus_dma.h,v 1.30 2006/09/03 00:26:17 jmg Exp $ */
-#ifndef _BUS_DMA_H_
-#define _BUS_DMA_H_
-
-#include <sys/_bus_dma.h>
-
-
-/*
- * Machine independent interface for mapping physical addresses to peripheral
- * bus 'physical' addresses, and assisting with DMA operations.
- *
- * XXX This file is always included from <machine/bus_dma.h> and should not
- *     (yet) be included directly.
- */
-
-/*
- * Flags used in various bus DMA methods.
- */
-#define BUS_DMA_WAITOK      0x00    /* safe to sleep (pseudo-flag) */
-#define BUS_DMA_NOWAIT      0x01    /* not safe to sleep */
-#define BUS_DMA_ALLOCNOW    0x02    /* perform resource allocation now */
-#define BUS_DMA_COHERENT    0x04    /* hint: map memory in a coherent way */
-#define BUS_DMA_ZERO        0x08    /* allocate zero'ed memory */
-#define BUS_DMA_BUS1        0x10    /* placeholders for bus functions... */
-#define BUS_DMA_BUS2        0x20
-#define BUS_DMA_BUS3        0x40
-#define BUS_DMA_BUS4        0x80
-
-/*
- * The following two flags are non-standard or specific to only certain
- * architectures
- */
-#define BUS_DMA_NOWRITE     0x100
-#define BUS_DMA_NOCACHE     0x200
-#define BUS_DMA_ISA     0x400   /* map memory for AXP ISA dma */
-
-/* Forwards needed by prototypes below. */
-struct mbuf;
-struct uio;
-
-/*
- * Operations performed by bus_dmamap_sync().
- */
-#define BUS_DMASYNC_PREREAD 1
-#define BUS_DMASYNC_POSTREAD    2
-#define BUS_DMASYNC_PREWRITE    4
-#define BUS_DMASYNC_POSTWRITE   8
-
-/*
- *  bus_dma_segment_t
- *
- *  Describes a single contiguous DMA transaction.  Values
- *  are suitable for programming into DMA registers.
- */
-typedef struct bus_dma_segment {
-    bus_addr_t  ds_addr;    /* DMA address */
-    bus_size_t  ds_len;     /* length of transfer */
-} bus_dma_segment_t;
-
-/*
- * A function that returns 1 if the address cannot be accessed by
- * a device and 0 if it can be.
- */
-typedef int bus_dma_filter_t(void *, bus_addr_t);
-
-/*
- * Generic helper function for manipulating mutexes.
- */
-void busdma_lock_mutex(void *arg, bus_dma_lock_op_t op);
-
-/*
- * Allocate a device specific dma_tag encapsulating the constraints of
- * the parent tag in addition to other restrictions specified:
- *
- *  alignment:  Alignment for segments.
- *  boundary:   Boundary that segments cannot cross.
- *  lowaddr:    Low restricted address that cannot appear in a mapping.
- *  highaddr:   High restricted address that cannot appear in a mapping.
- *  filtfunc:   An optional function to further test if an address
- *          within the range of lowaddr and highaddr cannot appear
- *          in a mapping.
- *  filtfuncarg:    An argument that will be passed to filtfunc in addition
- *          to the address to test.
- *  maxsize:    Maximum mapping size supported by this tag.
- *  nsegments:  Number of discontinuities allowed in maps.
- *  maxsegsz:   Maximum size of a segment in the map.
- *  flags:      Bus DMA flags.
- *  lockfunc:   An optional function to handle driver-defined lock
- *          operations.
- *  lockfuncarg:    An argument that will be passed to lockfunc in addition
- *          to the lock operation.
- *  dmat:       A pointer to set to a valid dma tag should the return
- *          value of this function indicate success.
- */
-/* XXX Should probably allow specification of alignment */
-int bus_dma_tag_create(bus_dma_tag_t parent, bus_size_t alignment,
-               bus_size_t boundary, bus_addr_t lowaddr,
-               bus_addr_t highaddr, bus_dma_filter_t *filtfunc,
-               void *filtfuncarg, bus_size_t maxsize, int nsegments,
-               bus_size_t maxsegsz, int flags, bus_dma_lock_t *lockfunc,
-               void *lockfuncarg, bus_dma_tag_t *dmat);
-
-int bus_dma_tag_destroy(bus_dma_tag_t dmat);
-
-/*
- * A function that processes a successfully loaded dma map or an error
- * from a delayed load map.
- */
-typedef void bus_dmamap_callback_t(void *, bus_dma_segment_t *, int, int);
-
-/*
- * Like bus_dmamap_callback but includes map size in bytes.  This is
- * defined as a separate interface to maintain compatibility for users
- * of bus_dmamap_callback_t--at some point these interfaces should be merged.
- */
-typedef void bus_dmamap_callback2_t(void *, bus_dma_segment_t *, int, bus_size_t, int);
-
-/*
- * XXX sparc64 uses the same interface, but a much different implementation.
- *     <machine/bus_dma.h> for the sparc64 arch contains the equivalent
- *     declarations.
- */
-#if !defined(__sparc64__)
-
-/*
- * Allocate a handle for mapping from kva/uva/physical
- * address space into bus device space.
- */
-int bus_dmamap_create(bus_dma_tag_t dmat, int flags, bus_dmamap_t *mapp);
-
-/*
- * Destroy a handle for mapping from kva/uva/physical
- * address space into bus device space.
- */
-int bus_dmamap_destroy(bus_dma_tag_t dmat, bus_dmamap_t map);
-
-/*
- * Allocate a piece of memory that can be efficiently mapped into
- * bus device space based on the constraints listed in the dma tag.
- * A dmamap to for use with dmamap_load is also allocated.
- */
-int bus_dmamem_alloc(bus_dma_tag_t dmat, void** vaddr, int flags,
-             bus_dmamap_t *mapp);
-
-/*
- * Free a piece of memory and its allocated dmamap, that was allocated
- * via bus_dmamem_alloc.
- */
-void bus_dmamem_free(bus_dma_tag_t dmat, void *vaddr, bus_dmamap_t map);
-
-/*
- * Map the buffer buf into bus space using the dmamap map.
- */
-int bus_dmamap_load(bus_dma_tag_t dmat, bus_dmamap_t map, void *buf,
-            bus_size_t buflen, bus_dmamap_callback_t *callback,
-            void *callback_arg, int flags);
-
-/*
- * Like bus_dmamap_load but for mbufs.  Note the use of the
- * bus_dmamap_callback2_t interface.
- */
-int bus_dmamap_load_mbuf(bus_dma_tag_t dmat, bus_dmamap_t map,
-             struct mbuf *mbuf,
-             bus_dmamap_callback2_t *callback, void *callback_arg,
-             int flags);
-
-int bus_dmamap_load_mbuf_sg(bus_dma_tag_t dmat, bus_dmamap_t map,
-                struct mbuf *mbuf, bus_dma_segment_t *segs,
-                int *nsegs, int flags);
-
-/*
- * Like bus_dmamap_load but for uios.  Note the use of the
- * bus_dmamap_callback2_t interface.
- */
-int bus_dmamap_load_uio(bus_dma_tag_t dmat, bus_dmamap_t map,
-            struct uio *ui,
-            bus_dmamap_callback2_t *callback, void *callback_arg,
-            int flags);
-
-/*
- * Perform a synchronization operation on the given map.
- */
-void _bus_dmamap_sync(bus_dma_tag_t, bus_dmamap_t, bus_dmasync_op_t);
-#define bus_dmamap_sync(dmat, dmamap, op)           \
-    do {                            \
-        if ((dmamap) != NULL)               \
-            _bus_dmamap_sync(dmat, dmamap, op); \
-    } while (0)
-
-/*
- * Release the mapping held by map.
- */
-void _bus_dmamap_unload(bus_dma_tag_t dmat, bus_dmamap_t map);
-#define bus_dmamap_unload(dmat, dmamap)             \
-    do {                            \
-        if ((dmamap) != NULL)               \
-            _bus_dmamap_unload(dmat, dmamap);   \
-    } while (0)
-
-#endif /* __sparc64__ */
-
-#endif /* _BUS_DMA_H_ */

deleted file src/libs/compat/freebsd_network/compat/sys/callout.h

@@ -1 @@
-/*
- * Copyright 2010, Axel Dörfler, axeld@pinc-software.de.
- * Copyright 2009, Colin Günther, coling@gmx.de.
- * Copyright 2007, Hugo Santos. All Rights Reserved.
- * Distributed under the terms of the MIT License.
- */
-#ifndef _FBSD_COMPAT_SYS_CALLOUT_H_
-#define _FBSD_COMPAT_SYS_CALLOUT_H_
-
-
-#include <sys/haiku-module.h>
-
-#include <sys/queue.h>
-
-
-struct callout {
-    struct list_link    link;
-    bigtime_t           due;
-    uint32              flags;
-
-    void *              c_arg;
-    void                (*c_func)(void *);
-    struct mtx *        c_mtx;
-    int                 c_flags;
-};
-
-
-#define CALLOUT_MPSAFE  0x0001
-
-
-void callout_init(struct callout *c, int mpsafe);
-void callout_init_mtx(struct callout *c, struct mtx *mutex, int flags);
-/* Time values are in ticks, see compat/sys/kernel.h for its definition */
-int callout_schedule(struct callout *c, int ticks);
-int callout_reset(struct callout *c, int ticks, void (*func)(void *), void *arg);
-int callout_pending(struct callout *c);
-int callout_active(struct callout *c);
-
-#define callout_drain(c)    _callout_stop_safe(c, 1)
-#define callout_stop(c)     _callout_stop_safe(c, 0)
-int _callout_stop_safe(struct callout *c, int safe);
-
-
-
-#endif  /* _FBSD_COMPAT_SYS_CALLOUT_H_ */

deleted file src/libs/compat/freebsd_network/compat/sys/cdefs.h

@@ -1 @@
-/*-
- * Copyright (c) 1991, 1993
- *  The Regents of the University of California.  All rights reserved.
- *
- * This code is derived from software contributed to Berkeley by
- * Berkeley Software Design, Inc.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *  @(#)cdefs.h 8.8 (Berkeley) 1/9/95
- * $FreeBSD$
- */
-#ifndef _FBSD_COMPAT_SYS_CDEFS_H_
-#define _FBSD_COMPAT_SYS_CDEFS_H_
-
-
-#include <posix/sys/cdefs.h>
-
-
-#define __FBSDID(str)   static const char __fbsdid[] = str
-
-/*
- * This code has been put in place to help reduce the addition of
- * compiler specific defines in FreeBSD code.  It helps to aid in
- * having a compiler-agnostic source tree.
- */
-
-#if defined(__GNUC__) || defined(__INTEL_COMPILER)
-
-#if __GNUC__ >= 3 || defined(__INTEL_COMPILER)
-#define __GNUCLIKE_ASM 3
-#define __GNUCLIKE_MATH_BUILTIN_CONSTANTS
-#else
-#define __GNUCLIKE_ASM 2
-#endif
-#define __GNUCLIKE___TYPEOF 1
-#define __GNUCLIKE___OFFSETOF 1
-#define __GNUCLIKE___SECTION 1
-
-#define __GNUCLIKE_ATTRIBUTE_MODE_DI 1
-
-#ifndef __INTEL_COMPILER
-# define __GNUCLIKE_CTOR_SECTION_HANDLING 1
-#endif
-
-#define __GNUCLIKE_BUILTIN_CONSTANT_P 1
-# if defined(__INTEL_COMPILER) && defined(__cplusplus) \
-    && __INTEL_COMPILER < 800
-#  undef __GNUCLIKE_BUILTIN_CONSTANT_P
-# endif
-
-#if (__GNUC_MINOR__ > 95 || __GNUC__ >= 3) && !defined(__INTEL_COMPILER)
-# define __GNUCLIKE_BUILTIN_VARARGS 1
-# define __GNUCLIKE_BUILTIN_STDARG 1
-# define __GNUCLIKE_BUILTIN_VAALIST 1
-#endif
-
-#if defined(__GNUC__)
-# define __GNUC_VA_LIST_COMPATIBILITY 1
-#endif
-
-#ifndef __INTEL_COMPILER
-# define __GNUCLIKE_BUILTIN_NEXT_ARG 1
-# define __GNUCLIKE_MATH_BUILTIN_RELOPS
-#endif
-
-#define __GNUCLIKE_BUILTIN_MEMCPY 1
-
-/* XXX: if __GNUC__ >= 2: not tested everywhere originally, where replaced */
-#define __CC_SUPPORTS_INLINE 1
-#define __CC_SUPPORTS___INLINE 1
-#define __CC_SUPPORTS___INLINE__ 1
-
-#define __CC_SUPPORTS___FUNC__ 1
-#define __CC_SUPPORTS_WARNING 1
-
-#define __CC_SUPPORTS_VARADIC_XXX 1 /* see varargs.h */
-
-#define __CC_SUPPORTS_DYNAMIC_ARRAY_INIT 1
-
-#endif /* __GNUC__ || __INTEL_COMPILER */
-
-
-/*
- * Macro to test if we're using a specific version of gcc or later.
- */
-#if defined(__GNUC__) && !defined(__INTEL_COMPILER)
-#define __GNUC_PREREQ__(ma, mi) \
-    (__GNUC__ > (ma) || __GNUC__ == (ma) && __GNUC_MINOR__ >= (mi))
-#else
-#define __GNUC_PREREQ__(ma, mi) 0
-#endif
-
-/*
- * GNU C version 2.96 adds explicit branch prediction so that
- * the CPU back-end can hint the processor and also so that
- * code blocks can be reordered such that the predicted path
- * sees a more linear flow, thus improving cache behavior, etc.
- *
- * The following two macros provide us with a way to utilize this
- * compiler feature.  Use __predict_true() if you expect the expression
- * to evaluate to true, and __predict_false() if you expect the
- * expression to evaluate to false.
- *
- * A few notes about usage:
- *
- *  * Generally, __predict_false() error condition checks (unless
- *    you have some _strong_ reason to do otherwise, in which case
- *    document it), and/or __predict_true() `no-error' condition
- *    checks, assuming you want to optimize for the no-error case.
- *
- *  * Other than that, if you don't know the likelihood of a test
- *    succeeding from empirical or other `hard' evidence, don't
- *    make predictions.
- *
- *  * These are meant to be used in places that are run `a lot'.
- *    It is wasteful to make predictions in code that is run
- *    seldomly (e.g. at subsystem initialization time) as the
- *    basic block reordering that this affects can often generate
- *    larger code.
- */
-#if __GNUC_PREREQ__(2, 96)
-#define __predict_true(exp)     __builtin_expect((exp), 1)
-#define __predict_false(exp)    __builtin_expect((exp), 0)
-#else
-#define __predict_true(exp)     (exp)
-#define __predict_false(exp)    (exp)
-#endif
-
-/*
- * We define this here since <stddef.h>, <sys/queue.h>, and <sys/types.h>
- * require it.
- */
-#if __GNUC_PREREQ__(4, 1)
-#define __offsetof(type, field)  __builtin_offsetof(type, field)
-#else
-#ifndef __cplusplus
-#define __offsetof(type, field) ((size_t)(&((type *)0)->field))
-#else
-#define __offsetof(type, field)                 \
-  (__offsetof__ (reinterpret_cast <size_t>          \
-                 (&reinterpret_cast <const volatile char &> \
-                  (static_cast<type *> (0)->field))))
-#endif
-#endif
-#define __rangeof(type, start, end) \
-    (__offsetof(type, end) - __offsetof(type, start))
-
-/*
- * Compiler-dependent macros to help declare dead (non-returning) and
- * pure (no side effects) functions, and unused variables.  They are
- * null except for versions of gcc that are known to support the features
- * properly (old versions of gcc-2 supported the dead and pure features
- * in a different (wrong) way).  If we do not provide an implementation
- * for a given compiler, let the compile fail if it is told to use
- * a feature that we cannot live without.
- */
-#ifdef lint
-#define __pure2
-#define __unused
-#define __packed
-#define __aligned(x)
-#define __section(x)
-#else
-#if !__GNUC_PREREQ__(2, 5) && !defined(__INTEL_COMPILER)
-#define __pure2
-#define __unused
-#endif
-#if __GNUC__ == 2 && __GNUC_MINOR__ >= 5 && __GNUC_MINOR__ < 7 && !defined(__INTEL_COMPILER)
-#define __pure2     __attribute__((__const__))
-#define __unused
-/* XXX Find out what to do for __packed, __aligned and __section */
-#endif
-#if __GNUC_PREREQ__(2, 7)
-#define __pure2     __attribute__((__const__))
-#define __unused    __attribute__((__unused__))
-#define __packed    __attribute__((__packed__))
-#define __aligned(x)    __attribute__((__aligned__(x)))
-#define __section(x)    __attribute__((__section__(x)))
-#endif
-
-#if __GNUC_PREREQ__(3, 1)
-#define __used      __attribute__((__used__))
-#else
-#if __GNUC_PREREQ__(2, 7)
-#define __used
-#endif
-#endif
-
-#if defined(__INTEL_COMPILER)
-#define __pure2     __attribute__((__const__))
-#define __unused    __attribute__((__unused__))
-#define __used      __attribute__((__used__))
-#define __packed    __attribute__((__packed__))
-#define __aligned(x)    __attribute__((__aligned__(x)))
-#define __section(x)    __attribute__((__section__(x)))
-#endif
-#endif
-
-/*
- * Compiler-dependent macros to declare that functions take printf-like
- * or scanf-like arguments.  They are null except for versions of gcc
- * that are known to support the features properly (old versions of gcc-2
- * didn't permit keeping the keywords out of the application namespace).
- */
-#if !__GNUC_PREREQ__(2, 7) && !defined(__INTEL_COMPILER)
-#define __printflike(fmtarg, firstvararg)
-#define __scanflike(fmtarg, firstvararg)
-#define __format_arg(fmtarg)
-#else
-#define __printflike(fmtarg, firstvararg) \
-        __attribute__((__format__ (__printf__, fmtarg, firstvararg)))
-#define __scanflike(fmtarg, firstvararg) \
-        __attribute__((__format__ (__scanf__, fmtarg, firstvararg)))
-#define __format_arg(fmtarg)    __attribute__((__format_arg__ (fmtarg)))
-#endif
-
-#if __GNUC_PREREQ__(3, 1)
-#define __noinline  __attribute__ ((__noinline__))
-#else
-#define __noinline
-#endif
-
-#if __GNUC_PREREQ__(3, 3)
-#define __nonnull(x)    __attribute__((__nonnull__(x)))
-#else
-#define __nonnull(x)
-#endif
-
-/*
- * The __CONCAT macro is used to concatenate parts of symbol names, e.g.
- * with "#define OLD(foo) __CONCAT(old,foo)", OLD(foo) produces oldfoo.
- * The __CONCAT macro is a bit tricky to use if it must work in non-ANSI
- * mode -- there must be no spaces between its arguments, and for nested
- * __CONCAT's, all the __CONCAT's must be at the left.  __CONCAT can also
- * concatenate double-quoted strings produced by the __STRING macro, but
- * this only works with ANSI C.
- *
- * __XSTRING is like __STRING, but it expands any macros in its argument
- * first.  It is only available with ANSI C.
- */
-#if defined(__STDC__) || defined(__cplusplus)
-#define __XSTRING(x)    __STRING(x) /* expand x, then stringify */
-
-#define __const     const       /* define reserved names to standard */
-#define __signed    signed
-#define __volatile  volatile
-#if defined(__cplusplus)
-#define __inline    inline      /* convert to C++ keyword */
-#else
-#if !(defined(__CC_SUPPORTS___INLINE))
-#define __inline            /* delete GCC keyword */
-#endif /* ! __CC_SUPPORTS___INLINE */
-#endif /* !__cplusplus */
-
-#else   /* !(__STDC__ || __cplusplus) */
-
-#if !defined(__CC_SUPPORTS___INLINE)
-#define __const             /* delete pseudo-ANSI C keywords */
-#define __inline
-#define __signed
-#define __volatile
-/*
- * In non-ANSI C environments, new programs will want ANSI-only C keywords
- * deleted from the program and old programs will want them left alone.
- * When using a compiler other than gcc, programs using the ANSI C keywords
- * const, inline etc. as normal identifiers should define -DNO_ANSI_KEYWORDS.
- * When using "gcc -traditional", we assume that this is the intent; if
- * __GNUC__ is defined but __STDC__ is not, we leave the new keywords alone.
- */
-#ifndef NO_ANSI_KEYWORDS
-#define const               /* delete ANSI C keywords */
-#define inline
-#define signed
-#define volatile
-#endif  /* !NO_ANSI_KEYWORDS */
-#endif  /* !__CC_SUPPORTS___INLINE */
-#endif  /* !(__STDC__ || __cplusplus) */
-
-#ifndef __DECONST
-#define __DECONST(type, var)    ((type)(uintptr_t)(const void *)(var))
-#endif
-
-#ifndef __UNCONST
-#define __UNCONST(var)  ((void*)(uintptr_t)(const void *)(var))
-#endif
-
-#endif

deleted file src/libs/compat/freebsd_network/compat/sys/condvar.h

@@ -1 @@
-/*
- * Copyright 2009, Colin Günther, coling@gmx.de.
- * All rights reserved. Distributed under the terms of the MIT License.
- */
-#ifndef _FBSD_COMPAT_SYS_CONDVAR_H_
-#define _FBSD_COMPAT_SYS_CONDVAR_H_
-
-
-#include <sys/queue.h>
-
-#ifdef __cplusplus
-} /* extern "C" */
-#include <kernel_c++_structs.h>
-extern "C" {
-#else
-#include <kernel_c++_structs.h>
-#endif
-
-
-struct cv {
-    struct ConditionVariable condition;
-};
-
-
-void cv_init(struct cv*, const char*);
-void cv_destroy(struct cv*);
-void cv_wait(struct cv*, struct mtx*);
-int cv_timedwait(struct cv*, struct mtx*, int);
-void cv_signal(struct cv*);
-
-#endif /* _FBSD_COMPAT_SYS_CONDVAR_H_ */

deleted file src/libs/compat/freebsd_network/compat/sys/ctype.h

@@ -1 @@
-/*
- * Copyright 2009 Haiku Inc. All rights reserved.
- * Distributed under the terms of the MIT License.
- */
-#ifndef _FBSD_COMPAT_SYS_CTYPE_H_
-#define _FBSD_COMPAT_SYS_CTYPE_H_
-
-
-#define isprint(c) ((c) >= ' ' && (c) <= '~')
-
-#endif /* _FBSD_COMPAT_SYS_CTYPE_H_ */

deleted file src/libs/compat/freebsd_network/compat/sys/endian.h

@@ -1 @@
-/*-
- * Copyright (c) 2002 Thomas Moestl <tmm@FreeBSD.org>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * $FreeBSD: src/sys/sys/endian.h,v 1.6 2003/10/15 20:05:57 obrien Exp $
- */
-#ifndef _FBSD_COMPAT_SYS_ENDIAN_H_
-#define _FBSD_COMPAT_SYS_ENDIAN_H_
-
-#include <stdint.h>
-#include <posix/endian.h>
-
-#include <support/ByteOrder.h>
-
-#include <sys/cdefs.h>
-#include <sys/_types.h>
-#include <machine/endian.h>
-
-#define _BYTE_ORDER     BYTE_ORDER
-#define _LITTLE_ENDIAN  LITTLE_ENDIAN
-#define _BIG_ENDIAN     BIG_ENDIAN
-
-#define __bswap16(x)    __swap_int16(x)
-#define __bswap32(x)    __swap_int32(x)
-#define __bswap64(x)    __swap_int64(x)
-
-/*
- * General byte order swapping functions.
- */
-#define bswap16(x)  __bswap16(x)
-#define bswap32(x)  __bswap32(x)
-#define bswap64(x)  __bswap64(x)
-
-/*
- * Host to big endian, host to little endian, big endian to host, and little
- * endian to host byte order functions as detailed in byteorder(9).
- */
-#if _BYTE_ORDER == _LITTLE_ENDIAN
-#define htobe16(x)  bswap16((x))
-#define htobe32(x)  bswap32((x))
-#define htobe64(x)  bswap64((x))
-#define htole16(x)  ((uint16_t)(x))
-#define htole32(x)  ((uint32_t)(x))
-#define htole64(x)  ((uint64_t)(x))
-
-#define be16toh(x)  bswap16((x))
-#define be32toh(x)  bswap32((x))
-#define be64toh(x)  bswap64((x))
-#define le16toh(x)  ((uint16_t)(x))
-#define le32toh(x)  ((uint32_t)(x))
-#define le64toh(x)  ((uint64_t)(x))
-#else /* _BYTE_ORDER != _LITTLE_ENDIAN */
-#define htobe16(x)  ((uint16_t)(x))
-#define htobe32(x)  ((uint32_t)(x))
-#define htobe64(x)  ((uint64_t)(x))
-#define htole16(x)  bswap16((x))
-#define htole32(x)  bswap32((x))
-#define htole64(x)  bswap64((x))
-
-#define be16toh(x)  ((uint16_t)(x))
-#define be32toh(x)  ((uint32_t)(x))
-#define be64toh(x)  ((uint64_t)(x))
-#define le16toh(x)  bswap16((x))
-#define le32toh(x)  bswap32((x))
-#define le64toh(x)  bswap64((x))
-#endif /* _BYTE_ORDER == _LITTLE_ENDIAN */
-
-/* Alignment-agnostic encode/decode bytestream to/from little/big endian. */
-
-static __inline uint16_t
-be16dec(const void *pp)
-{
-    unsigned char const *p = (unsigned char const *)pp;
-
-    return ((p[0] << 8) | p[1]);
-}
-
-static __inline uint32_t
-be32dec(const void *pp)
-{
-    unsigned char const *p = (unsigned char const *)pp;
-
-    return ((p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3]);
-}
-
-static __inline uint64_t
-be64dec(const void *pp)
-{
-    unsigned char const *p = (unsigned char const *)pp;
-
-    return (((uint64_t)be32dec(p) << 32) | be32dec(p + 4));
-}
-
-static __inline uint16_t
-le16dec(const void *pp)
-{
-    unsigned char const *p = (unsigned char const *)pp;
-
-    return ((p[1] << 8) | p[0]);
-}
-
-static __inline uint32_t
-le32dec(const void *pp)
-{
-    unsigned char const *p = (unsigned char const *)pp;
-
-    return ((p[3] << 24) | (p[2] << 16) | (p[1] << 8) | p[0]);
-}
-
-static __inline uint64_t
-le64dec(const void *pp)
-{
-    unsigned char const *p = (unsigned char const *)pp;
-
-    return (((uint64_t)le32dec(p + 4) << 32) | le32dec(p));
-}
-
-static __inline void
-be16enc(void *pp, uint16_t u)
-{
-    unsigned char *p = (unsigned char *)pp;
-
-    p[0] = (u >> 8) & 0xff;
-    p[1] = u & 0xff;
-}
-
-static __inline void
-be32enc(void *pp, uint32_t u)
-{
-    unsigned char *p = (unsigned char *)pp;
-
-    p[0] = (u >> 24) & 0xff;
-    p[1] = (u >> 16) & 0xff;
-    p[2] = (u >> 8) & 0xff;
-    p[3] = u & 0xff;
-}
-
-static __inline void
-be64enc(void *pp, uint64_t u)
-{
-    unsigned char *p = (unsigned char *)pp;
-
-    be32enc(p, u >> 32);
-    be32enc(p + 4, u & 0xffffffff);
-}
-
-static __inline void
-le16enc(void *pp, uint16_t u)
-{
-    unsigned char *p = (unsigned char *)pp;
-
-    p[0] = u & 0xff;
-    p[1] = (u >> 8) & 0xff;
-}
-
-static __inline void
-le32enc(void *pp, uint32_t u)
-{
-    unsigned char *p = (unsigned char *)pp;
-
-    p[0] = u & 0xff;
-    p[1] = (u >> 8) & 0xff;
-    p[2] = (u >> 16) & 0xff;
-    p[3] = (u >> 24) & 0xff;
-}
-
-static __inline void
-le64enc(void *pp, uint64_t u)
-{
-    unsigned char *p = (unsigned char *)pp;
-
-    le32enc(p, u & 0xffffffff);
-    le32enc(p + 4, u >> 32);
-}
-
-#endif  /* _SYS_ENDIAN_H_ */

deleted file src/libs/compat/freebsd_network/compat/sys/errno.h

@@ -1 @@
-/*
- * Copyright 2007 Haiku Inc. All rights reserved.
- * Distributed under the terms of the MIT License.
- */
-#ifndef _FBSD_COMPAT_SYS_ERRNO_H_
-#define _FBSD_COMPAT_SYS_ERRNO_H_
-
-
-#include <posix/errno.h>
-
-
-/* pseudo-errors returned inside freebsd compat layer to modify return to process */
-#define ERESTART        (B_ERRORS_END + 1)      /* restart syscall */
-#define EJUSTRETURN     (B_ERRORS_END + 2)      /* don't modify regs, just return */
-
-#endif

deleted file src/libs/compat/freebsd_network/compat/sys/event.h

@@ -1 @@
-/*
- * Copyright 2007 Haiku Inc. All rights reserved.
- * Distributed under the terms of the MIT License.
- */
-#ifndef _FBSD_COMPAT_SYS_EVENT_H_
-#define _FBSD_COMPAT_SYS_EVENT_H_
-
-
-struct knlist {
-    int _dummy;
-};
-
-#endif

deleted file src/libs/compat/freebsd_network/compat/sys/eventhandler.h

@@ -1 @@
-/*-
- * Copyright (c) 1999 Michael Smith <msmith@freebsd.org>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * $FreeBSD: src/sys/sys/eventhandler.h,v 1.33.2.1 2006/05/16 07:27:49 ps Exp $
- */
-#ifndef SYS_EVENTHANDLER_H
-#define SYS_EVENTHANDLER_H
-
-#include <sys/lock.h>
-#include <sys/ktr.h>
-#include <sys/mutex.h>
-#include <sys/queue.h>
-
-struct eventhandler_entry {
-    TAILQ_ENTRY(eventhandler_entry) ee_link;
-    int             ee_priority;
-#define EHE_DEAD_PRIORITY   (-1)
-    void                *ee_arg;
-};
-
-struct eventhandler_list {
-    char                *el_name;
-    int             el_flags;
-#define EHL_INITTED (1<<0)
-    u_int               el_runcount;
-    struct mtx          el_lock;
-    TAILQ_ENTRY(eventhandler_list)  el_link;
-    TAILQ_HEAD(,eventhandler_entry) el_entries;
-};
-
-typedef struct eventhandler_entry   *eventhandler_tag;
-
-#define EHL_LOCK(p)     mtx_lock(&(p)->el_lock)
-#define EHL_UNLOCK(p)       mtx_unlock(&(p)->el_lock)
-#define EHL_LOCK_ASSERT(p, x)   mtx_assert(&(p)->el_lock, x)
-
-/*
- * Macro to invoke the handlers for a given event.
- */
-#define _EVENTHANDLER_INVOKE(name, list, ...) do {          \
-    struct eventhandler_entry *_ep;                 \
-    struct eventhandler_entry_ ## name *_t;             \
-                                    \
-    KASSERT((list)->el_flags & EHL_INITTED,             \
-       ("eventhandler_invoke: running non-inited list"));       \
-    EHL_LOCK_ASSERT((list), MA_OWNED);              \
-    (list)->el_runcount++;                      \
-    KASSERT((list)->el_runcount > 0,                \
-        ("eventhandler_invoke: runcount overflow"));        \
-    CTR0(KTR_EVH, "eventhandler_invoke(\"" __STRING(name) "\")");   \
-    TAILQ_FOREACH(_ep, &((list)->el_entries), ee_link) {        \
-        if (_ep->ee_priority != EHE_DEAD_PRIORITY) {        \
-            EHL_UNLOCK((list));             \
-            _t = (struct eventhandler_entry_ ## name *)_ep; \
-            CTR1(KTR_EVH, "eventhandler_invoke: executing %p", \
-                (void *)_t->eh_func);           \
-            _t->eh_func(_ep->ee_arg , ## __VA_ARGS__);  \
-            EHL_LOCK((list));               \
-        }                           \
-    }                               \
-    KASSERT((list)->el_runcount > 0,                \
-        ("eventhandler_invoke: runcount underflow"));       \
-    (list)->el_runcount--;                      \
-    if ((list)->el_runcount == 0)                   \
-        eventhandler_prune_list(list);              \
-    EHL_UNLOCK((list));                     \
-} while (0)
-
-/*
- * Slow handlers are entirely dynamic; lists are created
- * when entries are added to them, and thus have no concept of "owner",
- *
- * Slow handlers need to be declared, but do not need to be defined. The
- * declaration must be in scope wherever the handler is to be invoked.
- */
-#define EVENTHANDLER_DECLARE(name, type)                \
-struct eventhandler_entry_ ## name                  \
-{                                   \
-    struct eventhandler_entry   ee;             \
-    type                eh_func;            \
-};                                  \
-struct __hack
-
-#define EVENTHANDLER_INVOKE(name, ...)                  \
-do {                                    \
-    struct eventhandler_list *_el;                  \
-                                    \
-    if ((_el = eventhandler_find_list(#name)) != NULL)      \
-        _EVENTHANDLER_INVOKE(name, _el , ## __VA_ARGS__);   \
-} while (0)
-
-#define EVENTHANDLER_REGISTER(name, func, arg, priority)        \
-    eventhandler_register(NULL, #name, func, arg, priority)
-
-#define EVENTHANDLER_DEREGISTER(name, tag)              \
-do {                                    \
-    struct eventhandler_list *_el;                  \
-                                    \
-    if ((_el = eventhandler_find_list(#name)) != NULL)      \
-        eventhandler_deregister(_el, tag);          \
-} while(0)
-    
-
-eventhandler_tag eventhandler_register(struct eventhandler_list *list, 
-        const char *name, void *func, void *arg, int priority);
-void    eventhandler_deregister(struct eventhandler_list *list,
-        eventhandler_tag tag);
-struct eventhandler_list *eventhandler_find_list(const char *name);
-void    eventhandler_prune_list(struct eventhandler_list *list);
-
-/*
- * Standard system event queues.
- */
-
-/* Generic priority levels */
-#define EVENTHANDLER_PRI_FIRST  0
-#define EVENTHANDLER_PRI_ANY    10000
-#define EVENTHANDLER_PRI_LAST   20000
-
-/* Shutdown events */
-typedef void (*shutdown_fn)(void *, int);
-
-#define SHUTDOWN_PRI_FIRST  EVENTHANDLER_PRI_FIRST
-#define SHUTDOWN_PRI_DEFAULT    EVENTHANDLER_PRI_ANY
-#define SHUTDOWN_PRI_LAST   EVENTHANDLER_PRI_LAST
-
-EVENTHANDLER_DECLARE(shutdown_pre_sync, shutdown_fn);   /* before fs sync */
-EVENTHANDLER_DECLARE(shutdown_post_sync, shutdown_fn);  /* after fs sync */
-EVENTHANDLER_DECLARE(shutdown_final, shutdown_fn);
-
-/* Low memory event */
-typedef void (*vm_lowmem_handler_t)(void *, int);
-#define LOWMEM_PRI_DEFAULT  EVENTHANDLER_PRI_FIRST
-EVENTHANDLER_DECLARE(vm_lowmem, vm_lowmem_handler_t);
-
-/*
- * Process events
- * process_fork and exit handlers are called without Giant.
- * exec handlers are called with Giant, but that is by accident.
- */
-struct proc;
-
-typedef void (*exitlist_fn)(void *, struct proc *);
-typedef void (*forklist_fn)(void *, struct proc *, struct proc *, int);
-typedef void (*execlist_fn)(void *, struct proc *);
-
-EVENTHANDLER_DECLARE(process_exit, exitlist_fn);
-EVENTHANDLER_DECLARE(process_fork, forklist_fn);
-EVENTHANDLER_DECLARE(process_exec, execlist_fn);
-
-typedef void (*uma_zone_chfn)(void *);
-EVENTHANDLER_DECLARE(nmbclusters_change, uma_zone_chfn);
-EVENTHANDLER_DECLARE(maxsockets_change, uma_zone_chfn);
-#endif /* SYS_EVENTHANDLER_H */

deleted file src/libs/compat/freebsd_network/compat/sys/firmware.h

@@ -1 @@
-/*
- * Copyright 2009 Haiku Inc. All rights reserved.
- * Distributed under the terms of the MIT License.
- */
-#ifndef _FBSD_COMPAT_SYS_FIRMWARE_H_
-#define _FBSD_COMPAT_SYS_FIRMWARE_H_
-
-
-#define FIRMWARE_UNLOAD 0x0001
-
-
-struct firmware {
-    const char*     name;       // system-wide name
-    const void*     data;       // location of image
-    size_t          datasize;   // size of image in bytes
-    unsigned int    version;    // version of the image
-};
-
-
-const struct firmware* firmware_get(const char*);
-void firmware_put(const struct firmware*, int);
-
-#endif /* _FBSD_COMPAT_SYS_FIRMWARE_H_ */

deleted file src/libs/compat/freebsd_network/compat/sys/haiku-module.h

@@ -1 @@
-/*
- * Copyright 2009, Colin Günther. All Rights Reserved.
- * Copyright 2007, Hugo Santos. All Rights Reserved.
- * Distributed under the terms of the MIT License.
- */
-#ifndef _FBSD_COMPAT_SYS_HAIKU_MODULE_H_
-#define _FBSD_COMPAT_SYS_HAIKU_MODULE_H_
-
-
-#include <Drivers.h>
-#include <KernelExport.h>
-
-#include <kernel/lock.h>
-#include <net_stack.h>
-
-
-#undef ASSERT
-    /* private/kernel/debug.h sets it */
-
-typedef struct device *device_t;
-typedef struct devclass *devclass_t;
-
-typedef int (*device_method_signature_t)(device_t dev);
-
-typedef int device_probe_t(device_t dev);
-typedef int device_attach_t(device_t dev);
-typedef int device_detach_t(device_t dev);
-typedef int device_resume_t(device_t dev);
-typedef int device_suspend_t(device_t dev);
-
-struct device_method {
-    const char *name;
-    device_method_signature_t method;
-};
-
-typedef struct device_method device_method_t;
-
-#define DEVMETHOD(name, func)   { #name, (device_method_signature_t)&func }
-#define DEVMETHOD_END   { 0, 0 }
-
-typedef struct {
-    const char *name;
-    device_method_t *methods;
-    size_t softc_size;
-} driver_t;
-
-#define DRIVER_MODULE_NAME(name, busname) \
-    __fbsd_ ## name ## _ ## busname
-
-status_t _fbsd_init_hardware(driver_t *driver[]);
-status_t _fbsd_init_drivers(driver_t *driver[]);
-status_t _fbsd_uninit_drivers(driver_t *driver[]);
-
-extern const char *gDriverName;
-driver_t *__haiku_select_miibus_driver(device_t dev);
-driver_t *__haiku_probe_miibus(device_t dev, driver_t *drivers[]);
-status_t __haiku_handle_fbsd_drivers_list(status_t (*handler)(driver_t *[]));
-
-status_t init_wlan_stack(void);
-void uninit_wlan_stack(void);
-status_t start_wlan(device_t);
-status_t stop_wlan(device_t);
-status_t wlan_control(void*, uint32, void*, size_t);
-status_t wlan_close(void*);
-status_t wlan_if_l2com_alloc(void*);
-
-/* we define the driver methods with HAIKU_FBSD_DRIVERS_GLUE to
- * force the rest of the stuff to be linked back with the driver.
- * While gcc 2.95 packs everything from the static library onto
- * the final binary, gcc 4.x rightfuly doesn't. */
-
-#define HAIKU_FBSD_DRIVERS_GLUE(publicname)                             \
-    extern const char *gDeviceNameList[];                               \
-    extern device_hooks gDeviceHooks;                                   \
-    const char *gDriverName = #publicname;                              \
-    int32 api_version = B_CUR_DRIVER_API_VERSION;                       \
-    status_t init_hardware()                                            \
-    {                                                                   \
-        return __haiku_handle_fbsd_drivers_list(_fbsd_init_hardware);   \
-    }                                                                   \
-    status_t init_driver()                                              \
-    {                                                                   \
-        return __haiku_handle_fbsd_drivers_list(_fbsd_init_drivers);    \
-    }                                                                   \
-    void uninit_driver()                                                \
-    {                                                                   \
-        __haiku_handle_fbsd_drivers_list(_fbsd_uninit_drivers);         \
-    }                                                                   \
-    const char **publish_devices()                                      \
-        { return gDeviceNameList; }                                     \
-    device_hooks *find_device(const char *name)                         \
-        { return &gDeviceHooks; }                                       \
-    status_t init_wlan_stack(void)                                      \
-        { return B_OK; }                                                \
-    void uninit_wlan_stack(void) {}                                     \
-    status_t start_wlan(device_t dev)                                   \
-        { return B_OK; }                                                \
-    status_t stop_wlan(device_t dev)                                    \
-        { return B_OK; }                                                \
-    status_t wlan_control(void *cookie, uint32 op, void *arg,           \
-        size_t length)                                                  \
-        { return B_BAD_VALUE; }                                         \
-    status_t wlan_close(void* cookie)                                   \
-        { return B_OK; }                                                \
-    status_t wlan_if_l2com_alloc(void* ifp)                             \
-        { return B_OK; }
-
-#define HAIKU_FBSD_DRIVER_GLUE(publicname, name, busname)               \
-    extern driver_t *DRIVER_MODULE_NAME(name, busname);                 \
-    status_t __haiku_handle_fbsd_drivers_list(status_t (*proc)(driver_t *[])) {\
-        driver_t *drivers[] = {                                         \
-            DRIVER_MODULE_NAME(name, busname),                          \
-            NULL                                                        \
-        };                                                              \
-        return (*proc)(drivers);                                        \
-    }                                                                   \
-    HAIKU_FBSD_DRIVERS_GLUE(publicname);
-
-#define HAIKU_FBSD_WLAN_DRIVERS_GLUE(publicname)                        \
-    extern const char *gDeviceNameList[];                               \
-    extern device_hooks gDeviceHooks;                                   \
-    const char *gDriverName = #publicname;                              \
-    int32 api_version = B_CUR_DRIVER_API_VERSION;                       \
-    status_t init_hardware()                                            \
-    {                                                                   \
-        return __haiku_handle_fbsd_drivers_list(_fbsd_init_hardware);   \
-    }                                                                   \
-    status_t init_driver()                                              \
-    {                                                                   \
-        return __haiku_handle_fbsd_drivers_list(_fbsd_init_drivers);    \
-    }                                                                   \
-    void uninit_driver()                                                \
-    {                                                                   \
-        __haiku_handle_fbsd_drivers_list(_fbsd_uninit_drivers);         \
-    }                                                                   \
-    const char **publish_devices()                                      \
-        { return gDeviceNameList; }                                     \
-    device_hooks *find_device(const char *name)                         \
-        { return &gDeviceHooks; }
-
-#define HAIKU_FBSD_WLAN_DRIVER_GLUE(publicname, name, busname)          \
-    extern driver_t *DRIVER_MODULE_NAME(name, busname);                 \
-    status_t __haiku_handle_fbsd_drivers_list(status_t (*proc)(driver_t *[])) {\
-        driver_t *drivers[] = {                                         \
-            DRIVER_MODULE_NAME(name, busname),                          \
-            NULL                                                        \
-        };                                                              \
-        return (*proc)(drivers);                                        \
-    }                                                                   \
-    HAIKU_FBSD_WLAN_DRIVERS_GLUE(publicname);
-
-#define HAIKU_FBSD_RETURN_MII_DRIVER(drivers)                   \
-    driver_t *__haiku_select_miibus_driver(device_t dev)        \
-    {                                                           \
-        return __haiku_probe_miibus(dev, drivers);              \
-    }
-
-#define HAIKU_FBSD_MII_DRIVER(name)                             \
-    extern driver_t *DRIVER_MODULE_NAME(name, miibus);          \
-    driver_t *__haiku_select_miibus_driver(device_t dev)        \
-    {                                                           \
-        driver_t *drivers[] = {                                 \
-            DRIVER_MODULE_NAME(name, miibus),                   \
-            NULL                                                \
-        };                                                      \
-        return __haiku_probe_miibus(dev, drivers);              \
-    }
-
-#define NO_HAIKU_FBSD_MII_DRIVER()                              \
-    HAIKU_FBSD_RETURN_MII_DRIVER(NULL)
-
-extern spinlock __haiku_intr_spinlock;
-extern int __haiku_disable_interrupts(device_t dev);
-extern void __haiku_reenable_interrupts(device_t dev);
-
-#define HAIKU_CHECK_DISABLE_INTERRUPTS      __haiku_disable_interrupts
-#define HAIKU_REENABLE_INTERRUPTS           __haiku_reenable_interrupts
-
-#define NO_HAIKU_CHECK_DISABLE_INTERRUPTS()             \
-    int HAIKU_CHECK_DISABLE_INTERRUPTS(device_t dev) {  \
-        panic("should never be called.");               \
-        return -1; \
-    }
-
-#define NO_HAIKU_REENABLE_INTERRUPTS() \
-    void HAIKU_REENABLE_INTERRUPTS(device_t dev) {}
-
-extern int __haiku_driver_requirements;
-
-enum {
-    FBSD_TASKQUEUES     = 1 << 0,
-    FBSD_FAST_TASKQUEUE = 1 << 1,
-    FBSD_SWI_TASKQUEUE  = 1 << 2,
-    FBSD_WLAN           = 1 << 3,
-};
-
-#define HAIKU_DRIVER_REQUIREMENTS(flags) \
-    int __haiku_driver_requirements = (flags)
-
-#define HAIKU_DRIVER_REQUIRES(flag) (__haiku_driver_requirements & (flag))
-
-
-/* #pragma mark - firmware loading */
-
-
-/*
- * Only needed to be specified in the glue code of drivers which actually need
- * to load firmware. See iprowifi2100 for an example.
- */
-
-extern const uint __haiku_firmware_version;
-
-/* Use 0 if driver doesn't care about firmware version. */
-#define HAIKU_FIRMWARE_VERSION(version) \
-    const uint __haiku_firmware_version = (version)
-
-extern const uint __haiku_firmware_parts_count;
-extern const char* __haiku_firmware_name_map[][2];
-
-#define HAIKU_FIRMWARE_NAME_MAP(firmwarePartsCount) \
-    const uint __haiku_firmware_parts_count = firmwarePartsCount; \
-    const char* __haiku_firmware_name_map[firmwarePartsCount][2]
-
-#define NO_HAIKU_FIRMWARE_NAME_MAP() \
-    const uint __haiku_firmware_parts_count = 0; \
-    const char* __haiku_firmware_name_map[0][2] = {}
-
-
-/* #pragma mark - synchronization */
-
-
-#define HAIKU_INTR_REGISTER_STATE \
-    cpu_status __haiku_cpu_state = 0
-
-#define HAIKU_INTR_REGISTER_ENTER() do {        \
-    __haiku_cpu_state = disable_interrupts();   \
-    acquire_spinlock(&__haiku_intr_spinlock);   \
-} while (0)
-
-#define HAIKU_INTR_REGISTER_LEAVE() do {        \
-    release_spinlock(&__haiku_intr_spinlock);   \
-    restore_interrupts(__haiku_cpu_state);      \
-} while (0)
-
-#define HAIKU_PROTECT_INTR_REGISTER(x) do {     \
-    HAIKU_INTR_REGISTER_STATE;                  \
-    HAIKU_INTR_REGISTER_ENTER();                \
-    x;                                          \
-    HAIKU_INTR_REGISTER_LEAVE();                \
-} while (0)
-
-#define DEFINE_CLASS_0(name, driver, methods, size) \
-    driver_t driver = { #name, methods, size }
-
-#define DRIVER_MODULE(name, busname, driver, devclass, evh, arg) \
-    driver_t *DRIVER_MODULE_NAME(name, busname) = &(driver); \
-    devclass_t *__class_ ## name ## _ ## busname ## _ ## devclass = &(devclass)
-
-#define DRIVER_MODULE_ORDERED(name, busname, driver, devclass, evh, arg, order) \
-    DRIVER_MODULE(name, busname, driver, devclass, evh, arg)
-
-#define nitems(_a)     (sizeof((_a)) / sizeof((_a)[0]))
-
-#endif  /* _FBSD_COMPAT_SYS_HAIKU_MODULE_H_ */

deleted file src/libs/compat/freebsd_network/compat/sys/ioccom.h

@@ -1 @@
-/*
- * Copyright 2009, Colin Günther, coling@gmx.de.
- * All rights reserved. Distributed under the terms of the MIT License.
- */
-#ifndef _FBSD_COMPAT_SYS_IOCCOM_H_
-#define _FBSD_COMPAT_SYS_IOCCOM_H_
-
-
-#define _IOW(g,n,t)     SIOCEND + n
-#define _IOWR(g,n,t)    SIOCEND + n
-
-#endif /* _FBSD_COMPAT_SYS_IOCCOM_H_ */

deleted file src/libs/compat/freebsd_network/compat/sys/kernel.h

@@ -1 @@
-/*
- * Copyright 2007-2009 Haiku Inc. All rights reserved.
- * Distributed under the terms of the MIT License.
- */
-#ifndef _FBSD_COMPAT_SYS_KERNEL_H_
-#define _FBSD_COMPAT_SYS_KERNEL_H_
-
-
-#include <stddef.h>
-
-#include <sys/haiku-module.h>
-
-#include <sys/linker_set.h>
-#include <sys/queue.h>
-
-
-/*
- *
- * The rate at which FreeBSD can generate callouts (kind of timeout mechanism).
- * For FreeBSD 8 this is typically 1000 times per second (100 for ARM).
- * This value is defined in a file called subr_param.c
- *
- * WHile Haiku can have a much higher granularity, it is not a good idea to have
- * this since FreeBSD tries to do certain tasks based on ticks, for instance
- * autonegotiation and wlan scanning.
- * Suffixing LL prevents integer overflows during calculations.
- * as it defines a long long constant.*/
-#define hz  1000LL
-
-#define ticks_to_usecs(t) (1000000*((bigtime_t)t) / hz)
-
-typedef void (*system_init_func_t)(void *);
-
-
-struct __system_init {
-    system_init_func_t func;
-};
-
-/* TODO implement SYSINIT/SYSUNINIT subsystem */
-#define SYSINIT(uniquifier, subsystem, order, func, ident) \
-    struct __system_init __init_##uniquifier = { (system_init_func_t) func }
-
-#define SYSUNINIT(uniquifier, subsystem, order, func, ident) \
-    struct __system_init __uninit_##uniquifier = { (system_init_func_t) func }
-
-#define TUNABLE_INT(path, var)
-#define TUNABLE_INT_FETCH(path, var)
-
-extern int ticks;
-
-#endif

deleted file src/libs/compat/freebsd_network/compat/sys/ktr.h

@@ -1 @@
-/*-
- * Copyright (c) 1996 Berkeley Software Design, Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. Berkeley Software Design Inc's name may not be used to endorse or
- *    promote products derived from this software without specific prior
- *    written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY BERKELEY SOFTWARE DESIGN INC ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL BERKELEY SOFTWARE DESIGN INC BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *  from BSDI $Id: ktr.h,v 1.10.2.7 2000/03/16 21:44:42 cp Exp $
- * $FreeBSD: src/sys/sys/ktr.h,v 1.32.2.2 2006/01/23 14:56:33 marius Exp $
- */
-
-/*
- *  Wraparound kernel trace buffer support.
- */
-#ifndef _SYS_KTR_H_
-#define _SYS_KTR_H_
-
-/*
- * Trace classes
- */
-#define KTR_GEN     0x00000001      /* General (TR) */
-#define KTR_NET     0x00000002      /* Network */
-#define KTR_DEV     0x00000004      /* Device driver */
-#define KTR_LOCK    0x00000008      /* MP locking */
-#define KTR_SMP     0x00000010      /* MP general */
-#define KTR_FS      0x00000020      /* Filesystem */
-#define KTR_PMAP    0x00000040      /* Pmap tracing */
-#define KTR_MALLOC  0x00000080      /* Malloc tracing */
-#define KTR_TRAP    0x00000100      /* Trap processing */
-#define KTR_INTR    0x00000200      /* Interrupt tracing */
-#define KTR_SIG     0x00000400      /* Signal processing */
-#define KTR_CLK     0x00000800      /* hardclock verbose */
-#define KTR_PROC    0x00001000      /* Process scheduling */
-#define KTR_SYSC    0x00002000      /* System call */
-#define KTR_INIT    0x00004000      /* System initialization */
-#define KTR_KGDB    0x00008000      /* Trace kgdb internals */
-#define KTR_IO      0x00010000      /* Upper I/O  */
-#define KTR_EVH     0x00020000      /* Eventhandler */
-#define KTR_VFS     0x00040000      /* VFS events */
-#define KTR_VOP     0x00080000      /* Auto-generated vop events */
-#define KTR_VM      0x00100000      /* The virtual memory system */
-#define KTR_WITNESS 0x00200000
-#define KTR_RUNQ    0x00400000      /* Run queue */
-#define KTR_CONTENTION  0x00800000      /* Lock contention */
-#define KTR_UMA     0x01000000      /* UMA slab allocator */
-#define KTR_CALLOUT 0x02000000      /* Callouts and timeouts */
-#define KTR_GEOM    0x04000000      /* GEOM I/O events */
-#define KTR_BUSDMA  0x08000000      /* busdma(9) events */
-#define KTR_CRITICAL    0x10000000      /* Critical sections */
-#define KTR_SCHED   0x20000000      /* Machine parsed sched info. */
-#define KTR_BUF     0x40000000      /* Buffer cache */
-#define KTR_ALL     0x7fffffff
-
-/*
- * Trace classes which can be assigned to particular use at compile time
- * These must remain in high 22 as some assembly code counts on it
- */
-#define KTR_CT1     0x01000000
-#define KTR_CT2     0x02000000
-#define KTR_CT3     0x04000000
-#define KTR_CT4     0x08000000
-#define KTR_CT5     0x10000000
-#define KTR_CT6     0x20000000
-#define KTR_CT7     0x40000000
-#define KTR_CT8     0x80000000
-
-/* Trace classes to compile in */
-#ifdef KTR
-#ifndef KTR_COMPILE
-#define KTR_COMPILE (KTR_ALL)
-#endif
-#else   /* !KTR */
-#undef KTR_COMPILE
-#define KTR_COMPILE 0
-#endif  /* KTR */
-
-/* Trace classes that can not be used with KTR_ALQ */
-#define KTR_ALQ_MASK    (KTR_WITNESS)
-
-/*
- * Version number for ktr_entry struct.  Increment this when you break binary
- * compatibility.
- */
-#define KTR_VERSION 2
-
-#define KTR_PARMS   6
-
-#ifndef LOCORE
-
-struct ktr_entry {
-    u_int64_t ktr_timestamp;
-    int ktr_cpu;
-    int ktr_line;
-    const   char *ktr_file;
-    const   char *ktr_desc;
-    struct  thread *ktr_thread;
-    u_long  ktr_parms[KTR_PARMS];
-};
-
-extern int ktr_cpumask;
-extern int ktr_mask;
-extern int ktr_entries;
-extern int ktr_verbose;
-
-extern volatile int ktr_idx;
-extern struct ktr_entry ktr_buf[];
-
-#ifdef KTR
-
-#if 0
-void    ktr_tracepoint(u_int mask, const char *file, int line,
-        const char *format, u_long arg1, u_long arg2, u_long arg3,
-        u_long arg4, u_long arg5, u_long arg6);
-#else
-extern void driver_printf(const char *format, ...);
-#define ktr_tracepoint(mask, file, line, format, arg1, arg2, arg3, arg4, arg5, arg6) \
-    driver_printf("(%s:%i) " format "\n", file, line, arg1, arg2, arg3, arg4, arg5, arg6)
-#endif
-
-#define CTR6(m, format, p1, p2, p3, p4, p5, p6) do {            \
-    if (KTR_COMPILE & (m))                      \
-        ktr_tracepoint((m), __FILE__, __LINE__, format,     \
-            (u_long)(p1), (u_long)(p2), (u_long)(p3),       \
-            (u_long)(p4), (u_long)(p5), (u_long)(p6));      \
-    } while(0)
-#define CTR0(m, format)         CTR6(m, format, 0, 0, 0, 0, 0, 0)
-#define CTR1(m, format, p1)     CTR6(m, format, p1, 0, 0, 0, 0, 0)
-#define CTR2(m, format, p1, p2)     CTR6(m, format, p1, p2, 0, 0, 0, 0)
-#define CTR3(m, format, p1, p2, p3) CTR6(m, format, p1, p2, p3, 0, 0, 0)
-#define CTR4(m, format, p1, p2, p3, p4) CTR6(m, format, p1, p2, p3, p4, 0, 0)
-#define CTR5(m, format, p1, p2, p3, p4, p5) CTR6(m, format, p1, p2, p3, p4, p5, 0)
-#else   /* KTR */
-#define CTR0(m, d)
-#define CTR1(m, d, p1)
-#define CTR2(m, d, p1, p2)
-#define CTR3(m, d, p1, p2, p3)
-#define CTR4(m, d, p1, p2, p3, p4)
-#define CTR5(m, d, p1, p2, p3, p4, p5)
-#define CTR6(m, d, p1, p2, p3, p4, p5, p6)
-#endif  /* KTR */
-
-#define TR0(d)              CTR0(KTR_GEN, d)
-#define TR1(d, p1)          CTR1(KTR_GEN, d, p1)
-#define TR2(d, p1, p2)          CTR2(KTR_GEN, d, p1, p2)
-#define TR3(d, p1, p2, p3)      CTR3(KTR_GEN, d, p1, p2, p3)
-#define TR4(d, p1, p2, p3, p4)      CTR4(KTR_GEN, d, p1, p2, p3, p4)
-#define TR5(d, p1, p2, p3, p4, p5)  CTR5(KTR_GEN, d, p1, p2, p3, p4, p5)
-#define TR6(d, p1, p2, p3, p4, p5, p6)  CTR6(KTR_GEN, d, p1, p2, p3, p4, p5, p6)
-
-/*
- * Trace initialization events, similar to CTR with KTR_INIT, but
- * completely ifdef'ed out if KTR_INIT isn't in KTR_COMPILE (to
- * save string space, the compiler doesn't optimize out strings
- * for the conditional ones above).
- */
-#if (KTR_COMPILE & KTR_INIT) != 0
-#define ITR0(d)             CTR0(KTR_INIT, d)
-#define ITR1(d, p1)         CTR1(KTR_INIT, d, p1)
-#define ITR2(d, p1, p2)         CTR2(KTR_INIT, d, p1, p2)
-#define ITR3(d, p1, p2, p3)     CTR3(KTR_INIT, d, p1, p2, p3)
-#define ITR4(d, p1, p2, p3, p4)     CTR4(KTR_INIT, d, p1, p2, p3, p4)
-#define ITR5(d, p1, p2, p3, p4, p5) CTR5(KTR_INIT, d, p1, p2, p3, p4, p5)
-#define ITR6(d, p1, p2, p3, p4, p5, p6) CTR6(KTR_INIT, d, p1, p2, p3, p4, p5, p6)
-#else
-#define ITR0(d)
-#define ITR1(d, p1)
-#define ITR2(d, p1, p2)
-#define ITR3(d, p1, p2, p3)
-#define ITR4(d, p1, p2, p3, p4)
-#define ITR5(d, p1, p2, p3, p4, p5)
-#define ITR6(d, p1, p2, p3, p4, p5, p6)
-#endif
-
-#endif /* !LOCORE */
-
-#endif /* !_SYS_KTR_H_ */

deleted file src/libs/compat/freebsd_network/compat/sys/libkern.h

@@ -1 @@
-/*
- * Copyright 2009, Colin Günther, coling@gmx.de.
- * All rights reserved. Distributed under the terms of the MIT License.
- */
-#ifndef _FBSD_COMPAT_SYS_LIBKERN_H_
-#define _FBSD_COMPAT_SYS_LIBKERN_H_
-
-
-#include <sys/cdefs.h>
-#include <sys/types.h>
-
-
-extern int random(void);
-uint32_t arc4random(void);
-
-static __inline int imax(int a, int b) { return (a > b ? a : b); }
-
-extern int abs(int a);
-
-#endif /* _FBSD_COMPAT_SYS_LIBKERN_H_ */

deleted file src/libs/compat/freebsd_network/compat/sys/limits.h

@@ -1 @@
-/*
- * Copyright 2009 Haiku Inc. All rights reserved.
- * Distributed under the terms of the MIT License.
- */
-#ifndef _FBSD_COMPAT_SYS_LIMITS_H_
-#define _FBSD_COMPAT_SYS_LIMITS_H_
-
-
-#endif /* _FBSD_COMPAT_SYS_LIMITS_H_ */

deleted file src/libs/compat/freebsd_network/compat/sys/linker.h

@@ -1 @@
-/*
- * Copyright 2009 Haiku Inc. All rights reserved.
- * Distributed under the terms of the MIT License.
- */
-#ifndef _FBSD_COMPAT_SYS_LINKER_H_
-#define _FBSD_COMPAT_SYS_LINKER_H_
-
-
-#endif /* _FBSD_COMPAT_SYS_LINKER_H_ */

deleted file src/libs/compat/freebsd_network/compat/sys/linker_set.h

@@ -1 @@
-/*
- * Copyright 2009 Haiku Inc. All rights reserved.
- * Distributed under the terms of the MIT License.
- */
-#ifndef _FBSD_COMPAT_SYS_LINKER_SET_H_
-#define _FBSD_COMPAT_SYS_LINKER_SET_H_
-
-
-#ifndef _FBSD_COMPAT_SYS_CDEFS_H_
-#error this file needs sys/cdefs.h as a prerequisite
-#endif
-
-/*
- * The following macros are used to declare global sets of objects, which
- * are collected by the linker into a `linker_set' as defined below.
- * For ELF, this is done by constructing a separate segment for each set.
- */
-
-/*
- * Private macros, not to be used outside this header file.
- */
-#ifdef __GNUCLIKE___SECTION
-#define __MAKE_SET(set, sym)                        \
-    static void const * const __set_##set##_sym_##sym       \
-    __section("set_" #set) __used = &sym
-#else /* !__GNUCLIKE___SECTION */
-#ifndef lint
-#error this file needs to be ported to your compiler
-#endif /* lint */
-#define __MAKE_SET(set, sym)    extern void const * const (__set_##set##_sym_##sym)
-#endif /* __GNUCLIKE___SECTION */
-
-/*
- * Public macros.
- */
-#define TEXT_SET(set, sym)  __MAKE_SET(set, sym)
-#define DATA_SET(set, sym)  __MAKE_SET(set, sym)
-#define BSS_SET(set, sym)   __MAKE_SET(set, sym)
-#define ABS_SET(set, sym)   __MAKE_SET(set, sym)
-#define SET_ENTRY(set, sym) __MAKE_SET(set, sym)
-
-/*
- * Initialize before referring to a given linker set.
- */
-#define SET_DECLARE(set, ptype)                     \
-    extern ptype *__CONCAT(__start_set_,set);           \
-    extern ptype *__CONCAT(__stop_set_,set)
-
-#define SET_BEGIN(set)                          \
-    (&__CONCAT(__start_set_,set))
-#define SET_LIMIT(set)                          \
-    (&__CONCAT(__stop_set_,set))
-
-/*
- * Iterate over all the elements of a set.
- *
- * Sets always contain addresses of things, and "pvar" points to words
- * containing those addresses.  Thus is must be declared as "type **pvar",
- * and the address of each set item is obtained inside the loop by "*pvar".
- */
-#define SET_FOREACH(pvar, set)                      \
-    for (pvar = SET_BEGIN(set); pvar < SET_LIMIT(set); pvar++)
-
-#endif /* _FBSD_COMPAT_SYS_LINKER_SET_H_ */

deleted file src/libs/compat/freebsd_network/compat/sys/malloc.h

@@ -1 @@
-/*
- * Copyright 2009, Colin Günther, coling@gmx.de.
- * Copyright 2007, Hugo Santos. All Rights Reserved.
- * Distributed under the terms of the MIT License.
- */
-#ifndef _FBSD_COMPAT_SYS_MALLOC_H_
-#define _FBSD_COMPAT_SYS_MALLOC_H_
-
-
-#include <malloc.h>
-
-#include <vm/vm.h>
-
-#include <sys/param.h>
-#include <sys/queue.h>
-#include <sys/_mutex.h>
-
-
-/*
- * flags to malloc.
- */
-#define M_NOWAIT        0x0001
-#define M_WAITOK        0x0002
-#define M_ZERO          0x0100
-
-#define M_MAGIC         877983977   /* time when first defined :-) */
-
-#define M_DEVBUF
-
-
-void *_kernel_malloc(size_t size, int flags);
-void _kernel_free(void *ptr);
-
-void *_kernel_contigmalloc(const char *file, int line, size_t size, int flags,
-    vm_paddr_t low, vm_paddr_t high, unsigned long alignment,
-    unsigned long boundary);
-void _kernel_contigfree(void *addr, unsigned long size);
-
-#define kernel_malloc(size, base, flags) \
-    _kernel_malloc(size, flags)
-
-#define kernel_free(ptr, base) \
-    _kernel_free(ptr)
-
-#define kernel_contigmalloc(size, type, flags, low, high, alignment, boundary) \
-    _kernel_contigmalloc(__FILE__, __LINE__, size, flags, low, high, \
-        alignment, boundary)
-
-#define kernel_contigfree(addr, size, base) \
-    _kernel_contigfree(addr, size)
-
-#ifdef FBSD_DRIVER
-#   define malloc(size, tag, flags) kernel_malloc(size, tag, flags)
-#   define free(pointer, tag)       kernel_free(pointer, tag)
-#   define contigmalloc(size, type, flags, low, high, alignment, boundary) \
-        _kernel_contigmalloc(__FILE__, __LINE__, size, flags, low, high, \
-            alignment, boundary)
-#   define contigfree(addr, size, base) \
-        _kernel_contigfree(addr, size)
-#endif
-
-#define MALLOC_DEFINE(type, shortdesc, longdesc)    int type[1]
-
-#define MALLOC_DECLARE(type) \
-        extern int type[1]
-
-#endif  /* _FBSD_COMPAT_SYS_MALLOC_H_ */

deleted file src/libs/compat/freebsd_network/compat/sys/mbuf-fbsd.h

@@ -1 @@
-/*-
- * Copyright (c) 1982, 1986, 1988, 1993
- *  The Regents of the University of California.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *  @(#)mbuf.h  8.5 (Berkeley) 2/19/95
- * $FreeBSD: src/sys/sys/mbuf.h,v 1.170.2.6 2006/03/23 23:24:32 sam Exp $
- */
-#ifndef _FBSD_COMPAT_SYS_MBUF_FBSD_H_
-#define _FBSD_COMPAT_SYS_MBUF_FBSD_H_
-
-/*
- * Set the m_data pointer of a newly-allocated mbuf (m_get/MGET) to place
- * an object of the specified size at the end of the mbuf, longword aligned.
- */
-#define M_ALIGN(m, len) do {                        \
-    (m)->m_data += (MLEN - (len)) & ~(sizeof(long) - 1);        \
-} while (0)
-
-/*
- * As above, for mbufs allocated with m_gethdr/MGETHDR
- * or initialized by M_COPY_PKTHDR.
- */
-#define MH_ALIGN(m, len) do {                       \
-    (m)->m_data += (MHLEN - (len)) & ~(sizeof(long) - 1);       \
-} while (0)
-
-/*
-#define MEXT_IS_REF(m)  (((m)->m_ext.ref_cnt != NULL)           \
-    && (*((m)->m_ext.ref_cnt) > 1))
- */
-#define MEXT_IS_REF(m)  0
-
-/*
- * Evaluate TRUE if it's safe to write to the mbuf m's data region (this
- * can be both the local data payload, or an external buffer area,
- * depending on whether M_EXT is set).
- */
-
-/*
-#define M_WRITABLE(m)   (!((m)->m_flags & M_RDONLY) && (!((m)->m_flags  \
-                & M_EXT) || !MEXT_IS_REF(m)))
- */
-#define M_WRITABLE(m)   (!((m)->m_flags & M_EXT) || !MEXT_IS_REF(m))
-
-/*
- * Compute the amount of space available
- * before the current start of data in an mbuf.
- *
- * The M_WRITABLE() is a temporary, conservative safety measure: the burden
- * of checking writability of the mbuf data area rests solely with the caller.
- */
-#define M_LEADINGSPACE(m)                       \
-    ((m)->m_flags & M_EXT ?                     \
-        (M_WRITABLE(m) ? (m)->m_data - (m)->m_ext.ext_buf : 0): \
-        (m)->m_flags & M_PKTHDR ? (m)->m_data - (m)->m_pktdat : \
-        (m)->m_data - (m)->m_dat)
-
-/*
- * Compute the amount of space available after the end of data in an mbuf.
- *
- * The M_WRITABLE() is a temporary, conservative safety measure: the burden
- * of checking writability of the mbuf data area rests solely with the caller.
- */
-#define M_TRAILINGSPACE(m)                      \
-    ((m)->m_flags & M_EXT ?                     \
-        (M_WRITABLE(m) ? (m)->m_ext.ext_buf + (m)->m_ext.ext_size   \
-        - ((m)->m_data + (m)->m_len) : 0) :         \
-        &(m)->m_dat[MLEN] - ((m)->m_data + (m)->m_len))
-
-/*
- * Arrange to prepend space of size plen to mbuf m.
- * If a new mbuf must be allocated, how specifies whether to wait.
- * If the allocation fails, the original mbuf chain is freed and m is
- * set to NULL.
- */
-#define M_PREPEND(m, plen, how) do {                    \
-    struct mbuf **_mmp = &(m);                  \
-    struct mbuf *_mm = *_mmp;                   \
-    int _mplen = (plen);                        \
-    int __mhow = (how);                     \
-                                    \
-    MBUF_CHECKSLEEP(how);                       \
-    if (M_LEADINGSPACE(_mm) >= _mplen) {                \
-        _mm->m_data -= _mplen;                  \
-        _mm->m_len += _mplen;                   \
-    } else                              \
-        _mm = m_prepend(_mm, _mplen, __mhow);           \
-    if (_mm != NULL && _mm->m_flags & M_PKTHDR)         \
-        _mm->m_pkthdr.len += _mplen;                \
-    *_mmp = _mm;                            \
-} while (0)
-
-#endif

deleted file src/libs/compat/freebsd_network/compat/sys/mbuf.h

@@ -1 @@
-/*
- * Copyright 2009, Colin Günther, coling@gmx.de.
- * Copyright 2007, Hugo Santos. All Rights Reserved.
- * Distributed under the terms of the MIT License.
- */
-#ifndef _FBSD_COMPAT_SYS_MBUF_H_
-#define _FBSD_COMPAT_SYS_MBUF_H_
-
-
-#include <sys/queue.h>
-#include <sys/systm.h>
-#include <vm/uma.h>
-
-
-#define MLEN        ((int)(MSIZE - sizeof(struct m_hdr)))
-#define MHLEN       ((int)(MLEN - sizeof(struct pkthdr)))
-
-#define MINCLSIZE   (MHLEN + 1)
-
-#define MBTOM(how)  (how)
-#define M_DONTWAIT  M_NOWAIT
-#define M_TRYWAIT   M_WAITOK
-#define M_WAIT      M_WAITOK
-
-#define MT_DATA     1
-
-#define M_EXT       0x00000001
-#define M_PKTHDR    0x00000002
-#define M_RDONLY    0x00000008
-#define M_PROTO1    0x00000010
-#define M_PROTO2    0x00000020
-#define M_PROTO3    0x00000040
-#define M_PROTO4    0x00000080
-#define M_PROTO5    0x00000100
-#define M_BCAST     0x00000200
-#define M_MCAST     0x00000400
-#define M_FRAG      0x00000800
-#define M_FIRSTFRAG 0x00001000
-#define M_LASTFRAG  0x00002000
-#define M_VLANTAG   0x00010000
-#define M_PROTO6    0x00080000
-#define M_PROTO7    0x00100000
-#define M_PROTO8    0x00200000
-
-#define M_COPYFLAGS (M_PKTHDR | M_RDONLY | M_BCAST | M_MCAST | M_FRAG \
-    | M_FIRSTFRAG | M_LASTFRAG | M_VLANTAG)
-    // Flags preserved when copying m_pkthdr
-
-#define M_MOVE_PKTHDR(to, from) m_move_pkthdr((to), (from))
-#define MGET(m, how, type)      ((m) = m_get((how), (type)))
-#define MGETHDR(m, how, type)   ((m) = m_gethdr((how), (type)))
-#define MCLGET(m, how)          m_clget((m), (how))
-
-#define mtod(m, type)   ((type)((m)->m_data))
-
-// Check if the supplied mbuf has a packet header, or else panic.
-#define M_ASSERTPKTHDR(m) KASSERT(m != NULL && m->m_flags & M_PKTHDR, \
-    ("%s: no mbuf packet header!", __func__))
-
-#define MBUF_CHECKSLEEP(how) do { } while (0)
-
-#define MTAG_PERSISTENT 0x800
-
-#define EXT_CLUSTER     1       // 2048 bytes
-#define EXT_JUMBOP      4       // Page size
-#define EXT_JUMBO9      5       // 9 * 1024 bytes
-#define EXT_NET_DRV     100     // custom ext_buf provided by net driver
-
-#define CSUM_IP         0x0001
-#define CSUM_TCP        0x0002
-#define CSUM_UDP        0x0004
-#define CSUM_TSO        0x0020
-#define CSUM_IP_CHECKED 0x0100
-#define CSUM_IP_VALID   0x0200
-#define CSUM_DATA_VALID 0x0400
-#define CSUM_PSEUDO_HDR 0x0800
-#define CSUM_DELAY_DATA (CSUM_TCP | CSUM_UDP)
-
-// TODO After all network driver are updated to the FreeBSD 8 version this can
-// changed
-#if __FreeBSD_version__ >= 8
-#define MEXTADD(m, buf, size, free, arg1, arg2, flags, type) \
-    m_extadd((m), (caddr_t)(buf), (size), (free),(arg1),(arg2),(flags), (type))
-#else
-#define MEXTADD(m, buf, size, free, args, flags, type) \
-    m_extadd((m), (caddr_t)(buf), (size), (free),(args),(flags), (type))
-#endif
-
-
-extern int max_linkhdr;
-extern int max_protohdr;
-extern int max_hdr;
-extern int max_datalen;     // MHLEN - max_hdr
-
-
-struct m_hdr {
-    struct mbuf*    mh_next;
-    struct mbuf*    mh_nextpkt;
-    caddr_t         mh_data;
-    int             mh_len;
-    int             mh_flags;
-    short           mh_type;
-};
-
-struct pkthdr {
-    struct ifnet*                   rcvif;
-    int                             len;
-    int                             csum_flags;
-    int                             csum_data;
-    uint16_t                        tso_segsz;
-    uint16_t                        ether_vtag;
-    SLIST_HEAD(packet_tags, m_tag)  tags;
-};
-
-struct m_tag {
-    SLIST_ENTRY(m_tag)  m_tag_link;     // List of packet tags
-    u_int16_t           m_tag_id;       // Tag ID
-    u_int16_t           m_tag_len;      // Length of data
-    u_int32_t           m_tag_cookie;   // ABI/Module ID
-    void                (*m_tag_free)(struct m_tag*);
-};
-
-struct m_ext {
-    caddr_t         ext_buf;
-    unsigned int    ext_size;
-    int             ext_type;
-};
-
-struct mbuf {
-    struct m_hdr m_hdr;
-    union {
-        struct {
-            struct pkthdr   MH_pkthdr;
-            union {
-                struct m_ext    MH_ext;
-                char            MH_databuf[MHLEN];
-            } MH_dat;
-        } MH;
-        char M_databuf[MLEN];
-    } M_dat;
-};
-
-
-#define m_next      m_hdr.mh_next
-#define m_len       m_hdr.mh_len
-#define m_data      m_hdr.mh_data
-#define m_type      m_hdr.mh_type
-#define m_flags     m_hdr.mh_flags
-#define m_nextpkt   m_hdr.mh_nextpkt
-#define m_act       m_nextpkt
-#define m_pkthdr    M_dat.MH.MH_pkthdr
-#define m_ext       M_dat.MH.MH_dat.MH_ext
-#define m_pktdat    M_dat.MH.MH_dat.MH_databuf
-#define m_dat       M_dat.M_databuf
-
-
-void            m_adj(struct mbuf*, int);
-void            m_align(struct mbuf*, int);
-int             m_append(struct mbuf*, int, c_caddr_t);
-void            m_cat(struct mbuf*, struct mbuf*);
-void            m_clget(struct mbuf*, int);
-void*           m_cljget(struct mbuf*, int, int);
-struct mbuf*    m_collapse(struct mbuf*, int, int);
-void            m_copyback(struct mbuf*, int, int, caddr_t);
-void            m_copydata(const struct mbuf*, int, int, caddr_t);
-struct mbuf*    m_copypacket(struct mbuf*, int);
-struct mbuf*    m_defrag(struct mbuf*, int);
-struct mbuf*    m_devget(char*, int, int, struct ifnet*,
-    void(*) (char*, caddr_t, u_int));
-
-struct mbuf*    m_dup(struct mbuf*, int);
-int             m_dup_pkthdr(struct mbuf*, struct mbuf*, int);
-
-// TODO After all network driver are updated to the FreeBSD 8 version this can
-// changed
-#if __FreeBSD_version__ >= 8
-void            m_extadd(struct mbuf*, caddr_t, u_int, void(*) (void*, void*),
-    void*, void*, int, int);
-#else
-void            m_extadd(struct mbuf*, caddr_t, u_int, void(*) (void*, void*),
-    void*, int, int);
-#endif
-
-u_int           m_fixhdr(struct mbuf*);
-struct mbuf*    m_free(struct mbuf*);
-void            m_freem(struct mbuf*);
-struct mbuf*    m_get(int, short);
-struct mbuf*    m_gethdr(int, short);
-struct mbuf*    m_getjcl(int, short, int, int);
-u_int           m_length(struct mbuf*, struct mbuf**);
-struct mbuf*    m_getcl(int, short, int);
-void            m_move_pkthdr(struct mbuf*, struct mbuf*);
-struct mbuf*    m_prepend(struct mbuf*, int, int);
-struct mbuf*    m_pulldown(struct mbuf*, int, int, int*);
-struct mbuf*    m_pullup(struct mbuf*, int);
-struct mbuf*    m_split(struct mbuf*, int, int);
-struct mbuf*    m_unshare(struct mbuf*, int);
-
-struct m_tag*   m_tag_alloc(u_int32_t, int, int, int);
-void            m_tag_delete(struct mbuf*, struct m_tag*);
-void            m_tag_delete_chain(struct mbuf*, struct m_tag*);
-void            m_tag_free_default(struct m_tag*);
-struct m_tag*   m_tag_locate(struct mbuf*, u_int32_t, int, struct m_tag*);
-struct m_tag*   m_tag_copy(struct m_tag*, int);
-int             m_tag_copy_chain(struct mbuf*, struct mbuf*, int);
-void            m_tag_delete_nonpersistent(struct mbuf*);
-
-
-static inline void
-m_tag_setup(struct m_tag* tagPointer, u_int32_t cookie, int type, int length)
-{
-    tagPointer->m_tag_id = type;
-    tagPointer->m_tag_len = length;
-    tagPointer->m_tag_cookie = cookie;
-}
-
-
-static inline void
-m_tag_free(struct m_tag* tag)
-{
-    (*tag->m_tag_free)(tag);
-}
-
-
-static inline void
-m_tag_prepend(struct mbuf* memoryBuffer, struct m_tag* tag)
-{
-    SLIST_INSERT_HEAD(&memoryBuffer->m_pkthdr.tags, tag, m_tag_link);
-}
-
-
-static inline void
-m_tag_unlink(struct mbuf* memoryBuffer, struct m_tag* tag)
-{
-    SLIST_REMOVE(&memoryBuffer->m_pkthdr.tags, tag, m_tag, m_tag_link);
-}
-
-
-#include <sys/mbuf-fbsd.h>
-
-#endif  /* _FBSD_COMPAT_SYS_MBUF_H_ */

deleted file src/libs/compat/freebsd_network/compat/sys/module.h

@@ -1 @@
-#ifndef _FBSD_COMPAT_SYS_MODULE_H_
-#define _FBSD_COMPAT_SYS_MODULE_H_
-
-
-#include <sys/linker_set.h>
-
-
-typedef struct module* module_t;
-
-typedef enum modeventtype {
-    MOD_LOAD,
-    MOD_UNLOAD,
-    MOD_SHUTDOWN,
-    MOD_QUIESCE
-} modeventtype_t;
-
-
-#define DECLARE_MODULE(name, data, sub, order)
-
-#define MODULE_VERSION(name, version)
-#define MODULE_DEPEND(module, mdepend, vmin, vpref, vmax)
-
-#endif

deleted file src/libs/compat/freebsd_network/compat/sys/mount.h

@@ -1 @@
-/*
- * Copyright 2009 Haiku Inc. All rights reserved.
- * Distributed under the terms of the MIT License.
- */
-#ifndef _FBSD_COMPAT_SYS_MOUNT_H_
-#define _FBSD_COMPAT_SYS_MOUNT_H_
-
-
-#endif /* _FBSD_COMPAT_SYS_MOUNT_H_ */

deleted file src/libs/compat/freebsd_network/compat/sys/mutex.h

@@ -1 @@
-/*
- * Copyright 2009, Colin Günther, coling@gmx.de.
- * Copyright 2007, Hugo Santos. All Rights Reserved.
- * Distributed under the terms of the MIT License.
- */
-#ifndef _FBSD_COMPAT_SYS_MUTEX_H_
-#define _FBSD_COMPAT_SYS_MUTEX_H_
-
-
-#include <sys/haiku-module.h>
-
-#include <sys/queue.h>
-#include <sys/_mutex.h>
-#include <sys/pcpu.h>
-#include <machine/atomic.h>
-#include <machine/cpufunc.h>
-
-
-#define MA_OWNED        0x1
-#define MA_NOTOWNED     0x2
-#define MA_RECURSED     0x4
-#define MA_NOTRECURSED  0x8
-
-#define mtx_assert(mtx, what)
-
-#define MTX_DEF             0x0000
-#define MTX_RECURSE         0x0004
-#define MTX_QUIET           0x40000
-#define MTX_DUPOK           0x400000
-
-
-#define MTX_NETWORK_LOCK    "network driver"
-
-#define NET_LOCK_GIANT()
-#define NET_UNLOCK_GIANT()
-
-
-extern struct mtx Giant;
-
-
-void mtx_init(struct mtx*, const char*, const char*, int);
-void mtx_destroy(struct mtx*);
-
-
-static inline void
-mtx_lock(struct mtx* mutex)
-{
-    if (mutex->type == MTX_DEF) {
-        mutex_lock(&mutex->u.mutex.lock);
-        mutex->u.mutex.owner = find_thread(NULL);
-    } else if (mutex->type == MTX_RECURSE)
-        recursive_lock_lock(&mutex->u.recursive);
-}
-
-
-static inline void
-mtx_unlock(struct mtx* mutex)
-{
-    if (mutex->type == MTX_DEF) {
-        mutex->u.mutex.owner = -1;
-        mutex_unlock(&mutex->u.mutex.lock);
-    } else if (mutex->type == MTX_RECURSE)
-        recursive_lock_unlock(&mutex->u.recursive);
-}
-
-
-static inline int
-mtx_initialized(struct mtx* mutex)
-{
-    /* TODO */
-    return 1;
-}
-
-
-static inline int
-mtx_owned(struct mtx* mutex)
-{
-    if (mutex->type == MTX_DEF)
-        return mutex->u.mutex.owner == find_thread(NULL);
-    if (mutex->type == MTX_RECURSE) {
-#if KDEBUG
-        return mutex->u.recursive.lock.holder == find_thread(NULL);
-#else
-        return mutex->u.recursive.holder == find_thread(NULL);
-#endif
-    }
-
-    return 0;
-}
-
-
-#endif  /* _FBSD_COMPAT_SYS_MUTEX_H_ */

deleted file src/libs/compat/freebsd_network/compat/sys/namei.h

@@ -1 @@
-/*
- * Copyright 2009 Haiku Inc. All rights reserved.
- * Distributed under the terms of the MIT License.
- */
-#ifndef _FBSD_COMPAT_SYS_NAMEI_H_
-#define _FBSD_COMPAT_SYS_NAMEI_H_
-
-
-#endif /* _FBSD_COMPAT_SYS_NAMEI_H_ */

deleted file src/libs/compat/freebsd_network/compat/sys/param.h

@@ -1 @@
-/*
- * Copyright 2009, Colin Günther, coling@gmx.de.
- * Copyright 2007, Hugo Santos. All Rights Reserved.
- * Distributed under the terms of the MIT License.
- */
-#ifndef _FBSD_COMPAT_SYS_PARAM_H_
-#define _FBSD_COMPAT_SYS_PARAM_H_
-
-
-#include <posix/sys/param.h>
-
-#include <sys/types.h>
-#include <sys/cdefs.h>
-#include <sys/errno.h>
-#include <sys/time.h>
-#include <sys/priority.h>
-
-
-/* The version this compatibility layer is based on */
-#define __FreeBSD_version 800107
-
-#define MAXBSIZE    0x10000
-
-#define PAGE_SHIFT  12
-#define PAGE_MASK   (PAGE_SIZE - 1)
-
-#define trunc_page(x)   ((x) & ~PAGE_MASK)
-
-#define ptoa(x)         ((unsigned long)((x) << PAGE_SHIFT))
-#define atop(x)         ((unsigned long)((x) >> PAGE_SHIFT))
-
-/* MAJOR FIXME */
-#define Maxmem          (32768)
-
-#ifndef MSIZE
-#define MSIZE 256
-#endif
-
-#ifndef MCLSHIFT
-#define MCLSHIFT 11
-#endif
-
-#define MCLBYTES        (1 << MCLSHIFT)
-
-#define MJUMPAGESIZE    PAGE_SIZE
-#define MJUM9BYTES      (9 * 1024)
-#define MJUM16BYTES     (16 * 1024)
-
-#define ALIGN_BYTES     (sizeof(unsigned long) - 1)
-#define ALIGN(x)        ((((unsigned long)x) + ALIGN_BYTES) & ~ALIGN_BYTES)
-
-/* Macros for counting and rounding. */
-#ifndef howmany
-#define howmany(x, y)   (((x)+((y)-1))/(y))
-#endif
-#define roundup(x, y)   ((((x)+((y)-1))/(y))*(y))  /* to any y */
-#define roundup2(x, y)  (((x) + ((y) - 1)) & (~((y) - 1)))
-#define rounddown(x, y)  (((x) / (y)) * (y))
-
-#define PRIMASK 0x0ff
-#define PCATCH  0x100
-#define PDROP   0x200
-#define PBDRY   0x400
-
-#define NBBY    8       /* number of bits in a byte */
-
-/* Bit map related macros. */
-#define setbit(a,i) (((unsigned char *)(a))[(i)/NBBY] |= 1<<((i)%NBBY))
-#define clrbit(a,i) (((unsigned char *)(a))[(i)/NBBY] &= ~(1<<((i)%NBBY)))
-#define isset(a,i)                          \
-    (((const unsigned char *)(a))[(i)/NBBY] & (1<<((i)%NBBY)))
-#define isclr(a,i)                          \
-    ((((const unsigned char *)(a))[(i)/NBBY] & (1<<((i)%NBBY))) == 0)
-
-#endif  /* _FBSD_COMPAT_SYS_PARAM_H_ */

deleted file src/libs/compat/freebsd_network/compat/sys/pcpu.h

@@ -1 @@
-/*
- * Copyright 2009, Colin Günther, coling@gmx.de.
- * All rights reserved. Distributed under the terms of the MIT License.
- */
-#ifndef _FBSD_COMPAT_SYS_PCPU_H_
-#define _FBSD_COMPAT_SYS_PCPU_H_
-
-
-#include <OS.h>
-
-
-struct thread;
-
-#define curthread ((struct thread*)NULL)
-    /* NOTE: Dereferencing curthread will crash, which is intentional. There is
-       no FreeBSD compatible struct thread and Haiku's should not be used as it
-       is only valid for the current thread or with proper locking. Currently
-       only priv_check() expects a struct thread parameter and ignores it. Using
-       NULL will show us when other uses appear. */
-
-
-#endif /* _FBSD_COMPAT_SYS_PCPU_H_ */

deleted file src/libs/compat/freebsd_network/compat/sys/priority.h

@@ -1 @@
-/*
- * Copyright 2009 Haiku Inc. All rights reserved.
- * Distributed under the terms of the MIT License.
- */
-#ifndef _FBSD_COMPAT_SYS_PRIORITY_H_
-#define _FBSD_COMPAT_SYS_PRIORITY_H_
-
-
-#define PRI_MIN_KERN    (64)
-#define PZERO           (PRI_MIN_KERN + 20)
-
-#endif /* _FBSD_COMPAT_SYS_PRIORITY_H_ */

deleted file src/libs/compat/freebsd_network/compat/sys/priv.h

@@ -1 @@
-/*
- * Copyright 2009, Colin Günther, coling@gmx.de.
- * All rights reserved. Distributed under the terms of the MIT License.
- */
-#ifndef _FBSD_COMPAT_SYS_PRIV_H_
-#define _FBSD_COMPAT_SYS_PRIV_H_
-
-
-#include <sys/cdefs.h>
-
-
-/*
- * 802.11-related privileges.
- */
-#define PRIV_NET80211_GETKEY    440 /* Query 802.11 keys. */
-#define PRIV_NET80211_MANAGE    441 /* Administer 802.11. */
-
-#define PRIV_DRIVER     14  /* Low-level driver privilege. */
-
-
-/*
- * Privilege check interfaces, modeled after historic suser() interfacs, but
- * with the addition of a specific privilege name.  No flags are currently
- * defined for the API.  Historically, flags specified using the real uid
- * instead of the effective uid, and whether or not the check should be
- * allowed in jail.
- */
-struct thread;
-
-
-__BEGIN_DECLS
-
-int priv_check(struct thread*, int);
-
-__END_DECLS
-
-
-#endif /* _FBSD_COMPAT_SYS_PRIV_H_ */

deleted file src/libs/compat/freebsd_network/compat/sys/proc.h

@@ -1 @@
-/*
- * Copyright 2009 Haiku Inc. All rights reserved.
- * Distributed under the terms of the MIT License.
- */
-#ifndef _FBSD_COMPAT_SYS_PROC_H_
-#define _FBSD_COMPAT_SYS_PROC_H_
-
-
-#endif /* _FBSD_COMPAT_SYS_PROC_H_ */

deleted file src/libs/compat/freebsd_network/compat/sys/rman.h

@@ -1 @@
-/*
- * Copyright 2007, Hugo Santos. All Rights Reserved.
- * Distributed under the terms of the MIT License.
- */
-
-
-/*-
- * Copyright 1998 Massachusetts Institute of Technology
- *
- * Permission to use, copy, modify, and distribute this software and
- * its documentation for any purpose and without fee is hereby
- * granted, provided that both the above copyright notice and this
- * permission notice appear in all copies, that both the above
- * copyright notice and this permission notice appear in all
- * supporting documentation, and that the name of M.I.T. not be used
- * in advertising or publicity pertaining to distribution of the
- * software without specific, written prior permission.  M.I.T. makes
- * no representations about the suitability of this software for any
- * purpose.  It is provided "as is" without express or implied
- * warranty.
- * 
- * THIS SOFTWARE IS PROVIDED BY M.I.T. ``AS IS''.  M.I.T. DISCLAIMS
- * ALL EXPRESS OR IMPLIED WARRANTIES WITH REGARD TO THIS SOFTWARE,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT
- * SHALL M.I.T. BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
- * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
- * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
- * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * $FreeBSD$
- */
-#ifndef _FBSD_COMPAT_SYS_RMAN_H_
-#define _FBSD_COMPAT_SYS_RMAN_H_
-
-
-#include <machine/_bus.h>
-#include <machine/resource.h>
-
-
-#define RF_ACTIVE       0x0002
-#define RF_SHAREABLE    0x0004
-#define RF_OPTIONAL     0x0080
-
-#define RF_ALIGNMENT_SHIFT      10 /* alignment size bit starts bit 10 */
-#define RF_ALIGNMENT_LOG2(x)    ((x) << RF_ALIGNMENT_SHIFT)
-
-struct resource {
-    int                 r_type;
-    bus_space_tag_t     r_bustag;       /* bus_space tag */
-    bus_space_handle_t  r_bushandle;    /* bus_space handle */
-    area_id             r_mapped_area;
-};
-
-
-bus_space_handle_t rman_get_bushandle(struct resource *);
-bus_space_tag_t rman_get_bustag(struct resource *);
-int rman_get_rid(struct resource *);
-
-
-static inline u_long
-rman_get_start(struct resource *resourcePointer)
-{
-    return resourcePointer->r_bushandle;
-}
-
-
-static inline uint32_t
-rman_make_alignment_flags(uint32_t size)
-{
-    int i;
-
-    /*
-     * Find the hightest bit set, and add one if more than one bit
-     * set.  We're effectively computing the ceil(log2(size)) here.
-     */
-    for (i = 31; i > 0; i--)
-        if ((1 << i) & size)
-            break;
-    if (~(1 << i) & size)
-        i++;
-
-    return RF_ALIGNMENT_LOG2(i);
-}
-#endif /* _FBSD_COMPAT_SYS_RMAN_H_ */

deleted file src/libs/compat/freebsd_network/compat/sys/socket.h

@@ -1 @@
-/*
- * Copyright 2009, Colin Günther, coling@gmx.de.
- * All rights reserved. Distributed under the terms of the MIT License.
- */
-#ifndef _FBSD_COMPAT_SYS_SOCKET_H_
-#define _FBSD_COMPAT_SYS_SOCKET_H_
-
-
-#include <posix/sys/socket.h>
-
-#include <sys/cdefs.h>
-#include <sys/_types.h>
-
-
-// TODO Should be incorporated into Haikus socket.h with a number below AF_MAX
-#define AF_IEEE80211    AF_MAX + 1  /* IEEE 802.11 protocol */
-
-#endif /* _FBSD_COMPAT_SYS_SOCKET_H_ */

deleted file src/libs/compat/freebsd_network/compat/sys/sockio.h

@@ -1 @@
-/*
- * Copyright 2007-2009 Haiku Inc. All rights reserved.
- * Distributed under the terms of the MIT License.
- */
-#ifndef _FBSD_COMPAT_SYS_SOCKIO_H_
-#define _FBSD_COMPAT_SYS_SOCKIO_H_
-
-
-#include <posix/sys/sockio.h>
-
-#include <sys/ioccom.h>
-
-
-#define SIOCSIFCAP  SIOCSPACKETCAP
-
-#endif

deleted file src/libs/compat/freebsd_network/compat/sys/sysctl.h

@@ -1 @@
-/*
- * Copyright 2009 Haiku Inc. All rights reserved.
- * Distributed under the terms of the MIT License.
- */
-#ifndef _FBSD_COMPAT_SYS_SYSCTL_H_
-#define _FBSD_COMPAT_SYS_SYSCTL_H_
-
-
-#include <sys/queue.h>
-
-
-#ifdef _KERNEL
-
-struct sysctl_req {
-    void *newptr;
-};
-
-struct sysctl_ctx_list {
-};
-
-struct sysctl_oid_list {
-};
-
-
-#define SYSCTL_HANDLER_ARGS void *oidp, void *arg1, int arg2, \
-    struct sysctl_req *req
-
-#define OID_AUTO    (-1)
-
-#define CTLTYPE     0xf /* Mask for the type */
-#define CTLTYPE_NODE    1   /* name is a node */
-#define CTLTYPE_INT 2   /* name describes an integer */
-#define CTLTYPE_STRING  3   /* name describes a string */
-#define CTLTYPE_QUAD    4   /* name describes a 64-bit number */
-#define CTLTYPE_OPAQUE  5   /* name describes a structure */
-#define CTLTYPE_STRUCT  CTLTYPE_OPAQUE  /* name describes a structure */
-#define CTLTYPE_UINT    6   /* name describes an unsigned integer */
-#define CTLTYPE_LONG    7   /* name describes a long */
-#define CTLTYPE_ULONG   8   /* name describes an unsigned long */
-#define CTLTYPE_U64     9   /* name describes an unsigned 64-bit number */
-
-#define CTLFLAG_RD  0x80000000  /* Allow reads of variable */
-#define CTLFLAG_WR  0x40000000  /* Allow writes to the variable */
-#define CTLFLAG_RW  (CTLFLAG_RD|CTLFLAG_WR)
-#define CTLFLAG_NOLOCK  0x20000000  /* XXX Don't Lock */
-#define CTLFLAG_ANYBODY 0x10000000  /* All users can set this var */
-#define CTLFLAG_SECURE  0x08000000  /* Permit set only if securelevel<=0 */
-#define CTLFLAG_PRISON  0x04000000  /* Prisoned roots can fiddle */
-#define CTLFLAG_DYN 0x02000000  /* Dynamic oid - can be freed */
-#define CTLFLAG_SKIP    0x01000000  /* Skip this sysctl when listing */
-#define CTLMASK_SECURE  0x00F00000  /* Secure level */
-#define CTLFLAG_TUN 0x00080000  /* Tunable variable */
-#define CTLFLAG_MPSAFE  0x00040000  /* Handler is MP safe */
-#define CTLFLAG_RDTUN   (CTLFLAG_RD|CTLFLAG_TUN)
-
-
-static inline int
-sysctl_ctx_init(struct sysctl_ctx_list *clist)
-{
-    return -1;
-}
-
-
-static inline int
-sysctl_ctx_free(struct sysctl_ctx_list *clist)
-{
-    return -1;
-}
-
-
-static inline void *
-sysctl_add_oid(struct sysctl_ctx_list *clist, void *parent, int nbr, 
-    const char *name, int kind, void *arg1, int arg2,
-    int (*handler) (SYSCTL_HANDLER_ARGS), const char *fmt, const char *descr)
-{
-    return NULL;
-}
-
-
-static inline int sysctl_handle_long(SYSCTL_HANDLER_ARGS) { return -1; }
-static inline int sysctl_handle_opaque(SYSCTL_HANDLER_ARGS) { return -1; }
-static inline int sysctl_handle_quad(SYSCTL_HANDLER_ARGS) { return -1; }
-static inline int sysctl_handle_int(SYSCTL_HANDLER_ARGS) { return -1; }
-static inline int sysctl_handle_64(SYSCTL_HANDLER_ARGS) { return -1; }
-static inline int sysctl_handle_string(SYSCTL_HANDLER_ARGS) { return -1; }
-
-
-#define SYSCTL_OUT(r, p, l) -1
-
-#define __DESCR(x) ""
-
-#define SYSCTL_ADD_OID(ctx, parent, nbr, name, kind, a1, a2, handler, fmt, descr) \
-    sysctl_add_oid(ctx, parent, nbr, name, kind, a1, a2, handler, fmt, \
-    __DESCR(descr))
-
-#define SYSCTL_ADD_NODE(ctx, parent, nbr, name, access, handler, descr) \
-    sysctl_add_oid(ctx, parent, nbr, name, CTLTYPE_NODE|(access),       \
-    0, 0, handler, "N", __DESCR(descr))
-
-#define SYSCTL_ADD_STRING(ctx, parent, nbr, name, access, arg, len, descr)  \
-    sysctl_add_oid(ctx, parent, nbr, name, CTLTYPE_STRING|(access),         \
-    arg, len, sysctl_handle_string, "A", __DESCR(descr))
-
-#define SYSCTL_ADD_INT(ctx, parent, nbr, name, access, ptr, val, descr) \
-    sysctl_add_oid(ctx, parent, nbr, name, CTLTYPE_INT|(access),        \
-    ptr, val, sysctl_handle_int, "I", __DESCR(descr))
-
-#define SYSCTL_ADD_UINT(ctx, parent, nbr, name, access, ptr, val, descr)    \
-    sysctl_add_oid(ctx, parent, nbr, name, CTLTYPE_UINT|(access),           \
-    ptr, val, sysctl_handle_int, "IU", __DESCR(descr))
-
-#define SYSCTL_ADD_XINT(ctx, parent, nbr, name, access, ptr, val, descr)    \
-    sysctl_add_oid(ctx, parent, nbr, name, CTLTYPE_UINT|(access),           \
-    ptr, val, sysctl_handle_int, "IX", __DESCR(descr))
-
-#define SYSCTL_ADD_LONG(ctx, parent, nbr, name, access, ptr, descr) \
-    sysctl_add_oid(ctx, parent, nbr, name, CTLTYPE_LONG|(access),   \
-    ptr, 0, sysctl_handle_long, "L", __DESCR(descr))
-
-#define SYSCTL_ADD_ULONG(ctx, parent, nbr, name, access, ptr, descr)    \
-    sysctl_add_oid(ctx, parent, nbr, name, CTLTYPE_ULONG|(access),      \
-    ptr, 0, sysctl_handle_long, "LU", __DESCR(descr))
-
-#define SYSCTL_ADD_QUAD(ctx, parent, nbr, name, access, ptr, descr) \
-    sysctl_add_oid(ctx, parent, nbr, name, CTLTYPE_QUAD|(access),   \
-    ptr, 0, sysctl_handle_quad, "Q", __DESCR(descr))
-
-#define SYSCTL_ADD_UQUAD(ctx, parent, nbr, name, access, ptr, descr)    \
-    sysctl_add_oid(ctx, parent, nbr, name,                              \
-    CTLTYPE_U64 | CTLFLAG_MPSAFE | (access),                            \
-    ptr, 0, sysctl_handle_64, "QU", __DESCR(descr))
-
-#define SYSCTL_ADD_OPAQUE(ctx, parent, nbr, name, access, ptr, len, fmt, descr) \
-    sysctl_add_oid(ctx, parent, nbr, name, CTLTYPE_OPAQUE|(access), \
-    ptr, len, sysctl_handle_opaque, fmt, __DESCR(descr))
-
-#define SYSCTL_ADD_STRUCT(ctx, parent, nbr, name, access, ptr, type, descr) \
-    sysctl_add_oid(ctx, parent, nbr, name, CTLTYPE_OPAQUE|(access),         \
-    ptr, sizeof(struct type), sysctl_handle_opaque, "S," #type, __DESCR(descr))
-
-#define SYSCTL_ADD_PROC(ctx, parent, nbr, name, access, ptr, arg, handler, fmt, descr) \
-    sysctl_add_oid(ctx, parent, nbr, name, (access), ptr, arg, handler, fmt, \
-    __DESCR(descr))
-
-
-static inline void *
-SYSCTL_CHILDREN(void *ptr)
-{
-    return NULL;
-}
-
-
-#define SYSCTL_STATIC_CHILDREN(...) NULL
-
-#define SYSCTL_DECL(name) \
-    extern struct sysctl_oid_list sysctl_##name##_children
-
-#define SYSCTL_NODE(...)
-#define SYSCTL_INT(...)
-#define SYSCTL_UINT(...)
-#define SYSCTL_PROC(...)
-
-#endif
-
-#endif

deleted file src/libs/compat/freebsd_network/compat/sys/syslog.h

@@ -1 @@
-/*
- * Copyright 2009 Haiku Inc. All rights reserved.
- * Distributed under the terms of the MIT License.
- */
-#ifndef _FBSD_COMPAT_SYS_SYSLOG_H_
-#define _FBSD_COMPAT_SYS_SYSLOG_H_
-
-
-#define LOG_ERR 3 /* error conditions */
-
-#endif /* _FBSD_COMPAT_SYS_SYSLOG_H_ */

deleted file src/libs/compat/freebsd_network/compat/sys/systm.h

@@ -1 @@
-/*
- * Copyright 2009, Colin Günther, coling@gmx.de.
- * Copyright 2007, Hugo Santos. All Rights Reserved.
- * Distributed under the terms of the MIT License.
- */
-#ifndef _FBSD_COMPAT_SYS_SYSTM_H_
-#define _FBSD_COMPAT_SYS_SYSTM_H_
-
-
-#include <stdint.h>
-#include <stdio.h>
-#include <string.h>
-#include <strings.h>
-
-#include <machine/atomic.h>
-#include <machine/cpufunc.h>
-
-#include <sys/callout.h>
-#include <sys/cdefs.h>
-#include <sys/queue.h>
-
-#include <sys/libkern.h>
-
-
-#define printf freebsd_printf
-int printf(const char *format, ...) __printflike(1, 2);
-
-
-#define ovbcopy(f, t, l) bcopy((f), (t), (l))
-
-#define bootverbose 1
-
-#ifdef INVARIANTS
-#define KASSERT(cond,msg) do {  \
-    if (!(cond))                \
-        panic msg;              \
-} while (0)
-#else
-#define KASSERT(exp,msg) do { \
-} while (0)
-#endif
-
-#define DELAY(n) \
-    do {                \
-        if (n < 1000)   \
-            spin(n);    \
-        else            \
-            snooze(n);  \
-    } while (0)
-
-void wakeup(void *);
-
-#ifndef CTASSERT /* Allow lint to override */
-#define CTASSERT(x)         _CTASSERT(x, __LINE__)
-#define _CTASSERT(x, y)     __CTASSERT(x, y)
-#define __CTASSERT(x, y)    typedef char __assert ## y[(x) ? 1 : -1]
-#endif
-
-
-static inline int
-copyin(const void * __restrict udaddr, void * __restrict kaddr,
-    size_t len)
-{
-    return user_memcpy(kaddr, udaddr, len);
-}
-
-
-static inline int
-copyout(const void * __restrict kaddr, void * __restrict udaddr,
-    size_t len)
-{
-    return user_memcpy(udaddr, kaddr, len);
-}
-
-
-static inline void log(int level, const char *fmt, ...) { }
-
-
-int snprintf(char *, size_t, const char *, ...) __printflike(3, 4);
-extern int sprintf(char *buf, const char *, ...);
-
-extern void driver_vprintf(const char *format, va_list vl);
-#define vprintf(fmt, vl) driver_vprintf(fmt, vl)
-
-extern int vsnprintf(char *, size_t, const char *, __va_list)
-    __printflike(3, 0);
-
-int msleep(void *, struct mtx *, int, const char *, int);
-int _pause(const char *, int);
-#define pause(waitMessage, timeout) _pause((waitMessage), (timeout))
-#define tsleep(channel, priority, waitMessage, timeout) \
-    msleep((channel), NULL, (priority), (waitMessage), (timeout))
-
-struct unrhdr;
-struct unrhdr *new_unrhdr(int low, int high, struct mtx *mutex);
-void delete_unrhdr(struct unrhdr *);
-int alloc_unr(struct unrhdr *);
-void free_unr(struct unrhdr *, u_int);
-
-extern char *getenv(const char *name);
-extern void    freeenv(char *env);
-
-#endif  /* _FBSD_COMPAT_SYS_SYSTM_H_ */

deleted file src/libs/compat/freebsd_network/compat/sys/taskqueue.h

@@ -1 @@
-/*
- * Copyright 2007 Haiku Inc. All rights reserved.
- * Distributed under the terms of the MIT License.
- */
-#ifndef _FBSD_COMPAT_SYS_TASKQUEUE_H_
-#define _FBSD_COMPAT_SYS_TASKQUEUE_H_
-
-
-#include <sys/queue.h>
-#include <sys/_task.h>
-
-
-#define PI_NET  (B_REAL_TIME_DISPLAY_PRIORITY - 1)
-
-#define TASK_INIT(taskp, prio, hand, arg) task_init(taskp, prio, hand, arg)
-
-
-typedef void (*taskqueue_enqueue_fn)(void *context);
-
-
-struct taskqueue;
-struct taskqueue *taskqueue_create(const char *name, int mflags,
-    taskqueue_enqueue_fn enqueue, void *context);
-int taskqueue_start_threads(struct taskqueue **tq, int count, int pri,
-    const char *name, ...) __printflike(4, 5);
-void taskqueue_free(struct taskqueue *tq);
-void taskqueue_drain(struct taskqueue *tq, struct task *task);
-void taskqueue_block(struct taskqueue *queue);
-void taskqueue_unblock(struct taskqueue *queue);
-int taskqueue_enqueue(struct taskqueue *tq, struct task *task);
-
-void taskqueue_thread_enqueue(void *context);
-
-extern struct taskqueue *taskqueue_fast;
-extern struct taskqueue *taskqueue_swi;
-
-int taskqueue_enqueue_fast(struct taskqueue *queue, struct task *task);
-struct taskqueue *taskqueue_create_fast(const char *name, int mflags,
-    taskqueue_enqueue_fn enqueue, void *context);
-
-void task_init(struct task *, int prio, task_handler_t handler, void *arg);
-
-#endif

deleted file src/libs/compat/freebsd_network/compat/sys/time.h

@@ -1 @@
-/*
- * Copyright 2009, Colin Günther, coling@gmx.de.
- * All rights reserved. Distributed under the terms of the MIT License.
- */
-#ifndef _FBSD_COMPAT_SYS_TIME_H_
-#define _FBSD_COMPAT_SYS_TIME_H_
-
-
-#include <posix/sys/time.h>
-
-#include <sys/_timeval.h>
-#include <sys/types.h>
-
-
-#define time_uptime (system_time() / 1000000)
-
-
-int ppsratecheck(struct timeval*, int*, int);
-
-#endif /* _FBSD_COMPAT_SYS_TIME_H_ */

deleted file src/libs/compat/freebsd_network/compat/sys/types.h

@@ -1 @@
-/*
- * Copyright 2007 Haiku Inc. All rights reserved.
- * Distributed under the terms of the MIT License.
- */
-#ifndef _FBSD_COMPAT_SYS_TYPES_H_
-#define _FBSD_COMPAT_SYS_TYPES_H_
-
-
-#include <posix/stdint.h>
-#include <posix/sys/types.h>
-
-#include <sys/cdefs.h>
-
-#include <machine/endian.h>
-#include <sys/_types.h>
-
-
-typedef int boolean_t;
-typedef __const char* c_caddr_t;
-typedef uint64_t u_quad_t;
-
-#endif

src/servers/net/Jamfile

@@ -2 +2 @@
 
 UsePrivateHeaders app net shared storage ;
 
+UseHeaders [ FDirName $(HAIKU_TOP) headers compatibility bsd ] : true ;
+DEFINES += _BSD_SOURCE ;
+
 UseHeaders [ FDirName $(HAIKU_TOP) src libs compat freebsd_network compat ]
     : true ;
 UseHeaders [ FDirName $(HAIKU_TOP) src libs compat freebsd_wlan ] : true ;