From fbeb3bd523d0e2790a537c67f69f92ff89303184 Mon Sep 17 00:00:00 2001 From: Sander Vrijders Date: Wed, 17 Feb 2016 17:18:27 +0100 Subject: include: Add list implementation This adds a list implementation similar to the one found in the Linux kernel. --- include/ouroboros/list.h | 270 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 270 insertions(+) create mode 100644 include/ouroboros/list.h (limited to 'include') diff --git a/include/ouroboros/list.h b/include/ouroboros/list.h new file mode 100644 index 00000000..7c59df7a --- /dev/null +++ b/include/ouroboros/list.h @@ -0,0 +1,270 @@ +/* + * Ouroboros - Copyright (C) 2016 + * + * Simple doubly linked list implementation. + * + * Some of the internal functions ("__xxx") are useful when + * manipulating whole lists rather than single entries, as + * sometimes we already know the next/prev entries and we can + * generate better code by using them directly rather than + * using the generic single-entry routines. + * + * Sander Vrijders + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#ifndef OUROBOROS_LIST_H +#define OUROBOROS_LIST_H + +/* + * This file is from the Linux Kernel (include/linux/list.h) + * and modified by simply removing hardware prefetching of list items. + * Here by copyright, credits attributed to wherever they belong. + * Kulesh Shanmugasundaram (kulesh [squiggly] isis.poly.edu) + */ + +struct list_head { + struct list_head * next, * prev; +}; + +#define LIST_HEAD_INIT(name) { &(name), &(name) } + +#define LIST_HEAD(name) \ + struct list_head name = LIST_HEAD_INIT(name) + +#define INIT_LIST_HEAD(ptr) do { \ + (ptr)->next = (ptr); (ptr)->prev = (ptr); \ +} while (0) + +/* + * Insert a new entry between two known consecutive entries. + * + * This is only for internal list manipulation where we know + * the prev/next entries already! + */ +static inline void __list_add(struct list_head * new, + struct list_head * prev, + struct list_head * next) +{ + next->prev = new; + new->next = next; + new->prev = prev; + prev->next = new; +} + +/** + * list_add - add a new entry + * @new: new entry to be added + * @head: list head to add it after + * + * Insert a new entry after the specified head. + * This is good for implementing stacks. + */ +void list_add(struct list_head * new, + struct list_head * head) +{ + __list_add(new, head, head->next); +} + +/** + * list_add_tail - add a new entry + * @new: new entry to be added + * @head: list head to add it before + * + * Insert a new entry before the specified head. + * This is useful for implementing queues. + */ +void list_add_tail(struct list_head * new, + struct list_head * head) +{ + __list_add(new, head->prev, head); +} + +/* + * Delete a list entry by making the prev/next entries + * point to each other. + * + * This is only for internal list manipulation where we know + * the prev/next entries already! + */ +static inline void __list_del(struct list_head * prev, + struct list_head * next) +{ + next->prev = prev; + prev->next = next; +} + +/** + * list_del - deletes entry from list. + * @entry: the element to delete from the list. + * Note: list_empty on entry does not return true after this, + * the entry is in an undefined state. + */ +void list_del(struct list_head * entry) +{ + __list_del(entry->prev, entry->next); + entry->next = (void *) 0; + entry->prev = (void *) 0; +} + +/** + * list_del_init - deletes entry from list and reinitialize it. + * @entry: the element to delete from the list. + */ +void list_del_init(struct list_head * entry) +{ + __list_del(entry->prev, entry->next); + INIT_LIST_HEAD(entry); +} + +/** + * list_move - delete from one list and add as another's head + * @list: the entry to move + * @head: the head that will precede our entry + */ +void list_move(struct list_head * list, + struct list_head * head) +{ + __list_del(list->prev, list->next); + list_add(list, head); +} + +/** + * list_move_tail - delete from one list and add as another's tail + * @list: the entry to move + * @head: the head that will follow our entry + */ +void list_move_tail(struct list_head * list, + struct list_head * head) +{ + __list_del(list->prev, list->next); + list_add_tail(list, head); +} + +/** + * list_empty - tests whether a list is empty + * @head: the list to test. + */ +int list_empty(struct list_head * head) +{ + return head->next == head; +} + +static inline void __list_splice(struct list_head *list, + struct list_head *head) +{ + struct list_head *first = list->next; + struct list_head *last = list->prev; + struct list_head *at = head->next; + + first->prev = head; + head->next = first; + + last->next = at; + at->prev = last; +} + +/** + * list_splice - join two lists + * @list: the new list to add. + * @head: the place to add it in the first list. + */ +void list_splice(struct list_head * list, + struct list_head * head) +{ + if (!list_empty(list)) + __list_splice(list, head); +} + +/** + * list_splice_init - join two lists and reinitialise the emptied list. + * @list: the new list to add. + * @head: the place to add it in the first list. + * + * The list at @list is reinitialised + */ +void list_splice_init(struct list_head * list, + struct list_head * head) +{ + if (!list_empty(list)) { + __list_splice(list, head); + INIT_LIST_HEAD(list); + } +} + +/** + * list_entry - get the struct for this entry + * @ptr: the &struct list_head pointer. + * @type: the type of the struct this is embedded in. + * @member: the name of the list_struct within the struct. + */ +#define list_entry(ptr, type, member) \ + ((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member))) + +/** + * list_for_each - iterate over a list + * @pos: the &struct list_head to use as a loop counter. + * @head: the head for your list. + */ +#define list_for_each(pos, head) \ + for (pos = (head)->next; pos != (head); \ + pos = pos->next) +/** + * list_for_each_prev - iterate over a list backwards + * @pos: the &struct list_head to use as a loop counter. + * @head: the head for your list. + */ +#define list_for_each_prev(pos, head) \ + for (pos = (head)->prev; pos != (head); \ + pos = pos->prev) + +/** + * list_for_each_safe - iterate over a list safe against removal of list entry + * @pos: the &struct list_head to use as a loop counter. + * @n: another &struct list_head to use as temporary storage + * @head: the head for your list. + */ +#define list_for_each_safe(pos, n, head) \ + for (pos = (head)->next, n = pos->next; pos != (head); \ + pos = n, n = pos->next) + +/** + * list_for_each_entry - iterate over list of given type + * @pos: the type * to use as a loop counter. + * @head: the head for your list. + * @member: the name of the list_struct within the struct. + */ +#define list_for_each_entry(pos, head, member) \ + for (pos = list_entry((head)->next, typeof(*pos), member); \ + &pos->member != (head); \ + pos = list_entry(pos->member.next, typeof(*pos), member)) + +/** + * list_for_each_entry_safe - iterate over list of given type safe + * against removal of list entry + * @pos: the type * to use as a loop counter. + * @n: another type * to use as temporary storage + * @head: the head for your list. + * @member: the name of the list_struct within the struct. + */ +#define list_for_each_entry_safe(pos, n, head, member) \ + for (pos = list_entry((head)->next, typeof(*pos), member), \ + n = list_entry(pos->member.next, typeof(*pos), member); \ + &pos->member != (head); \ + pos = n, n = list_entry(n->member.next, typeof(*n), member)) + + +#endif -- cgit v1.2.3 From 24ae159ad312144c552455fbae445ed62a9fec2f Mon Sep 17 00:00:00 2001 From: Sander Vrijders Date: Wed, 17 Feb 2016 17:19:08 +0100 Subject: include: Add bitmap implementation This adds a bitmap implementation loosely based on the one found in the Linux kernel. The functions in the header file actually act as a wrapper around the actual bitmap implementation for portability reasons. --- include/ouroboros/bitmap.h | 41 ++++++++++ src/lib/bitmap.c | 194 +++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 235 insertions(+) create mode 100644 include/ouroboros/bitmap.h create mode 100644 src/lib/bitmap.c (limited to 'include') diff --git a/include/ouroboros/bitmap.h b/include/ouroboros/bitmap.h new file mode 100644 index 00000000..6296e2e0 --- /dev/null +++ b/include/ouroboros/bitmap.h @@ -0,0 +1,41 @@ +/* + * Ouroboros - Copyright (C) 2016 + * + * RINA bitmap implementation - wraps around bitmap from Linux kernel + * + * Sander Vrijders + * Francesco Salvestrini + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#ifndef OUROBOROS_BITMAP_H +#define OUROBOROS_BITMAP_H + +#include +#include +#include + +struct rbmp; + +struct rbmp * rbmp_create(size_t bits, ssize_t offset); +int rbmp_destroy(struct rbmp * b); + +ssize_t rbmp_allocate(struct rbmp * instance); +int rbmp_release(struct rbmp * instance, + ssize_t id); +bool rbmp_is_id_ok(struct rbmp * b, ssize_t id); + +#endif diff --git a/src/lib/bitmap.c b/src/lib/bitmap.c new file mode 100644 index 00000000..3e1ba049 --- /dev/null +++ b/src/lib/bitmap.c @@ -0,0 +1,194 @@ +/* + * Ouroboros - Copyright (C) 2016 + * + * Bitmap implementation - taken partly from Linux kernel + * + * Sander Vrijders + * Francesco Salvestrini + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include +#include +#include +#include +#include + +#define BITS_PER_BYTE 8 + +#define BITS_PER_LONG (sizeof(long) * BITS_PER_BYTE) + +#define BIT_WORD(nr) ((nr) / BITS_PER_LONG) + +#define DIV_ROUND_UP(n,d) (((n) + (d) - 1) / (d)) + +#define BITS_TO_LONGS(nr) \ + DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(long)) + +#define BITS_IN_BITMAP ((2 << BITS_PER_BYTE) * sizeof(size_t)) + +static unsigned long find_next_zero_bit(const unsigned long * addr, + unsigned long nbits) +{ + unsigned long tmp; + unsigned long start = 0; + unsigned long pos = 0; + unsigned long mask; + + /* First find correct word */ + tmp = ~addr[start]; + while (!tmp) { + start++; + if (start >= (nbits / BITS_PER_LONG)) + return nbits; + + tmp = ~addr[start]; + } + + /* Find the free bit in the word */ + mask = 1UL; + while (!(tmp ^ mask)) { + pos++; + mask = 1UL << pos; + } + + return (start * BITS_PER_LONG) + pos; +} + +static void bitmap_zero(unsigned long * dst, + unsigned int nbits) +{ + unsigned int len = BITS_TO_LONGS(nbits) * sizeof(unsigned long); + memset(dst, 0, len); +} + +static void bitmap_clear(unsigned long * map, + unsigned int start) +{ + unsigned long * p = map + BIT_WORD(start); + unsigned long mask = ~(1UL << (start % (BITS_PER_LONG - 1))); + + *p &= mask; +} + + +static void bitmap_set(unsigned long * map, + unsigned int start) +{ + unsigned long * p = map + BIT_WORD(start); + unsigned long mask = 1UL << (start % (BITS_PER_LONG - 1)); + + *p |= mask; +} + +struct rbmp { + ssize_t offset; + size_t size; + + unsigned long bitmap[BITS_TO_LONGS(BITS_IN_BITMAP)]; +}; + +struct rbmp * rbmp_create(size_t bits, ssize_t offset) +{ + struct rbmp * tmp; + + if (bits == 0) + return NULL; + + tmp = malloc(sizeof(*tmp)); + if (!tmp) + return NULL; + + tmp->size = bits; + tmp->offset = offset; + bitmap_zero(tmp->bitmap, BITS_IN_BITMAP); + + return tmp; +} + + +int rbmp_destroy(struct rbmp * b) +{ + if (!b) + return -1; + + free(b); + + return 0; +} + +static ssize_t bad_id(struct rbmp * b) +{ + assert(b); + + return b->offset - 1; +} + +ssize_t rbmp_allocate(struct rbmp * b) +{ + ssize_t id; + + if (!b) + return bad_id(b); + + id = (ssize_t) find_next_zero_bit(b->bitmap, + BITS_IN_BITMAP); + + if (id == BITS_IN_BITMAP) + return bad_id(b); + + bitmap_set(b->bitmap, id); + + return id + b->offset; +} + +static bool is_id_ok(struct rbmp * b, + ssize_t id) +{ + assert(b); + + if ((id < b->offset) || (id > (b->offset + b->size))) + return false; + + return true; +} + +bool rbmp_is_id_ok(struct rbmp * b, + ssize_t id) +{ + if (!b) + return false; + + return is_id_ok(b, id); +} + +int rbmp_release(struct rbmp * b, + ssize_t id) +{ + ssize_t rid; + + if (!b) + return -1; + + if (!is_id_ok(b, id)) + return -1; + + rid = id - b->offset; + + bitmap_clear(b->bitmap, id); + + return 0; +} -- cgit v1.2.3 From 7cd377ad7cb8c636262a27b31341b8c54dd797fb Mon Sep 17 00:00:00 2001 From: Sander Vrijders Date: Mon, 22 Feb 2016 17:36:10 +0100 Subject: include: Fix common includes common.h will now include stdbool and several other useful includes (size_t for instance). --- include/ouroboros/common.h | 2 ++ src/lib/CMakeLists.txt | 1 + src/lib/bitmap.c | 1 - 3 files changed, 3 insertions(+), 1 deletion(-) (limited to 'include') diff --git a/include/ouroboros/common.h b/include/ouroboros/common.h index f2be815f..90431208 100644 --- a/include/ouroboros/common.h +++ b/include/ouroboros/common.h @@ -24,6 +24,8 @@ #define OUROBOROS_COMMON_H #include +#include +#include typedef uint32_t port_id_t; diff --git a/src/lib/CMakeLists.txt b/src/lib/CMakeLists.txt index 5c0e6bbe..11183716 100644 --- a/src/lib/CMakeLists.txt +++ b/src/lib/CMakeLists.txt @@ -8,6 +8,7 @@ set(SOURCE_FILES # Add source files here bitmap.c cdap.c + irm.c ) add_library(ouroboros SHARED ${SOURCE_FILES}) diff --git a/src/lib/bitmap.c b/src/lib/bitmap.c index 3e1ba049..cb414e7f 100644 --- a/src/lib/bitmap.c +++ b/src/lib/bitmap.c @@ -22,7 +22,6 @@ */ #include -#include #include #include #include -- cgit v1.2.3 From f128b07498d22d5bc0cea0270e960b2b7c66248c Mon Sep 17 00:00:00 2001 From: Dimitri Staessens Date: Tue, 23 Feb 2016 00:06:35 +0100 Subject: Initial du_buff code Compiles but untested. Expect bugs. --- CMakeLists.txt | 2 +- include/ouroboros/du_buff.h | 65 +++++++++ src/lib/CMakeLists.txt | 1 + src/lib/du_buff.c | 333 ++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 400 insertions(+), 1 deletion(-) create mode 100644 include/ouroboros/du_buff.h create mode 100644 src/lib/du_buff.c (limited to 'include') diff --git a/CMakeLists.txt b/CMakeLists.txt index 1ca05c95..efbc3706 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,4 +1,4 @@ -cmake_minimum_required(VERSION 3.1.0) +cmake_minimum_required(VERSION 3.0.0) set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake") #set(CMAKE_VERBOSE_MAKEFILE ON) diff --git a/include/ouroboros/du_buff.h b/include/ouroboros/du_buff.h new file mode 100644 index 00000000..1d7b260a --- /dev/null +++ b/include/ouroboros/du_buff.h @@ -0,0 +1,65 @@ +/* + * Ouroboros - Copyright (C) 2016 + * + * Data Unit Buffer + * + * Dimitri Staessens + * Sander Vrijders + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#ifndef OUROBOROS_DU_BUFF_H +#define OUROBOROS_DU_BUFF_H + +#include +#include +#include + +#include "list.h" + +/*FIXME: to be defined inside du_buff_t */ + +struct buffer { + uint8_t * data; + size_t size; + struct list_head list; +} buffer; + +typedef struct { + struct buffer * buffer; + size_t size; + size_t du_start; + size_t du_end; + struct list_head list; +} du_buff_t; + +du_buff_t * du_buff_create(size_t size); +void du_buff_destroy(du_buff_t * dub); + +int du_buff_init(du_buff_t * dub, + size_t start, + uint8_t * data, + size_t len); + +uint8_t * du_buff_data_ptr_start(du_buff_t * dub); +uint8_t * du_buff_data_ptr_end(du_buff_t * dub); + +int du_buff_head_alloc(du_buff_t * dub, size_t size); +int du_buff_tail_alloc(du_buff_t * dub, size_t size); +int du_buff_head_release(du_buff_t * dub, size_t size); +int du_buff_tail_release(du_buff_t * dub, size_t size); + +#endif /* OUROBOROS_DU_BUFF_H */ diff --git a/src/lib/CMakeLists.txt b/src/lib/CMakeLists.txt index 5c0e6bbe..9a6f1946 100644 --- a/src/lib/CMakeLists.txt +++ b/src/lib/CMakeLists.txt @@ -8,6 +8,7 @@ set(SOURCE_FILES # Add source files here bitmap.c cdap.c + du_buff.c ) add_library(ouroboros SHARED ${SOURCE_FILES}) diff --git a/src/lib/du_buff.c b/src/lib/du_buff.c new file mode 100644 index 00000000..1944634d --- /dev/null +++ b/src/lib/du_buff.c @@ -0,0 +1,333 @@ +/* + * Ouroboros - Copyright (C) 2016 + * + * Data Unit Buffer + * + * Dimitri Staessens + * Sander Vrijders + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include +#include +#include +#include "ouroboros/du_buff.h" + +#define OUROBOROS_PREFIX "du_buff" + +#include "ouroboros/logs.h" + +void buffer_destroy (struct buffer * buf) +{ + if (buf == NULL) { + LOG_DBG("buffer_destroy: Bogus input, bugging out."); + return; + } + + list_del(&(buf->list)); + + free (&(buf->data)); + + free (buf); +} + + +void buffer_destroy_list(struct buffer * buf) +{ + struct list_head * ptr; + struct list_head * n; + + if (buf == NULL) { + LOG_DBG("buffer_destroy_list: Bogus input, bugging out."); + return; + } + + list_for_each_safe(ptr, n, &(buf->list)) { + struct buffer * tmp = list_entry(ptr, struct buffer, list); + list_del(ptr); + buffer_destroy(tmp); + } +} + +struct buffer * buffer_create (size_t size) +{ + struct buffer * head = NULL; + size_t remaining = size; + const size_t page_size = sysconf(_SC_PAGESIZE); + + while (remaining > 0) { + struct buffer * buf; + size_t sz = remaining < page_size ? remaining : page_size; + + buf = (struct buffer *)malloc(sizeof(struct buffer)); + if (buf == NULL) { + LOG_WARN("buffer_create: could not allocate struct."); + return NULL; + } + + buf->data=(uint8_t *)malloc(sz); + if (buf->data == NULL) { + LOG_WARN("buffer_create: allocate memblock failed."); + buffer_destroy_list(head); + return NULL; + } + + buf->size = sz; + INIT_LIST_HEAD(&(buf->list)); + + if (head == NULL) + head = buf; + else + list_add_tail(&(buf->list), &(head->list)); + + remaining -= buf->size; + } + + return head; +} + +struct buffer * buffer_seek(const struct buffer * head, size_t pos) +{ + struct list_head * ptr = NULL; + struct buffer * hit = NULL; + size_t cur_buf_start = 0; + size_t cur_buf_end = 0; + + if (head = NULL) { + LOG_DBG("buffer_seek: Bogus input, bugging out."); + return NULL; + } + + list_for_each(ptr, &(head->list)) { + struct buffer * tmp = list_entry(ptr, struct buffer, list); + + cur_buf_end = cur_buf_start + tmp->size; + + if (cur_buf_end > pos) + return tmp; + + cur_buf_start = cur_buf_end; + } + + return NULL; +} + +uint8_t * buffer_seek_pos(const struct buffer * head, size_t pos) +{ + struct list_head * ptr = NULL; + struct buffer * hit = NULL; + size_t cur_buf_start = 0; + size_t cur_buf_end = 0; + + if (head = NULL) { + LOG_DBG("buffer_seek_pos: Bogus input, bugging out."); + return NULL; + } + + list_for_each(ptr, &(head->list)) { + struct buffer * tmp = list_entry(ptr, struct buffer, list); + + cur_buf_end = cur_buf_start + tmp->size; + + if (cur_buf_end > pos) + return tmp->data + (pos - cur_buf_start); + + cur_buf_start = cur_buf_end; + } + + return NULL; +} + +int buffer_copy_data(struct buffer * head, + size_t pos, + const void * src, + size_t len) +{ + struct list_head * ptr = NULL; + struct buffer * buf_start = NULL; + struct buffer * buf_end = NULL; + uint8_t * ptr_start = NULL; + size_t space_in_buf; + size_t bytes_remaining; + uint8_t * copy_pos = NULL; + + if (head == NULL || src == NULL) { + LOG_DBG("buffer_copy_data: Bogus input, bugging out."); + return -EINVAL; + } + + buf_start = buffer_seek(head, pos); + buf_end = buffer_seek(head, pos + len); + + if (buf_start == NULL || buf_end == NULL) { + LOG_DBG("buffer_copy_data: Index out of bounds %d, %d", + pos, + pos+len); + return -EINVAL; + } + + ptr_start = buffer_seek_pos(head, pos); + + if (buf_start == buf_end) { + memcpy(ptr_start, src, len); + return 0; + } + + copy_pos = (uint8_t *)src; + bytes_remaining = len; + list_for_each(ptr, &(buf_start->list)) { + struct buffer * tmp = list_entry(ptr, struct buffer, list); + space_in_buf = tmp->data + tmp->size - ptr_start; + if (space_in_buf >= bytes_remaining) { + memcpy(ptr_start, copy_pos, bytes_remaining); + return 0; + } + else + memcpy(ptr_start, copy_pos, space_in_buf); + bytes_remaining -= space_in_buf; + } + + return 0; +} + +du_buff_t * du_buff_create(size_t size) +{ + du_buff_t * dub = (du_buff_t *)malloc(sizeof(du_buff_t)); + + if (dub == NULL) { + LOG_DBG("create: Bogus input, bugging out."); + return NULL; + } + + dub->buffer = buffer_create(size); + if (dub->buffer == NULL) { + free (dub); + return NULL; + } + + dub->size = size; + dub->du_start = 0; + dub->du_end = 0; + + INIT_LIST_HEAD(&(dub->list)); + + return dub; +} + +void du_buff_destroy(du_buff_t * dub) +{ + if (dub == NULL) { + LOG_DBG("destroy: Bogus input, bugging out."); + return; + } + buffer_destroy_list(dub->buffer); + + list_del(&(dub->list)); + + free (dub); +} + +int du_buff_init(du_buff_t * dub, + size_t start, + uint8_t * data, + size_t len) +{ + if (dub == NULL || data == NULL) { + LOG_DBG("init: Bogus input, bugging out."); + return -EINVAL; + } + + if (start + len > dub->size) { + LOG_DBG("init: Index out of bounds %d", start); + return -EINVAL; + } + + dub->du_start = start; + dub->du_end = start + len; + + return buffer_copy_data(dub->buffer, start, data, len); + +} + +uint8_t * du_buff_data_ptr_start(du_buff_t * dub) +{ + if (dub == NULL) { + LOG_DBG("data_ptr_start: Bogus input, bugging out."); + return NULL; + } + return buffer_seek_pos(dub->buffer, dub->du_start); +} + +uint8_t * du_buff_data_ptr_end(du_buff_t * dub) +{ + if (dub == NULL) { + LOG_DBG("data_ptr_end: Bogus input, bugging out."); + return NULL; + } + return buffer_seek_pos(dub->buffer, dub->du_end); +} + +int du_buff_head_alloc(du_buff_t * dub, size_t size) +{ + if (dub->du_start - size < 0) { + LOG_WARN("head_alloc: failed to allocate PCI headspace"); + return -1; + } + + dub->du_start -= size; + + return 0; +} +int du_buff_tail_alloc(du_buff_t * dub, size_t size) +{ + if (dub->du_end + size >= dub->size) { + LOG_WARN("tail_alloc: failed to allocate PCI tailspace"); + return -1; + } + + dub->du_end += size; + + return 0; + +} + +int du_buff_head_release(du_buff_t * dub, size_t size) +{ + if (size > dub->du_end - dub->du_start) { + LOG_WARN("head_release: tried to release beyond sdu boundary"); + return -1; + } + + dub->du_start += size; + + /* FIXME: copy some random crap to the buffer for security */ + + return 0; +} + +int du_buff_tail_release(du_buff_t * dub, size_t size) +{ + if (size > dub->du_end - dub->du_start) { + LOG_WARN("tail_release: tried to release beyond sdu boundary"); + return -1; + } + + dub->du_end -= size; + + /* FIXME: copy some random crap to the buffer for security */ + + return 0; +} -- cgit v1.2.3 From 8dea4896c5f69aa2faf77b77028ad968709e705f Mon Sep 17 00:00:00 2001 From: Dimitri Staessens Date: Tue, 23 Feb 2016 10:48:29 +0100 Subject: logs.h: Added LOG_DBGF macro Displays the function name in the log message. --- include/ouroboros/logs.h | 2 ++ 1 file changed, 2 insertions(+) (limited to 'include') diff --git a/include/ouroboros/logs.h b/include/ouroboros/logs.h index c72fb9ae..6f9986dc 100644 --- a/include/ouroboros/logs.h +++ b/include/ouroboros/logs.h @@ -43,6 +43,8 @@ #define LOG_DBG(FMT, ARGS...) do { } while (0) #endif +#define LOG_DBGF(FMT, ARGS...) LOG_DBG("%s: " FMT, __FUNCTION__, ##ARGS) + #define LOG_MISSING LOG_ERR("Missing code in %s:%d",__FILE__, __LINE__) #endif -- cgit v1.2.3 From 95c7e9a6a298702ae217b22d3f95313c0b1020af Mon Sep 17 00:00:00 2001 From: Dimitri Staessens Date: Tue, 23 Feb 2016 10:46:44 +0100 Subject: lib: cleanup of du_buff du_buff.h : moved struct buffer to source du_buff.c : fixed formatting LOG_DBGF used --- include/ouroboros/du_buff.h | 15 ++-------- src/lib/du_buff.c | 68 +++++++++++++++++++++++++++++++-------------- 2 files changed, 50 insertions(+), 33 deletions(-) (limited to 'include') diff --git a/include/ouroboros/du_buff.h b/include/ouroboros/du_buff.h index 1d7b260a..522733f8 100644 --- a/include/ouroboros/du_buff.h +++ b/include/ouroboros/du_buff.h @@ -24,19 +24,10 @@ #ifndef OUROBOROS_DU_BUFF_H #define OUROBOROS_DU_BUFF_H -#include -#include -#include - +#include "common.h" #include "list.h" -/*FIXME: to be defined inside du_buff_t */ - -struct buffer { - uint8_t * data; - size_t size; - struct list_head list; -} buffer; +struct buffer; typedef struct { struct buffer * buffer; @@ -51,7 +42,7 @@ void du_buff_destroy(du_buff_t * dub); int du_buff_init(du_buff_t * dub, size_t start, - uint8_t * data, + uint8_t * data, size_t len); uint8_t * du_buff_data_ptr_start(du_buff_t * dub); diff --git a/src/lib/du_buff.c b/src/lib/du_buff.c index 1944634d..53d9c3e4 100644 --- a/src/lib/du_buff.c +++ b/src/lib/du_buff.c @@ -30,10 +30,16 @@ #include "ouroboros/logs.h" -void buffer_destroy (struct buffer * buf) +struct buffer { + uint8_t * data; + size_t size; + struct list_head list; +} buffer; + +void buffer_destroy(struct buffer * buf) { if (buf == NULL) { - LOG_DBG("buffer_destroy: Bogus input, bugging out."); + LOG_DBGF("Bogus input, bugging out."); return; } @@ -51,7 +57,7 @@ void buffer_destroy_list(struct buffer * buf) struct list_head * n; if (buf == NULL) { - LOG_DBG("buffer_destroy_list: Bogus input, bugging out."); + LOG_DBGF("Bogus input, bugging out."); return; } @@ -72,15 +78,15 @@ struct buffer * buffer_create (size_t size) struct buffer * buf; size_t sz = remaining < page_size ? remaining : page_size; - buf = (struct buffer *)malloc(sizeof(struct buffer)); + buf = (struct buffer *) malloc(sizeof(struct buffer)); if (buf == NULL) { - LOG_WARN("buffer_create: could not allocate struct."); + LOG_WARN("Could not allocate struct."); return NULL; } - buf->data=(uint8_t *)malloc(sz); + buf->data = (uint8_t *) malloc(sz); if (buf->data == NULL) { - LOG_WARN("buffer_create: allocate memblock failed."); + LOG_WARN("Could not allocate memory block."); buffer_destroy_list(head); return NULL; } @@ -107,7 +113,7 @@ struct buffer * buffer_seek(const struct buffer * head, size_t pos) size_t cur_buf_end = 0; if (head = NULL) { - LOG_DBG("buffer_seek: Bogus input, bugging out."); + LOG_DBGF("Bogus input, bugging out."); return NULL; } @@ -133,7 +139,7 @@ uint8_t * buffer_seek_pos(const struct buffer * head, size_t pos) size_t cur_buf_end = 0; if (head = NULL) { - LOG_DBG("buffer_seek_pos: Bogus input, bugging out."); + LOG_DBGF("Bogus input, bugging out."); return NULL; } @@ -165,7 +171,7 @@ int buffer_copy_data(struct buffer * head, uint8_t * copy_pos = NULL; if (head == NULL || src == NULL) { - LOG_DBG("buffer_copy_data: Bogus input, bugging out."); + LOG_DBGF("Bogus input, bugging out."); return -EINVAL; } @@ -173,7 +179,7 @@ int buffer_copy_data(struct buffer * head, buf_end = buffer_seek(head, pos + len); if (buf_start == NULL || buf_end == NULL) { - LOG_DBG("buffer_copy_data: Index out of bounds %d, %d", + LOG_DBGF("Index out of bounds %d, %d", pos, pos+len); return -EINVAL; @@ -208,7 +214,7 @@ du_buff_t * du_buff_create(size_t size) du_buff_t * dub = (du_buff_t *)malloc(sizeof(du_buff_t)); if (dub == NULL) { - LOG_DBG("create: Bogus input, bugging out."); + LOG_DBGF("Bogus input, bugging out."); return NULL; } @@ -230,7 +236,7 @@ du_buff_t * du_buff_create(size_t size) void du_buff_destroy(du_buff_t * dub) { if (dub == NULL) { - LOG_DBG("destroy: Bogus input, bugging out."); + LOG_DBGF("Bogus input, bugging out."); return; } buffer_destroy_list(dub->buffer); @@ -246,12 +252,12 @@ int du_buff_init(du_buff_t * dub, size_t len) { if (dub == NULL || data == NULL) { - LOG_DBG("init: Bogus input, bugging out."); + LOG_DBG("Bogus input, bugging out."); return -EINVAL; } if (start + len > dub->size) { - LOG_DBG("init: Index out of bounds %d", start); + LOG_DBGF("Index out of bounds %d", start); return -EINVAL; } @@ -265,7 +271,7 @@ int du_buff_init(du_buff_t * dub, uint8_t * du_buff_data_ptr_start(du_buff_t * dub) { if (dub == NULL) { - LOG_DBG("data_ptr_start: Bogus input, bugging out."); + LOG_DBGF("Bogus input, bugging out."); return NULL; } return buffer_seek_pos(dub->buffer, dub->du_start); @@ -274,7 +280,7 @@ uint8_t * du_buff_data_ptr_start(du_buff_t * dub) uint8_t * du_buff_data_ptr_end(du_buff_t * dub) { if (dub == NULL) { - LOG_DBG("data_ptr_end: Bogus input, bugging out."); + LOG_DBG("Bogus input, bugging out."); return NULL; } return buffer_seek_pos(dub->buffer, dub->du_end); @@ -282,8 +288,13 @@ uint8_t * du_buff_data_ptr_end(du_buff_t * dub) int du_buff_head_alloc(du_buff_t * dub, size_t size) { + if (dub == NULL) { + LOG_DBGF("Bogus input, bugging out."); + return -EINVAL; + } + if (dub->du_start - size < 0) { - LOG_WARN("head_alloc: failed to allocate PCI headspace"); + LOG_WARN("Failed to allocate PCI headspace"); return -1; } @@ -293,8 +304,13 @@ int du_buff_head_alloc(du_buff_t * dub, size_t size) } int du_buff_tail_alloc(du_buff_t * dub, size_t size) { + if (dub == NULL) { + LOG_DBGF("Bogus input, bugging out."); + return -EINVAL; + } + if (dub->du_end + size >= dub->size) { - LOG_WARN("tail_alloc: failed to allocate PCI tailspace"); + LOG_WARN("Failed to allocate PCI tailspace"); return -1; } @@ -306,8 +322,13 @@ int du_buff_tail_alloc(du_buff_t * dub, size_t size) int du_buff_head_release(du_buff_t * dub, size_t size) { + if (dub == NULL) { + LOG_DBGF("Bogus input, bugging out."); + return -EINVAL; + } + if (size > dub->du_end - dub->du_start) { - LOG_WARN("head_release: tried to release beyond sdu boundary"); + LOG_WARN("Tried to release beyond sdu boundary"); return -1; } @@ -320,8 +341,13 @@ int du_buff_head_release(du_buff_t * dub, size_t size) int du_buff_tail_release(du_buff_t * dub, size_t size) { + if (dub == NULL) { + LOG_DBGF("Bogus input, bugging out."); + return -EINVAL; + } + if (size > dub->du_end - dub->du_start) { - LOG_WARN("tail_release: tried to release beyond sdu boundary"); + LOG_WARN("Tried to release beyond sdu boundary"); return -1; } -- cgit v1.2.3 From c36daed13ba47edf59aa47e27aeffa35b3030f0e Mon Sep 17 00:00:00 2001 From: Dimitri Staessens Date: Tue, 23 Feb 2016 12:06:03 +0100 Subject: du_buff: Restructured for information hiding Moved struct buffer and struct du_buff definitions to the source file. --- include/ouroboros/du_buff.h | 12 +++--------- src/lib/du_buff.c | 10 +++++++++- 2 files changed, 12 insertions(+), 10 deletions(-) (limited to 'include') diff --git a/include/ouroboros/du_buff.h b/include/ouroboros/du_buff.h index 522733f8..d23f4b09 100644 --- a/include/ouroboros/du_buff.h +++ b/include/ouroboros/du_buff.h @@ -27,15 +27,9 @@ #include "common.h" #include "list.h" -struct buffer; - -typedef struct { - struct buffer * buffer; - size_t size; - size_t du_start; - size_t du_end; - struct list_head list; -} du_buff_t; +struct du_buff; + +typedef struct du_buff du_buff_t; du_buff_t * du_buff_create(size_t size); void du_buff_destroy(du_buff_t * dub); diff --git a/src/lib/du_buff.c b/src/lib/du_buff.c index 53d9c3e4..84bf528c 100644 --- a/src/lib/du_buff.c +++ b/src/lib/du_buff.c @@ -34,7 +34,15 @@ struct buffer { uint8_t * data; size_t size; struct list_head list; -} buffer; +}; + +struct du_buff { + struct buffer * buffer; + size_t size; + size_t du_start; + size_t du_end; + struct list_head list; +}; void buffer_destroy(struct buffer * buf) { -- cgit v1.2.3