diff options
53 files changed, 2090 insertions, 1218 deletions
diff --git a/hicn-light/CMakeLists.txt b/hicn-light/CMakeLists.txt index 5d0d59b43..42e7d0a01 100644 --- a/hicn-light/CMakeLists.txt +++ b/hicn-light/CMakeLists.txt @@ -45,7 +45,7 @@ if(${CMAKE_SYSTEM_NAME} STREQUAL "Android") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${ANDROID_C_FLAGS}") endif() -set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -DLIBRTA_DISABLE_VALIDATION -DPARCLibrary_DISABLE_VALIDATION") +set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -DLIBRTA_DISABLE_VALIDATION ") include(IosMacros) include(WindowsMacros) diff --git a/hicn-light/cmake/Modules/Packaging.cmake b/hicn-light/cmake/Modules/Packaging.cmake index 2b9f4a7b9..936ea6dd4 100644 --- a/hicn-light/cmake/Modules/Packaging.cmake +++ b/hicn-light/cmake/Modules/Packaging.cmake @@ -21,7 +21,7 @@ set(${HICN_LIGHT}_DESCRIPTION ) set(${HICN_LIGHT}_DEB_DEPENDENCIES - "lib${LIBHICN} (>= stable_version), libparc (>= 1.0)" + "lib${LIBHICN} (>= stable_version), libapr1, libaprutil1" CACHE STRING "Dependencies for deb/rpm package." ) @@ -31,7 +31,7 @@ set(${HICN_LIGHT}_DEB_PACKAGE_CONTROL_EXTRA ) set(${HICN_LIGHT}_RPM_DEPENDENCIES - "lib${LIBHICN} >= stable_version, libparc >= 1.0" + "lib${LIBHICN} >= stable_version, libapr1, libaprutil1" CACHE STRING "Dependencies for deb/rpm package." ) diff --git a/hicn-light/src/hicn/base/bitmap.h b/hicn-light/src/hicn/base/bitmap.h index 8fd9fcd70..4a78af567 100644 --- a/hicn-light/src/hicn/base/bitmap.h +++ b/hicn-light/src/hicn/base/bitmap.h @@ -23,7 +23,12 @@ #ifndef UTIL_BITMAP_H #define UTIL_BITMAP_H +#include <assert.h> #include <string.h> +#include <sys/param.h> // MIN, MAX + +#include <hicn/util/log.h> + #include "common.h" #include "vector.h" @@ -37,8 +42,9 @@ typedef uint_fast32_t bitmap_t; * @param[in,out] bitmap Bitmap to allocate and initialize * @param[in] max_size Bitmap max_size */ -#define bitmap_init(bitmap, max_size) \ - vector_init(bitmap, next_pow2(max_size / BITMAP_WIDTH(bitmap))) +#define bitmap_init(bitmap, init_size, max_size) \ + vector_init(bitmap, next_pow2(init_size / BITMAP_WIDTH(bitmap)), \ + max_size == 0 ? 0 : next_pow2(max_size / BITMAP_WIDTH(bitmap))) /* * @brief Ensures a bitmap is sufficiently large to hold an element at the @@ -51,7 +57,13 @@ typedef uint_fast32_t bitmap_t; * - This function should always be called before writing to a bitmap element * to eventually make room for it (the bitmap will eventually be resized). */ -#define bitmap_ensure_pos(bitmap, pos) vector_ensure_pos(bitmap, pos / BITMAP_WIDTH(bitmap)) +static inline +int +bitmap_ensure_pos(bitmap_t * bitmap, off_t pos) +{ + size_t offset = pos / BITMAP_WIDTH(bitmap); + return vector_ensure_pos(bitmap, offset); +} /** * @brief Retrieve the state of the i-th bit in the bitmap. @@ -59,7 +71,15 @@ typedef uint_fast32_t bitmap_t; * @param[in] bitmap The bitmap to access. * @param[in] i The bit position. */ -#define bitmap_get(bitmap, i) (((bitmap)[(i) / BITMAP_WIDTH(bitmap)] & (1 << ((i) % BITMAP_WIDTH(bitmap)))) >> ((i) % BITMAP_WIDTH(bitmap))) +static inline +int +bitmap_get(const bitmap_t * bitmap, off_t i) +{ + size_t offset = i / BITMAP_WIDTH(bitmap); + size_t pos = i % BITMAP_WIDTH(bitmap); + size_t shift = BITMAP_WIDTH(bitmap) - pos - 1; + return (bitmap[offset] >> shift) & 1; +} /* * @brief Returns whether the i-th bit is set (equal to 1) in a bitmap. @@ -70,6 +90,7 @@ typedef uint_fast32_t bitmap_t; * @return bool */ #define bitmap_is_set(bitmap, i) (bitmap_get((bitmap), (i)) == 1) +#define bitmap_is_unset(bitmap, i) (bitmap_get((bitmap), (i)) == 0) /* * @brief Returns whether the i-th bit is unset (equal to 0) in a bitmap. @@ -79,19 +100,94 @@ typedef uint_fast32_t bitmap_t; * * @return bool */ -#define bitmap_is_unset(bitmap, i) (bitmap_get((bitmap), (i)) == 0) +static inline +int +bitmap_set(bitmap_t * bitmap, off_t i) +{ + if (bitmap_ensure_pos(bitmap, i) < 0) + return -1; + size_t offset = i / BITMAP_WIDTH(bitmap); + size_t pos = i % BITMAP_WIDTH(bitmap); + size_t shift = BITMAP_WIDTH(bitmap) - pos - 1; + bitmap[offset] |= 1ul << shift; + return 0; +} + +static inline +int +bitmap_unset(bitmap_t * bitmap, off_t i) +{ + if (bitmap_ensure_pos(bitmap, i) < 0) + return -1; + size_t offset = i / BITMAP_WIDTH(bitmap); + size_t pos = i % BITMAP_WIDTH(bitmap); + size_t shift = BITMAP_WIDTH(bitmap) - pos - 1; + bitmap[offset] &= ~ (1ul << shift); + return 0; +} + + +static inline +int +bitmap_set_range(bitmap_t * bitmap, off_t from, off_t to) +{ + assert(from <= to); + ssize_t offset_from = from / BITMAP_WIDTH(bitmap); + ssize_t offset_to = to / BITMAP_WIDTH(bitmap); + size_t pos_from = from % BITMAP_WIDTH(bitmap); + size_t pos_to = to % BITMAP_WIDTH(bitmap); + + + /* + * First block initialization is needed if <from> is not aligned with the + * bitmap element size or if to is within the same one. + */ + if ((pos_from != 0) || ((offset_to == offset_from) && (pos_to != BITMAP_WIDTH(bitmap) - 1))) { + size_t from_end = MIN(to, (offset_from + 1) * BITMAP_WIDTH(bitmap)); + for (size_t k = from; k < from_end; k++) { + if (bitmap_set(bitmap, k) < 0) + goto END; + } + } + + /* + * Second block is needed if <to> is not aligned with the bitmap element + * size + */ + if ((pos_to != BITMAP_WIDTH(bitmap) - 1) && (offset_to != offset_from)) { + size_t to_start = MAX(from, offset_to * BITMAP_WIDTH(bitmap)); + for (size_t k = to_start; k < to; k++) { + if (bitmap_set(bitmap, k) < 0) + goto END; + } + } + + if (pos_from != 0) + offset_from += 1; + if (pos_to != BITMAP_WIDTH(bitmap) - 1) + offset_to -= 1; + + /* + * We need to cover both elements at position offset_from and offset_to + * provided that offset_from is not bigger + */ + if (offset_to >= offset_from) { + memset(&bitmap[offset_from], 0xFF, (offset_to - offset_from + 1) * sizeof(bitmap[0])); + } + + return 0; + +END: + ERROR("Error setting bitmap range\n"); + return -1; +} -#define bitmap_set(bitmap, i) bitmap[(i) / BITMAP_WIDTH(bitmap)] |= 1 << ((i) % BITMAP_WIDTH(bitmap)) +#define bitmap_set_to(bitmap, to) bitmap_set_range((bitmap), 0, (to)) -#define bitmap_unset(bitmap, i) bitmap[(i) / BITMAP_WIDTH(bitmap)] &= ~ (1 << ((i) % BITMAP_WIDTH(bitmap))) +#define bitmap_free(bitmap) vector_free(bitmap) -#define bitmap_set_to(bitmap, pos) \ -do { \ - size_t offset = (pos / BITMAP_WIDTH(bitmap) + 1); \ - memset(bitmap, 0xFF, pos * sizeof(bitmap[0])); \ - size_t set_bits = offset * BITMAP_WIDTH(bitmap); \ - for (unsigned i = pos; i < set_bits; i++) \ - bitmap_unset(bitmap, i); \ -} while(0); +#ifdef WITH_TESTS +#define bitmap_get_alloc_size(bitmap) vector_get_alloc_size(bitmap) +#endif /* WITH_TESTS */ #endif /* UTIL_BITMAP_H */ diff --git a/hicn-light/src/hicn/base/common.h b/hicn-light/src/hicn/base/common.h index 996050308..9ba426bb8 100644 --- a/hicn-light/src/hicn/base/common.h +++ b/hicn-light/src/hicn/base/common.h @@ -46,7 +46,7 @@ uint32_t __inline __builtin_clz(uint32_t value) { return 32; } -uint32_t __inline __builtin_clzll(uint64_t value) { +uint32_t __inline __builtin_clzl2(uint64_t value) { uint32_t leading_zero = 0; if (_BitScanReverse64(&leading_zero, value)) return 63 - leading_zero; @@ -57,6 +57,6 @@ uint32_t __inline __builtin_clzll(uint64_t value) { #define __builtin_clzl __builtin_clzll #endif -#define next_pow2(x) (x == 1 ? 1 : 1<<(64-__builtin_clzl(x-1))) +#define next_pow2(x) (x <= 1 ? 1 : 1ul <<(64-__builtin_clzl(x-1))) #endif /* UTIL_COMMON_H */ diff --git a/hicn-light/src/hicn/base/pool.c b/hicn-light/src/hicn/base/pool.c index 0f5f728e3..31abb13f1 100644 --- a/hicn-light/src/hicn/base/pool.c +++ b/hicn-light/src/hicn/base/pool.c @@ -30,36 +30,52 @@ #include "common.h" #include "pool.h" +#include <stdio.h> // XXX + void -_pool_init(void ** pool_ptr, size_t elt_size, size_t max_size) +_pool_init(void ** pool_ptr, size_t elt_size, size_t init_size, size_t max_size) { assert(pool_ptr); assert(elt_size); - pool_hdr_t * ph = calloc(POOL_HDRLEN + elt_size * max_size, 1); - if (!ph) { - *pool_ptr = NULL; - return; - } + init_size = next_pow2(init_size); + + if (max_size && init_size > max_size) + goto ERR_MAX_SIZE; + + /* The initial pool size is rounded to the next power of two */ + size_t alloc_size = next_pow2(init_size); + + pool_hdr_t * ph = calloc(POOL_HDRLEN + alloc_size * elt_size, 1); + if (!ph) + goto ERR_MALLOC; ph->elt_size = elt_size; + ph->alloc_size = alloc_size; ph->max_size = max_size; /* Free indices */ off_t * free_indices; - vector_init(free_indices, max_size); - for(unsigned i = 0; i < max_size; i++) - free_indices[i] = (max_size - 1) - i; - vector_len(free_indices) = max_size; + vector_init(free_indices, init_size, max_size); + for(unsigned i = 0; i < init_size; i++) + free_indices[i] = (init_size - 1) - i; + vector_len(free_indices) = init_size; ph->free_indices = free_indices; /* Free bitmap */ uint_fast32_t * fb = ph->free_bitmap; - bitmap_init(fb, max_size); - bitmap_set_to(fb, max_size); + bitmap_init(fb, init_size, max_size); + bitmap_set_to(fb, init_size); ph->free_bitmap = fb; *pool_ptr = (uint8_t*)ph + POOL_HDRLEN; + + return; + +ERR_MALLOC: +ERR_MAX_SIZE: + *pool_ptr = NULL; + return; } void @@ -73,42 +89,59 @@ void _pool_resize(void ** pool_ptr, size_t elt_size) { pool_hdr_t * ph = pool_hdr(*pool_ptr); - size_t old_elts = ph->max_size; - size_t new_elts = old_elts * 2; + size_t old_size = ph->alloc_size; + size_t new_size = old_size * 2; + + if (ph->max_size && new_size > ph->max_size) + goto ERR_MAX_SIZE; /* Double pool storage */ - ph = realloc(ph, POOL_HDRLEN + new_elts * elt_size); - if (!ph) { - *pool_ptr = NULL; - return; - } + ph = realloc(ph, POOL_HDRLEN + new_size * elt_size); + if (!ph) + goto ERR_REALLOC; ph->elt_size = elt_size; - ph->max_size = new_elts; + ph->alloc_size = new_size; /* - * After resize, the pool will have old_elts free indices, ranging from - * old_elts to (new_elts - 1) + * After resize, the pool will have new free indices, ranging from + * old_size to (new_size - 1) */ - off_t * free_indices = ph->free_indices; - vector_ensure_pos(free_indices, old_elts); - for (unsigned i = 0; i < old_elts; i++) - free_indices[i] = new_elts - 1 - i; + vector_ensure_pos(ph->free_indices, old_size); + for (unsigned i = 0; i < old_size; i++) + ph->free_indices[i] = new_size - 1 - i; + vector_len(ph->free_indices) = old_size; + + /* We also need to update the bitmap */ + bitmap_ensure_pos(ph->free_bitmap, new_size - 1); + bitmap_set_range(ph->free_bitmap, old_size, new_size - 1); /* Reassign pool pointer */ *pool_ptr = (uint8_t*)ph + POOL_HDRLEN; + + return; + +ERR_REALLOC: +ERR_MAX_SIZE: + *pool_ptr = NULL; + return; } -void +off_t _pool_get(void ** pool_ptr, void ** elt, size_t elt_size) { pool_hdr_t * ph = pool_hdr(*pool_ptr); uint64_t l = vector_len(ph->free_indices); - if (l == 0) + if (l == 0) { _pool_resize(pool_ptr, elt_size); + ph = pool_hdr(*pool_ptr); + l = vector_len(ph->free_indices); + } off_t free_id = ph->free_indices[l - 1]; vector_len(ph->free_indices)--; + bitmap_unset(ph->free_bitmap, free_id); *elt = *pool_ptr + free_id; memset(*elt, 0, sizeof(elt)); + return free_id; } void diff --git a/hicn-light/src/hicn/base/pool.h b/hicn-light/src/hicn/base/pool.h index 8335c9bc5..57172192b 100644 --- a/hicn-light/src/hicn/base/pool.h +++ b/hicn-light/src/hicn/base/pool.h @@ -51,6 +51,7 @@ typedef struct { size_t elt_size; + size_t alloc_size; size_t max_size; uint_fast32_t * free_bitmap; /* bitmap of free indices */ off_t * free_indices; /* vector of free indices */ @@ -76,7 +77,7 @@ typedef struct { * * NOTE: that an empty pool might be equal to NULL. */ -void _pool_init(void ** pool_ptr, size_t elt_size, size_t max_size); +void _pool_init(void ** pool_ptr, size_t elt_size, size_t init_size, size_t max_size); /** * @brief Free a pool data structure (helper). @@ -105,7 +106,7 @@ void _pool_resize(void ** pool_ptr, size_t elt_size); * NOTES: * - The memory chunk is cleared upon attribution */ -void _pool_get(void ** pool, void ** elt, size_t elt_size); +off_t _pool_get(void ** pool, void ** elt, size_t elt_size); /** * @brief Put an element back into the pool data structure (helper). @@ -127,8 +128,8 @@ void _pool_put(void ** pool, void ** elt, size_t elt_size); * * NOTE: that an empty pool might be equal to NULL. */ -#define pool_init(pool, max_size) \ - _pool_init((void**)&pool, sizeof(pool[0]), max_size); +#define pool_init(pool, init_size, max_size) \ + _pool_init((void**)&pool, sizeof(pool[0]), init_size, max_size); /** * @brief Free a pool data structure. @@ -168,6 +169,8 @@ void _pool_put(void ** pool, void ** elt, size_t elt_size); #define pool_validate_id(pool, id) \ bitmap_is_unset((pool_hdr(pool))->free_bitmap, (id)) +#define pool_get_free_indices_size(pool) vector_len(pool_hdr(pool)->free_indices) + /** * @brief Returns the current length of the pool. * @@ -180,7 +183,7 @@ void _pool_put(void ** pool, void ** elt, size_t elt_size); * size of the pool. */ #define pool_len(pool) \ - (pool_hdr(pool)->max_size - vector_len((pool_hdr(pool)->free_indices))) + (pool_hdr(pool)->alloc_size - pool_get_free_indices_size(pool)) /** * @brief Enumerate elements from a pool. @@ -226,4 +229,10 @@ do { \ pool_enumerate((pool), _pool_var(i), (eltp), BODY); \ } while(0) +#ifdef WITH_TESTS +#define pool_get_alloc_size(bitmap) pool_hdr(pool)->alloc_size +#define pool_get_free_indices(pool) pool_hdr(pool)->free_indices +#define pool_get_free_bitmap(pool) pool_hdr(pool)->free_bitmap +#endif /* WITH_TESTS */ + #endif /* UTIL_POOL_H */ diff --git a/hicn-light/src/hicn/base/test/test-bitmap.cc b/hicn-light/src/hicn/base/test/test-bitmap.cc index d6ab94f3e..1a62edba3 100644 --- a/hicn-light/src/hicn/base/test/test-bitmap.cc +++ b/hicn-light/src/hicn/base/test/test-bitmap.cc @@ -24,60 +24,114 @@ #include <netinet/in.h> extern "C" { -#include <hicn/base/vector.h> +#define WITH_TESTS #include <hicn/base/bitmap.h> } +#define DEFAULT_SIZE 10 + class BitmapTest : public ::testing::Test { - protected: - BitmapTest() { - } +protected: + BitmapTest() { } - virtual ~BitmapTest() { + virtual ~BitmapTest() { } - // You can do clean-up work that doesn't throw exceptions here. - } + bitmap_t * bitmap; +}; - // If the constructor and destructor are not enough for setting up - // and cleaning up each test, you can define the following methods: +/* + * TEST: bitmap allocation + */ +TEST_F(BitmapTest, BitmapAllocation) +{ + int rc; - virtual void SetUp() { - bitmap_init(bitmap, 1024); - } + /* + * We take a value < 32 on purpose to avoid confusion on the choice of a 32 + * or 64 bit integer for storage + */ + size_t size_not_pow2 = DEFAULT_SIZE; + bitmap_init(bitmap, size_not_pow2, 0); - virtual void TearDown() { - free(bitmap); - } - uint32_t *bitmap; -}; + /* + * Bitmap should have been allocated with a size rounded to the next power + * of 2 + */ + EXPECT_EQ(bitmap_get_alloc_size(bitmap), 1); + + /* By default, no element should be set */ + EXPECT_FALSE(bitmap_is_set(bitmap, 0)); + EXPECT_TRUE(bitmap_is_unset(bitmap, 0)); + + EXPECT_EQ(bitmap_get_alloc_size(bitmap), 1); + + EXPECT_FALSE(bitmap_is_set(bitmap, size_not_pow2 - 1)); + EXPECT_TRUE(bitmap_is_unset(bitmap, size_not_pow2 - 1)); + + /* Bitmap should not have been reallocated */ + EXPECT_EQ(bitmap_get_alloc_size(bitmap), 1); + + /* After setting a bit after the end, bitmap should have been reallocated */ + bitmap_set(bitmap, sizeof(bitmap[0]) * 8 - 1); + EXPECT_EQ(bitmap_get_alloc_size(bitmap), 1); + + /* After setting a bit after the end, bitmap should have been reallocated */ + rc = bitmap_set(bitmap, sizeof(bitmap[0]) * 8); + EXPECT_GE(rc, 0); + EXPECT_EQ(bitmap_get_alloc_size(bitmap), 2); + + rc = bitmap_set(bitmap, sizeof(bitmap[0]) * 8 + 1); + EXPECT_GE(rc, 0); + EXPECT_EQ(bitmap_get_alloc_size(bitmap), 2); + + bitmap_free(bitmap); + + size_t size_pow2 = 16; + + /* Limiting test for allocation size */ + bitmap_init(bitmap, size_pow2, 0); + EXPECT_EQ(bitmap_get_alloc_size(bitmap), 1); + + bitmap_free(bitmap); +} TEST_F(BitmapTest, BitmapSet) { - bitmap_set(bitmap, 20); - EXPECT_TRUE(bitmap_is_set(bitmap, 20)); - EXPECT_FALSE(bitmap_is_unset(bitmap, 20)); - EXPECT_FALSE(bitmap_is_set(bitmap, 19)); - EXPECT_TRUE(bitmap_is_unset(bitmap, 19)); + bitmap_init(bitmap, DEFAULT_SIZE, 0); + + bitmap_set(bitmap, 20); + EXPECT_TRUE(bitmap_is_set(bitmap, 20)); + EXPECT_FALSE(bitmap_is_unset(bitmap, 20)); + EXPECT_FALSE(bitmap_is_set(bitmap, 19)); + EXPECT_TRUE(bitmap_is_unset(bitmap, 19)); + bitmap_free(bitmap); } TEST_F(BitmapTest, BitmapUnSet) { - bitmap_set(bitmap, 20); - bitmap_set(bitmap, 19); - bitmap_unset(bitmap, 20); - EXPECT_FALSE(bitmap_is_set(bitmap, 20)); - EXPECT_TRUE(bitmap_is_unset(bitmap, 20)); - EXPECT_TRUE(bitmap_is_set(bitmap, 19)); - EXPECT_FALSE(bitmap_is_unset(bitmap, 19)); + bitmap_init(bitmap, DEFAULT_SIZE, 0); + + bitmap_set(bitmap, 20); + bitmap_set(bitmap, 19); + bitmap_unset(bitmap, 20); + EXPECT_FALSE(bitmap_is_set(bitmap, 20)); + EXPECT_TRUE(bitmap_is_unset(bitmap, 20)); + EXPECT_TRUE(bitmap_is_set(bitmap, 19)); + EXPECT_FALSE(bitmap_is_unset(bitmap, 19)); + bitmap_free(bitmap); } TEST_F(BitmapTest, BitmapSetTo) { - bitmap_set_to(bitmap, 40); - EXPECT_TRUE(bitmap_is_set(bitmap, 20)); - EXPECT_TRUE(bitmap_is_set(bitmap, 21)); - EXPECT_TRUE(bitmap_is_unset(bitmap, 41)); - EXPECT_TRUE(bitmap_is_unset(bitmap, 42)); + bitmap_init(bitmap, DEFAULT_SIZE, 0); + + bitmap_set_to(bitmap, 40); + EXPECT_TRUE(bitmap_is_set(bitmap, 20)); + EXPECT_TRUE(bitmap_is_set(bitmap, 21)); + EXPECT_TRUE(bitmap_is_unset(bitmap, 41)); + EXPECT_TRUE(bitmap_is_unset(bitmap, 42)); + + bitmap_free(bitmap); } int main(int argc, char **argv) diff --git a/hicn-light/src/hicn/base/test/test-pool.cc b/hicn-light/src/hicn/base/test/test-pool.cc index 86c1c1270..1146ef2b7 100644 --- a/hicn-light/src/hicn/base/test/test-pool.cc +++ b/hicn-light/src/hicn/base/test/test-pool.cc @@ -24,45 +24,135 @@ #include <netinet/in.h> extern "C" { +#define WITH_TESTS #include <hicn/base/pool.h> } +/* + * TODO + * - test max_size + */ + +#define DEFAULT_SIZE 10 + class PoolTest : public ::testing::Test { - protected: - PoolTest() { - } +protected: + PoolTest() { } + virtual ~PoolTest() { } - virtual ~PoolTest() { - // You can do clean-up work that doesn't throw exceptions here. - } + int *pool; +}; - // If the constructor and destructor are not enough for setting up - // and cleaning up each test, you can define the following methods: +TEST_F(PoolTest, PoolAllocation) +{ + int rc; - virtual void SetUp() { - - } + pool_init(pool, DEFAULT_SIZE, 0); - virtual void TearDown() { - pool_free(pool); - } + size_t pool_size = next_pow2(DEFAULT_SIZE); - int *pool; -}; + EXPECT_EQ(pool_get_alloc_size(pool), pool_size); + + /* Check that free indices and bitmaps are correctly initialize */ + off_t * fi = pool_get_free_indices(pool); + EXPECT_EQ(vector_len(fi), pool_size); + EXPECT_EQ(fi[0], pool_size - 1); + EXPECT_EQ(fi[pool_size - 1], 0); + + /* The allocated size of the underlying vector should be the next power of two */ + EXPECT_EQ(vector_get_alloc_size(fi), pool_size); + + bitmap_t * fb = pool_get_free_bitmap(pool); + EXPECT_TRUE(bitmap_is_set(fb, 0)); + EXPECT_TRUE(bitmap_is_set(fb, pool_size - 2)); + EXPECT_TRUE(bitmap_is_set(fb, pool_size - 1)); + EXPECT_TRUE(bitmap_is_unset(fb, pool_size)); + + /* Getting elements from the pool should correctly update the free indices + * and bitmap */ + int * elt; + + rc = pool_get(pool, elt); + EXPECT_GE(rc, 0); + EXPECT_EQ(vector_len(fi), pool_size - 1); + EXPECT_TRUE(bitmap_is_unset(fb, 0)); + + rc = pool_get(pool, elt); + EXPECT_GE(rc, 0); + EXPECT_EQ(vector_len(fi), pool_size - 2); + EXPECT_TRUE(bitmap_is_unset(fb, 1)); + + for (unsigned i = 0; i < pool_size - 4; i++) { + rc = pool_get(pool, elt); + EXPECT_GE(rc, 0); + } + + rc = pool_get(pool, elt); + EXPECT_GE(rc, 0); + EXPECT_EQ(vector_len(fi), 1); + EXPECT_TRUE(bitmap_is_unset(fb, pool_size - 2)); + + rc = pool_get(pool, elt); + EXPECT_GE(rc, 0); + EXPECT_EQ(vector_len(fi), 0); + EXPECT_TRUE(bitmap_is_unset(fb, pool_size - 1)); + /* + * Getting elements within the allocated range should not have triggered a + * resize + */ + EXPECT_EQ(pool_len(pool), pool_size); + + /* + * Getting elements once the allocated range has been exceeded should + * trigger a resize + */ + rc = pool_get(pool, elt); + EXPECT_GE(rc, 0); + + EXPECT_EQ(pool_get_alloc_size(pool), pool_size * 2); + + EXPECT_EQ(pool_len(pool), pool_size + 1); + + /* + * Doubling the size, we should have again pool_size elements free, minus 1 + */ + EXPECT_EQ(pool_get_free_indices_size(pool), pool_size - 1); + + /* + * NOTE: this is wrong as there has been a realloc and the old fi + * pointer is now invalid + */ + //EXPECT_EQ(vector_len(fi), pool_size - 1); + + /* And the bitmap should also be correctly modified */ + fb = pool_get_free_bitmap(pool); + EXPECT_TRUE(bitmap_is_unset(fb, pool_size)); + + /* Check that surrounding values are also correct */ + EXPECT_TRUE(bitmap_is_unset(fb, pool_size - 1)); + EXPECT_TRUE(bitmap_is_set(fb, pool_size + 1)); + + /* Setting elements after should through */ + + /* Check that free indices and bitmaps are correctly updated */ + + pool_free(pool); +} + +// XXX todo : check state after several get and put TEST_F(PoolTest, PoolPut) { - pool_init(pool, 1024); - int* elt; - pool_get(pool, elt); - *elt = 10; + pool_init(pool, DEFAULT_SIZE, 0); + + int* elt; + pool_get(pool, elt); + *elt = 10; printf("2\n"); - pool_put(pool, elt); + pool_put(pool, elt); printf("3\n"); - - //pool_get(pool) - //loop_ = loop_create(); - //EXPECT_TRUE(loop_ != NULL); + + pool_free(pool); } diff --git a/hicn-light/src/hicn/base/test/test-vector.cc b/hicn-light/src/hicn/base/test/test-vector.cc index e5eeff910..59571b053 100644 --- a/hicn-light/src/hicn/base/test/test-vector.cc +++ b/hicn-light/src/hicn/base/test/test-vector.cc @@ -24,64 +24,90 @@ #include <netinet/in.h> extern "C" { +#define WITH_TESTS #include <hicn/base/vector.h> } +/* + * TODO + * - test max_size + */ + +#define DEFAULT_SIZE 10 + class VectorTest : public ::testing::Test { - protected: - VectorTest() { - } +protected: + VectorTest() { } + virtual ~VectorTest() { } - virtual ~VectorTest() { - // You can do clean-up work that doesn't throw exceptions here. - } + int *vector = NULL; +}; - // If the constructor and destructor are not enough for setting up - // and cleaning up each test, you can define the following methods: +/* TEST: Vector allocation and initialization */ +TEST_F(VectorTest, VectorAllocate) +{ + vector_init(vector, DEFAULT_SIZE, 0); - virtual void SetUp() {; - vector_init(vector, 1024); - } + /* Allocated size should be the next power of two */ + EXPECT_EQ(vector_get_alloc_size(vector), 16); - virtual void TearDown() { - vector_free(vector); - } + /* Setting elements within the allocated size should not trigger a resize */ + vector_ensure_pos(vector, 15); + EXPECT_EQ(vector_get_alloc_size(vector), 16); - int *vector = NULL; + /* Setting elements after should through */ + vector_ensure_pos(vector, 16); + EXPECT_EQ(vector_get_alloc_size(vector), 32); -}; + /* Check that free indices and bitmaps are correctly updated */ + + vector_free(vector); +} TEST_F(VectorTest, VectorSize) { - vector_push(vector, 109); - vector_push(vector, 109); - int size = vector_len(vector); - EXPECT_EQ(size, 2); - vector_push(vector, 109); - size = vector_len(vector); - EXPECT_EQ(size, 3); + vector_init(vector, DEFAULT_SIZE, 0); + + vector_push(vector, 109); + int size = vector_len(vector); + EXPECT_EQ(size, 1); + vector_push(vector, 109); + size = vector_len(vector); + EXPECT_EQ(size, 2); + vector_push(vector, 109); + size = vector_len(vector); + EXPECT_EQ(size, 3); + vector_free(vector); } TEST_F(VectorTest, VectorCheckValue) { - vector_push(vector, 109); - vector_push(vector, 200); - EXPECT_EQ(vector[0], 109); - EXPECT_EQ(vector[1], 200); + vector_init(vector, DEFAULT_SIZE, 0); + + vector_push(vector, 109); + vector_push(vector, 200); + EXPECT_EQ(vector[0], 109); + EXPECT_EQ(vector[1], 200); + + vector_free(vector); } TEST_F(VectorTest, VectorEnsurePos) { - printf (" %p\n", vector); - vector_ensure_pos(vector, 1025); - for (int i = 0; i <1025; i++) { - printf("i %d\n", i); + vector_init(vector, DEFAULT_SIZE, 0); + printf (" %p\n", vector); - vector_push(vector, i); - } - int size = vector_len(vector); - EXPECT_EQ(size, 1025); + vector_ensure_pos(vector, 1025); + for (int i = 0; i <1025; i++) { + //printf("i %d\n", i); + //printf (" %p\n", vector); + vector_push(vector, i); + } + int size = vector_len(vector); + EXPECT_EQ(size, 1025); + + vector_free(vector); } int main(int argc, char **argv) diff --git a/hicn-light/src/hicn/base/vector.c b/hicn-light/src/hicn/base/vector.c index b994a4465..43110414a 100644 --- a/hicn-light/src/hicn/base/vector.c +++ b/hicn-light/src/hicn/base/vector.c @@ -28,9 +28,10 @@ #define DEFAULT_VECTOR_SIZE 64 void -_vector_init(void ** vector_ptr, size_t elt_size, size_t init_size) +_vector_init(void ** vector_ptr, size_t elt_size, size_t init_size, size_t max_size) { assert(vector_ptr); + assert(max_size == 0 || init_size < max_size); if (init_size == 0) init_size = DEFAULT_VECTOR_SIZE; @@ -40,6 +41,7 @@ _vector_init(void ** vector_ptr, size_t elt_size, size_t init_size) vector_hdr_t * vh = vector_hdr(*vector_ptr); vh->cur_size = 0; + vh->max_size = max_size; } void @@ -49,23 +51,42 @@ _vector_free(void ** vector_ptr) *vector_ptr = NULL; } -bool +int _vector_resize(void ** vector_ptr, size_t elt_size, off_t pos) { - vector_hdr_t * vh = *vector_ptr ? vector_hdr(*vector_ptr) : NULL; + vector_hdr_t * vh; - /* - * Round the allocated size to the next power of 2 of the requested position - */ - size_t new_elts = (pos > 0) ? next_pow2(pos) : vh->max_size * 2; + size_t old_size; - vh = realloc(vh, VECTOR_HDRLEN + new_elts * elt_size); + if (*vector_ptr) { + vh = vector_hdr(*vector_ptr); + old_size = vh->alloc_size; + } else { + vh = NULL; + old_size = 0; + } + + /* Round the allocated size to the next power of 2 of the requested position */ + size_t new_size = next_pow2(pos); + + /* Don't grow the vector back */ + if (new_size < old_size) + return 0; + + /* Don't exceed maximum size (for init, check is done beforehand) */ + if (vh && vh->max_size && new_size > vh->max_size) + return -1; + + vh = realloc(vh, VECTOR_HDRLEN + new_size * elt_size); if (!vh) - return false; - vh->max_size = new_elts; + return -1; + vh->alloc_size = new_size; + + /* Zero out the newly allocated memory (except headers) */ + memset((uint8_t*)vh + VECTOR_HDRLEN + old_size * elt_size, 0, (new_size - old_size) * elt_size); /* Reassign vector pointer */ *vector_ptr = (uint8_t*)vh + VECTOR_HDRLEN; - return true; + return 0; } diff --git a/hicn-light/src/hicn/base/vector.h b/hicn-light/src/hicn/base/vector.h index 06ffa4428..ff12e6ee6 100644 --- a/hicn-light/src/hicn/base/vector.h +++ b/hicn-light/src/hicn/base/vector.h @@ -45,7 +45,7 @@ #ifndef UTIL_VECTOR_H #define UTIL_VECTOR_H -#include <stdbool.h> +#include <stdint.h> #include <stddef.h> #include <stdint.h> #include <string.h> @@ -58,7 +58,8 @@ typedef struct { size_t cur_size; /** Vector current size (corresponding to the highest used element). */ - size_t max_size; /** The currently allocated size. */ + size_t alloc_size; /** The currently allocated size. */ + size_t max_size; /** The maximum allowed size (0 = no limit) */ } vector_hdr_t; /* Make sure elements following the header are aligned */ @@ -80,7 +81,7 @@ typedef struct { * @param[in] elt_size Size of a vector element. * @param[in] max_size Maximum vector size (O = unlimited). */ -void _vector_init(void ** vector_ptr, size_t elt_size, size_t max_size); +void _vector_init(void ** vector_ptr, size_t elt_size, size_t init_size, size_t max_size); /** * @brief Free a vector data structure. @@ -97,7 +98,7 @@ void _vector_free(void ** vector_ptr); * @param[in] pos The position at which the vector should be able to hold an * element. * - * @return bool Flag indicating whether the vector has been correctly resized. + * @return int Flag indicating whether the vector has been correctly resized. * * NOTE: * - The resize operation does not specify the final size of the vector but @@ -105,7 +106,7 @@ void _vector_free(void ** vector_ptr); * position. This allows the caller not to care about doing successive calls to * this API while the vector is growing in size. */ -bool _vector_resize(void ** vector_ptr, size_t elt_size, off_t pos); +int _vector_resize(void ** vector_ptr, size_t elt_size, off_t pos); /** * @brief Ensures a vector is sufficiently large to hold an element at the @@ -115,7 +116,7 @@ bool _vector_resize(void ** vector_ptr, size_t elt_size, off_t pos); * @param[in] elt_size The size of a vector element. * @param[in] pos The position to validate. * - * @return bool Flag indicating whether the vector is available. + * @return int Flag indicating whether the vector is available. * * NOTE: * - This function should always be called before writing to a vector element @@ -124,13 +125,13 @@ bool _vector_resize(void ** vector_ptr, size_t elt_size, off_t pos); * be resized. */ static inline -bool +int _vector_ensure_pos(void ** vector_ptr, size_t elt_size, off_t pos) { vector_hdr_t * vh = vector_hdr(*vector_ptr); - if (pos >= vh->max_size) - return _vector_resize(vector_ptr, elt_size, pos); - return true; + if (pos >= vh->alloc_size) + return _vector_resize(vector_ptr, elt_size, pos + 1); + return 0; } /** @@ -146,15 +147,17 @@ _vector_ensure_pos(void ** vector_ptr, size_t elt_size, off_t pos) * maximum size). */ static inline -bool +int _vector_push(void ** vector_ptr, size_t elt_size, void * elt) { vector_hdr_t * vh = vector_hdr(*vector_ptr); - if (!_vector_ensure_pos(vector_ptr, elt_size, vh->cur_size)) - return false; - /*(*vector_ptr)[vh->cur_size++] = elt; */ - memcpy((uint8_t*)vector_ptr + vh->cur_size++ * elt_size, elt, elt_size); - return true; + if (_vector_ensure_pos(vector_ptr, elt_size, vh->cur_size) < 0) + return -1; + /* Always get header after a potential resize */ + memcpy((uint8_t*)*vector_ptr + vh->cur_size * elt_size, elt, elt_size); + vh = vector_hdr(*vector_ptr); + vh->cur_size++; + return 0; } /******************************************************************************/ @@ -165,9 +168,13 @@ _vector_push(void ** vector_ptr, size_t elt_size, void * elt) * * @param[in,out] vector Vector to allocate and initialize. * @param[in] max_size Maximum vector size (nonzero). + * + * NOTE: + * - Allocated memory is set to 0 (used by bitmap) */ -#define vector_init(vector, max_size) \ - _vector_init((void**)&vector, sizeof(vector[0]), max_size) + +#define vector_init(vector, init_size, max_size) \ + _vector_init((void**)&vector, sizeof(vector[0]), init_size, max_size) /** * @brief Free a vector data structure. @@ -184,7 +191,7 @@ _vector_push(void ** vector_ptr, size_t elt_size, void * elt) * @param[in] pos The position at which the vector should be able to hold an * element. * - * @return bool Flag indicating whether the vector has been correctly resized. + * @return int Flag indicating whether the vector has been correctly resized. * * NOTE: * - The resize operation does not specify the final size of the vector but @@ -193,6 +200,7 @@ _vector_push(void ** vector_ptr, size_t elt_size, void * elt) * this API while the vector is growing in size. * - If the new size is smaller than the current size, the content of the * vector will be truncated. + * - Newly allocated memory is set to 0 (used by bitmap) */ #define vector_resize(vector) _vector_resize((void**)&(vector), sizeof((vector)[0]), 0) @@ -241,6 +249,10 @@ do { \ * - A user should always call vector_ensure_pos to ensure the vector is * sufficiently large to hold an element at the specified position. */ -#define vector_len(vector) vector_hdr((vector))->cur_size +#define vector_len(vector) vector_hdr(vector)->cur_size + +#ifdef WITH_TESTS +#define vector_get_alloc_size(vector) vector_hdr(vector)->alloc_size +#endif /* WITH_TESTS */ #endif /* UTIL_VECTOR_H */ diff --git a/hicn-light/src/hicn/command_line/daemon/hicnLightDaemon_main.c b/hicn-light/src/hicn/command_line/daemon/hicnLightDaemon_main.c index f3fbf84dd..c743de743 100644 --- a/hicn-light/src/hicn/command_line/daemon/hicnLightDaemon_main.c +++ b/hicn-light/src/hicn/command_line/daemon/hicnLightDaemon_main.c @@ -369,6 +369,12 @@ int main(int argc, const char *argv[]) { } #endif + /* + * The loop should be created before the forwarder instance as it is needed + * for timers + */ + MAIN_LOOP = loop_create(); + forwarder_t * forwarder = forwarder_create(); if (!forwarder) { ERROR("Forwarder initialization failed. Are you running it with sudo privileges?"); @@ -377,7 +383,7 @@ int main(int argc, const char *argv[]) { configuration_t * configuration = forwarder_get_configuration(forwarder); if (capacity > -1) { - configuration_content_store_set_size(configuration, capacity); + configuration_cs_set_size(configuration, capacity); } forwarder_setup_local_listeners(forwarder, port); @@ -389,7 +395,6 @@ int main(int argc, const char *argv[]) { configurationPort); /* Main loop */ - MAIN_LOOP = loop_create(); if (loop_dispatch(MAIN_LOOP) < 0) { ERROR("Failed to run main loop"); return EXIT_FAILURE; diff --git a/hicn-light/src/hicn/config/configuration.c b/hicn-light/src/hicn/config/configuration.c index a6f78f9c2..fed9d95ed 100644 --- a/hicn-light/src/hicn/config/configuration.c +++ b/hicn-light/src/hicn/config/configuration.c @@ -51,8 +51,8 @@ #define DEFAULT_COST 1 #define DEFAULT_PORT 1234 -#define make_ack(msg) msg->header.messageType = ACK_LIGHT -#define make_nack(msg) msg->header.messageType = NACK_LIGHT +#define make_ack(msg) ((msg_header_t *)msg)->header.messageType = ACK_LIGHT +#define make_nack(msg) ((msg_header_t *)msg)->header.messageType = NACK_LIGHT #define msg_malloc_list(msg, N) \ do { \ @@ -224,7 +224,7 @@ configuration_on_listener_add(configuration_t * config, uint8_t * packet, return (uint8_t*)msg; NACK: - make_ack(msg); + make_nack(msg); return (uint8_t*)msg; } @@ -291,7 +291,7 @@ configuration_on_listener_remove(configuration_t * config, uint8_t * packet, return (uint8_t*)msg; NACK: - make_ack(msg); + make_nack(msg); return (uint8_t*)msg; } @@ -348,7 +348,7 @@ configuration_on_listener_list(configuration_t * config, uint8_t * packet, msg_listener_list_reply_t * msg; msg_malloc_list(msg, n) if (!msg) - return NULL; + goto NACK; cmd_listener_list_item_t * payload = &msg->payload; listener_t * listener; @@ -358,6 +358,10 @@ configuration_on_listener_list(configuration_t * config, uint8_t * packet, }); return (uint8_t*)msg; + +NACK: + make_nack(msg); + return (uint8_t*)msg; } /* Connection */ @@ -435,7 +439,7 @@ configuration_on_connection_add(configuration_t * config, uint8_t * packet, return (uint8_t*)msg; NACK: - make_ack(msg); + make_nack(msg); return (uint8_t*)msg; } @@ -488,7 +492,7 @@ configuration_on_connection_remove(configuration_t * config, uint8_t * packet, return (uint8_t*)msg; NACK: - make_ack(msg); + make_nack(msg); return (uint8_t*)msg; } @@ -578,7 +582,7 @@ configuration_on_connection_list(configuration_t * config, uint8_t * packet, msg_connection_list_reply_t * msg; msg_malloc_list(msg, n) if (!msg) - return NULL; + goto NACK; cmd_connection_list_item_t * payload = &msg->payload; connection_t * connection; @@ -588,6 +592,10 @@ configuration_on_connection_list(configuration_t * config, uint8_t * packet, }); return (uint8_t*)msg; + +NACK: + make_nack(msg); + return (uint8_t*)msg; } uint8_t * @@ -622,7 +630,7 @@ configuration_on_connection_set_admin_state(configuration_t * config, return (uint8_t*)msg; NACK: - make_ack(msg); + make_nack(msg); return (uint8_t*)msg; } @@ -652,7 +660,7 @@ configuration_on_connection_update(configuration_t * config, uint8_t * packet, NACK: #endif /* WITH_POLICY */ - make_ack(msg); + make_nack(msg); return (uint8_t*)msg; } @@ -684,7 +692,7 @@ configuration_on_connection_set_priority(configuration_t * config, NACK: #endif /* WITH_POLICY */ - make_ack(msg); + make_nack(msg); return (uint8_t*)msg; } @@ -716,7 +724,7 @@ configuration_on_connection_set_tags(configuration_t * config, uint8_t * packet, NACK: #endif /* WITH_POLICY */ - make_ack(msg); + make_nack(msg); return (uint8_t*)msg; } @@ -751,7 +759,7 @@ configuration_on_route_add(configuration_t * config, uint8_t * packet, return (uint8_t*)msg; NACK: - make_ack(msg); + make_nack(msg); return (uint8_t*)msg; } @@ -782,7 +790,7 @@ configuration_on_route_remove(configuration_t * config, uint8_t * packet, return (uint8_t*)msg; NACK: - make_ack(msg); + make_nack(msg); return (uint8_t*)msg; } @@ -811,7 +819,7 @@ configuration_on_route_list(configuration_t * config, uint8_t * packet, msg_route_list_reply_t * msg; msg_malloc_list(msg, n); if (!msg) - return NULL; + goto NACK; cmd_route_list_item_t * payload = &msg->payload; fib_foreach_entry(fib, entry, { @@ -850,6 +858,10 @@ configuration_on_route_list(configuration_t * config, uint8_t * packet, }); return (uint8_t*)msg; + +NACK: + make_nack(msg); + return (uint8_t*)msg; } @@ -869,16 +881,16 @@ configuration_on_cache_set_store(configuration_t * config, uint8_t * packet, goto NACK; bool value = (bool)control->activate; - forwarder_content_store_set_store(config->forwarder, value); + forwarder_cs_set_store(config->forwarder, value); /* XXX Why do we need to check ? */ - if (forwarder_content_store_get_store(config->forwarder) != value) + if (forwarder_cs_get_store(config->forwarder) != value) goto NACK; make_ack(msg); return (uint8_t*)msg; NACK: - make_ack(msg); + make_nack(msg); return (uint8_t*)msg; } @@ -896,16 +908,16 @@ configuration_on_cache_set_serve(configuration_t * config, uint8_t * packet, goto NACK; bool value = (bool)control->activate; - forwarder_content_store_set_serve(config->forwarder, value); + forwarder_cs_set_serve(config->forwarder, value); /* XXX Why do we need to check ? */ - if (forwarder_content_store_get_serve(config->forwarder) != value) + if (forwarder_cs_get_serve(config->forwarder) != value) goto NACK; make_ack(msg); return (uint8_t*)msg; NACK: - make_ack(msg); + make_nack(msg); return (uint8_t*)msg; } @@ -918,7 +930,7 @@ configuration_on_cache_clear(configuration_t * config, uint8_t * packet, msg_cache_clear_t * msg = (msg_cache_clear_t *)packet; - forwarder_content_store_clear(config->forwarder); + forwarder_cs_clear(config->forwarder); make_ack(msg); return (uint8_t*)msg; @@ -1039,7 +1051,7 @@ configuration_on_wldr_set(configuration_t * config, uint8_t * packet, return (uint8_t*)msg; NACK: - make_ack(msg); + make_nack(msg); return (uint8_t*)msg; } @@ -1098,7 +1110,7 @@ configuration_on_punting_add(configuration_t * config, uint8_t * packet, NACK: #endif - make_ack(msg); + make_nack(msg); return (uint8_t*)msg; } @@ -1124,7 +1136,7 @@ configuration_on_mapme_enable(configuration_t * config, uint8_t * packet, return (uint8_t*)msg; NACK: - make_ack(msg); + make_nack(msg); return (uint8_t*)msg; } @@ -1148,7 +1160,7 @@ configuration_on_mapme_set_discovery(configuration_t * config, uint8_t * packet, return (uint8_t*)msg; NACK: - make_ack(msg); + make_nack(msg); return (uint8_t*)msg; } @@ -1221,7 +1233,7 @@ configuration_on_mapme_send_update(configuration_t * config, uint8_t * packet, }); NACK: - make_ack(msg); + make_nack(msg); return (uint8_t*)msg; } @@ -1252,7 +1264,7 @@ configuration_on_policy_add(configuration_t * config, uint8_t * packet, NACK: #endif /* WITH_POLICY */ - make_ack(msg); + make_nack(msg); return (uint8_t*)msg; } @@ -1282,7 +1294,7 @@ configuration_on_policy_remove(configuration_t * config, uint8_t * packet, NACK: #endif /* WITH_POLICY */ - make_ack(msg); + make_nack(msg); return (uint8_t*)msg; } @@ -1298,10 +1310,10 @@ configuration_on_policy_list(configuration_t * config, uint8_t * packet, size_t n = fib_get_size(fib); #ifdef WITH_POLICY - msg_policy_list_reply_t * msg; + msg_policy_list_reply_t * msg = (msg_policy_list_reply_t *)packet; msg_malloc_list(msg, n); if (!msg) - return NULL; + goto NACK; cmd_policy_list_item_t * payload = &msg->payload; @@ -1333,23 +1345,25 @@ configuration_on_policy_list(configuration_t * config, uint8_t * packet, }); return (uint8_t*)msg; -#else - return NULL; #endif /* WITH_POLICY */ + +NACK: + make_nack(msg); + return (uint8_t *)msg; } size_t -configuration_content_store_get_size(configuration_t * config) +configuration_cs_get_size(configuration_t * config) { return config->maximumContentObjectStoreSize; } void -configuration_content_store_set_size(configuration_t * config, size_t size) +configuration_cs_set_size(configuration_t * config, size_t size) { config->maximumContentObjectStoreSize = size; - forwarder_content_store_set_size(config->forwarder, + forwarder_cs_set_size(config->forwarder, config->maximumContentObjectStoreSize); } @@ -1359,58 +1373,59 @@ configuration_get_forwarder(const configuration_t * config) { } -// =========================== -// Main functions that deal with receiving commands, executing them, and sending -// ACK/NACK - -uint8_t * -configuration_dispatch_command(configuration_t * config, command_type_t command_type, - uint8_t * packet, unsigned ingress_id) +ssize_t +configuration_receive_command(configuration_t * config, msgbuf_t * msgbuf) { + assert(config); + assert(msgbuf); + + uint8_t * packet = msgbuf_get_packet(msgbuf); + unsigned ingress_id = msgbuf_get_connection_id(msgbuf); + + uint8_t * reply = NULL; + + /* + * For most commands, the packet will simply be transformed into an ack. + * For list commands, a new message will be allocated, and the return value + * might eventually be NULL in case of an error. That is why the free the + * reply at the end in these circumstances. + * + * XXX rework this part. + */ + command_type_t command_type = msgbuf_get_command_type(msgbuf); switch (command_type) { #define _(l, u) \ case COMMAND_TYPE_ ## u: \ - return configuration_on_ ## l(config, packet, ingress_id); + reply = configuration_on_ ## l(config, packet, ingress_id); \ + assert(reply); \ + break; foreach_command_type #undef _ case COMMAND_TYPE_UNDEFINED: case COMMAND_TYPE_N: ERROR("Unexpected command type"); + reply = packet; + make_nack(reply); break; } - return NULL; -} - -void configuration_receive_command(configuration_t * config, - command_type_t command_type, uint8_t * packet, unsigned ingress_id) -{ - assert(config); - assert(command_type_is_valid(command_type)); - assert(packet); - - bool nack = false; - - uint8_t * reply = configuration_dispatch_command(config, command_type, packet, ingress_id); - if (!reply) { - reply = packet; - msg_header_t * hdr = (msg_header_t *)reply; - make_nack(hdr); - nack = true; - } connection_table_t * table = forwarder_get_connection_table(config->forwarder); const connection_t *connection = connection_table_at(table, ingress_id); connection_send_packet(connection, reply, false); - switch (command_type) { + switch (msgbuf->command.type) { case COMMAND_TYPE_LISTENER_LIST: case COMMAND_TYPE_CONNECTION_LIST: case COMMAND_TYPE_ROUTE_LIST: case COMMAND_TYPE_POLICY_LIST: - if (!nack) + /* Free replies that have been allocated (not NACK's) */ + if (((msg_header_t *)reply)->header.messageType != NACK_LIGHT) free(reply); break; default: break; } + + // XXX only if we consumed the whole packet. + return (ssize_t)msgbuf_get_len(msgbuf); } diff --git a/hicn-light/src/hicn/config/configuration.h b/hicn-light/src/hicn/config/configuration.h index 86efa5236..fa1b0410c 100644 --- a/hicn-light/src/hicn/config/configuration.h +++ b/hicn-light/src/hicn/config/configuration.h @@ -26,7 +26,8 @@ #ifndef configuration_h #define configuration_h -#include <hicn/utils/commands.h> +#include "../core/msgbuf.h" +#include "../utils/commands.h" typedef struct configuration_s configuration_t; @@ -67,8 +68,7 @@ void configuration_free(configuration_t * config); void configuration_setup_all_listeners(configuration_t *config, uint16_t port, const char *localPath); -void configuration_receive_command(configuration_t *config, command_type_t command, - uint8_t * packet, unsigned ingress_id); +ssize_t configuration_receive_command(configuration_t *config, msgbuf_t * msgbuf); /** * Returns the configured size of the content store @@ -84,7 +84,7 @@ void configuration_receive_command(configuration_t *config, command_type_t comma * <#example#> * @endcode */ -size_t configuration_content_store_get_size(configuration_t *config); +size_t configuration_cs_get_size(configuration_t *config); /** * Sets the size of the content store (in objects, not bytes) @@ -98,7 +98,7 @@ size_t configuration_content_store_get_size(configuration_t *config); * <#example#> * @endcode */ -void configuration_content_store_set_size(configuration_t *config, size_t size); +void configuration_cs_set_size(configuration_t *config, size_t size); strategy_type_t configuration_get_strategy(configuration_t *config, const char *prefix); diff --git a/hicn-light/src/hicn/content_store/lru.c b/hicn-light/src/hicn/content_store/lru.c index 30f972ce9..72d3e4302 100644 --- a/hicn-light/src/hicn/content_store/lru.c +++ b/hicn-light/src/hicn/content_store/lru.c @@ -29,9 +29,9 @@ // XXX TODO #if 0 -static void _content_store_lru_Log(ContentStoreInterface *storeImpl) { - content_store_lru_data_t *store = - (content_store_lru_data_t *)contentStoreInterface_GetPrivateData(storeImpl); +static void _cs_lru_Log(ContentStoreInterface *storeImpl) { + cs_lru_data_t *store = + (cs_lru_data_t *)contentStoreInterface_GetPrivateData(storeImpl); logger_Log(store->logger, LoggerFacility_Processor, PARCLogLevel_All, __func__, @@ -47,40 +47,40 @@ static void _content_store_lru_Log(ContentStoreInterface *storeImpl) { static bool -_content_store_lru_remove_least_used(content_store_t * cs) +_cs_lru_remove_least_used(cs_t * cs) { - if (content_store_size(cs) == 0) + if (cs_size(cs) == 0) return false; #if 0 ListLruEntry *lruEntry = listLRU_PopTail(store->lru); - content_store_entry_t *storeEntry = - (content_store_entry_t *)listLRU_EntryGetData(lruEntry); + cs_entry_t *storeEntry = + (cs_entry_t *)listLRU_EntryGetData(lruEntry); #else - content_store_entry_t * entry = NULL; + cs_entry_t * entry = NULL; #endif DEBUG("CS %p LRU evict msgbuf %p (#evictions %" PRIu64 ")", - cs, content_store_entry_message(entry), + cs, cs_entry_message(entry), cs->stats.lru.countLruEvictions); - content_store_purge_entry(cs, entry); + cs_purge_entry(cs, entry); return true; } static void -_evictByStorePolicy(content_store_t * cs, uint64_t currentTimeInTicks) +_evictByStorePolicy(cs_t * cs, uint64_t currentTimeInTicks) { // We need to make room. Here's the plan: // 1) Check to see if anything has expired. If so, remove it and we're done. // If not, 2) Remove the least recently used item. - content_store_entry_t *entry = + cs_entry_t *entry = listTimeOrdered_GetOldest(store->indexByExpirationTime); - if (entry && content_store_entry_has_expiry_time(entry) && - (currentTimeInTicks > content_store_entry_get_expiry_time(entry))) { + if (entry && cs_entry_has_expiry_time(entry) && + (currentTimeInTicks > cs_entry_get_expiry_time(entry))) { // Found an expired entry. Remove it, and we're done. store->stats.countExpiryEvictions++; @@ -88,103 +88,92 @@ _evictByStorePolicy(content_store_t * cs, uint64_t currentTimeInTicks) (void *)store, (void *)contentStoreEntry_GetMessage(entry), store->stats.countExpiryEvictions); - _content_store_lru_purge_entry(store, entry); + _cs_lru_purge_entry(store, entry); } else { store->stats.countLruEvictions++; - _content_store_lru_remove_least_used(store); + _cs_lru_remove_least_used(store); } } #endif void -content_store_lru_initialize(content_store_t * cs) +cs_lru_initialize(cs_t * cs) { - content_store_lru_data_t * data = cs->data; - - data->lru = NULL; - if (!data->lru) { - ERROR("Could not create LRU index"); - goto ERR_INDEX; - } - -ERR_INDEX: - return; + /* We start with an empty double-linked list */ + cs->lru.head = 0; + cs->lru.tail = 0; } void -content_store_lru_finalize(content_store_t * cs) +cs_lru_finalize(cs_t * cs) { - content_store_lru_data_t * data = cs->data; - - if (data->lru != NULL) - ; // XXX TODO listLRU_Destroy(&(store->lru)); + /* Nothing to do */ } -bool -content_store_lru_add_entry(content_store_t * cs, content_store_entry_t * entry) +/** + * @brief LRU processing related to the insertion of a new entry in the content + * store. + * @param[in] cs Content store. + * @param[in] entry_id Identifier of the entry in the content store entry pool. + * + * @return int Error code : 0 if succesful, a negative value otherwise. + * + * NOTE: + * - We insert the new element at the head of the double-linked list. + */ +static +int +cs_lru_add_entry(cs_t * cs, off_t entry_id) { assert(cs); - assert(entry); - - if (content_store_size(cs) == 0) - return false; -#if 0 - content_store_lru_data_t * data = cs->data; - - content_store_entry_t *dataEntry = parcHashCodeTable_Get(data->storageByName, content); - if(dataEntry) - _content_store_lru_purge_entry(data, dataEntry); - uint64_t expiryTimeTicks = contentStoreEntry_MaxExpiryTime; - if (message_HasContentExpiryTime(content)) - expiryTimeTicks = message_GetContentExpiryTimeTicks(content); + cs_entry_t * entry = &cs->entries[entry_id]; + assert(entry); - // Don't add anything that's already expired or has exceeded RCT. - if (now >= expiryTimeTicks) - return false; + if (cs->lru.head != INVALID_ENTRY_ID) { + cs_entry_t * head_entry = cs_entry_at(cs, cs->lru.head); + assert(head_entry->lru.prev == INVALID_ENTRY_ID); + head_entry->lru.prev = entry_id; - if (data->objectCount >= data->objectCapacity) - // Store is full. Need to make room. - _evictByStorePolicy(data, now); + entry->lru.next = cs->lru.head; + entry->lru.prev = INVALID_ENTRY_ID; - // And now add a new entry to the head of the LRU. - content_store_entry_t *entry = contentStoreEntry_Create(content, data->lru); - if (!entry) - return false; + cs->lru.head = entry_id; + } else { + /* The list is empty */ + assert(cs->lru.tail == INVALID_ENTRY_ID); - if (!parcHashCodeTable_Add(data->storageByName, content, entry)) { - // Free what we just created, but did not add. 'entry' has ownership of - // 'copy', and so will call _Release() on it - contentStoreEntry_Release(&entry); - WARN("ContentStoreLRU %p failed to add message %p to hash table", - (void *)data, (void *)content); - return false; + entry->lru.next = INVALID_ENTRY_ID; + entry->lru.prev = INVALID_ENTRY_ID; + cs->lru.head = cs->lru.tail = entry_id; } - if (content_store_entry_has_expiry_time(entry)) - listTimeOrdered_Add(data->indexByExpirationTime, entry); - - data->objectCount++; - data->stats.countAdds++; - - DEBUG("ContentStoreLRU %p saved message %p (object count %" PRIu64 ")", - data, msgbuf, content_store_size(cs)); -#endif - return true; + return 0; } /** - * Remove a content_store_entry_t from all tables and indices. + * Remove a cs_entry_t from all tables and indices. */ static -void -content_store_lru_remove_entry(content_store_t * cs, content_store_entry_t * entry) +int +cs_lru_remove_entry(cs_t * cs, cs_entry_t * entry) { assert(cs); assert(entry); - // - // XXX REMOVE ENTRY FROM LRU + + off_t entry_id = cs_get_entry_id(cs, entry); + + if (entry->lru.prev == INVALID_ENTRY_ID) { + /* Not already on the head of the LRU */ + cs_entry_t * prev_entry = cs_entry_at(cs, entry->lru.prev); + assert(prev_entry); + prev_entry->lru.next = entry_id; + } else { + assert(cs->lru.head == entry_id); + } + + return 0; } -DECLARE_CONTENT_STORE(lru); +DECLARE_CS(lru); diff --git a/hicn-light/src/hicn/content_store/lru.h b/hicn-light/src/hicn/content_store/lru.h index 61341921f..574f9da7d 100644 --- a/hicn-light/src/hicn/content_store/lru.h +++ b/hicn-light/src/hicn/content_store/lru.h @@ -13,14 +13,18 @@ * limitations under the License. */ -#ifndef HICNLIGHT_CONTENT_STORE_LRU_H -#define HICNLIGHT_CONTENT_STORE_LRU_H +#ifndef HICNLIGHT_CS_LRU_H +#define HICNLIGHT_CS_LRU_H typedef struct { - // This LRU is just for keeping track of insertion and access order. - //ListLru *lru; - void * lru; -} content_store_lru_data_t; + off_t prev; + off_t next; +} cs_entry_lru_state_t; + +typedef struct { + off_t head; + off_t tail; +} cs_lru_state_t; typedef struct { uint64_t countExpiryEvictions; @@ -29,6 +33,6 @@ typedef struct { uint64_t countAdds; uint64_t countHits; uint64_t countMisses; -} content_store_lru_stats_t; +} cs_lru_stats_t; -#endif /* HICNLIGHT_CONTENT_STORE_LRU_H */ +#endif /* HICNLIGHT_CS_LRU_H */ diff --git a/hicn-light/src/hicn/core/CMakeLists.txt b/hicn-light/src/hicn/core/CMakeLists.txt index b1f952a43..f877717aa 100644 --- a/hicn-light/src/hicn/core/CMakeLists.txt +++ b/hicn-light/src/hicn/core/CMakeLists.txt @@ -26,8 +26,8 @@ list(APPEND HEADER_FILES ${CMAKE_CURRENT_SOURCE_DIR}/listener.h ${CMAKE_CURRENT_SOURCE_DIR}/listener_table.h ${CMAKE_CURRENT_SOURCE_DIR}/listener_vft.h - ${CMAKE_CURRENT_SOURCE_DIR}/messagePacketType.h ${CMAKE_CURRENT_SOURCE_DIR}/msgbuf.h + ${CMAKE_CURRENT_SOURCE_DIR}/msgbuf_pool.h ${CMAKE_CURRENT_SOURCE_DIR}/packet_cache.h ${CMAKE_CURRENT_SOURCE_DIR}/pit.h ${CMAKE_CURRENT_SOURCE_DIR}/prefix_stats.h @@ -57,6 +57,7 @@ list(APPEND SOURCE_FILES ${CMAKE_CURRENT_SOURCE_DIR}/listener_vft.c ${CMAKE_CURRENT_SOURCE_DIR}/mapme.c ${CMAKE_CURRENT_SOURCE_DIR}/msgbuf.c + ${CMAKE_CURRENT_SOURCE_DIR}/msgbuf_pool.c ${CMAKE_CURRENT_SOURCE_DIR}/nameBitvector.c ${CMAKE_CURRENT_SOURCE_DIR}/name.c ${CMAKE_CURRENT_SOURCE_DIR}/packet_cache.c diff --git a/hicn-light/src/hicn/core/address.h b/hicn-light/src/hicn/core/address.h index d13fc99ed..35d0f63ea 100644 --- a/hicn-light/src/hicn/core/address.h +++ b/hicn-light/src/hicn/core/address.h @@ -18,8 +18,8 @@ * \brief Address */ -#ifndef HICN_ADDRESS_H -#define HICN_ADDRESS_H +#ifndef HICNLIGHT_ADDRESS_H +#define HICNLIGHT_ADDRESS_H #include <netinet/in.h> @@ -84,5 +84,5 @@ extern const char * _address_family_str[]; #define address6_empty(address) (memcmp(address6_ip(address).s6_addr, &in6addr_any, sizeof(struct in6_addr)) == 0) #define address_empty(address) (address_family(address) == AF_INET ? address4_empty(address) : address6_empty(address)) -#endif /* HICN_ADDRESS_H */ +#endif /* HICNLIGHT_ADDRESS_H */ diff --git a/hicn-light/src/hicn/core/address_pair.h b/hicn-light/src/hicn/core/address_pair.h index 7a08426a4..4dfdfd9de 100644 --- a/hicn-light/src/hicn/core/address_pair.h +++ b/hicn-light/src/hicn/core/address_pair.h @@ -18,8 +18,8 @@ * \brief Address pair */ -#ifndef HICN_ADDRESS_PAIR_H -#define HICN_ADDRESS_PAIR_H +#ifndef HICNLIGHT_ADDRESS_PAIR_H +#define HICNLIGHT_ADDRESS_PAIR_H #include <hicn/core/address.h> #include <hicn/util/ip_address.h> @@ -40,9 +40,9 @@ int address_pair_from_ip_port(address_pair_t * pair, int family, (address_family(address_pair_get_local(pair))) #define address_pair_get_remote_family(pair) \ (address_family(address_pair_get_remote(pair))) -#define address_pair_get_family(pair) address_pair_local_family(pair) +#define address_pair_get_family(pair) address_pair_get_local_family(pair) #define address_pair_is_valid(pair) \ (address_pair_get_local_family(pair) == address_pair_get_remote_family(pair)) -#endif /* HICN_ADDRESS_PAIR_H */ +#endif /* HICNLIGHT_ADDRESS_PAIR_H */ diff --git a/hicn-light/src/hicn/core/connection.c b/hicn-light/src/hicn/core/connection.c index ba56ce459..680e82b9b 100644 --- a/hicn-light/src/hicn/core/connection.c +++ b/hicn-light/src/hicn/core/connection.c @@ -399,9 +399,9 @@ connection_process_buffer(connection_t * connection, const uint8_t * buffer, siz msgbuf_t msgbuf; MessagePacketType packet_type; if (messageHandler_IsInterest(message->messageHead)) { - packet_type = MESSAGE_TYPE_INTEREST; + packet_type = MSGBUF_TYPE_INTEREST; } else if (messageHandler_IsData(message->messageHead)) { - packet_type = MESSAGE_TYPE_DATA; + packet_type = MSGBUF_TYPE_DATA; } else { ERROR("Dropped packet that is not interest nor data"); return -1; @@ -457,18 +457,27 @@ _connection_send(const connection_t * connection, msgbuf_t * msgbuf, bool queue) } bool -connection_send(const connection_t * connection, msgbuf_t * msgbuf, bool queue) +connection_flush(const connection_t * connection) { - assert(connection); + // XXX Replace this with a proper flush function to avoid implementing the + // same thing everywhere + return _connection_send(connection, NULL, false); +} - /* NULL message means flush */ - if (!msgbuf) - return _connection_send(connection, NULL, false); +bool +connection_send(const connection_t * connection, off_t msgbuf_id, bool queue) +{ + assert(connection); + assert(msgbuf_id_is_valid(msgbuf_id)); // XXX we now have a flush() function if (!connection_is_up(connection)) return false; - if (msgbuf_get_type(msgbuf) == MESSAGE_TYPE_DATA) { + const forwarder_t * forwarder = connection_get_forwarder(connection); + const msgbuf_pool_t * msgbuf_pool = forwarder_get_msgbuf_pool(forwarder); + msgbuf_t * msgbuf = msgbuf_pool_at(msgbuf_pool, msgbuf_id); + + if (msgbuf_get_type(msgbuf) == MSGBUF_TYPE_DATA) { uint8_t conn_id = (uint8_t)connection_get_id(connection); msgbuf_update_pathlabel(msgbuf, conn_id); } @@ -504,7 +513,7 @@ connection_resend(const connection_t * connection, msgbuf_t * msgbuf, bool if (!connection_is_up(connection)) return ret; - if (msgbuf_get_type(msgbuf) == MESSAGE_TYPE_DATA) { + if (msgbuf_get_type(msgbuf) == MSGBUF_TYPE_DATA) { uint8_t conn_id = (uint8_t)connection_get_id(connection); uint32_t old_path_label = msgbuf_get_pathlabel(msgbuf); msgbuf_update_pathlabel(msgbuf, conn_id); @@ -551,7 +560,7 @@ connection_wldr_allow_autostart(connection_t * connection, bool value) } bool -connection_wldr_autostart_is_allowed(connection_t * connection) +connection_wldr_autostart_is_allowed(const connection_t * connection) { return connection->wldr_autostart; } @@ -579,7 +588,7 @@ connection_has_wldr(const connection_t * connection) } void -connection_wldr_detect_losses(const connection_t * connection, msgbuf_t * msgbuf) +connection_wldr_detect_losses(const connection_t * connection, const msgbuf_t * msgbuf) { if (!connection->wldr) return; @@ -587,7 +596,7 @@ connection_wldr_detect_losses(const connection_t * connection, msgbuf_t * msgbuf } void -connection_wldr_handle_notification(const connection_t * connection, msgbuf_t * msgbuf) +connection_wldr_handle_notification(const connection_t * connection, const msgbuf_t * msgbuf) { if (!connection->wldr) return; diff --git a/hicn-light/src/hicn/core/connection.h b/hicn-light/src/hicn/core/connection.h index 6297e193c..d9ef817d2 100644 --- a/hicn-light/src/hicn/core/connection.h +++ b/hicn-light/src/hicn/core/connection.h @@ -87,6 +87,7 @@ typedef struct { #define connection_get_name(C) ((C)->name) #define connection_get_type(C) ((C)->type) #define connection_has_valid_id(C) (connection_id_is_valid(connection_get_id(C))) +#define connection_has_valid_type(C) (face_type_is_valid(connection_get_type(C))) #define connection_get_pair(C) (&(C)->pair) #define connection_get_local(C) (address_pair_local(connection_get_pair(C))) #define connection_get_remote(C) (address_pair_remote(connection_get_pair(C))) @@ -191,7 +192,9 @@ int connection_finalize(connection_t * connection); int connection_send_packet(const connection_t * connection, const uint8_t * packet, size_t size); -bool connection_send(const connection_t * connection, msgbuf_t * msgbuf, +bool connection_flush(const connection_t * connection); + +bool connection_send(const connection_t * connection, off_t msgbuf_id, bool queue); size_t connection_process_buffer(connection_t * connection, const uint8_t * buffer, size_t size); @@ -200,14 +203,16 @@ size_t connection_process_buffer(connection_t * connection, const uint8_t * buff void connection_wldr_allow_autostart(connection_t * connection, bool value); -bool connection_wldr_autostart_is_allowed(connection_t * connection); +bool connection_wldr_autostart_is_allowed(const connection_t * connection); void connection_wldr_enable(connection_t * connection, bool value); bool connection_has_wldr(const connection_t * connection); -void connection_wldr_detect_losses(const connection_t * connection, msgbuf_t * msgbuf); +void connection_wldr_detect_losses(const connection_t * connection, const msgbuf_t * msgbuf); + +void connection_wldr_handle_notification(const connection_t * connection, const msgbuf_t * msgbuf); -void connection_wldr_handle_notification(const connection_t * connection, msgbuf_t * msgbuf); +#define connection_get_forwarder(connection) (connection->forwarder) #endif /* HICNLIGHT_CONNECTION_H */ diff --git a/hicn-light/src/hicn/core/connection_table.c b/hicn-light/src/hicn/core/connection_table.c index 0b7df0384..c4010fe40 100644 --- a/hicn-light/src/hicn/core/connection_table.c +++ b/hicn-light/src/hicn/core/connection_table.c @@ -46,7 +46,7 @@ _connection_table_create(size_t init_size, size_t max_size) * We start by allocating a reasonably-sized pool, as this will eventually * be resized if needed. */ - pool_init(table->connections, init_size); + pool_init(table->connections, init_size, 0); return table; } diff --git a/hicn-light/src/hicn/core/connection_vft.h b/hicn-light/src/hicn/core/connection_vft.h index 589f39536..1ff4d7702 100644 --- a/hicn-light/src/hicn/core/connection_vft.h +++ b/hicn-light/src/hicn/core/connection_vft.h @@ -42,10 +42,11 @@ const connection_ops_t connection_ ## NAME = { \ .get_socket = listener_ ## NAME ## _get_socket, \ .send = connection_ ## NAME ## _send, \ .send_packet = connection_ ## NAME ## _send_packet, \ - .read_callback = connection_ ## NAME ## _read_callback, \ .data_size = sizeof(connection_ ## NAME ## _data_t), \ }; +// .read_callback = connection_ ## NAME ## _read_callback, + extern const connection_ops_t * connection_vft[]; #endif /* HICNLIGHT_CONNECTION_VFT_H */ diff --git a/hicn-light/src/hicn/core/content_store.c b/hicn-light/src/hicn/core/content_store.c index 77d40ace5..74b675224 100644 --- a/hicn-light/src/hicn/core/content_store.c +++ b/hicn-light/src/hicn/core/content_store.c @@ -26,10 +26,10 @@ #include "content_store.h" -extern const content_store_ops_t content_store_lru; +extern const cs_ops_t cs_lru; -const content_store_ops_t * const content_store_vft[] = { - [CONTENT_STORE_TYPE_LRU] = &content_store_lru, +const cs_ops_t * const cs_vft[] = { + [CS_TYPE_LRU] = &cs_lru, }; // XXX TODO replace by a single packet cache @@ -37,26 +37,35 @@ const content_store_ops_t * const content_store_vft[] = { // XXX TODO getting rid of logger and the need to acquire // XXX TODO separate cs from vft, same with strategy -#define content_store_entry_from_msgbuf(entry, msgbuf) \ +#define cs_entry_from_msgbuf(entry, msgbuf) \ do { \ (entry)->hasExpiryTimeTicks = msgbuf_HasContentExpiryTime(msgbuf); \ if ((entry)->hasExpiryTimeTicks) \ (entry)->expiryTimeTicks = msgbuf_GetContentExpiryTimeTicks(msgbuf); \ } while(0) +/* This is only used as a hint for first allocation, as the table is resizeable */ +#define DEFAULT_CS_SIZE 64 -content_store_t * -_content_store_create(content_store_type_t type, size_t init_size, size_t max_size) +cs_t * +_cs_create(cs_type_t type, size_t init_size, size_t max_size) { - content_store_t * cs = malloc(sizeof(content_store_t)); + if (!CS_TYPE_VALID(type)) { + ERROR("[cs_create] Invalid content store type"); + return NULL; + } + + if (init_size == 0) + init_size = DEFAULT_CS_SIZE; + + cs_t * cs = malloc(sizeof(cs_t)); if (!cs) - goto ERR_MALLOC; - if (!CONTENT_STORE_TYPE_VALID(type)) - goto ERR_TYPE; + return NULL; + cs->type = type; // XXX TODO an entry = data + metadata specific to each policy - pool_init(cs->entries, init_size); + pool_init(cs->entries, init_size, max_size); // data // options @@ -66,59 +75,65 @@ _content_store_create(content_store_type_t type, size_t init_size, size_t max_si // index by name cs->index_by_name = kh_init(cs_name); +#if 0 cs->index_by_expiry_time = NULL; if (!cs->index_by_expiry_time) { ERROR("Could not create index (expiry time)"); goto ERR_INDEX_EXPIRY; } +#endif + cs_vft[type]->initialize(cs); - // XXX indices specific to each policy => vft - // index by expiration time - // lru ? - - content_store_vft[type]->initialize(cs); - + return cs; +#if 0 ERR_INDEX_EXPIRY: - // XXX TODO -ERR_TYPE: -ERR_MALLOC: + free(cs); + // XXX + return NULL; +#endif } void -content_store_free(content_store_t * cs) +cs_free(cs_t * cs) { - content_store_vft[cs->type]->finalize(cs); + cs_vft[cs->type]->finalize(cs); +#if 0 if (cs->index_by_expiry_time) ; //listTimeOrdered_Release(&(store->indexByExpirationTime)); +#endif } -void content_store_clear(content_store_t * cs) +void cs_clear(cs_t * cs) { // XXX TODO } -msgbuf_t * -content_store_match(content_store_t * cs, msgbuf_t * msgbuf, uint64_t now) +off_t +cs_match(cs_t * cs, off_t msgbuf_id, uint64_t now) { assert(cs); + + const msgbuf_pool_t * msgbuf_pool = cs_get_msgbuf_pool(cs); + const msgbuf_t * msgbuf = msgbuf_pool_at(msgbuf_pool, msgbuf_id); + assert(msgbuf); - assert(msgbuf_get_type(msgbuf) == MESSAGE_TYPE_INTEREST); + assert(msgbuf_get_type(msgbuf) == MSGBUF_TYPE_INTEREST); /* Lookup entry by name */ khiter_t k = kh_get_cs_name(cs->index_by_name, msgbuf_get_name(msgbuf)); if (k == kh_end(cs->index_by_name)) - return NULL; - content_store_entry_t * entry = cs->entries + kh_val(cs->index_by_name, k); + return INVALID_MSGBUF_ID; + cs_entry_t * entry = cs->entries + kh_val(cs->index_by_name, k); assert(entry); /* Remove any expired entry */ - if (content_store_entry_has_expiry_time(entry) && - content_store_entry_expiry_time(entry) < now) { + if (cs_entry_has_expiry_time(entry) && + cs_entry_get_expiry_time(entry) < now) { // the entry is expired, we can remove it - content_store_remove_entry(cs, entry); + cs_remove_entry(cs, entry); goto NOT_FOUND; } @@ -130,69 +145,139 @@ content_store_match(content_store_t * cs, msgbuf_t * msgbuf, uint64_t now) DEBUG("CS %p LRU match %p (hits %" PRIu64 ", misses %" PRIu64 ")", cs, msgbuf, cs->stats.lru.countHits, cs->stats.lru.countMisses); - return content_store_entry_message(entry); + return cs_entry_get_msgbuf_id(entry); NOT_FOUND: cs->stats.lru.countMisses++; DEBUG("ContentStoreLRU %p missed msgbuf %p (hits %" PRIu64 ", misses %" PRIu64 ")", cs, msgbuf, cs->stats.lru.countHits, cs->stats.lru.countMisses); - return NULL; + return INVALID_MSGBUF_ID; } -void -content_store_add(content_store_t * cs, msgbuf_t * msgbuf, uint64_t now) +// XXX temp +// XXX pool member pointer might change, not the ID. +#define msgbuf_acquire(x) (x) + +cs_entry_t * +cs_add(cs_t * cs, off_t msgbuf_id, uint64_t now) { assert(cs); - assert(msgbuf); - assert(msgbuf_get_type(msgbuf) == MESSAGE_TYPE_DATA); + assert(msgbuf_id_is_valid(msgbuf_id)); + +#if DEBUG + forwarder_t * forwarder = cs_get_forwarder(cs); + msgbuf_t * msgbuf = msgbuf_pool_at(msgbuf_pool, msgbuf_id); + assert(msgbuf_get_type(msgbuf) == MSGBUF_TYPE_DATA); +#endif - content_store_entry_t * entry = NULL; +#if 0 + // entry exists ? + cs_entry_t *dataEntry = parcHashCodeTable_Get(data->storageByName, content); + if(dataEntry) + _cs_lru_purge_entry(data, dataEntry); +#endif + +#if 0 + // check expiration + uint64_t expiryTimeTicks = contentStoreEntry_MaxExpiryTime; + if (message_HasContentExpiryTime(content)) + expiryTimeTicks = message_GetContentExpiryTimeTicks(content); + + // Don't add anything that's already expired or has exceeded RCT. + if (now >= expiryTimeTicks) + return false; +#endif + +#if 0 + // evict + if (data->objectCount >= data->objectCapacity) + // Store is full. Need to make room. + _evictByStorePolicy(data, now); +#endif + + cs_entry_t * entry = NULL; + off_t entry_id = pool_get(cs->entries, entry); + if (!entry) + goto ERR_ENTRY; + + *entry = (cs_entry_t) { + .msgbuf_id = msgbuf_id, + .hasExpiryTimeTicks = false, // XXX + .expiryTimeTicks = 0, // XXX + }; + + // update indices + + // update policy index + /* eg. LRU: add new the entry at the head of the LRU */ + if (!cs_vft[cs->type]->add_entry(cs, entry_id)) + goto ERR_VFT; - /* borrow from content_store_lru_add_entry */ +#if 0 + // update expiry time index + if (cs_entry_has_expiry_time(entry)) { + } +#endif + +#if 0 + // stats + data->objectCount++; + data->stats.countAdds++; +#endif + + return entry; - content_store_vft[cs->type]->add_entry(cs, entry); +ERR_VFT: + pool_put(cs->entries, entry); +ERR_ENTRY: + return NULL; } -void -content_store_remove_entry(content_store_t * cs, content_store_entry_t * entry) +int +cs_remove_entry(cs_t * cs, cs_entry_t * entry) { assert(cs); assert(entry); - if (content_store_entry_has_expiry_time(entry)) + if (cs_entry_has_expiry_time(entry)) ; // XXX TODO listTimeOrdered_Remove(store->indexByExpirationTime, entryToPurge); - msgbuf_t * msgbuf = content_store_entry_message(entry); + off_t msgbuf_id = cs_entry_get_msgbuf_id(entry); + + const msgbuf_pool_t * msgbuf_pool = cs_get_msgbuf_pool(cs); + const msgbuf_t * msgbuf = msgbuf_pool_at(msgbuf_pool, msgbuf_id); + khiter_t k = kh_get_cs_name(cs->index_by_name, msgbuf_get_name(msgbuf)); if (k != kh_end(cs->index_by_name)) kh_del(cs_name, cs->index_by_name, k); // This will take care of LRU entry for instance - content_store_vft[cs->type]->remove_entry(cs, entry); + cs_vft[cs->type]->remove_entry(cs, entry); //store->objectCount--; pool_put(cs->entries, entry); + return 0; } // // XXX TODO what is the difference between purge and remove ? bool -content_store_remove(content_store_t * cs, msgbuf_t * msgbuf) +cs_remove(cs_t * cs, msgbuf_t * msgbuf) { assert(cs); assert(msgbuf); - assert(msgbuf_get_type(msgbuf) == MESSAGE_TYPE_DATA); + assert(msgbuf_get_type(msgbuf) == MSGBUF_TYPE_DATA); /* Lookup entry by name */ khiter_t k = kh_get_cs_name(cs->index_by_name, msgbuf_get_name(msgbuf)); if (k == kh_end(cs->index_by_name)) return false; - content_store_entry_t * entry = cs->entries + kh_val(cs->index_by_name, k); + cs_entry_t * entry = cs->entries + kh_val(cs->index_by_name, k); assert(entry); - content_store_remove_entry(cs, entry); + cs_remove_entry(cs, entry); return true; } diff --git a/hicn-light/src/hicn/core/content_store.h b/hicn-light/src/hicn/core/content_store.h index 5cddeaa87..2973b3955 100644 --- a/hicn-light/src/hicn/core/content_store.h +++ b/hicn-light/src/hicn/core/content_store.h @@ -1,41 +1,44 @@ -#ifndef HICNLIGHT_CONTENT_STORE_H -#define HICNLIGHT_CONTENT_STORE_H +#ifndef HICNLIGHT_CS_H +#define HICNLIGHT_CS_H -#include <hicn/base/khash.h> -#include <hicn/base/pool.h> -#include <hicn/core/msgbuf.h> -#include <hicn/core/name.h> -#include <hicn/content_store/lru.h> +#include "msgbuf.h" +#include "msgbuf_pool.h" +#include "name.h" +#include "../base/khash.h" +#include "../base/pool.h" +#include "../content_store/lru.h" + +#define INVALID_ENTRY_ID ~0ul /* off_t */ typedef struct { - msgbuf_t * message; + off_t msgbuf_id; //ListLruEntry *lruEntry; bool hasExpiryTimeTicks; uint64_t expiryTimeTicks; // single value for both ? 0 allowed ? -} content_store_entry_t; + union { + off_t prev; + off_t next; + } lru; +} cs_entry_t; -#define content_store_entry_message(entry) ((entry)->message) -#define content_store_entry_has_expiry_time(entry) ((entry)->hasExpiryTimeTicks) -#define content_store_entry_expiry_time(entry) ((entry)->expiryTimeTicks) +#define cs_entry_get_msgbuf_id(entry) ((entry)->msgbuf_id) +#define cs_entry_has_expiry_time(entry) ((entry)->hasExpiryTimeTicks) +#define cs_entry_get_expiry_time(entry) ((entry)->expiryTimeTicks) typedef enum { - CONTENT_STORE_TYPE_UNDEFINED, - CONTENT_STORE_TYPE_LRU, - CONTENT_STORE_TYPE_N, -} content_store_type_t; + CS_TYPE_UNDEFINED, + CS_TYPE_LRU, + CS_TYPE_N, +} cs_type_t; -#define CONTENT_STORE_TYPE_VALID(type) \ - (type != CONTENT_STORE_TYPE_UNDEFINED) && \ - (type != CONTENT_STORE_TYPE_N) +#define CS_TYPE_VALID(type) \ + (type != CS_TYPE_UNDEFINED) && \ + (type != CS_TYPE_N) typedef struct { /* The maximum allowed expiry time (will never be exceeded). */ uint64_t max_expiry_time; // XXX part of lru ? -} content_store_options_t; - -typedef union { - content_store_lru_stats_t lru; -} content_store_stats_t; +} cs_options_t; // XXX TODO #define name_hash(name) (name_HashCode(name)) @@ -44,22 +47,30 @@ typedef union { KHASH_INIT(cs_name, const Name *, unsigned, 0, name_hash, name_hash_eq); typedef struct { - content_store_type_t type; - size_t max_size; + cs_type_t type; // XXX TODO api to dynamically set max size - content_store_entry_t * entries; // pool + cs_entry_t * entries; // pool kh_cs_name_t * index_by_name; +#if 0 void * index_by_expiry_time; - //ListTimeOrdered *indexByExpirationTime; - +#endif + const msgbuf_pool_t * msgbuf_pool; void * data; // per cs type data void * options; - content_store_stats_t stats; -} content_store_t; + + union { + cs_lru_stats_t lru; + } stats; + + + union { + cs_lru_state_t lru; + }; +} cs_t; /** * @brief Create a new content store (extended parameters) @@ -68,42 +79,53 @@ typedef struct { * @param[in] init_size Initially allocated size (hint, 0 = use default value) * @param[in] max_size Maximum size (0 = unlimited) * - * @return content_store_t* - The newly created content store + * @return cs_t* - The newly created content store */ -content_store_t * _content_store_create(content_store_type_t type, size_t init_size, size_t max_size); +cs_t * _cs_create(cs_type_t type, size_t init_size, size_t max_size); /** * @brief Create a new content store * * @param[in] type Content store type * - * @return content_store_t* - The newly created content store + * @return cs_t* - The newly created content store */ -#define content_store_create( TYPE) _content_store_create((TYPE), 0, 0) +#define cs_create(TYPE) _cs_create((TYPE), 0, 0) + +void cs_free(cs_t * cs); + +void cs_clear(cs_t * cs); + +off_t cs_match(cs_t * cs, off_t msgbuf_id, uint64_t now); -void content_store_free(content_store_t * cs); +cs_entry_t * cs_add(cs_t * cs, off_t msgbuf_id, uint64_t now); -void content_store_clear(content_store_t * cs); +int cs_remove_entry(cs_t * cs, cs_entry_t * entry); -msgbuf_t * content_store_match(content_store_t * cs, msgbuf_t * msgbuf, uint64_t now); +bool cs_remove(cs_t * cs, msgbuf_t * msgbuf); -void content_store_add(content_store_t * cs, msgbuf_t * msgbuf, uint64_t now); +#define cs_size(content_store) (pool_len(cs->entries)) -void content_store_remove_entry(content_store_t * cs, content_store_entry_t * entry); +void cs_purge_entry(cs_t * cs, cs_entry_t * entry); -bool content_store_remove(content_store_t * cs, msgbuf_t * msgbuf); +#define cs_get_entry_id(cs, entry) (entry - cs->entries) -#define content_store_size(content_store) (pool_len(cs->entries)) +#define cs_entry_at(cs, id) (&(cs)->entries[id]) -void content_store_purge_entry(content_store_t * cs, content_store_entry_t * entry); +static inline +const msgbuf_pool_t * +cs_get_msgbuf_pool(const cs_t * cs) +{ + return cs->msgbuf_pool; +} typedef struct { const char * name; - void (*initialize)(content_store_t * cs); + void (*initialize)(cs_t * cs); - void (*finalize)(content_store_t * cs); + void (*finalize)(cs_t * cs); /** * Place a Message representing a ContentObject into the ContentStore. If @@ -116,7 +138,7 @@ typedef struct { * UTC epoch. */ // XXX Do we always get now before adding ? - bool (*add_entry)(content_store_t * cs, content_store_entry_t * entry); + int (*add_entry)(cs_t * cs, off_t entry_id); /** * The function to call to remove content from the ContentStore. @@ -126,19 +148,19 @@ typedef struct { * @param storeImpl - a pointer to this ContentStoreInterface instance. * @param content - a pointer to a `Message` to remove from the store. */ - void (*remove_entry)(content_store_t * cs, content_store_entry_t * entry); + int (*remove_entry)(cs_t * cs, cs_entry_t * entry); -} content_store_ops_t; +} cs_ops_t; -extern const content_store_ops_t * const content_store_vft[]; +extern const cs_ops_t * const cs_vft[]; -#define DECLARE_CONTENT_STORE(NAME) \ - const content_store_ops_t content_store_ ## NAME = { \ +#define DECLARE_CS(NAME) \ + const cs_ops_t cs_ ## NAME = { \ .name = #NAME, \ - .initialize = content_store_ ## NAME ## _initialize, \ - .finalize = content_store_ ## NAME ## _finalize, \ - .add_entry = content_store_ ## NAME ## _add_entry, \ - .remove_entry = content_store_ ## NAME ## _remove_entry, \ + .initialize = cs_ ## NAME ## _initialize, \ + .finalize = cs_ ## NAME ## _finalize, \ + .add_entry = cs_ ## NAME ## _add_entry, \ + .remove_entry = cs_ ## NAME ## _remove_entry, \ } -#endif /* HICNLIGHT_CONTENT_STORE_H */ +#endif /* HICNLIGHT_CS_H */ diff --git a/hicn-light/src/hicn/core/forwarder.c b/hicn-light/src/hicn/core/forwarder.c index 9c3df906d..543fc99e4 100644 --- a/hicn-light/src/hicn/core/forwarder.c +++ b/hicn-light/src/hicn/core/forwarder.c @@ -31,7 +31,7 @@ #include <errno.h> #include <fcntl.h> #include <signal.h> -#include <hicn/hicn-light/config.h> +//#include <hicn/hicn-light/config.h> #include <stdarg.h> #include <stdio.h> #include <stdlib.h> @@ -41,18 +41,20 @@ #define __STDC_FORMAT_MACROS #include <inttypes.h> -#include <hicn/core/connection_table.h> -#include <hicn/core/listener_table.h> -#include <hicn/core/pit.h> -#include <hicn/core/fib.h> -#include <hicn/core/content_store.h> -#include <hicn/core/forwarder.h> -#include <hicn/core/messagePacketType.h> +#include "connection_table.h" +#include "content_store.h" +#include "fib.h" +#include "forwarder.h" +#include "listener_table.h" #ifdef WITH_MAPME -#include <hicn/core/mapme.h> +#include "mapme.h" #endif /* WITH_MAPME */ -#include <hicn/config/configuration.h> -#include <hicn/config/configuration_file.h> +#include "msgbuf.h" +#include "msgbuf_pool.h" +#include "pit.h" +#include "../config/configuration.h" +#include "../config/configuration_file.h" +#include "../io/base.h" // MAX_MSG #ifdef WITH_PREFIX_STATS #include <hicn/core/prefix_stats.h> @@ -61,10 +63,8 @@ #include <hicn/core/wldr.h> #include <hicn/util/log.h> -#define DEFAULT_PIT_SIZE 65535 - typedef struct { - uint32_t countReceived; + uint32_t countReceived; // Interest & Data only uint32_t countInterestsReceived; uint32_t countObjectsReceived; @@ -110,15 +110,16 @@ struct forwarder_s { pit_t * pit; - content_store_t * content_store; + cs_t * cs; fib_t * fib; + msgbuf_pool_t * msgbuf_pool; #ifdef WITH_MAPME mapme_t * mapme; #endif /* WITH_MAPME */ - bool store_in_content_store; - bool serve_from_content_store; + bool store_in_cs; + bool serve_from_cs; forwarder_stats_t stats; #ifdef WITH_PREFIX_STATS @@ -132,7 +133,7 @@ struct forwarder_s { unsigned pending_conn[MAX_MSG]; size_t num_pending_conn; - msgbuf_t msgbuf; /* Storage for msgbuf, which are currently processed 1 by 1 */ + //msgbuf_t msgbuf; /* Storage for msgbuf, which are currently processed 1 by 1 */ }; @@ -172,27 +173,6 @@ forwarder_seed(forwarder_t * forwarder) { #endif } -int -init_batch_buffers(batch_buffer_t * bb) -{ - /* Setup recvmmsg data structures. */ - for (unsigned i = 0; i < MAX_MSG; i++) { - char *buf = &bb->buffers[i][0]; - struct iovec *iovec = &bb->iovecs[i]; - struct mmsghdr *msg = &bb->msghdr[i]; - - msg->msg_hdr.msg_iov = iovec; - msg->msg_hdr.msg_iovlen = 1; - - msg->msg_hdr.msg_name = &bb->addrs[i]; - msg->msg_hdr.msg_namelen = sizeof(struct sockaddr_storage); - - iovec->iov_base = &buf[0]; - iovec->iov_len = MTU; - } - return 0; -} - forwarder_t * forwarder_create() { @@ -218,22 +198,26 @@ forwarder_create() if (!forwarder->fib) goto ERR_FIB; - forwarder->pit = pit_create(DEFAULT_PIT_SIZE); + forwarder->msgbuf_pool = msgbuf_pool_create(); + if (!forwarder->msgbuf_pool) + goto ERR_PACKET_POOL; + + forwarder->pit = pit_create(); if (!forwarder->pit) goto ERR_PIT; size_t objectStoreSize = - configuration_content_store_get_size(forwarder_get_configuration(forwarder)); - forwarder->content_store = _content_store_create(CONTENT_STORE_TYPE_LRU, + configuration_cs_get_size(forwarder_get_configuration(forwarder)); + forwarder->cs = _cs_create(CS_TYPE_LRU, objectStoreSize, 0); - if (!forwarder->content_store) - goto ERR_CONTENT_STORE; + if (!forwarder->cs) + goto ERR_CS; - // the two flags for the content_store are set to true by default. If the content_store + // the two flags for the cs are set to true by default. If the cs // is active it always work as expected unless the use modifies this // values using controller - forwarder->store_in_content_store = true; - forwarder->serve_from_content_store = true; + forwarder->store_in_cs = true; + forwarder->serve_from_cs = true; #if 0 forwarder->signal_term = dispatcher_CreateSignalEvent( @@ -293,10 +277,12 @@ ERR_MAPME: dispatcher_Destroy(&(forwarder->dispatcher)); #endif - content_store_free(forwarder->content_store); -ERR_CONTENT_STORE: + cs_free(forwarder->cs); +ERR_CS: pit_free(forwarder->pit); ERR_PIT: + msgbuf_pool_free(forwarder->msgbuf_pool); +ERR_PACKET_POOL: fib_free(forwarder->fib); ERR_FIB: connection_table_free(forwarder->connection_table); @@ -335,8 +321,9 @@ forwarder_free(forwarder_t * forwarder) dispatcher_Destroy(&(forwarder->dispatcher)); #endif - content_store_free(forwarder->content_store); + cs_free(forwarder->cs); pit_free(forwarder->pit); + msgbuf_pool_free(forwarder->msgbuf_pool); fib_free(forwarder->fib); connection_table_free(forwarder->connection_table); listener_table_free(forwarder->listener_table); @@ -394,63 +381,56 @@ forwarder_get_listener_table(forwarder_t * forwarder) } void -forwarder_content_store_set_store(forwarder_t * forwarder, bool val) +forwarder_cs_set_store(forwarder_t * forwarder, bool val) { assert(forwarder); - forwarder->store_in_content_store = val; + forwarder->store_in_cs = val; } bool -forwarder_content_store_get_store(forwarder_t * forwarder) +forwarder_cs_get_store(forwarder_t * forwarder) { assert(forwarder); - return forwarder->store_in_content_store; + return forwarder->store_in_cs; } void -forwarder_content_store_set_serve(forwarder_t * forwarder, bool val) +forwarder_cs_set_serve(forwarder_t * forwarder, bool val) { assert(forwarder); - forwarder->serve_from_content_store = val; + forwarder->serve_from_cs = val; } bool -forwarder_content_store_get_serve(forwarder_t * forwarder) +forwarder_cs_get_serve(forwarder_t * forwarder) { assert(forwarder); - return forwarder->serve_from_content_store; + return forwarder->serve_from_cs; } void -forwarder_content_store_set_size(forwarder_t * forwarder, size_t size) +forwarder_cs_set_size(forwarder_t * forwarder, size_t size) { assert(forwarder); - content_store_free(forwarder->content_store); + cs_free(forwarder->cs); // XXX TODO #if 0 - ContentStoreConfig content_storeConfig = {.objectCapacity = + ContentStoreConfig csConfig = {.objectCapacity = maximumContentStoreSize}; - forwarder->content_store = - content_storeLRU_Create(&content_storeConfig, forwarder->logger); + forwarder->cs = + csLRU_Create(&csConfig, forwarder->logger); #endif } void -forwarder_content_store_clear(forwarder_t * forwarder) +forwarder_cs_clear(forwarder_t * forwarder) { assert(forwarder); - content_store_clear(forwarder->content_store); -} - -void -forwarder_receive_command(forwarder_t * forwarder, command_type_t command_type, - uint8_t * packet, unsigned connection_id) -{ - configuration_receive_command(forwarder->config, command_type, packet, connection_id); + cs_clear(forwarder->cs); } /** @@ -465,17 +445,20 @@ forwarder_receive_command(forwarder_t * forwarder, command_type_t command_type, * */ static -void -forwarder_drop(forwarder_t * forwarder, msgbuf_t *message) +ssize_t +forwarder_drop(forwarder_t * forwarder, off_t msgbuf_id) { forwarder->stats.countDropped++; - switch (msgbuf_get_type(message)) { - case MESSAGE_TYPE_INTEREST: + const msgbuf_pool_t * msgbuf_pool = forwarder_get_msgbuf_pool(forwarder); + const msgbuf_t * msgbuf = msgbuf_pool_at(msgbuf_pool, msgbuf_id); + + switch (msgbuf_get_type(msgbuf)) { + case MSGBUF_TYPE_INTEREST: forwarder->stats.countInterestsDropped++; break; - case MESSAGE_TYPE_DATA: + case MSGBUF_TYPE_DATA: forwarder->stats.countObjectsDropped++; break; @@ -484,6 +467,7 @@ forwarder_drop(forwarder_t * forwarder, msgbuf_t *message) break; } + return msgbuf_get_len(msgbuf); // dont destroy message here, its done at end of receive } @@ -493,23 +477,26 @@ forwarder_drop(forwarder_t * forwarder, msgbuf_t *message) * */ static -void -forwarder_forward_via_connection(forwarder_t * forwarder, msgbuf_t * msgbuf, +ssize_t +forwarder_forward_via_connection(forwarder_t * forwarder, off_t msgbuf_id, unsigned conn_id) { connection_table_t * table = forwarder_get_connection_table(forwarder); + + const msgbuf_pool_t * msgbuf_pool = forwarder_get_msgbuf_pool(forwarder); + const msgbuf_t * msgbuf = msgbuf_pool_at(msgbuf_pool, msgbuf_id); + const connection_t * conn = connection_table_get_by_id(table, conn_id); if (!conn) { forwarder->stats.countDroppedConnectionNotFound++; - DEBUG("forward msgbuf %p to interface %u not found (count %u)", - msgbuf, conn_id, forwarder->stats.countDroppedConnectionNotFound); - forwarder_drop(forwarder, msgbuf); - return; + DEBUG("forward msgbuf %lu to interface %u not found (count %u)", + msgbuf_id, conn_id, forwarder->stats.countDroppedConnectionNotFound); + return forwarder_drop(forwarder, msgbuf_id); } /* Always queue the packet... */ - bool success = connection_send(conn, msgbuf, true); + bool success = connection_send(conn, msgbuf_id, true); /* ... and mark the connection as pending if this is not yet the case */ unsigned i; @@ -523,18 +510,17 @@ forwarder_forward_via_connection(forwarder_t * forwarder, msgbuf_t * msgbuf, if (!success) { forwarder->stats.countSendFailures++; - DEBUG("forward msgbuf %p to interface %u send failure (count %u)", msgbuf, - conn_id, forwarder->stats.countSendFailures); - forwarder_drop(forwarder, msgbuf); - return; + DEBUG("forward msgbuf %llu to interface %u send failure (count %u)", + msgbuf_id, conn_id, forwarder->stats.countSendFailures); + return forwarder_drop(forwarder, msgbuf_id); } switch (msgbuf_get_type(msgbuf)) { - case MESSAGE_TYPE_INTEREST: + case MSGBUF_TYPE_INTEREST: forwarder->stats.countInterestForwarded++; break; - case MESSAGE_TYPE_DATA: + case MSGBUF_TYPE_DATA: forwarder->stats.countObjectsForwarded++; break; @@ -546,6 +532,7 @@ forwarder_forward_via_connection(forwarder_t * forwarder, msgbuf_t * msgbuf, conn_id, forwarder->stats.countInterestForwarded, forwarder->stats.countObjectsForwarded); + return (msgbuf_get_len(msgbuf)); } /** @@ -559,14 +546,16 @@ forwarder_forward_via_connection(forwarder_t * forwarder, msgbuf_t * msgbuf, static unsigned forwarder_forward_to_nexthops(forwarder_t * forwarder, - msgbuf_t *msgbuf, const nexthops_t * nexthops) + off_t msgbuf_id, const nexthops_t * nexthops) { unsigned forwardedCopies = 0; + const msgbuf_pool_t * msgbuf_pool = forwarder_get_msgbuf_pool(forwarder); + msgbuf_t * msgbuf = msgbuf_pool_at(msgbuf_pool, msgbuf_id); unsigned ingressId = msgbuf_get_connection_id(msgbuf); uint32_t old_path_label = 0; - if (msgbuf_get_type(msgbuf) == MESSAGE_TYPE_DATA) + if (msgbuf_get_type(msgbuf) == MSGBUF_TYPE_DATA) old_path_label = msgbuf_get_pathlabel(msgbuf); unsigned nexthop; @@ -575,13 +564,13 @@ forwarder_forward_to_nexthops(forwarder_t * forwarder, continue; forwardedCopies++; - forwarder_forward_via_connection(forwarder, msgbuf, nexthop); + forwarder_forward_via_connection(forwarder, msgbuf_id, nexthop); // everytime we send out a message we need to restore the original path // label of the message this is important because we keep a single copy // of the message (single pointer) and we modify the path label at each // send. - if (msgbuf_get_type(msgbuf) == MESSAGE_TYPE_DATA) + if (msgbuf_get_type(msgbuf) == MSGBUF_TYPE_DATA) msgbuf_set_pathlabel(msgbuf, old_path_label); }); @@ -591,12 +580,15 @@ forwarder_forward_to_nexthops(forwarder_t * forwarder, static bool -forwarder_forward_via_fib(forwarder_t * forwarder, msgbuf_t *msgbuf, +forwarder_forward_via_fib(forwarder_t * forwarder, off_t msgbuf_id, pit_verdict_t verdict) { assert(forwarder); - assert(msgbuf); - assert(msgbuf_get_type(msgbuf) == MESSAGE_TYPE_INTEREST); + assert(msgbuf_id_is_valid(msgbuf_id)); + + const msgbuf_pool_t * msgbuf_pool = forwarder_get_msgbuf_pool(forwarder); + msgbuf_t * msgbuf = msgbuf_pool_at(msgbuf_pool, msgbuf_id); + assert(msgbuf_get_type(msgbuf) == MSGBUF_TYPE_INTEREST); fib_entry_t *fib_entry = fib_match_message(forwarder->fib, msgbuf); if (!fib_entry) @@ -650,7 +642,7 @@ forwarder_forward_via_fib(forwarder_t * forwarder, msgbuf_t *msgbuf, entry_Release(&entry); #endif - if (forwarder_forward_to_nexthops(forwarder, msgbuf, nexthops) <= 0) { + if (forwarder_forward_to_nexthops(forwarder, msgbuf_id, nexthops) <= 0) { DEBUG("Message %p returned an emtpy next hop set", msgbuf); return false; } @@ -661,43 +653,49 @@ forwarder_forward_via_fib(forwarder_t * forwarder, msgbuf_t *msgbuf, static bool -_satisfy_from_content_store(forwarder_t * forwarder, msgbuf_t *interest_msgbuf) +_satisfy_from_cs(forwarder_t * forwarder, off_t msgbuf_id) { assert(forwarder); - assert(msgbuf_get_type(interest_msgbuf) == MESSAGE_TYPE_INTEREST); + assert(msgbuf_id_is_valid(msgbuf_id)); + + const msgbuf_pool_t * msgbuf_pool = forwarder_get_msgbuf_pool(forwarder); + const msgbuf_t * msgbuf = msgbuf_pool_at(msgbuf_pool, msgbuf_id); + + assert(msgbuf_get_type(msgbuf) == MSGBUF_TYPE_INTEREST); - if (msgbuf_get_interest_lifetime(interest_msgbuf) == 0) + if (msgbuf_get_lifetime(msgbuf) == 0) return false; - if (!forwarder->serve_from_content_store) + if (!forwarder->serve_from_cs) return false; // See if there's a match in the store. - msgbuf_t * data_msgbuf = content_store_match(forwarder->content_store, - interest_msgbuf, ticks_now()); + off_t data_msgbuf_id = cs_match(forwarder_get_cs(forwarder), msgbuf_id, + ticks_now()); - if (!data_msgbuf) + if (msgbuf_id_is_valid(data_msgbuf_id)) return false; // Remove it from the PIT. nexthops is allocated, so need to destroy - nexthops_t * nexthops = pit_on_data(forwarder->pit, data_msgbuf); + nexthops_t * nexthops = pit_on_data(forwarder->pit, data_msgbuf_id); assert(nexthops); // Illegal state: got a null nexthops for an interest we just inserted // send message in reply, then done forwarder->stats.countInterestsSatisfiedFromStore++; - DEBUG("Message %p satisfied from content store (satisfied count %u)", - interest_msgbuf, forwarder->stats.countInterestsSatisfiedFromStore); + DEBUG("Message %lu satisfied from content store (satisfied count %u)", + msgbuf_id, forwarder->stats.countInterestsSatisfiedFromStore); + msgbuf_t * data_msgbuf = msgbuf_pool_at(msgbuf_pool, data_msgbuf_id); msgbuf_reset_pathlabel(data_msgbuf); - forwarder_forward_to_nexthops(forwarder, data_msgbuf, nexthops); + forwarder_forward_to_nexthops(forwarder, data_msgbuf_id, nexthops); return true; } /** - * @function forwarder_receive_interest + * @function forwarder_process_interest * @abstract Receive an interest from the network * @discussion * (1) if interest in the PIT, aggregate in PIT @@ -707,22 +705,34 @@ _satisfy_from_content_store(forwarder_t * forwarder, msgbuf_t *interest_msgbuf) * */ static -void -forwarder_receive_interest(forwarder_t * forwarder, msgbuf_t * msgbuf) +ssize_t +forwarder_process_interest(forwarder_t * forwarder, off_t msgbuf_id) { assert(forwarder); - assert(msgbuf); - assert(msgbuf_get_type(msgbuf) == MESSAGE_TYPE_INTEREST); + assert(msgbuf_id_is_valid(msgbuf_id)); + + const msgbuf_pool_t * msgbuf_pool = forwarder_get_msgbuf_pool(forwarder); + const msgbuf_t * msgbuf = msgbuf_pool_at(msgbuf_pool, msgbuf_id); + + assert(msgbuf_get_type(msgbuf) == MSGBUF_TYPE_INTEREST); + + forwarder->stats.countReceived++; forwarder->stats.countInterestsReceived++; + char *nameString = name_ToString(msgbuf_get_name(msgbuf)); + DEBUG( "Message %p ingress %3u length %5u received name %s", msgbuf, + msgbuf_get_connection_id(msgbuf), msgbuf_get_len(msgbuf), nameString); + free(nameString); + + // (1) Try to aggregate in PIT - pit_verdict_t verdict = pit_on_interest(forwarder->pit, msgbuf); + pit_verdict_t verdict = pit_on_interest(forwarder->pit, msgbuf_id); switch(verdict) { case PIT_VERDICT_AGGREGATE: forwarder->stats.countInterestsAggregated++; DEBUG("Message %p aggregated in PIT (aggregated count %u)", msgbuf, forwarder->stats.countInterestsAggregated); - return; + return msgbuf_get_len(msgbuf); case PIT_VERDICT_FORWARD: case PIT_VERDICT_RETRANSMIT: @@ -735,30 +745,30 @@ forwarder_receive_interest(forwarder_t * forwarder, msgbuf_t * msgbuf) // interest, we need to remove the PIT entry. // (2) Try to satisfy from content store - if (_satisfy_from_content_store(forwarder, msgbuf)) { + if (_satisfy_from_cs(forwarder, msgbuf_id)) { // done // If we found a content object in the CS, - // messageProcess_Satisfy_from_content_store already cleared the PIT state - return; + // messageProcess_Satisfy_from_cs already cleared the PIT state + return msgbuf_get_len(msgbuf); } // (3) Try to forward it - if (forwarder_forward_via_fib(forwarder, msgbuf, verdict)) { + if (forwarder_forward_via_fib(forwarder, msgbuf_id, verdict)) { // done - return; + return msgbuf_get_len(msgbuf); } // Remove the PIT entry? forwarder->stats.countDroppedNoRoute++; - DEBUG("Message %p did not match FIB, no route (count %u)", - msgbuf, forwarder->stats.countDroppedNoRoute); + DEBUG("Message %lu did not match FIB, no route (count %u)", + msgbuf_id, forwarder->stats.countDroppedNoRoute); - forwarder_drop(forwarder, msgbuf); + return forwarder_drop(forwarder, msgbuf_id); } /** - * @function forwarder_receive_data + * @function forwarder_process_data * @abstract Process an in-bound content object * @discussion * (1) If it does not match anything in the PIT, drop it @@ -768,19 +778,27 @@ forwarder_receive_interest(forwarder_t * forwarder, msgbuf_t * msgbuf) * @param <#param1#> */ static -void -forwarder_receive_data(forwarder_t * forwarder, - msgbuf_t *msgbuf) +ssize_t +forwarder_process_data(forwarder_t * forwarder, off_t msgbuf_id) { + const msgbuf_pool_t * msgbuf_pool = forwarder_get_msgbuf_pool(forwarder); + const msgbuf_t * msgbuf = msgbuf_pool_at(msgbuf_pool, msgbuf_id); + + char *nameString = name_ToString(msgbuf_get_name(msgbuf)); + DEBUG( "Message %lu ingress %3u length %5u received name %s", msgbuf_id, + msgbuf_get_connection_id(msgbuf), msgbuf_get_len(msgbuf), nameString); + free(nameString); + + forwarder->stats.countReceived++; forwarder->stats.countObjectsReceived++; - nexthops_t * ingressSetUnion = pit_on_data(forwarder->pit, msgbuf); + nexthops_t * ingressSetUnion = pit_on_data(forwarder->pit, msgbuf_id); if (!ingressSetUnion) { // (1) If it does not match anything in the PIT, drop it forwarder->stats.countDroppedNoReversePath++; - DEBUG("Message %p did not match PIT, no reverse path (count %u)", - msgbuf, forwarder->stats.countDroppedNoReversePath); + DEBUG("Message %lu did not match PIT, no reverse path (count %u)", + msgbuf_id, forwarder->stats.countDroppedNoReversePath); // MOVE PROBE HOOK ELSEWHERE // XXX relationship with forwarding strategy... insert hooks @@ -803,95 +821,68 @@ forwarder_receive_data(forwarder_t * forwarder, const connection_table_t * table = forwarder_get_connection_table(forwarder); const connection_t * conn = connection_table_get_by_id(table, msgbuf_get_connection_id(msgbuf)); - if (forwarder->store_in_content_store && connection_is_local(conn)) { - content_store_add(forwarder->content_store, msgbuf, ticks_now()); + if (forwarder->store_in_cs && connection_is_local(conn)) { + cs_add(forwarder->cs, msgbuf_id, ticks_now()); DEBUG("Message %p store in CS anyway", msgbuf); } - forwarder_drop(forwarder, msgbuf); + return forwarder_drop(forwarder, msgbuf_id); } else { // (2) Add to Content Store. Store may remove expired content, if necessary, // depending on store policy. - if (forwarder->store_in_content_store) { - content_store_add(forwarder->content_store, msgbuf, ticks_now()); + if (forwarder->store_in_cs) { + cs_add(forwarder->cs, msgbuf_id, ticks_now()); } // (3) Reverse path forward via PIT entries - forwarder_forward_to_nexthops(forwarder, msgbuf, ingressSetUnion); + return forwarder_forward_to_nexthops(forwarder, msgbuf_id, ingressSetUnion); } } - -/** - * A NULL msgbuf is used to indicate the end of a batch - */ void -forwarder_receive(forwarder_t * forwarder, msgbuf_t * msgbuf) +forwarder_flush_connections(forwarder_t * forwarder) { - assert(forwarder); - - /* Send batch ? */ - if (!msgbuf) { - const connection_table_t * table = forwarder_get_connection_table(forwarder); - for (unsigned i = 0; i < forwarder->num_pending_conn; i++) { - const connection_t * conn = connection_table_at(table, forwarder->pending_conn[i]); - // flush - connection_send(conn, NULL, false); + const connection_table_t * table = forwarder_get_connection_table(forwarder); + + for (unsigned i = 0; i < forwarder->num_pending_conn; i++) { + unsigned conn_id = forwarder->pending_conn[i]; + const connection_t * conn = connection_table_at(table, conn_id); + if (!connection_flush(conn)) { + WARN("Could not flush connection queue"); + // XXX keep track of non flushed connections... } - forwarder->num_pending_conn = 0; } + forwarder->num_pending_conn = 0; +} +// XXX move to wldr file, worst case in connection. +void +forwarder_apply_wldr(const forwarder_t * forwarder, const msgbuf_t * msgbuf, connection_t * connection) +{ // this are the checks needed to implement WLDR. We set wldr only on the STAs - // and we let the AP to react according to choise of the client. + // and we let the AP to react according to choice of the client. // if the STA enables wldr using the set command, the AP enable wldr as well // otherwise, if the STA disable it the AP remove wldr // WLDR should be enabled only on the STAs using the command line // TODO // disable WLDR command line on the AP - connection_table_t * table = forwarder_get_connection_table(forwarder); - connection_t * conn = connection_table_get_by_id(table, msgbuf_get_connection_id(msgbuf)); - if (!conn) - return; - if (msgbuf_has_wldr(msgbuf)) { - if (connection_has_wldr(conn)) { + if (connection_has_wldr(connection)) { // case 1: WLDR is enabled - connection_wldr_detect_losses(conn, msgbuf); - } else if (!connection_has_wldr(conn) && - connection_wldr_autostart_is_allowed(conn)) { + connection_wldr_detect_losses(connection, msgbuf); + } else if (!connection_has_wldr(connection) && + connection_wldr_autostart_is_allowed(connection)) { // case 2: We are on an AP. We enable WLDR - connection_wldr_enable(conn, true); - connection_wldr_detect_losses(conn, msgbuf); + connection_wldr_enable(connection, true); + connection_wldr_detect_losses(connection, msgbuf); } // case 3: Ignore WLDR } else { - if (connection_has_wldr(conn) && connection_wldr_autostart_is_allowed(conn)) { + if (connection_has_wldr(connection) && connection_wldr_autostart_is_allowed(connection)) { // case 1: STA do not use WLDR, we disable it - connection_wldr_enable(conn, false); + connection_wldr_enable(connection, false); } } - - forwarder->stats.countReceived++; - - char *nameString = name_ToString(msgbuf_get_name(msgbuf)); - DEBUG( "Message %p ingress %3u length %5u received name %s", msgbuf, - msgbuf_get_connection_id(msgbuf), msgbuf_get_len(msgbuf), nameString); - free(nameString); - - switch (msgbuf_get_type(msgbuf)) { - case MESSAGE_TYPE_INTEREST: - forwarder_receive_interest(forwarder, msgbuf); - break; - - case MESSAGE_TYPE_DATA: - forwarder_receive_data(forwarder, msgbuf); - break; - - default: - forwarder_drop(forwarder, msgbuf); - break; - } - } bool @@ -1006,7 +997,7 @@ forwarder_set_strategy(forwarder_t * forwarder, Name * name_prefix, { assert(forwarder); assert(name_prefix); - // assert(strategy_type_is_valid(strategy_type)); + assert(STRATEGY_TYPE_VALID(strategy_type)); /* strategy_options might be NULL */ fib_entry_t * entry = fib_contains(forwarder->fib, name_prefix); @@ -1016,12 +1007,12 @@ forwarder_set_strategy(forwarder_t * forwarder, Name * name_prefix, fib_entry_set_strategy(entry, strategy_type, strategy_options); } -content_store_t * -forwarder_get_content_store(const forwarder_t * forwarder) +cs_t * +forwarder_get_cs(const forwarder_t * forwarder) { assert(forwarder); - return forwarder->content_store; + return forwarder->cs; } // ======================================================= @@ -1055,10 +1046,17 @@ static void _signal_cb(int sig, PARCEventType events, void *user_data) { #endif fib_t * -forwarder_get_fib(forwarder_t * forwarder) { +forwarder_get_fib(forwarder_t * forwarder) +{ return forwarder->fib; } +msgbuf_pool_t * +forwarder_get_msgbuf_pool(const forwarder_t * forwarder) +{ + return forwarder->msgbuf_pool; +} + #ifdef WITH_MAPME void forwarder_on_connection_event(const forwarder_t * forwarder, @@ -1082,116 +1080,120 @@ forwarder_get_prefix_stats_mgr(const forwarder_t * forwarder) } #endif /* WITH_PREFIX_STATS */ -static -void -process_interest(forwarder_t * forwarder, listener_t * listener, - unsigned conn_id, uint8_t * packet, size_t size, const address_pair_t * pair) -{ - if (!connection_id_is_valid(conn_id)) { - conn_id = listener_create_connection(listener, pair); - } - - assert(messageHandler_GetTotalPacketLength(packet) == size); - - msgbuf_from_packet(&forwarder->msgbuf, packet, size, MESSAGE_TYPE_INTEREST, conn_id, ticks_now()); - forwarder_receive(listener->forwarder, &forwarder->msgbuf); -} +/** + * @brief Process a packet by creating the corresponding message buffer and + * dispatching it to the forwarder for further processing. + * @param[in] forwarder Forwarder instance. + * + */ +// XXX ??? XXX = process for listener as we are resolving connection id +// -static -void -process_data(forwarder_t * forwarder, listener_t * listener, - unsigned conn_id, uint8_t * packet, size_t size, const address_pair_t * pair) +msgbuf_type_t get_type_from_packet(uint8_t * packet) { - if (!connection_id_is_valid(conn_id)) { - INFO("Ignoring data packet associated to no connection"); - return; - } + if (messageHandler_IsTCP(packet)) { + if (messageHandler_IsData(packet)) { + return MSGBUF_TYPE_DATA; + } else if (messageHandler_IsInterest(packet)) { + return MSGBUF_TYPE_INTEREST; + } else { + return MSGBUF_TYPE_UNDEFINED; + } - assert(messageHandler_GetTotalPacketLength(packet) == size); + } else if (messageHandler_IsWldrNotification(packet)) { + return MSGBUF_TYPE_WLDR_NOTIFICATION; - msgbuf_from_packet(&forwarder->msgbuf, packet, size, MESSAGE_TYPE_DATA, conn_id, ticks_now()); - forwarder_receive(listener->forwarder, &forwarder->msgbuf); + } else if (mapme_match_packet(packet)) { + return MSGBUF_TYPE_MAPME; -} + } else if (*packet == REQUEST_LIGHT) { + return MSGBUF_TYPE_COMMAND; -static -void -process_wldr_notification(forwarder_t * forwarder, listener_t * listener, - unsigned conn_id, uint8_t * packet, size_t size, const address_pair_t * pair) -{ - if (!connection_id_is_valid(conn_id)) { - INFO("Ignoring WLDR notification not associated to a connection"); - return; + } else { + return MSGBUF_TYPE_UNDEFINED; } - - assert(messageHandler_GetTotalPacketLength(packet) == size); - - connection_table_t * table = forwarder_get_connection_table(forwarder); - connection_t * connection = connection_table_at(table, conn_id); - - msgbuf_from_packet(&forwarder->msgbuf, packet, size, MESSAGE_TYPE_WLDR_NOTIFICATION, conn_id, ticks_now()); - connection_wldr_handle_notification(connection, &forwarder->msgbuf); - } -static -void -process_mapme(forwarder_t * forwarder, listener_t * listener, - unsigned conn_id, uint8_t * packet, size_t size, const address_pair_t * pair) +ssize_t +forwarder_receive(forwarder_t * forwarder, listener_t * listener, + off_t msgbuf_id, address_pair_t * pair, Ticks now) { - if (!connection_id_is_valid(conn_id)) - conn_id = listener_create_connection(listener, pair); - mapme_process(forwarder->mapme, packet, conn_id); -} + assert(forwarder); + /* listener can be NULL */ + assert(msgbuf_id_is_valid(msgbuf_id)); + assert(pair); -static -void -process_command(const forwarder_t * forwarder, listener_t * listener, - unsigned conn_id, uint8_t * packet, size_t size, const address_pair_t * pair) -{ - if (!connection_id_is_valid(conn_id)) - conn_id = listener_create_connection(listener, pair); + const msgbuf_pool_t * msgbuf_pool = forwarder_get_msgbuf_pool(forwarder); + msgbuf_t * msgbuf = msgbuf_pool_at(msgbuf_pool, msgbuf_id); - command_type_t command_type= *(packet + 1); - if (command_type >= COMMAND_TYPE_N) { - ERROR("Invalid command"); - return; - } - forwarder_receive_command(listener->forwarder, command_type, packet, conn_id); + assert(msgbuf); -} + uint8_t * packet = msgbuf_get_packet(msgbuf); + size_t size = msgbuf_get_len(msgbuf); + assert(messageHandler_GetTotalPacketLength(packet) == size); // XXX confirm ? -// = process for listener as we are resolving connection id -// XXX this would typically be inside the forwarder -void -process_packet(forwarder_t * forwarder, listener_t * listener, uint8_t * packet, size_t size, address_pair_t * pair) -{ /* Connection lookup */ const connection_table_t * table = forwarder_get_connection_table(listener->forwarder); - const connection_t * conn = connection_table_get_by_pair(table, pair); - unsigned conn_id = conn ? connection_table_get_connection_id(table, conn): CONNECTION_ID_UNDEFINED; + connection_t * connection = connection_table_get_by_pair(table, pair); + unsigned conn_id = connection + ? connection_table_get_connection_id(table, connection) + : CONNECTION_ID_UNDEFINED; assert((conn_id != CONNECTION_ID_UNDEFINED) || listener); - // Actually hooks should be defined for each packet type to avoid this - // spaghetti code - if (messageHandler_IsTCP(packet)) { - if (messageHandler_IsData(packet)) { - process_data(forwarder, listener, conn_id, packet, size, pair); - } else if (messageHandler_IsInterest(packet)) { - process_interest(forwarder, listener, conn_id, packet, size, pair); - } else { - INFO("Unknown TCP packet received"); - forwarder_drop(forwarder, NULL); - } - } else if (messageHandler_IsWldrNotification(packet)) { - process_wldr_notification(forwarder, listener, conn_id, packet, size, pair); - } else if (mapme_match_packet(packet)) { - process_mapme(forwarder, listener, conn_id, packet, size, pair); - } else if (*packet == REQUEST_LIGHT) { - process_command(forwarder, listener, conn_id, packet, size, pair); - } else { - INFO("Unknown packet received"); - forwarder_drop(forwarder, NULL); + msgbuf_type_t type = get_type_from_packet(msgbuf_get_packet(msgbuf)); + + msgbuf->type = type; + msgbuf->connection_id = conn_id; + msgbuf->recv_ts = now; + msgbuf->refs = 1; + + switch(type) { + case MSGBUF_TYPE_INTEREST: + if (!connection_id_is_valid(msgbuf->connection_id)) + msgbuf->connection_id = listener_create_connection(listener, pair); + msgbuf->id.name = name_create_from_interest(packet); + forwarder_apply_wldr(forwarder, msgbuf, connection); + forwarder_process_interest(forwarder, msgbuf_id); + break; + + case MSGBUF_TYPE_DATA: + if (!connection_id_is_valid(msgbuf->connection_id)) + return forwarder_drop(forwarder, msgbuf_id); + msgbuf->id.name = name_create_from_data(packet); + forwarder_apply_wldr(forwarder, msgbuf, connection); + forwarder_process_data(forwarder, msgbuf_id); + break; + + case MSGBUF_TYPE_WLDR_NOTIFICATION: + if (!connection_id_is_valid(msgbuf->connection_id)) + return forwarder_drop(forwarder, msgbuf_id); + connection_wldr_handle_notification(connection, msgbuf); + return msgbuf_get_len(msgbuf); + + case MSGBUF_TYPE_MAPME: + // XXX what about acks ? + if (!connection_id_is_valid(msgbuf->connection_id)) + msgbuf->connection_id = listener_create_connection(listener, pair); + mapme_process(forwarder->mapme, msgbuf); + return msgbuf_get_len(msgbuf); + + case MSGBUF_TYPE_COMMAND: + // XXX before it used to create the connection + if (!connection_id_is_valid(msgbuf->connection_id)) + return forwarder_drop(forwarder, msgbuf_id); + msgbuf->command.type = *(packet + 1); // XXX use header + if (msgbuf->command.type >= COMMAND_TYPE_N) { + ERROR("Invalid command"); + return -msgbuf_get_len(msgbuf); + } + return configuration_receive_command(forwarder->config, msgbuf); + + case MSGBUF_TYPE_UNDEFINED: + case MSGBUF_TYPE_N: + // XXX Unexpected... shall we abort ? + return forwarder_drop(forwarder, msgbuf_id); } + + return size; } diff --git a/hicn-light/src/hicn/core/forwarder.h b/hicn-light/src/hicn/core/forwarder.h index 5d999a319..a76e36530 100644 --- a/hicn-light/src/hicn/core/forwarder.h +++ b/hicn-light/src/hicn/core/forwarder.h @@ -18,8 +18,8 @@ * only be called within the forwarders thread of execution. */ -#ifndef forwarder_h -#define forwarder_h +#ifndef HICNLIGHT_FORWARDER_H +#define HICN_LIGHT_FORWARDER_H //#ifndef _WIN32 //#include <sys/time.h> @@ -34,6 +34,7 @@ #include <hicn/core/connection.h> #include <hicn/core/connection_table.h> #include <hicn/core/listener_table.h> +#include <hicn/core/msgbuf_pool.h> #include <hicn/config/configuration.h> @@ -46,27 +47,12 @@ #include <hicn/utils/commands.h> -#define MAX_MSG 64 //16 //32 -#define MTU 1500 - - -typedef struct batch_buffer_s { - /* sendmmsg / recvmmsg data structures */ - struct mmsghdr msghdr[MAX_MSG]; // XXX = {0}; - char buffers[MAX_MSG][MTU]; - struct iovec iovecs[MAX_MSG]; // XXX = {0}; - struct sockaddr_storage addrs[MAX_MSG]; -} batch_buffer_t; - -int init_batch_buffers(batch_buffer_t * bb); - // ============================================== typedef struct forwarder_s forwarder_t; /** - * @function forwarder_Create - * @abstract Create the forwarder and use the provided logger for diagnostic + * @brief Create the forwarder and use the provided logger for diagnostic * output * @discussion * If the logger is null, hicn-light will create a STDOUT logger. @@ -76,14 +62,12 @@ typedef struct forwarder_s forwarder_t; forwarder_t * forwarder_create(); /** - * @function forwarder_Destroy - * @abstract Destroys the forwarder, stopping all traffic and freeing all memory + * @brief Destroys the forwarder, stopping all traffic and freeing all memory */ void forwarder_free(forwarder_t * forwarder); /** - * @function forwarder_SetupAllListeners - * @abstract Setup all listeners (tcp, udp, local, ether, ip multicast) on all + * @brief Setup all listeners (tcp, udp, local, ether, ip multicast) on all * interfaces * @discussion * Sets up all listeners on all running interfaces. This provides a quick and @@ -97,8 +81,7 @@ void forwarder_free(forwarder_t * forwarder); void forwarder_setup_all_listeners(forwarder_t * forwarder, uint16_t port, const char *local_path); /** - * @function forwarder_SetupAllListeners - * @abstract Setup one tcp and one udp listener on address 127.0.0.1 and the + * @brief Setup one tcp and one udp listener on address 127.0.0.1 and the * given port */ void forwarder_setup_local_listeners(forwarder_t * forwarder, uint16_t port); @@ -110,14 +93,13 @@ void forwarder_setup_local_listeners(forwarder_t * forwarder, uint16_t port); * You need to have "add listener" lines in the file to receive connections. No * default listeners are configured. * - * @param [in] forwarder An alloated forwarder_t - * @param [in] filename The path to the configuration file + * @param[in] forwarder An alloated forwarder_t + * @param[in] filename The path to the configuration file */ void forwarder_read_config(forwarder_t * forwarder, const char * filename); /** - * @function forwarder_GetConfiguration - * @abstract The configuration object + * @brief The configuration object * @discussion * The configuration contains all user-issued commands. It does not include * dynamic state. @@ -127,7 +109,7 @@ configuration_t * forwarder_get_configuration(forwarder_t * forwarder); /** * Returns the set of currently active listeners * - * @param [in] forwarder An allocated hicn-light forwarder + * @param[in] forwarder An allocated hicn-light forwarder * * @retval non-null The set of active listeners * @retval null An error @@ -137,7 +119,7 @@ listener_table_t * forwarder_get_listener_table(forwarder_t *forwarder); /** * Returns the forwrder's connection table * - * @param [in] forwarder An allocated hicn-light forwarder + * @param[in] forwarder An allocated hicn-light forwarder * * @retval non-null The connection tabler * @retval null An error @@ -145,54 +127,46 @@ listener_table_t * forwarder_get_listener_table(forwarder_t *forwarder); */ connection_table_t * forwarder_get_connection_table(const forwarder_t *forwarder); -void forwarder_content_store_set_store(forwarder_t * forwarder, bool val); +void forwarder_cs_set_store(forwarder_t * forwarder, bool val); -bool forwarder_content_store_get_store(forwarder_t * forwarder); +bool forwarder_cs_get_store(forwarder_t * forwarder); -void forwarder_content_store_set_serve(forwarder_t * forwarder, bool val); +void forwarder_cs_set_serve(forwarder_t * forwarder, bool val); -bool forwarder_content_store_get_serve(forwarder_t * forwarder); +bool forwarder_cs_get_serve(forwarder_t * forwarder); /** * Sets the maximum number of content objects in the content store * * Implementation dependent - may wipe the cache. */ -void forwarder_content_store_set_size(forwarder_t * forwarder, size_t size); +void forwarder_cs_set_size(forwarder_t * forwarder, size_t size); -void forwarder_content_store_clear(forwarder_t *forwarder); +void forwarder_cs_clear(forwarder_t *forwarder); -void forwarder_receive_command(forwarder_t * forwarder, command_type_t command_type, - uint8_t * packet, unsigned connection_id); - -void forwarder_receive(forwarder_t * forwarder, msgbuf_t * message); +ssize_t forwarder_receive_command(forwarder_t * forwarder, msgbuf_t * msgbuf); /** - * @function forwarder_add_or_update_route - * @abstract Adds or updates a route on all the message processors + * @brief Adds or updates a route on all the message processors */ bool forwarder_add_or_update_route(forwarder_t * forwarder, ip_prefix_t * prefix, unsigned ingress_id); /** - * @function forwarder_remove_route - * @abstract Removes a route from all the message processors + * @brief Removes a route from all the message processors */ bool forwarder_remove_route(forwarder_t * forwarder, ip_prefix_t * prefix, unsigned ingress_id); #ifdef WITH_POLICY /** - * @function forwarder_add_or_update_policy - * @abstract Adds or updates a policy on the message processor + * @brief Adds or updates a policy on the message processor */ bool forwarder_add_or_update_policy(forwarder_t * forwarder, ip_prefix_t * prefix, policy_t * policy); - /** - * @function forwarder_RemovePolicy - * @abstract Removes a policy from the message processor + * @brief Removes a policy from the message processor */ bool forwarder_remove_policy(forwarder_t * forwarder, ip_prefix_t * prefix); @@ -207,37 +181,42 @@ void forwarder_remove_connection_id_from_routes(forwarder_t * forwarder, void forwarder_set_strategy(forwarder_t * forwarder, Name * name_prefix, strategy_type_t strategy_type, strategy_options_t * strategy_options); -content_store_t * forwarder_get_content_store(const forwarder_t * forwarder); +cs_t * forwarder_get_cs(const forwarder_t * forwarder); /** - * @function forwarder_getFib - * @abstract Returns the hICN forwarder's FIB. - * @param [in] forwarder - Pointer to the hICN forwarder. + * @brief Returns the forwarder's FIB. + * @param[in] forwarder - Pointer to the forwarder. * @returns Pointer to the hICN FIB. */ fib_t * forwarder_get_fib(forwarder_t * forwarder); +/** + * @brief Return the forwarder packet pool. + * @param[in] forwarder The forwarder from which to retrieve the packet + * pool. + * @return msgbuf_pool_t * The forwarder packet pool. + */ +msgbuf_pool_t * forwarder_get_msgbuf_pool(const forwarder_t * forwarder); + #ifdef WITH_MAPME /** - * @function forwarder_onConnectionEvent - * @abstract Callback fired upon addition of a new connection through the + * @brief Callback fired upon addition of a new connection through the * control protocol. - * @param [in] forwarder - Pointer to the hICN forwarder. - * @param [in] conn - Pointer to the newly added connection. - * @param [in] event - Connection event + * @param[in] forwarder - Pointer to the forwarder. + * @param[in] conn - Pointer to the newly added connection. + * @param[in] event - Connection event */ void forwarder_on_connection_event(const forwarder_t * forwarder, const connection_t * connection, connection_event_t event); /** - * @function forwarder_ProcessMapMe - * @abstract Callback fired by an hICN listener upon reception of a MAP-Me + * @brief Callback fired by an hICN listener upon reception of a MAP-Me * message. - * @param [in] forwarder - Pointer to the hICN forwarder. - * @param [in] msgBuffer - MAP-Me buffer - * @param [in] conn_id - Ingress connection id + * @param[in] forwarder - Pointer to the forwarder. + * @param[in] msgBuffer - MAP-Me buffer + * @param[in] conn_id - Ingress connection id */ void forwarder_process_mapme(const forwarder_t * forwarder, const uint8_t * packet, unsigned conn_id); @@ -250,7 +229,15 @@ struct mapme_s * forwarder_get_mapme(const forwarder_t * forwarder); const prefix_stats_mgr_t * forwarder_get_prefix_stats_mgr(const forwarder_t * forwarder); #endif /* WITH_PREFIX_STATS */ -void process_packet(forwarder_t * forwarder, listener_t * listener, - uint8_t * packet, size_t size, address_pair_t * pair); +void forwarder_flush_connections(forwarder_t * forwarder); + +/** + * @brief Handles a newly received packet from a listener. + * + * NOTE: the received msgbuf is incomplete and only holds the packet content and + * size/ + */ +ssize_t forwarder_receive(forwarder_t * forwarder, listener_t * listener, + off_t msgbuf_id, address_pair_t * pair, Ticks now); -#endif // forwarder_h +#endif // HICN_LIGHT_FORWARDER_H diff --git a/hicn-light/src/hicn/core/listener.c b/hicn-light/src/hicn/core/listener.c index 5857c0c88..d24fafba0 100644 --- a/hicn-light/src/hicn/core/listener.c +++ b/hicn-light/src/hicn/core/listener.c @@ -19,14 +19,14 @@ */ - #include <string.h> // strdup -#include <hicn/core/listener_vft.h> -#include <hicn/base/loop.h> -#include <hicn/core/forwarder.h> #include <hicn/util/log.h> -#include "listener.h" + +#include "forwarder.h" +#include "listener_vft.h" +#include "../base/loop.h" +#include "../io/base.h" listener_t * listener_create(face_type_t type, const address_t * address, @@ -89,7 +89,7 @@ listener_initialize(listener_t * listener, face_type_t type, const char * name, // XXX data should be pre-allocated here loop_fd_event_create(&listener->event_data, MAIN_LOOP, listener->fd, listener, - (fd_callback_t)listener_vft[listener->type]->read_callback, NULL); + (fd_callback_t)listener_read_callback, NULL); if (!listener->event_data) { goto ERR_REGISTER_FD; @@ -151,7 +151,8 @@ int listener_get_socket(const listener_t * listener, const address_t * local, { assert(listener); assert(listener_has_valid_type(listener)); - // assert(pair); + assert(local); + assert(remote); return listener_vft[listener->type]->get_socket(listener, local, remote, interface_name); @@ -201,63 +202,115 @@ listener_punt(const listener_t * listener, const char * prefix_s) return listener_vft[listener_get_type(listener)]->punt(listener, prefix_s); } + ssize_t -listener_read_callback(forwarder_t * forwarder, listener_t * listener, int fd, - address_t * local_addr, uint8_t * packet, size_t size) +listener_read_single(listener_t * listener) { - // XXX TODO mutualize code across all listeners - // some do not support batches - // - // XXX negative in case of error - // 0 if we don't consume yet because we don't have enough - // needed for TCP !! - return size; + assert(listener); + + size_t processed_size; + size_t total_size = 0; + + msgbuf_pool_t * msgbuf_pool = forwarder_get_msgbuf_pool(listener->forwarder); + + for (;;) { + + msgbuf_t * msgbuf = NULL; + off_t msgbuf_id = msgbuf_pool_get(msgbuf_pool, msgbuf); + if (!msgbuf_id_is_valid(msgbuf_id)) + return 0; + + address_pair_t pair; + pair.local = *listener_get_address(listener); + + ssize_t n = listener_vft[listener->type]->read_single(listener->fd, msgbuf, + address_pair_get_remote(&pair)); + if (n < 1) + return 0; + + /* Process received packet */ + processed_size = forwarder_receive(listener->forwarder, listener, + msgbuf_id, &pair, ticks_now()); + if (processed_size <= 0) + break; + + total_size += processed_size; + } + + /* + * Even through the current listener does not allow batching, the connection + * on which we went packets might do batching (even without sendmmsg), and + * we need to inform the system that we want to proceed to sending packets. + */ + forwarder_flush_connections(listener->forwarder); + return total_size; + } -void -listener_batch_read_callback(forwarder_t * forwarder, listener_t * listener, - int fd, address_t * local_addr, batch_buffer_t * bb) +ssize_t +listener_read_batch(listener_t * listener) { - assert(bb); + assert(listener); - // XXX potential improvement : receive in a loop while we have messages to - // read + size_t processed_size; + size_t total_size = 0; + + forwarder_t * forwarder = listener->forwarder; + msgbuf_pool_t * msgbuf_pool = forwarder_get_msgbuf_pool(forwarder); + /* Receive messages in the loop as long as we manage to fill the buffers */ + int r = 0; + do { + /* Prepare the msgbuf and address pair arrays */ + msgbuf_t * msgbuf[MAX_MSG]; + if (!msgbuf_pool_getn(msgbuf_pool, msgbuf, MAX_MSG)) + break; + + address_pair_t pair[MAX_MSG]; + address_t * address_remote[MAX_MSG]; + for (unsigned i = 0; i < MAX_MSG; i++) + address_remote[i] = address_pair_get_remote(&pair[i]); + + ssize_t n = listener_vft[listener->type]->read_batch(listener->fd, + msgbuf, address_remote, MAX_MSG); + // XXX error check + + for (unsigned i = 0; i < n; i++) { + processed_size = forwarder_receive(forwarder, listener, + msgbuf_pool_get_id(msgbuf_pool, msgbuf[i]), + &pair[i], ticks_now()); + if (processed_size <= 0) + break; + + total_size += processed_size; + } - // XXX - int r = recvmmsg(fd, bb->msghdr, MAX_MSG, 0, NULL); - if (r == 0) - return; + } while(r == MAX_MSG); /* backpressure based on queue size ? */ - if (r < 0) { - if (errno == EINTR) - return; - perror("recv()"); - return; - } + /* + * Signal to the forwarder that we reached the end of a batch and we need to + * flush connections out + */ + forwarder_flush_connections(forwarder); - for (int i = 0; i < r; i++) { - struct mmsghdr *msg = &bb->msghdr[i]; - uint8_t * packet = msg->msg_hdr.msg_iov->iov_base; - size_t size = msg->msg_hdr.msg_iovlen; + return total_size; - /* BEGIN packet processing */ +} -#ifdef __APPLE__ - // XXX explain - msg->msg_hdr.msg_namelen = 0x00; -#endif +ssize_t +listener_read_callback(listener_t * listener, int fd, void * user_data) +{ + // XXX make a single callback and arbitrate between read and readbatch + assert(listener); + assert(fd == listener->fd); - /* Construct address pair used for connection lookup */ - address_pair_t pair; - pair.local = *local_addr; - pair.remote = *(address_t*)msg->msg_hdr.msg_name; - // in the case of a connection, we should assert the remote + if (listener_vft[listener->type]->read_batch) + return listener_read_batch(listener); - process_packet(forwarder, listener, packet, size, &pair); - } + return listener_read_single(listener); } + #if 0 void _listener_callback(evutil_socket_t fd, short what, void * arg) diff --git a/hicn-light/src/hicn/core/listener.h b/hicn-light/src/hicn/core/listener.h index ea2a5d3d8..eb1ec6893 100644 --- a/hicn-light/src/hicn/core/listener.h +++ b/hicn-light/src/hicn/core/listener.h @@ -23,10 +23,11 @@ #include <hicn/core/address_pair.h> #include <hicn/face.h> -#include <hicn/base/loop.h> + +#include "msgbuf.h" +#include "../base/loop.h" struct forwarder_s; -struct batch_buffer_s; typedef struct { address_t address; @@ -89,11 +90,21 @@ void listener_setup_local_ipv4(const struct forwarder_s * forwarder, uint16_t p void listener_process_packet(const listener_t * listener, const uint8_t * packet, size_t size); -ssize_t listener_read_callback(struct forwarder_s * forwarder, listener_t * listener, - int fd, address_t * local_addr, uint8_t * packet, size_t size); -void listener_batch_read_callback(struct forwarder_s * forwarder, - listener_t * listener, int fd, address_t * local_addr, - struct batch_buffer_s * bb); +ssize_t listener_read_single(listener_t * listener); +ssize_t listener_read_batch(listener_t * listener); + +/** + * @brief Callback helper function for batch reading data from listener fd. + * + * This function is usually called from the listener read callback to proceed to + * actual reading of data from the fd. + * + * @see listener_read_callback + * + * NOTE: the function returns size_t as for TCP we might need to know how much + * data we can consume from the socket. + */ +ssize_t listener_read_callback(listener_t * listener, int fd, void * user_data); #endif /* HICNLIGHT_LISTENER_H */ diff --git a/hicn-light/src/hicn/core/listener_table.c b/hicn-light/src/hicn/core/listener_table.c index f69ad7535..9750fbbe8 100644 --- a/hicn-light/src/hicn/core/listener_table.c +++ b/hicn-light/src/hicn/core/listener_table.c @@ -46,7 +46,7 @@ _listener_table_create(size_t init_size, size_t max_size) * We start by allocating a reasonably-sized pool, as this will eventually * be resized if needed. */ - pool_init(table->listeners, init_size); + pool_init(table->listeners, init_size, 0); return table; } diff --git a/hicn-light/src/hicn/core/listener_vft.h b/hicn-light/src/hicn/core/listener_vft.h index 2f70dd67d..6440475e7 100644 --- a/hicn-light/src/hicn/core/listener_vft.h +++ b/hicn-light/src/hicn/core/listener_vft.h @@ -36,7 +36,9 @@ typedef struct { msgbuf_t * msgbuf, bool queue); int (*send_packet)(const connection_t * connection, const uint8_t * packet, size_t size); - void (*read_callback)(listener_t * listener, int fd, void * data); + ssize_t (*read_single)(int fd, msgbuf_t * msgbuf, address_t * address); + ssize_t (*read_batch)(int fd, msgbuf_t ** msgbuf, address_t ** address, + size_t len); size_t data_size; } listener_ops_t; @@ -46,7 +48,8 @@ const listener_ops_t listener_ ## NAME = { \ .finalize = listener_ ## NAME ## _finalize, \ .punt = listener_ ## NAME ## _punt, \ .get_socket = listener_ ## NAME ## _get_socket, \ - .read_callback = listener_ ## NAME ## _read_callback, \ + .read_single = listener_ ## NAME ## _read_single, \ + .read_batch = listener_ ## NAME ## _read_batch, \ .data_size = sizeof(listener_ ## NAME ## _data_t), \ } diff --git a/hicn-light/src/hicn/core/mapme.c b/hicn-light/src/hicn/core/mapme.c index ae4a29f13..8f40cb34a 100644 --- a/hicn-light/src/hicn/core/mapme.c +++ b/hicn-light/src/hicn/core/mapme.c @@ -120,7 +120,6 @@ #include <hicn/core/connection.h> #include <hicn/core/forwarder.h> #include <hicn/core/msgbuf.h> -#include <hicn/core/messagePacketType.h> // packet types #include <hicn/core/ticks.h> #include <hicn/core/fib_entry.h> #include <hicn/core/pit.h> @@ -757,7 +756,7 @@ mapme_on_interest(mapme_t * mapme, uint8_t * packet, ERROR("Failed to send ACK packet"); } - Name *name = name_CreateFromPacket(packet, MESSAGE_TYPE_INTEREST); + Name *name = name_create_from_interest(packet); name_setLen(name, prefix->len); char *name_str = name_ToString(name); @@ -871,8 +870,7 @@ mapme_on_data(mapme_t *mapme, const uint8_t * packet, { INFO("Receive IU/IN Ack on connection %d", ingress_id); - const Name * name = - name_CreateFromPacket(packet, MESSAGE_TYPE_DATA); + const Name * name = name_create_from_data(packet); name_setLen((Name*) name, prefix->len); char * name_str = name_ToString(name); @@ -919,10 +917,14 @@ mapme_on_data(mapme_t *mapme, const uint8_t * packet, * processed by MAP-Me core. */ void -mapme_process(mapme_t *mapme, uint8_t *packet, unsigned conn_id) +mapme_process(mapme_t *mapme, msgbuf_t * msgbuf) { hicn_prefix_t prefix; mapme_params_t params; + + uint8_t * packet = msgbuf_get_packet(msgbuf); + unsigned conn_id = msgbuf_get_connection_id(msgbuf); + int rc = hicn_mapme_parse_packet(packet, &prefix, ¶ms); if (rc < 0) return; diff --git a/hicn-light/src/hicn/core/mapme.h b/hicn-light/src/hicn/core/mapme.h index 2bf5a413b..d1d21079f 100644 --- a/hicn-light/src/hicn/core/mapme.h +++ b/hicn-light/src/hicn/core/mapme.h @@ -27,9 +27,11 @@ #include <stdint.h> #include <hicn/hicn.h> -#include <hicn/core/connection.h> -#include <hicn/utils/commands.h> -#include <hicn/core/fib_entry.h> + +#include "connection.h" +#include "fib_entry.h" +#include "msgbuf.h" +#include "../utils/commands.h" typedef struct mapme_s mapme_t; @@ -64,7 +66,7 @@ bool mapme_match_packet(const uint8_t *msgBuffer); * @param [in] message - MAP-Me buffer * @param [in] conn_id - Ingress connection id */ -void mapme_process(mapme_t *mapme, uint8_t * packet, unsigned conn_id); +void mapme_process(mapme_t *mapme, msgbuf_t * msgbuf); int mapme_send_to_nexthop(const mapme_t * mapme, fib_entry_t * fib_entry, unsigned nexthop); @@ -117,10 +119,6 @@ void mapme_on_connection_event(const mapme_t *mapme, const connection_t * conn, nexthops_t * mapme_get_nexthops(const mapme_t *mapme, fib_entry_t *fib_entry, const msgbuf_t *interest); -hicn_mapme_type_t mapme_PktType_To_LibHicnPktType(MessagePacketType type); - -MessagePacketType mapme_LibHicnPktType_To_PktType(hicn_mapme_type_t type); - #endif /* WITH_MAPME */ #endif // mapme_h diff --git a/hicn-light/src/hicn/core/messageHandler.h b/hicn-light/src/hicn/core/messageHandler.h index e0eef5e7c..bc7ecf597 100644 --- a/hicn-light/src/hicn/core/messageHandler.h +++ b/hicn-light/src/hicn/core/messageHandler.h @@ -13,8 +13,8 @@ * limitations under the License. */ -#ifndef messageHandler -#define messageHandler +#ifndef HICNLIGHT_MESSAGE_HANDLER_H +#define HICNLIGHT_MESSAGE_HANDLER_H #include <stdlib.h> #ifndef _WIN32 @@ -22,7 +22,6 @@ #endif /* _WIN32 */ #include <hicn/hicn.h> -#include <hicn/core/messagePacketType.h> //#include <hicn/core/connection_table.h> @@ -620,4 +619,4 @@ static inline bool messageHandler_IsAProbe(const uint8_t *packet){ return false; } -#endif // Metis_metis_MessageHandler +#endif /* HICNLIGHT_MESSAGE_HANDLER_H */ diff --git a/hicn-light/src/hicn/core/msgbuf.h b/hicn-light/src/hicn/core/msgbuf.h index 3e96b3bbc..72480b535 100644 --- a/hicn-light/src/hicn/core/msgbuf.h +++ b/hicn-light/src/hicn/core/msgbuf.h @@ -18,63 +18,83 @@ * \brief hICN message buffer */ -#ifndef HICN_MSGBUF -#define HICN_MSGBUF +#ifndef HICNLIGHT_MSGBUF +#define HICNLIGHT_MSGBUF -#include <hicn/core/name.h> -#include <hicn/core/ticks.h> -#include <hicn/core/messageHandler.h> +#include "name.h" +#include "ticks.h" +#include "messageHandler.h" +#include "../utils/commands.h" + +struct name_s; + +#define MTU 1500 +#define INVALID_MSGBUF_ID ~0ul + +#define msgbuf_id_is_valid(msgbuf_id) (msgbuf_id != INVALID_MSGBUF_ID) + +#define foreach_type \ + _(UNDEFINED) \ + _(INTEREST) \ + _(DATA) \ + _(WLDR_NOTIFICATION) \ + _(MAPME) \ + _(COMMAND) \ + _(N) + +typedef enum { +#define _(x) MSGBUF_TYPE_ ## x, + foreach_type +#undef _ +} msgbuf_type_t; typedef struct { - Ticks receiveTime; - unsigned connection_id; - Name *name; - uint8_t *messageHead; unsigned length; - uint8_t packetType; + msgbuf_type_t type; + unsigned connection_id; + Ticks recv_ts; + unsigned refs; + union { + /* Interest or data packet */ + struct { + struct name_s * name; + } id; + /* Command packet */ + struct { + command_type_t type; + } command; + }; + uint8_t packet[MTU]; } msgbuf_t; -#define msgbuf_from_packet(MSGBUF, PACKET, LENGTH, TYPE, CONNID, RECV_TIME) \ -do { \ - *MSGBUF = (msgbuf_t) { \ - .receiveTime = (RECV_TIME), \ - .connection_id = (CONNID), \ - .messageHead = (PACKET), \ - .length = (LENGTH), \ - .packetType = (TYPE), \ - .name = (TYPE != MESSAGE_TYPE_WLDR_NOTIFICATION \ - ? name_CreateFromPacket((PACKET), (TYPE)) \ - : NULL), \ - }; \ -} while(0) - -#define msgbuf_get_name(M) ((M)->name) +#define msgbuf_get_name(M) ((M)->id.name) #define msgbuf_get_connection_id(M) ((M)->connection_id) -#define msgbuf_get_type(M) ((M)->packetType) -#define msgbuf_has_wldr(M) (messageHandler_HasWldr((M)->messageHead)) +#define msgbuf_get_type(M) ((M)->type) +#define msgbuf_has_wldr(M) (messageHandler_HasWldr((M)->packet)) #define msgbuf_get_len(M) ((M)->length) -#define msgbuf_get_packet(M) ((M)->messageHead) +#define msgbuf_get_packet(M) ((M)->packet) +#define msgbuf_get_command_type(M) ((M)->command.type) \ // XXX TODO EXPLAIN THE CONSTANT -#define msgbuf_get_interest_lifetime(M) (NSEC_TO_TICKS(messageHandler_GetInterestLifetime((M)->messageHead) * 1000000ULL)) +#define msgbuf_get_lifetime(M) (NSEC_TO_TICKS(messageHandler_GetInterestLifetime((M)->packet) * 1000000ULL)) -#define msgbuf_is_probe(M) messageHandler_IsAProbe((M)->messageHead) +#define msgbuf_is_probe(M) messageHandler_IsAProbe((M)->packet) /* Path label */ -#define msgbuf_get_pathlabel(M) (messageHandler_GetPathLabel((M)->messageHead)) -#define msgbuf_set_pathlabel(M, label) (messageHandler_SetPathLabel((M)->messageHead, label)) -#define msgbuf_update_pathlabel(M, outface) (messageHandler_SetPathLabel((M)->messageHead, outface)) -#define msgbuf_reset_pathlabel(M) (messageHandler_ResetPathLabel((M)->messageHead)) +#define msgbuf_get_pathlabel(M) (messageHandler_GetPathLabel((M)->packet)) +#define msgbuf_set_pathlabel(M, label) (messageHandler_SetPathLabel((M)->packet, label)) +#define msgbuf_update_pathlabel(M, outface) (messageHandler_SetPathLabel((M)->packet, outface)) +#define msgbuf_reset_pathlabel(M) (messageHandler_ResetPathLabel((M)->packet)) /* WLDR */ -#define msgbuf_reset_wldr_label(M) (messageHandler_ResetWldrLabel((M)->messageHead)) -#define msgbuf_get_wldr_label(M) (messageHandler_GetWldrLabel((M)->messageHead)) -#define msgbuf_get_wldr_expected_label(M) (messageHandler_GetWldrExpectedLabel((M)->messageHead)) -#define msgbuf_get_wldr_last_received(M) (messageHandler_GetWldrLastReceived((M)->messageHead)) -#define msgbuf_set_wldr_label(M, label) (messageHandler_GetWldrLabel((M)->messageHead, label)) +#define msgbuf_reset_wldr_label(M) (messageHandler_ResetWldrLabel((M)->packet)) +#define msgbuf_get_wldr_label(M) (messageHandler_GetWldrLabel((M)->packet)) +#define msgbuf_get_wldr_expected_label(M) (messageHandler_GetWldrExpectedLabel((M)->packet)) +#define msgbuf_get_wldr_last_received(M) (messageHandler_GetWldrLastReceived((M)->packet)) +#define msgbuf_set_wldr_label(M, label) (messageHandler_GetWldrLabel((M)->packet, label)) -#endif /* HICN_MSGBUF */ +#endif /* HICNLIGHT_MSGBUF */ diff --git a/hicn-light/src/hicn/core/msgbuf_pool.c b/hicn-light/src/hicn/core/msgbuf_pool.c new file mode 100644 index 000000000..597123a7a --- /dev/null +++ b/hicn-light/src/hicn/core/msgbuf_pool.c @@ -0,0 +1,84 @@ +/* + * Copyright (c) 2020 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @file msgbuf_pool.c + * @brief Implementation of hICN packet pool. + */ + +#include "../base/pool.h" +#include "msgbuf_pool.h" + +#define PACKET_POOL_DEFAULT_INIT_SIZE 1024 + +msgbuf_pool_t * +_msgbuf_pool_create(size_t init_size, size_t max_size) +{ + msgbuf_pool_t * msgbuf_pool = malloc(sizeof(msgbuf_pool_t)); + + if (init_size == 0) + init_size = PACKET_POOL_DEFAULT_INIT_SIZE; + + pool_init(msgbuf_pool->buffers, init_size, 0); + + return msgbuf_pool; +} + +void +msgbuf_pool_free(msgbuf_pool_t * msgbuf_pool) +{ + pool_free(msgbuf_pool->buffers); + free(msgbuf_pool); +} + +int +msgbuf_pool_get(msgbuf_pool_t * msgbuf_pool, msgbuf_t * msgbuf) +{ + pool_get(msgbuf_pool->buffers, msgbuf); + return 0; +} + +void +msgbuf_pool_put(msgbuf_pool_t * msgbuf_pool, msgbuf_t * msgbuf) +{ + pool_put(msgbuf_pool->buffers, msgbuf); +} + +int +msgbuf_pool_getn(msgbuf_pool_t * msgbuf_pool, msgbuf_t ** msgbuf, size_t n) +{ + for (unsigned i = 0; i < n; i++) { + if (!msgbuf_pool_get(msgbuf_pool, msgbuf[i])) { + for (unsigned j = 0; j < i; j++) { + msgbuf_pool_put(msgbuf_pool, msgbuf[j]); + return 0; + } + break; + } + } + return -1; +} + +off_t +msgbuf_pool_get_id(msgbuf_pool_t * msgbuf_pool, msgbuf_t * msgbuf) +{ + return msgbuf - msgbuf_pool->buffers; +} + +msgbuf_t * +msgbuf_pool_at(const msgbuf_pool_t * msgbuf_pool, off_t id) +{ + return msgbuf_pool->buffers + id; +} diff --git a/hicn-light/src/hicn/core/msgbuf_pool.h b/hicn-light/src/hicn/core/msgbuf_pool.h new file mode 100644 index 000000000..2ada9fa14 --- /dev/null +++ b/hicn-light/src/hicn/core/msgbuf_pool.h @@ -0,0 +1,65 @@ +/* + * Copyright (c) 2020 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @file msgbuf_pool.h + * @brief hICN msgbuf pool. + * + * THe msgbuf pool is used to store packet payloads while the packets are in + * transit, as well as holding them into the packet cache (PIT, CSS), WLDR, + * mapme, etc. + * + * Control packets might receive a special treatment in that they are eventually + * transformed into a ack/nack, but this should not affect any part of this + * design. + * + * Do we need a reference count, or simply a lock ? + * What about weak references ? + * We need to be sure that a pool element is never referenced ever again after + * it is deleted from the pool as its ID might be reaffected. + * + * It might even be better to store references to msgbuf's as they might hold + * additional information of interest about the packet... a bit like a skbuff in + * linux. Is this relevant for the packet cache ? + */ + +#ifndef HICNLIGHT_MSGBUF_POOL_H +#define HICNLIGHT_MSGBUF_POOL_H + +#include "msgbuf.h" + +#define MTU 1500 + +typedef struct { + msgbuf_t * buffers; +} msgbuf_pool_t; + +// 0 for init size means a default value (of 1024) +// 0 for max_size means no limit +msgbuf_pool_t * _msgbuf_pool_create(size_t init_size, size_t max_size); + +#define msgbuf_pool_create() _msgbuf_pool_create(0, 0) + +void msgbuf_pool_free(msgbuf_pool_t * msgbuf_pool); + +int msgbuf_pool_get(msgbuf_pool_t * msgbuf_pool, msgbuf_t * msgbuf); + +int msgbuf_pool_getn(msgbuf_pool_t * msgbuf_pool, msgbuf_t ** msgbuf, size_t n); + +off_t msgbuf_pool_get_id(msgbuf_pool_t * msgbuf_pool, msgbuf_t * msgbuf); + +msgbuf_t * msgbuf_pool_at(const msgbuf_pool_t * msgbuf_pool, off_t id); + +#endif /* HICNLIGHT_MSGBUF_POOL_H */ diff --git a/hicn-light/src/hicn/core/name.c b/hicn-light/src/hicn/core/name.c index d50ce4cc2..1b606d3c1 100644 --- a/hicn-light/src/hicn/core/name.c +++ b/hicn-light/src/hicn/core/name.c @@ -30,7 +30,9 @@ // assumption: the IPv6 address is the name, the TCP segment number is the ICN // segment -struct name { +// XXX leverage libhicn more here + +struct name_s { NameBitvector *content_name; uint32_t segment; uint32_t name_hash; @@ -71,33 +73,44 @@ static uint32_t _computeHash(Name *name) { // ============================================================================ Name * -name_CreateFromPacket(const uint8_t *packet, MessagePacketType type) +name_create_from_interest(const uint8_t * packet) { Name *name = malloc(sizeof(Name)); assert(name); // XXX TODO error handling if (messageHandler_GetIPPacketType(packet) == IPv6_TYPE) { - if (type == MESSAGE_TYPE_INTEREST) { - name->content_name = nameBitvector_CreateFromIn6Addr( - (struct in6_addr *)messageHandler_GetDestination(packet), 128); - } else if (type == MESSAGE_TYPE_DATA) { - name->content_name = nameBitvector_CreateFromIn6Addr( - (struct in6_addr *)messageHandler_GetSource(packet), 128); - } else { - free(name); - return NULL; - } + name->content_name = nameBitvector_CreateFromIn6Addr( (struct in6_addr + *)messageHandler_GetDestination(packet), 128); } else if (messageHandler_GetIPPacketType(packet) == IPv4_TYPE) { - if (type == MESSAGE_TYPE_INTEREST) { - name->content_name = nameBitvector_CreateFromInAddr( - *((uint32_t *)messageHandler_GetDestination(packet)), 32); - } else if (type == MESSAGE_TYPE_DATA) { - name->content_name = nameBitvector_CreateFromInAddr( - *((uint32_t *)messageHandler_GetSource(packet)), 32); - } else { - free(name); - return NULL; - } + name->content_name = nameBitvector_CreateFromInAddr( *((uint32_t + *)messageHandler_GetDestination(packet)), 32); + } else { + printf("Error: unknown message type\n"); + free(name); + return NULL; + } + + name->segment = messageHandler_GetSegment(packet); + name->name_hash = _computeHash(name); + + name->refCountPtr = malloc(sizeof(unsigned)); + assert(name->refCountPtr); // XXX TODO error handling + *name->refCountPtr = 1; + return name; +} + +Name * +name_create_from_data(const uint8_t * packet) +{ + Name *name = malloc(sizeof(Name)); + assert(name); // XXX TODO error handling + + if (messageHandler_GetIPPacketType(packet) == IPv6_TYPE) { + name->content_name = nameBitvector_CreateFromIn6Addr( (struct in6_addr + *)messageHandler_GetSource(packet), 128); + } else if (messageHandler_GetIPPacketType(packet) == IPv4_TYPE) { + name->content_name = nameBitvector_CreateFromInAddr( *((uint32_t + *)messageHandler_GetSource(packet)), 32); } else { printf("Error: unknown message type\n"); free(name); diff --git a/hicn-light/src/hicn/core/name.h b/hicn-light/src/hicn/core/name.h index f3b3f2a02..ef725c00f 100644 --- a/hicn-light/src/hicn/core/name.h +++ b/hicn-light/src/hicn/core/name.h @@ -19,20 +19,20 @@ #include <stdbool.h> #include <stdlib.h> -#include <hicn/core/messagePacketType.h> -#include <hicn/core/nameBitvector.h> +#include "nameBitvector.h" //#include <hicn/utils/address.h> //#include <hicn/utils/commands.h> -struct name; -typedef struct name Name; +struct name_s; +typedef struct name_s Name; /** * Creates a name from packet * */ -Name *name_CreateFromPacket(const uint8_t *memory, MessagePacketType type); +Name *name_create_from_interest(const uint8_t * packet); +Name *name_create_from_data(const uint8_t * packet); /** * Releases one reference count, and frees memory after last reference diff --git a/hicn-light/src/hicn/core/nexthops.h b/hicn-light/src/hicn/core/nexthops.h index b45ae360f..8e4878b45 100644 --- a/hicn-light/src/hicn/core/nexthops.h +++ b/hicn-light/src/hicn/core/nexthops.h @@ -18,11 +18,12 @@ * \brief Nexthops */ -#ifndef HICN_NEXTHOPS_H -#define HICN_NEXTHOPS_H +#ifndef HICNLIGHT_NEXTHOPS_H +#define HICNLIGHT_NEXTHOPS_H #include <stdint.h> #include <stdbool.h> +#include <stdlib.h> #include <hicn/core/strategy.h> @@ -151,4 +152,4 @@ nexthops_contains(nexthops_t * nexthops, unsigned nexthop) #define nexthops_select(nexthops, i) ((nexthops)->flags = 1 << (i)) #define nexthops_select_one(nexthops) (nexthops_select((nexthops), 0)) -#endif /* HICN_NEXTHOPS_H */ +#endif /* HICNLIGHT_NEXTHOPS_H */ diff --git a/hicn-light/src/hicn/core/pit.c b/hicn-light/src/hicn/core/pit.c index fa54e2429..e80d895ec 100644 --- a/hicn-light/src/hicn/core/pit.c +++ b/hicn-light/src/hicn/core/pit.c @@ -31,43 +31,56 @@ #include <assert.h> #include <stdio.h> +#include <stdlib.h> #define __STDC_FORMAT_MACROS #include <inttypes.h> -#include <hicn/core/msgbuf.h> -#include <hicn/base/pool.h> -#include <hicn/core/ticks.h> #include <hicn/util/log.h> +#include "msgbuf.h" +#include "msgbuf_pool.h" +#include "ticks.h" +#include "../base/pool.h" + #include "pit.h" // XXX TODO Should not be defined here #define DEFAULT_INTEREST_LIFETIME 4000000000ULL -static Ticks _pit_calculate_lifetime(pit_t * pit, - msgbuf_t *interest_msgbuf) { - uint64_t interestLifetimeTicks = - msgbuf_get_interest_lifetime(interest_msgbuf); - if (interestLifetimeTicks == 0) { - interestLifetimeTicks = NSEC_TO_TICKS(DEFAULT_INTEREST_LIFETIME); - } +static +Ticks +_pit_calculate_lifetime(pit_t * pit, const msgbuf_t * msgbuf) +{ + uint64_t lifetime = msgbuf_get_lifetime(msgbuf); + if (lifetime == 0) + lifetime = NSEC_TO_TICKS(DEFAULT_INTEREST_LIFETIME); - Ticks expiry_time = ticks_now() + interestLifetimeTicks; - return expiry_time; + return ticks_now() + lifetime; } -// max_elts default is 65535 +/* This is only used as a hint for first allocation, as the table is resizeable */ +#define DEFAULT_PIT_SIZE 65535 + pit_t * -pit_create(size_t max_elts) +_pit_create(size_t init_size, size_t max_size) { pit_t * pit = malloc(sizeof(pit_t)); if (!pit) return NULL; - pool_init(pit->entries, max_elts); + if (init_size == 0) + init_size = DEFAULT_PIT_SIZE; + + pit->max_size = max_size; + + /* Initialize indices */ pit->index_by_name = kh_init(pit_name); - DEBUG("PIT %p created", pit); + /* + * We start by allocating a reasonably-sized pool, as this will eventually + * be resized if needed. + */ + pool_init(pit->entries, init_size, 0); return pit; } @@ -76,53 +89,57 @@ void pit_free(pit_t * pit) { assert(pit); - // XXX TODO + + free(pit); DEBUG("PIT %p destroyed", pit); } pit_verdict_t -pit_on_interest(pit_t * pit, msgbuf_t * interest_msgbuf) +pit_on_interest(pit_t * pit, off_t msgbuf_id) { assert(pit); - assert(interest_msgbuf); - assert(msgbuf_get_type(interest_msgbuf) == MESSAGE_TYPE_INTEREST); + assert(msgbuf_id_is_valid(msgbuf_id)); + + const msgbuf_pool_t * msgbuf_pool = pit_get_msgbuf_pool(pit); + const msgbuf_t * msgbuf = msgbuf_pool_at(msgbuf_pool, msgbuf_id); + assert(msgbuf_get_type(msgbuf) == MSGBUF_TYPE_INTEREST); fib_entry_t * fib_entry; - Ticks expiry_time; + Ticks expire_ts; /* Lookup entry by name */ - khiter_t k = kh_get_pit_name(pit->index_by_name, msgbuf_get_name(interest_msgbuf)); + khiter_t k = kh_get_pit_name(pit->index_by_name, msgbuf_get_name(msgbuf)); if (k == kh_end(pit->index_by_name)) goto NOT_FOUND; pit_entry_t * entry = pit->entries + kh_val(pit->index_by_name, k); assert(entry); // has it expired? - if (ticks_now() >= pit_entry_get_expiry_time(entry)) + if (ticks_now() >= pit_entry_get_expire_ts(entry)) goto TIMEOUT; /* Extend entry lifetime */ - expiry_time = _pit_calculate_lifetime(pit, interest_msgbuf); - if (expiry_time > pit_entry_get_expiry_time(entry)) - pit_entry_set_expiry_time(entry, expiry_time); + expire_ts = _pit_calculate_lifetime(pit, msgbuf); + if (expire_ts > pit_entry_get_expire_ts(entry)) + pit_entry_set_expire_ts(entry, expire_ts); - unsigned connection_id = msgbuf_get_connection_id(interest_msgbuf); + unsigned connection_id = msgbuf_get_connection_id(msgbuf); // Is the reverse path already in the PIT entry? if (pit_entry_ingress_contains(entry, connection_id)) { // It is already in the PIT entry, so this is a retransmission, so // forward it. - DEBUG("Message %p existing entry (expiry %" PRIu64 ") and reverse path, forwarding", - interest_msgbuf, pit_entry_get_expiry_time(entry)); + DEBUG("Message %lu existing entry (expiry %" PRIu64 ") and reverse path, forwarding", + msgbuf_id, pit_entry_get_expire_ts(entry)); return PIT_VERDICT_RETRANSMIT; } // It is in the PIT but this is the first interest for the reverse path pit_entry_ingress_add(entry, connection_id); - DEBUG("Message %p existing entry (expiry %" PRIu64 ") and reverse path is new, aggregate", - interest_msgbuf, pit_entry_get_expiry_time(entry)); + DEBUG("Message %lu existing entry (expiry %" PRIu64 ") and reverse path is new, aggregate", + msgbuf_id, pit_entry_get_expire_ts(entry)); return PIT_VERDICT_AGGREGATE; TIMEOUT: @@ -131,36 +148,46 @@ TIMEOUT: fib_entry_on_timeout(fib_entry, pit_entry_get_egress(entry)); // it's an old entry, remove it - k = kh_get(pit_name, pit->index_by_name, msgbuf_get_name(interest_msgbuf)); + k = kh_get(pit_name, pit->index_by_name, msgbuf_get_name(msgbuf)); if (k != kh_end(pit->index_by_name)) kh_del(pit_name, pit->index_by_name, k); NOT_FOUND: /* Create PIT entry */ - expiry_time = _pit_calculate_lifetime(pit, interest_msgbuf); + expire_ts = _pit_calculate_lifetime(pit, msgbuf); - pit_allocate(pit, entry, interest_msgbuf); - pit_entry_from_msgbuf(entry, interest_msgbuf, expiry_time, ticks_now()); + pit_allocate(pit, entry, msgbuf); - DEBUG("Message %p added to PIT (expiry %" PRIu64 ") ingress %u", - interest_msgbuf, pit_entry_get_expiry_time(entry), - msgbuf_get_connection_id(interest_msgbuf)); + *entry = (pit_entry_t) { + .msgbuf_id = msgbuf_id, + .fib_entry = NULL, + .create_ts = ticks_now(), + .expire_ts = expire_ts, + }; + pit_entry_ingress_add(entry, msgbuf_get_connection_id(msgbuf)); + + DEBUG("Message %lu added to PIT (expiry %" PRIu64 ") ingress %u", + msgbuf_id, pit_entry_get_expire_ts(entry), + msgbuf_get_connection_id(msgbuf)); return PIT_VERDICT_FORWARD; } nexthops_t * -pit_on_data(pit_t * pit, const msgbuf_t * data_msgbuf) +pit_on_data(pit_t * pit, off_t msgbuf_id) { assert(pit); - assert(data_msgbuf); - assert(msgbuf_get_type(data_msgbuf) == MESSAGE_TYPE_DATA); + assert(msgbuf_id_is_valid(msgbuf_id)); + + const msgbuf_pool_t * msgbuf_pool = pit_get_msgbuf_pool(pit); + const msgbuf_t * msgbuf = msgbuf_pool_at(msgbuf_pool, msgbuf_id); + assert(msgbuf_get_type(msgbuf) == MSGBUF_TYPE_DATA); nexthops_t * nexthops = NULL; /* Lookup entry by name */ - khiter_t k = kh_get_pit_name(pit->index_by_name, msgbuf_get_name(data_msgbuf)); + khiter_t k = kh_get_pit_name(pit->index_by_name, msgbuf_get_name(msgbuf)); if (k == kh_end(pit->index_by_name)) goto NOT_FOUND; @@ -170,14 +197,14 @@ pit_on_data(pit_t * pit, const msgbuf_t * data_msgbuf) // here we need to check if the PIT entry is expired // if so, remove the PIT entry. Ticks now = ticks_now(); - if (now >= pit_entry_get_expiry_time(entry)) + if (now >= pit_entry_get_expire_ts(entry)) goto TIMEOUT; /* PIT entry is not expired, use it */ fib_entry_t * fib_entry = pit_entry_get_fib_entry(entry); if (fib_entry) fib_entry_on_data(fib_entry, pit_entry_get_egress(entry), - data_msgbuf, pit_entry_get_creation_time(entry), ticks_now()); + msgbuf, pit_entry_get_create_ts(entry), ticks_now()); // XXX TODO : be sure nexthops are valid b/c pit entry is removed // XXX TODO eventually pass holding structure as parameter @@ -192,20 +219,25 @@ NOT_FOUND: } void -pit_remove(pit_t * pit, const msgbuf_t * interest_msgbuf) +pit_remove(pit_t * pit, off_t msgbuf_id) { assert(pit); - assert(interest_msgbuf); - assert(msgbuf_get_type(interest_msgbuf) == MESSAGE_TYPE_INTEREST); + assert(msgbuf_id_is_valid(msgbuf_id)); + + const msgbuf_pool_t * msgbuf_pool = pit_get_msgbuf_pool(pit); + const msgbuf_t * msgbuf = msgbuf_pool_at(msgbuf_pool, msgbuf_id); + + assert(msgbuf); + assert(msgbuf_get_type(msgbuf) == MSGBUF_TYPE_INTEREST); - khiter_t k = kh_get(pit_name, pit->index_by_name, msgbuf_get_name(interest_msgbuf)); + khiter_t k = kh_get(pit_name, pit->index_by_name, msgbuf_get_name(msgbuf)); if (k == kh_end(pit->index_by_name)) return; //off_t index = kh_val(pit->index_by_name, k); //pit_entry_t * entry = pit_at(pit, index); kh_del(pit_name, pit->index_by_name, k); - DEBUG("Message %p removed from PIT", interest_msgbuf); + DEBUG("Message %p removed from PIT", msgbuf); } pit_entry_t * @@ -213,7 +245,7 @@ pit_lookup(const pit_t * pit, const msgbuf_t * interest_msgbuf) { assert(pit); assert(interest_msgbuf); - assert(msgbuf_get_type(interest_msgbuf) == MESSAGE_TYPE_INTEREST); + assert(msgbuf_get_type(interest_msgbuf) == MSGBUF_TYPE_INTEREST); khiter_t k = kh_get(pit_name, pit->index_by_name, msgbuf_get_name(interest_msgbuf)); diff --git a/hicn-light/src/hicn/core/pit.h b/hicn-light/src/hicn/core/pit.h index 1aedcfab9..5607827fe 100644 --- a/hicn-light/src/hicn/core/pit.h +++ b/hicn-light/src/hicn/core/pit.h @@ -1,7 +1,26 @@ +/* + * Copyright (c) 2017-2020 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @file pit.h + * @brief hICN Pending Interest Table (PIT) + */ + #ifndef HICNLIGHT_PIT_H #define HICNLIGHT_PIT_H - #include <hicn/base/khash.h> #include <hicn/core/nexthops.h> #include <hicn/core/msgbuf.h> @@ -10,14 +29,14 @@ #include <hicn/core/ticks.h> typedef struct { - msgbuf_t * msgbuf; + off_t msgbuf_id; nexthops_t ingressIdSet; nexthops_t egressIdSet; fib_entry_t * fib_entry; - Ticks creation_time; - Ticks expiry_time; + Ticks create_ts; + Ticks expire_ts; } pit_entry_t; typedef enum { @@ -30,10 +49,10 @@ typedef enum { #define pit_entry_get_egress(E) (&((E)->egressIdSet)) #define pit_entry_get_fib_entry(E) ((E)->fib_entry) #define pit_entry_set_fib_entry(E, FIB_ENTRY) ((E)->fib_entry = FIB_ENTRY) -#define pit_entry_get_creation_time(E) ((E)->creation_time) -#define pit_entry_get_expiry_time(E) ((E)->expiry_time) -#define pit_entry_set_expiry_time(E, EXPIRY_TIME) \ - (entry)->expiry_time = EXPIRY_TIME +#define pit_entry_get_create_ts(E) ((E)->create_ts) +#define pit_entry_get_expire_ts(E) ((E)->expire_ts) +#define pit_entry_set_expire_ts(E, EXPIRY_TIME) \ + (entry)->expire_ts = EXPIRY_TIME #define pit_entry_ingress_add(E, NH) \ nexthops_add(pit_entry_get_ingress(E), (NH)) @@ -44,26 +63,34 @@ typedef enum { #define pit_entry_egress_add(E, NH) \ nexthops_add(pit_entry_get_egress(E), (NH)) -#define pit_entry_from_msgbuf(E, MSGBUF, EXPIRY_TIME, CREATION_TIME) \ -do { \ - E->msgbuf = MSGBUF; \ - pit_entry_ingress_add(E, msgbuf_get_connection_id(MSGBUF)); \ - E->fib_entry = NULL; \ - E->creation_time = CREATION_TIME; \ - E->expiry_time = EXPIRY_TIME; \ -} while(0) - #define name_hash(name) (name_HashCode(name)) #define name_hash_eq(a, b) (name_hash(b) - name_hash(a)) KHASH_INIT(pit_name, const Name *, unsigned, 0, name_hash, name_hash_eq); typedef struct { + msgbuf_pool_t * msgbuf_pool; + size_t max_size; pit_entry_t * entries; // pool kh_pit_name_t * index_by_name; } pit_t; -pit_t * pit_create(size_t max_elts); +/** + * @brief Allocate a new PIT data structure (extended parameters) + * + * @param init_size Initial size (0 = default) + * @param max_size Maximum size (0 = unbounded) + * + * @return pit_t* Newly allocated PIT data structure + */ +pit_t * _pit_create(size_t init_size, size_t max_size); + +/** + * @brief Allocate a new PIT data structure + * + * @return pit_t* Newly allocated PIT data structure + */ +#define pit_create() _pit_create(0, 0) void pit_free(pit_t * pit); @@ -81,12 +108,14 @@ do { #define pit_at(pit, i) (pit->entries + i) -pit_verdict_t pit_on_interest(pit_t * pit, msgbuf_t * msgbuf); +pit_verdict_t pit_on_interest(pit_t * pit, off_t msgbuf_id); -nexthops_t * pit_on_data(pit_t * pit, const msgbuf_t * msgbuf); +nexthops_t * pit_on_data(pit_t * pit, off_t msgbuf_id); -void pit_remove(pit_t * pit, const msgbuf_t * msgbuf); +void pit_remove(pit_t * pit, off_t msgbuf_id); pit_entry_t * pit_lookup(const pit_t * pit, const msgbuf_t * msgbuf); +#define pit_get_msgbuf_pool(pit) (pit->msgbuf_pool) + #endif /* HICNLIGHT_PIT_H */ diff --git a/hicn-light/src/hicn/core/strategy.h b/hicn-light/src/hicn/core/strategy.h index 3d48c5510..67630bbab 100644 --- a/hicn-light/src/hicn/core/strategy.h +++ b/hicn-light/src/hicn/core/strategy.h @@ -17,15 +17,12 @@ * \file strategy.h * \brief hICN forwarding strategy */ -#ifndef HICN_STRATEGY_H -#define HICN_STRATEGY_H +#ifndef HICNLIGHT_STRATEGY_H +#define HICNLIGHT_STRATEGY_H -#include <hicn/core/name.h> -#include <hicn/core/msgbuf.h> - -#include <hicn/strategies/load_balancer.h> -#include <hicn/strategies/low_latency.h> -#include <hicn/strategies/random.h> +#include "../strategies/load_balancer.h" +#include "../strategies/low_latency.h" +#include "../strategies/random.h" typedef enum { STRATEGY_TYPE_UNDEFINED, @@ -67,4 +64,4 @@ typedef struct { } strategy_entry_t; -#endif /* HICN_STRATEGY_H */ +#endif /* HICNLIGHT_STRATEGY_H */ diff --git a/hicn-light/src/hicn/core/strategy_vft.h b/hicn-light/src/hicn/core/strategy_vft.h index e698c9d94..61166d3dd 100644 --- a/hicn-light/src/hicn/core/strategy_vft.h +++ b/hicn-light/src/hicn/core/strategy_vft.h @@ -17,11 +17,12 @@ * \file strategy_vft.h * \brief hICN forwarding strategy VFT */ -#ifndef HICN_STRATEGY_VFT_H -#define HICN_STRATEGY_VFT_H +#ifndef HICNLIGHT_STRATEGY_VFT_H +#define HICNLIGHT_STRATEGY_VFT_H -#include <hicn/core/strategy.h> -#include <hicn/core/nexthops.h> +#include "msgbuf.h" +#include "nexthops.h" +#include "strategy.h" /** * @typedef strategy_ops_t @@ -73,4 +74,4 @@ const strategy_ops_t strategy_ ## NAME = { \ .on_timeout = strategy_ ## NAME ## _on_timeout, \ } -#endif /* HICN_STRATEGY_VFT_H */ +#endif /* HICNLIGHT_STRATEGY_VFT_H */ diff --git a/hicn-light/src/hicn/core/wldr.c b/hicn-light/src/hicn/core/wldr.c index 5a6c876b9..e9b1f77f9 100644 --- a/hicn-light/src/hicn/core/wldr.c +++ b/hicn-light/src/hicn/core/wldr.c @@ -151,7 +151,9 @@ void wldr_set_label(wldr_t * wldr, msgbuf_t *msgbuf) { #endif } -void wldr_detect_losses(wldr_t * wldr, const connection_t * conn, msgbuf_t *msgbuf) { +void wldr_detect_losses(wldr_t * wldr, const connection_t * connection, + const msgbuf_t * msgbuf) +{ #if 0 if (message_HasWldr(msgbuf)) { // this is a normal wldr packet @@ -179,8 +181,9 @@ void wldr_detect_losses(wldr_t * wldr, const connection_t * conn, msgbuf_t *msgb #endif } -void wldr_handle_notification(wldr_t * wldr, const connection_t * conn, - msgbuf_t *msgbuf) { +void wldr_handle_notification(wldr_t * wldr, const connection_t * connection, + const msgbuf_t *msgbuf) +{ #if 0 uint16_t expected_lbl = (uint16_t)message_GetWldrExpectedLabel(msgbuf); uint16_t received_lbl = (uint16_t)message_GetWldrLastReceived(msgbuf); diff --git a/hicn-light/src/hicn/core/wldr.h b/hicn-light/src/hicn/core/wldr.h index cb2f0e2cf..529977223 100644 --- a/hicn-light/src/hicn/core/wldr.h +++ b/hicn-light/src/hicn/core/wldr.h @@ -44,8 +44,9 @@ void wldr_reset_state(wldr_t * wldr); void wldr_set_label(wldr_t * wldr, msgbuf_t * msgbuf); -void wldr_detect_losses(wldr_t * wldr, const connection_t * conn, msgbuf_t * msgbuf); +void wldr_detect_losses(wldr_t * wldr, const connection_t * connection, + const msgbuf_t * msgbuf); -void wldr_handle_notification(wldr_t *wldr, const connection_t * conn, - msgbuf_t * msgbuf); +void wldr_handle_notification(wldr_t *wldr, const connection_t * connection, + const msgbuf_t * msgbuf); #endif // wldr_h diff --git a/hicn-light/src/hicn/io/CMakeLists.txt b/hicn-light/src/hicn/io/CMakeLists.txt index d7e6977d6..80a1ba867 100644 --- a/hicn-light/src/hicn/io/CMakeLists.txt +++ b/hicn-light/src/hicn/io/CMakeLists.txt @@ -17,6 +17,7 @@ list(APPEND HEADER_FILES ) list(APPEND SOURCE_FILES + ${CMAKE_CURRENT_SOURCE_DIR}/base.c ${CMAKE_CURRENT_SOURCE_DIR}/hicn.c ${CMAKE_CURRENT_SOURCE_DIR}/tcp.c ${CMAKE_CURRENT_SOURCE_DIR}/udp.c diff --git a/hicn-light/src/hicn/io/base.c b/hicn-light/src/hicn/io/base.c new file mode 100644 index 000000000..35d8915a8 --- /dev/null +++ b/hicn-light/src/hicn/io/base.c @@ -0,0 +1,128 @@ +/* + * Copyright (c) 2020 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @file base.c + * #brief Implementation of base IO functions. + */ + +#include <hicn/util/log.h> + +#include "base.h" + +/** + * @brief Helper function for listener to read a single packet on a socket + */ +ssize_t io_read_single_fd(int fd, msgbuf_t * msgbuf, address_t * address) +{ + uint8_t * packet = msgbuf_get_packet(msgbuf); + size_t size = msgbuf_get_len(msgbuf); + + for(;;) { + ssize_t n = read(fd, packet, size); + if (n == 0) + return n; + if (n < 0) { + if (errno == EINTR) + continue; // XXX was break; + ERROR("read failed %d: (%d) %s", fd, errno, strerror(errno)); + return -1; + } + + msgbuf->length = n; + *address = ADDRESS_ANY(AF_UNSPEC, 0); // XXX placeholder, see hicn.c + } + + return 1; +} + +ssize_t io_read_single_socket(int fd, msgbuf_t * msgbuf, address_t * address) +{ + + struct sockaddr_storage * sa = (struct sockaddr_storage *)address; + socklen_t sa_len = sizeof(sa); + + uint8_t * packet = msgbuf_get_packet(msgbuf); + + for (;;) { + ssize_t n = recvfrom(fd, packet, MTU, 0, (struct sockaddr *)&sa, &sa_len); + if (n == 0) + return n; + if (n < 0) { + if (errno == EINTR) + continue; // XXX was break; + ERROR("recvfrom failed %d: (%d) %s", fd, errno, strerror(errno)); + return -1; + } + + msgbuf->length = n; + } + + return 1; +} + +#ifdef __linux__ +ssize_t io_read_batch_socket(int fd, msgbuf_t ** msgbuf, + address_t ** address, size_t batch_size) +{ + struct mmsghdr msghdr[batch_size]; + struct iovec iovecs[batch_size]; + struct sockaddr_storage addrs[batch_size]; + + /* Prepare the mmghdr struct for recvmmsg */ + for (unsigned i = 0; i < MAX_MSG; i++) { + struct mmsghdr *msg = &msghdr[i]; + *msg = (struct mmsghdr) { + .msg_hdr = { + .msg_iov = &iovecs[i], + .msg_iovlen = 1, + .msg_name = &addrs[i], + .msg_namelen = sizeof(struct sockaddr_storage), + .msg_control = NULL, + .msg_controllen = 0, + }, + }; + + iovecs[i] = (struct iovec) { + .iov_base = msgbuf_get_packet(msgbuf[i]), + .iov_len = MTU, + }; + } + + int n; + for (;;) { + n = recvmmsg(fd, msghdr, batch_size, /* flags */ 0, + /* timeout */ NULL); + if (n == 0) + return 0; + if (n < 0) { + if (errno == EINTR) + continue; // XXX was break; + ERROR("read failed %d: (%d) %s", fd, errno, strerror(errno)); + return (ssize_t) n; + } + + /* Assign size to msgbuf, and build address pair */ + for (int i = 0; i < n; i++) { + struct mmsghdr *msg = &msghdr[i]; + msgbuf[i]->length = msg->msg_hdr.msg_iovlen; + **address = *(address_t*)msg->msg_hdr.msg_name; + } + } + + return n; +} +#endif /* __linux__ */ + diff --git a/hicn-light/src/hicn/core/messagePacketType.h b/hicn-light/src/hicn/io/base.h index 9a559069e..639334072 100644 --- a/hicn-light/src/hicn/core/messagePacketType.h +++ b/hicn-light/src/hicn/io/base.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017-2019 Cisco and/or its affiliates. + * Copyright (c) 2020 Cisco and/or its affiliates. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at: @@ -14,22 +14,25 @@ */ /** - * @file message_packet_type_h - * @brief Defines the packet type for a HICN message - * + * @file base.h + * #brief Base IO functions. */ -#ifndef message_packet_type_h -#define message_packet_type_h +#ifndef HICNLIGHT_IO_BASE +#define HICNLIGHT_IO_BASE + +#include "../core/address_pair.h" +#include "../core/msgbuf.h" + +#define MAX_MSG 64 //16 //32 + +ssize_t io_read_single_fd(int fd, msgbuf_t * msgbuf, + address_t * address); + +ssize_t io_read_single_socket(int fd, msgbuf_t * msgbuf, + address_t * address); -typedef enum message_type { - MESSAGE_TYPE_UNDEFINED, - MESSAGE_TYPE_INTEREST, - MESSAGE_TYPE_DATA, - MESSAGE_TYPE_WLDR_NOTIFICATION, - MESSAGE_TYPE_MAPME, - MESSAGE_TYPE_COMMAND, - MESSAGE_TYPE_N, -} MessagePacketType; +ssize_t io_read_batch_socket(int fd, msgbuf_t ** msgbuf, + address_t ** address, size_t n); -#endif // message_packet_type_h +#endif /* HICNLIGHT_IO_BASE */ diff --git a/hicn-light/src/hicn/io/hicn.c b/hicn-light/src/hicn/io/hicn.c index 26c641e51..02b6728a9 100644 --- a/hicn-light/src/hicn/io/hicn.c +++ b/hicn-light/src/hicn/io/hicn.c @@ -26,17 +26,18 @@ #include <string.h> #include <unistd.h> -#include <hicn/core/listener.h> -#include <hicn/core/listener_vft.h> -#include <hicn/core/connection.h> -#include <hicn/core/connection_vft.h> -#include <hicn/core/connection_table.h> -#include <hicn/core/forwarder.h> -#include <hicn/core/mapme.h> -#include <hicn/core/messagePacketType.h> -#include <hicn/socket/api.h> #include <hicn/util/log.h> +#include "base.h" +#include "../core/listener.h" +#include "../core/listener_vft.h" +#include "../core/connection.h" +#include "../core/connection_vft.h" +#include "../core/connection_table.h" +#include "../core/forwarder.h" +#include "../core/mapme.h" +#include "../socket/api.h" + #define IPv6 6 #define IPv4 4 #define MTU_SIZE 1500 // bytes @@ -242,65 +243,7 @@ typedef struct { } listener_hicn_data_t; -static -void -listener_hicn_read_callback(listener_t * listener, int fd, void * data) -{ - assert(listener); - assert(!data); /* No user data */ - uint8_t packet[MTU_SIZE]; - - int family = address_family(&listener->address); - if ((family != AF_INET) && (family != AF_INET6)) { - /* - * We need to discard the frame. Read 1 byte. This will clear it off - * the stack. - */ - int nread = read(fd, packet, 1); - - if (nread > 0) { - DEBUG("Discarded frame from fd %d", fd); - } else if (nread < 0) { - ERROR("Error trying to discard frame from fd %d: (%d) %s", fd, errno, - strerror(errno)); - } - return; - } - -#if 0 - if (!(what & PARCEventType_Read)) - return; -#endif - - ssize_t n = read(fd, packet, MTU_SIZE); - if (n < 0) { - ERROR("read failed %d: (%d) %s", fd, errno, strerror(errno)); - return; - } - -#if 0 - address_t packet_addr; - if (_createAddressFromPacket(packet, &packet_addr) < 0) - return; - - address_pair_t pair_find = { - .local = packet_addr, - .remote = /* dummy */ hicn->localAddress, - }; - const Connection *conn = _lookupConnection(listener, &pair_find); - if (!conn) { - address_pair_t pair = { - .local = hicn->localAddress, - .remote = packet_addr, - }; - connid = _createNewConnection(listener, fd, &pair); - } else { - connid = connection_GetConnectionId(conn); - } -#endif - - listener_read_callback(listener->forwarder, listener, fd, &listener->address, packet, n); -} +#define listener_hicn_read_callback listener_read_callback bool listener_hicn_bind(listener_t * listener, const address_t * address) @@ -426,7 +369,8 @@ listener_hicn_get_socket(const listener_t * listener, const address_t * local, { assert(listener); assert(listener_get_type(listener) == FACE_TYPE_HICN); - // assert(pair); + assert(local); + assert(remote); /* ... */ @@ -434,6 +378,9 @@ listener_hicn_get_socket(const listener_t * listener, const address_t * local, } +#define listener_hicn_read_single io_read_single_fd +#define listener_hicn_read_batch NULL + DECLARE_LISTENER(hicn); /****************************************************************************** @@ -503,7 +450,7 @@ static int connection_hicn_send_packet(const connection_t * connection, const uint8_t * packet, size_t size) { - // assert(ops); + assert(connection); assert(packet); /* ... */ @@ -511,12 +458,4 @@ connection_hicn_send_packet(const connection_t * connection, const uint8_t * pac return 0; } -static -void -connection_hicn_read_callback(connection_t * connection, int fd, void * data) -{ - ERROR("Unexpected read callback for hicn connection"); - return; -} - DECLARE_CONNECTION(hicn); diff --git a/hicn-light/src/hicn/io/tcp.c b/hicn-light/src/hicn/io/tcp.c index 0ed9b4650..e4e2b06af 100644 --- a/hicn-light/src/hicn/io/tcp.c +++ b/hicn-light/src/hicn/io/tcp.c @@ -27,19 +27,19 @@ #include <stdio.h> #include <string.h> -#include <hicn/core/connection.h> -#include <hicn/core/connection_vft.h> -#include <hicn/core/listener.h> -#include <hicn/core/listener_vft.h> -#include <hicn/core/msgbuf.h> -#include <hicn/core/forwarder.h> - -#include <hicn/core/messageHandler.h> - -#include <hicn/utils/commands.h> +#include <hicn/hicn.h> #include <hicn/util/log.h> -#include <hicn/hicn.h> +#include "base.h" +#include "../core/connection.h" +#include "../core/connection_vft.h" +#include "../core/listener.h" +#include "../core/listener_vft.h" +#include "../core/msgbuf.h" +#include "../core/forwarder.h" +#include "../core/messageHandler.h" +#include "../utils/commands.h" + // 128 KB output queue #define OUTPUT_QUEUE_BYTES (128 * 1024) @@ -93,13 +93,8 @@ listener_tcp_get_socket(const listener_t * listener, const address_t * local, } -static -void -listener_tcp_read_callback(listener_t * listener, int fd, void * data) -{ - ERROR("[listener_tcp_read_callback] Not implemented"); - -} +#define listener_tcp_read_single io_read_single_socket +#define listener_tcp_read_batch NULL DECLARE_LISTENER(tcp); @@ -324,11 +319,10 @@ connection_tcp_sendv(connnection_t * connection, struct iovec * iov, // XXX too much repeated code with sendv here static int -connection_tcp_send(const connection_t * connection, //const address_t * address, - msgbuf_t * msgbuf, bool queue) +connection_tcp_send(const connection_t * connection, msgbuf_t * msgbuf, + bool queue) { assert(connection); - // assert(address); /* msgbuf can be NULL */ /* No need to flush */ @@ -459,12 +453,13 @@ ERR: * @param <#param1#> * @return <#return#> */ +#if 0 static void connection_tcp_read_callback(connection_t * connection, int fd, void * user_data) { - // assert(!!(what & PARCEventType_Read)); assert(connection); + /* user_data can be NULL */ connection_tcp_data_t * data = connection->data; assert(RECV_BUFLEN - data->woff > MTU); @@ -487,7 +482,7 @@ connection_tcp_read_callback(connection_t * connection, int fd, void * user_data uint8_t * packet = data->buf + data->roff; size_t size = data->woff - data->roff; /* > 0 */ - ssize_t used = listener_read_callback(connection->forwarder, NULL, fd, + ssize_t used = listener_read_callback(NULL, fd, address_pair_get_local(&connection->pair), packet, size); if (used < 0) return; // XXX close connection ? @@ -517,6 +512,7 @@ connection_tcp_read_callback(connection_t * connection, int fd, void * user_data return; } +#endif #if 0 static diff --git a/hicn-light/src/hicn/io/udp.c b/hicn-light/src/hicn/io/udp.c index f0eaf8fd0..38d643838 100644 --- a/hicn-light/src/hicn/io/udp.c +++ b/hicn-light/src/hicn/io/udp.c @@ -31,6 +31,7 @@ #include <fcntl.h> #include <stdbool.h> #include <stdio.h> +#include <stdlib.h> #include <string.h> #ifndef _WIN32 #include <sys/uio.h> @@ -46,19 +47,20 @@ #define UDP_GRO 104 #endif /* WITH_GSO */ -#include <hicn/core/address_pair.h> -#include <hicn/core/connection.h> -#include <hicn/core/connection_vft.h> -#include <hicn/core/listener.h> -#include <hicn/core/listener_vft.h> -#include <hicn/base/loop.h> -#include <hicn/core/msgbuf.h> -#include <hicn/core/forwarder.h> -#include <hicn/core/messageHandler.h> -#include <hicn/core/messagePacketType.h> -#include <hicn/hicn-light/config.h> #include <hicn/util/log.h> +#include "base.h" +#include "../base/loop.h" +#include "../core/address_pair.h" +#include "../core/connection.h" +#include "../core/connection_vft.h" +#include "../core/forwarder.h" +#include "../core/listener.h" +#include "../core/listener_vft.h" +#include "../core/messageHandler.h" +#include "../core/msgbuf.h" +//#include "../hicn-light/config.h" + // Batching based on recvmmsg is also generic // the difference is the handling of packet as in tcp we need to go through the // ring buffer first to do the framing, while in UDP this is already done @@ -75,8 +77,6 @@ typedef struct { uint16_t port; // in address ? - - batch_buffer_t bb; } listener_udp_data_t; #ifdef __ANDROID__ @@ -211,10 +211,10 @@ listener_udp_initialize(listener_t * listener) { assert(listener); +#if 0 listener_udp_data_t * data = listener->data; assert(data); - - init_batch_buffers(&data->bb); +#endif // XXX Socket creation should be a function per-se and not be called in // initialize ! @@ -287,18 +287,13 @@ ERR_SOCKET: return -1; } -static -void -listener_udp_read_callback(listener_t * listener, int fd, void * user_data) -{ - assert(listener); - assert(!user_data); - - listener_udp_data_t * data = listener->data; - assert(data); +#define listener_udp_read_single io_read_single_socket - listener_batch_read_callback(listener->forwarder, listener, fd, &listener->address, &data->bb); -} +#ifdef __linux__ +#define listener_udp_read_batch io_read_batch_socket +#else +#define listener_udp_read_batch NULL +#endif /* __linux__ */ DECLARE_LISTENER(udp); @@ -307,7 +302,8 @@ DECLARE_LISTENER(udp); ******************************************************************************/ typedef struct { - batch_buffer_t bb; + // XXX queue storage : msfbuf id + off_t queue[MAX_MSG]; // sized according to the max batch int queue_len; } connection_udp_data_t; @@ -323,8 +319,6 @@ connection_udp_initialize(connection_t * connection) connection_udp_data_t * data = connection->data; assert(data); - init_batch_buffers(&data->bb); - data->queue_len = 0; return 0; @@ -358,6 +352,10 @@ connection_udp_send(const connection_t * connection, msgbuf_t * msgbuf, bool que connection_udp_data_t * data = connection->data; assert(data); + forwarder_t * forwarder = connection->forwarder; + msgbuf_pool_t * msgbuf_pool = forwarder_get_msgbuf_pool(forwarder); + + /* Flush if required or if queue is full */ if ((!msgbuf) || (queue && (data->queue_len > MAX_MSG))) { /* Flush operation */ @@ -366,7 +364,38 @@ connection_udp_send(const connection_t * connection, msgbuf_t * msgbuf, bool que #else int flags = 0; #endif /* WITH_ZEROCOPY */ - int n = sendmmsg(connection->fd, data->bb.msghdr, data->queue_len, flags); + + + // BEGIN : send batch + + /* Preparing the struct mmsghdr for batch sending */ + struct mmsghdr msghdr[MAX_MSG]; + struct iovec iovecs[MAX_MSG]; + + /* Prepare the mmghdr struct for recvmmsg */ + for (unsigned i = 0; i < data->queue_len; i++) { + struct mmsghdr *msg = &msghdr[i]; + *msg = (struct mmsghdr) { + .msg_hdr = { + .msg_iov = &iovecs[i], + .msg_iovlen = 1, + .msg_name = NULL, + .msg_namelen = 0, + .msg_control = NULL, + .msg_controllen = 0, + }, + }; + + msgbuf_t * msgbuf = msgbuf_pool_at(msgbuf_pool, data->queue[i]); + iovecs[i] = (struct iovec) { + .iov_base = msgbuf_get_packet(msgbuf), + .iov_len = msgbuf_get_len(msgbuf), + }; + } + + // XXX build mmsghdr from the msgbuf queue + + int n = sendmmsg(connection->fd, msghdr, data->queue_len, flags); if (n == -1) { perror("sendmmsg()"); data->queue_len = 0; @@ -384,11 +413,10 @@ connection_udp_send(const connection_t * connection, msgbuf_t * msgbuf, bool que } if (queue) { - struct iovec *iovec = &data->bb.iovecs[data->queue_len++]; - iovec->iov_base = msgbuf_get_packet(msgbuf); - iovec->iov_len = msgbuf_get_len(msgbuf); - + /* Queue packet */ + data->queue[data->queue_len++] = msgbuf_pool_get_id(msgbuf_pool, msgbuf); } else { + /* Send one */ ssize_t writeLength = write(connection->fd, msgbuf_get_packet(msgbuf), msgbuf_get_len(msgbuf)); @@ -467,16 +495,13 @@ connection_udp_send_packet(const connection_t * connection, const uint8_t * pack return 0; } -static -void -connection_udp_read_callback(connection_t * connection, int fd, void * user_data) -{ - assert(connection); - assert(!user_data); +#define connection_udp_read_single listener_read_batch_socket listener_single_socket + +#ifdef __linux__ +#define connection_udp_read_batch listener_read_batch_socket +#else +#define connection_udp_read_batch NULL +#endif /* __linux__ */ - connection_udp_data_t * data = connection->data; - assert(data); - listener_batch_read_callback(connection->forwarder, NULL, fd, address_pair_get_local(&connection->pair), &data->bb); -} DECLARE_CONNECTION(udp); diff --git a/hicn-light/src/hicn/strategies/low_latency.h b/hicn-light/src/hicn/strategies/low_latency.h index 4745c4c47..ff8255eae 100644 --- a/hicn-light/src/hicn/strategies/low_latency.h +++ b/hicn-light/src/hicn/strategies/low_latency.h @@ -22,6 +22,8 @@ #define MAX_FWD_STRATEGY_RELATED_PREFIXES 10 +struct name_s; + typedef struct { } strategy_low_latency_nexthop_state_t; @@ -30,7 +32,7 @@ typedef struct { typedef struct { //Name ** related_prefixes; - Name *related_prefixes[MAX_FWD_STRATEGY_RELATED_PREFIXES]; + struct name_s * related_prefixes[MAX_FWD_STRATEGY_RELATED_PREFIXES]; unsigned related_prefixes_len; } strategy_low_latency_options_t; |