From 4251bbb496e64aeeceb70ab1a6716201051769e1 Mon Sep 17 00:00:00 2001 From: Sander Vrijders Date: Wed, 17 Feb 2016 17:23:06 +0100 Subject: lib: Update CMakeLists.txt Forgot to include the updated CMakeLists.txt file with the bitmap implementation. --- src/lib/CMakeLists.txt | 1 + 1 file changed, 1 insertion(+) (limited to 'src/lib/CMakeLists.txt') diff --git a/src/lib/CMakeLists.txt b/src/lib/CMakeLists.txt index 5099fa48..5c0e6bbe 100644 --- a/src/lib/CMakeLists.txt +++ b/src/lib/CMakeLists.txt @@ -6,6 +6,7 @@ include_directories(${CMAKE_BINARY_DIR}/include) set(SOURCE_FILES # Add source files here + bitmap.c cdap.c ) -- 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 'src/lib/CMakeLists.txt') 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 f5f5dcc60316d4f0a6ffb4ebff143f7eaa12894f Mon Sep 17 00:00:00 2001 From: Sander Vrijders Date: Mon, 22 Feb 2016 18:02:27 +0100 Subject: lib: Remove irm.c from CMakeLists.txt This removes the source file irm.c from CMakeLists.txt, as it is not yet in the repo. --- src/lib/CMakeLists.txt | 1 - 1 file changed, 1 deletion(-) (limited to 'src/lib/CMakeLists.txt') diff --git a/src/lib/CMakeLists.txt b/src/lib/CMakeLists.txt index 11183716..5c0e6bbe 100644 --- a/src/lib/CMakeLists.txt +++ b/src/lib/CMakeLists.txt @@ -8,7 +8,6 @@ set(SOURCE_FILES # Add source files here bitmap.c cdap.c - irm.c ) add_library(ouroboros SHARED ${SOURCE_FILES}) -- 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 'src/lib/CMakeLists.txt') 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