From 4edd696f0a9d16c1b9f6ab5eef6c9cdd414b77b7 Mon Sep 17 00:00:00 2001 From: Tushar Gohad Date: Sun, 29 Jun 2014 16:43:38 -0700 Subject: [PATCH] Add list.h, use include/ for erasurecode hdrs Signed-off-by: Tushar Gohad --- configure.ac | 2 +- include/{ => erasurecode}/erasurecode.h | 5 +- .../{ => erasurecode}/erasurecode_internal.h | 0 .../{ => erasurecode}/erasurecode_stdinc.h | 0 .../{ => erasurecode}/erasurecode_version.h | 0 include/erasurecode/list.h | 112 ++++++++++++++++++ include/{ => xor_codes}/xor_code.h | 0 include/{ => xor_codes}/xor_hd_code_defs.h | 0 8 files changed, 117 insertions(+), 2 deletions(-) rename include/{ => erasurecode}/erasurecode.h (98%) rename include/{ => erasurecode}/erasurecode_internal.h (100%) rename include/{ => erasurecode}/erasurecode_stdinc.h (100%) rename include/{ => erasurecode}/erasurecode_version.h (100%) create mode 100644 include/erasurecode/list.h rename include/{ => xor_codes}/xor_code.h (100%) rename include/{ => xor_codes}/xor_hd_code_defs.h (100%) diff --git a/configure.ac b/configure.ac index 012df1a..a2e7d70 100644 --- a/configure.ac +++ b/configure.ac @@ -52,7 +52,7 @@ AC_PROG_INSTALL AC_PROG_MAKE_SET dnl Set up compile and link options -INCLUDE="-I$srcdir/include" +INCLUDE="-I$srcdir/include -I$srcdir/include/erasurecode -I$srcdir/xor_codes" BASE_CFLAGS="-D_GNU_SOURCE=1" BASE_LDFLAGS="" BUILD_CFLAGS="$CFLAGS $CPPFLAGS" diff --git a/include/erasurecode.h b/include/erasurecode/erasurecode.h similarity index 98% rename from include/erasurecode.h rename to include/erasurecode/erasurecode.h index 4ddae7e..a86ba56 100644 --- a/include/erasurecode.h +++ b/include/erasurecode/erasurecode.h @@ -25,8 +25,9 @@ #ifndef _ERASURECODE_H_ #define _ERASURECODE_H_ -#include "erasurecode_version.h" +#include "erasurecode_list.h" #include "erasurecode_stdinc.h" +#include "erasurecode_version.h" #ifdef __cplusplus extern "C" { @@ -100,6 +101,8 @@ typedef enum { } LIBERASURECODE_ERROR_CODES; /* Backend registration interface */ +extern liberasurecode_registered_backends; + int liberasurecode_backend_register(ec_backend_t *backend); int liberasurecode_backend_unregister(ec_backend_t *backend); diff --git a/include/erasurecode_internal.h b/include/erasurecode/erasurecode_internal.h similarity index 100% rename from include/erasurecode_internal.h rename to include/erasurecode/erasurecode_internal.h diff --git a/include/erasurecode_stdinc.h b/include/erasurecode/erasurecode_stdinc.h similarity index 100% rename from include/erasurecode_stdinc.h rename to include/erasurecode/erasurecode_stdinc.h diff --git a/include/erasurecode_version.h b/include/erasurecode/erasurecode_version.h similarity index 100% rename from include/erasurecode_version.h rename to include/erasurecode/erasurecode_version.h diff --git a/include/erasurecode/list.h b/include/erasurecode/list.h new file mode 100644 index 0000000..6d83989 --- /dev/null +++ b/include/erasurecode/list.h @@ -0,0 +1,112 @@ +/* + * 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. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the University of + * California, Berkeley and its contributors. + * 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. + * + * BSD linked list implementation - extracted for use with liberasurecode + * + */ + +#ifndef _LIST_H +#define _LIST_H + +/* + * 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. + */ +/* + * 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_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) + +#endif // _LIST_H diff --git a/include/xor_code.h b/include/xor_codes/xor_code.h similarity index 100% rename from include/xor_code.h rename to include/xor_codes/xor_code.h diff --git a/include/xor_hd_code_defs.h b/include/xor_codes/xor_hd_code_defs.h similarity index 100% rename from include/xor_hd_code_defs.h rename to include/xor_codes/xor_hd_code_defs.h