lib, ipcpd: Add hashtable and PDU Forwarding Function

This adds a hash table that takes 64-bit integers as key and uses
separate chaining on collision. It also adds the PDU Forwarding
Function, which the Flow Manager can use to lookup the fd towards the
next hop. Routing policies will add/update/remove entries in the PFF.

7 files changed, 530 insertions, 0 deletions

diff --git a/src/ipcpd/normal/CMakeLists.txt b/src/ipcpd/normal/CMakeLists.txt
index e61c226d..67a7953b 100644
--- a/src/ipcpd/normal/CMakeLists.txt
+++ b/src/ipcpd/normal/CMakeLists.txt
@@ -32,6 +32,7 @@ set(SOURCE_FILES
   frct.c
   main.c
   path.c
+  pff.c
   ribmgr.c
   shm_pci.c
   # Add policies last
diff --git a/src/ipcpd/normal/pff.c b/src/ipcpd/normal/pff.c
new file mode 100644
index 00000000..99774ece
--- /dev/null
+++ b/src/ipcpd/normal/pff.c
@@ -0,0 +1,151 @@
+/*
+ * Ouroboros - Copyright (C) 2016
+ *
+ * PDU Forwarding Function
+ *
+ *    Sander Vrijders <[email protected]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#define OUROBOROS_PREFIX "pff"
+
+#include <ouroboros/config.h>
+#include <ouroboros/logs.h>
+#include <ouroboros/hashtable.h>
+#include <ouroboros/errno.h>
+
+#include <assert.h>
+#include <pthread.h>
+
+#include "pff.h"
+
+struct pff {
+        struct htable * table;
+        pthread_mutex_t lock;
+};
+
+struct pff * pff_create(void)
+{
+        struct pff * tmp;
+
+        tmp = malloc(sizeof(*tmp));
+        if (tmp == NULL)
+                return NULL;
+
+        tmp->table = htable_create(PFT_SIZE, false);
+        if (tmp->table == NULL) {
+                free(tmp);
+                return NULL;
+        }
+
+        pthread_mutex_init(&tmp->lock, NULL);
+
+        return tmp;
+}
+
+int pff_destroy(struct pff * instance)
+{
+        assert(instance);
+
+        htable_destroy(instance->table);
+        pthread_mutex_destroy(&instance->lock);
+        free(instance);
+
+        return 0;
+}
+
+int pff_add(struct pff * instance, uint64_t addr, int fd)
+{
+        int * val;
+
+        assert(instance);
+
+        val = malloc(sizeof(*val));
+        if (val == NULL)
+                return -ENOMEM;
+        *val = fd;
+
+        pthread_mutex_lock(&instance->lock);
+        if (htable_insert(instance->table, addr, val)) {
+                pthread_mutex_unlock(&instance->lock);
+                free(val);
+                return -1;
+        }
+        pthread_mutex_unlock(&instance->lock);
+
+        return 0;
+}
+
+int pff_update(struct pff * instance, uint64_t addr, int fd)
+{
+        int * val;
+
+        assert(instance);
+
+        val = malloc(sizeof(*val));
+        if (val == NULL)
+                return -ENOMEM;
+        *val = fd;
+
+        pthread_mutex_lock(&instance->lock);
+        if (htable_delete(instance->table, addr)) {
+                pthread_mutex_unlock(&instance->lock);
+                free(val);
+                return -1;
+        }
+
+        if (htable_insert(instance->table, addr, val)) {
+                pthread_mutex_unlock(&instance->lock);
+                free(val);
+                return -1;
+        }
+        pthread_mutex_unlock(&instance->lock);
+
+        return 0;
+}
+
+int pff_remove(struct pff * instance, uint64_t addr)
+{
+        assert(instance);
+
+        pthread_mutex_lock(&instance->lock);
+        if (htable_delete(instance->table, addr)) {
+                pthread_mutex_unlock(&instance->lock);
+                return -1;
+        }
+        pthread_mutex_unlock(&instance->lock);
+
+        return 0;
+}
+
+int pff_nhop(struct pff * instance, uint64_t addr)
+{
+        int * j;
+        int   fd;
+
+        assert(instance);
+
+        pthread_mutex_lock(&instance->lock);
+        j = (int *) htable_lookup(instance->table, addr);
+        if (j == NULL) {
+                pthread_mutex_unlock(&instance->lock);
+                return -1;
+        }
+        fd = *j;
+        pthread_mutex_unlock(&instance->lock);
+
+        return fd;
+}
diff --git a/src/ipcpd/normal/pff.h b/src/ipcpd/normal/pff.h
new file mode 100644
index 00000000..b9ea1971
--- /dev/null
+++ b/src/ipcpd/normal/pff.h
@@ -0,0 +1,55 @@
+/*
+ * Ouroboros - Copyright (C) 2016
+ *
+ * PDU Forwarding Function
+ *
+ *    Sander Vrijders   <[email protected]>
+ *    Dimitri Staessens <[email protected]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef OUROBOROS_IPCPD_NORMAL_PFF_H
+#define OUROBOROS_IPCPD_NORMAL_PFF_H
+
+#include <stdint.h>
+
+struct pff;
+
+/*
+ * PFF will take a type in the future,
+ * to allow different policies.
+ * Only 1 fd per next hop for now.
+ */
+struct pff * pff_create(void);
+
+int          pff_destroy(struct pff * instance);
+
+int          pff_add(struct pff * instance,
+                     uint64_t     addr,
+                     int          fd);
+
+int          pff_update(struct pff * instance,
+                        uint64_t     addr,
+                        int          fd);
+
+int          pff_remove(struct pff * instance,
+                        uint64_t     addr);
+
+/* Returns fd towards next hop */
+int          pff_nhop(struct pff * instance,
+                      uint64_t     addr);
+
+#endif /* OUROBOROS_IPCPD_NORMAL_PFF_H */
diff --git a/src/lib/CMakeLists.txt b/src/lib/CMakeLists.txt
index 20ea473d..9eaca9fd 100644
--- a/src/lib/CMakeLists.txt
+++ b/src/lib/CMakeLists.txt
@@ -30,6 +30,7 @@ set(SOURCE_FILES
   bitmap.c
   cdap.c
   dev.c
+  hashtable.c
   irm.c
   list.c
   lockfile.c
diff --git a/src/lib/hashtable.c b/src/lib/hashtable.c
new file mode 100644
index 00000000..cc73d6a0
--- /dev/null
+++ b/src/lib/hashtable.c
@@ -0,0 +1,188 @@
+/*
+ * Ouroboros - Copyright (C) 2016
+ *
+ * Hash table with separate chaining on collisions
+ *
+ *    Sander Vrijders <[email protected]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <ouroboros/config.h>
+#include <ouroboros/hashtable.h>
+#include <ouroboros/list.h>
+#include <ouroboros/errno.h>
+
+#include <assert.h>
+
+struct htable_entry {
+        struct list_head next;
+        uint64_t         key;
+        void *           val;
+};
+
+struct htable {
+        struct list_head * buckets;
+        bool               hash_key;
+        uint64_t           buckets_size;
+};
+
+struct htable * htable_create(uint64_t buckets, bool hash_key)
+{
+        struct htable * tmp;
+        unsigned int i;
+
+        if (buckets == 0)
+                return NULL;
+
+        buckets--;
+        buckets |= buckets >> 1;
+        buckets |= buckets >> 2;
+        buckets |= buckets >> 4;
+        buckets |= buckets >> 8;
+        buckets |= buckets >> 16;
+        buckets |= buckets >> 32;
+        buckets++;
+
+        tmp = malloc(sizeof(*tmp));
+        if (tmp == NULL)
+                return NULL;
+
+        tmp->hash_key = hash_key;
+        tmp->buckets_size = buckets;
+
+        tmp->buckets = malloc(buckets * sizeof(*tmp->buckets));
+        if (tmp->buckets == NULL) {
+                free(tmp);
+                return NULL;
+        }
+
+        for (i = 0; i < buckets; i++)
+                INIT_LIST_HEAD(&(tmp->buckets[i]));
+
+        return tmp;
+}
+
+int htable_destroy(struct htable * table)
+{
+        unsigned int          i;
+        struct list_head *    pos = NULL;
+        struct list_head *    n = NULL;
+        struct htable_entry * entry;
+
+        assert(table);
+
+        for (i = 0; i < table->buckets_size; i++) {
+                list_for_each_safe(pos, n, &(table->buckets[i])) {
+                        entry = list_entry(pos, struct htable_entry, next);
+                        free(entry->val);
+                        free(entry);
+                }
+        }
+
+        free(table->buckets);
+        free(table);
+
+        return 0;
+}
+
+static uint64_t hash(uint64_t x)
+{
+        x = (x ^ (x >> 30)) * UINT64_C(0xbf58476d1ce4e5b9);
+        x = (x ^ (x >> 27)) * UINT64_C(0x94d049bb133111eb);
+        x = x ^ (x >> 31);
+
+        return x;
+}
+
+static uint64_t calc_key(struct htable * table, uint64_t key)
+{
+        if (table->hash_key == true)
+                key = hash(key);
+
+        return (key & (table->buckets_size - 1));
+}
+
+int htable_insert(struct htable * table, uint64_t key, void * val)
+{
+        struct htable_entry * entry;
+        uint64_t              lookup_key;
+        struct list_head *    pos = NULL;
+
+        assert(table);
+
+        lookup_key = calc_key(table, key);
+
+        list_for_each(pos, &(table->buckets[lookup_key])) {
+                entry = list_entry(pos, struct htable_entry, next);
+                if (entry->key == key)
+                        return -1;
+        }
+
+        entry = malloc(sizeof(*entry));
+        if (entry == NULL)
+                return -ENOMEM;
+
+        entry->key = key;
+        entry->val = val;
+        INIT_LIST_HEAD(&entry->next);
+
+        list_add(&entry->next, &(table->buckets[lookup_key]));
+
+        return 0;
+}
+
+void * htable_lookup(struct htable * table, uint64_t key)
+{
+        struct htable_entry * entry;
+        struct list_head *    pos = NULL;
+        uint64_t              lookup_key;
+
+        assert(table);
+
+        lookup_key = calc_key(table, key);
+
+        list_for_each(pos, &(table->buckets[lookup_key])) {
+                entry = list_entry(pos, struct htable_entry, next);
+                if (entry->key == key)
+                        return entry->val;
+        }
+
+        return NULL;
+}
+
+int htable_delete(struct htable * table, uint64_t key)
+{
+        struct htable_entry * entry;
+        uint64_t              lookup_key;
+        struct list_head *    pos = NULL;
+        struct list_head *    n = NULL;
+
+        assert(table);
+
+        lookup_key = calc_key(table, key);
+
+        list_for_each_safe(pos, n, &(table->buckets[lookup_key])) {
+                entry = list_entry(pos, struct htable_entry, next);
+                if (entry->key == key) {
+                        list_del(&entry->next);
+                        free(entry->val);
+                        free(entry);
+                        return 0;
+                }
+        }
+
+        return -1;
+}
diff --git a/src/lib/tests/CMakeLists.txt b/src/lib/tests/CMakeLists.txt
index 2135cb95..64671934 100644
--- a/src/lib/tests/CMakeLists.txt
+++ b/src/lib/tests/CMakeLists.txt
@@ -4,6 +4,7 @@ get_filename_component(PARENT_DIR ${PARENT_PATH} NAME)
 create_test_sourcelist(${PARENT_DIR}_tests test_suite.c
                        # Add new tests here
                        bitmap_test.c
+                       hashtable_test.c
 )
 
 add_executable(${PARENT_DIR}_test EXCLUDE_FROM_ALL ${${PARENT_DIR}_tests})
diff --git a/src/lib/tests/hashtable_test.c b/src/lib/tests/hashtable_test.c
new file mode 100644
index 00000000..07070472
--- /dev/null
+++ b/src/lib/tests/hashtable_test.c
@@ -0,0 +1,133 @@
+/*
+ * Ouroboros - Copyright (C) 2016
+ *
+ * Test of the hash table
+ *
+ *    Sander Vrijders <[email protected]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include "hashtable.c"
+
+#include <stdio.h>
+
+#define HASHTABLE_SIZE 256
+#define INT_TEST 4
+
+int hashtable_test(int argc, char ** argv)
+{
+        struct htable * table;
+        int i;
+        int * j;
+
+        (void) argc;
+        (void) argv;
+
+        table = htable_create(HASHTABLE_SIZE, true);
+        if (table == NULL) {
+                printf("Failed to create.\n");
+                return -1;
+        }
+
+        if (htable_destroy(table)) {
+                printf("Failed to destroy.\n");
+                return -1;
+        }
+
+        table = htable_create(HASHTABLE_SIZE, false);
+        if (table == NULL) {
+                printf("Failed to create.\n");
+                return -1;
+        }
+
+        for (i = 0; i < HASHTABLE_SIZE + INT_TEST + 2; i++) {
+                j = malloc(sizeof(*j));
+                if (j == NULL) {
+                        printf("Failed to malloc.\n");
+                        htable_destroy(table);
+                        return -1;
+                }
+                *j = i;
+
+                if (htable_insert(table, i, (void *) j)) {
+                        printf("Failed to insert.\n");
+                        htable_destroy(table);
+                        return -1;
+                }
+        }
+
+        j = (int *) htable_lookup(table, INT_TEST);
+        if (j == NULL) {
+                printf("Failed to lookup.\n");
+                htable_destroy(table);
+                return -1;
+        }
+
+        if (*j != INT_TEST) {
+                printf("Lookup returned wrong value (%d != %d).\n",
+                       INT_TEST, *j);
+                htable_destroy(table);
+                return -1;
+        }
+
+        j = (int *) htable_lookup(table, HASHTABLE_SIZE + INT_TEST);
+        if (j == NULL) {
+                printf("Failed to lookup.\n");
+                htable_destroy(table);
+                return -1;
+        }
+
+        if (*j != HASHTABLE_SIZE + INT_TEST) {
+                printf("Lookup returned wrong value (%d != %d).\n",
+                       INT_TEST, *j);
+                htable_destroy(table);
+                return -1;
+        }
+
+        if (htable_delete(table, INT_TEST)) {
+                printf("Failed to delete.\n");
+                htable_destroy(table);
+                return -1;
+        }
+
+        j = (int *) htable_lookup(table, INT_TEST);
+        if (j != NULL) {
+                printf("Failed to delete properly.\n");
+                htable_destroy(table);
+                return -1;
+        }
+
+        j = (int *) htable_lookup(table, HASHTABLE_SIZE + INT_TEST);
+        if (j == NULL) {
+                printf("Failed to lookup after deletion.\n");
+                htable_destroy(table);
+                return -1;
+        }
+
+        if (*j != HASHTABLE_SIZE + INT_TEST) {
+                printf("Lookup returned wrong value (%d != %d).\n",
+                       INT_TEST, *j);
+                htable_destroy(table);
+                return -1;
+        }
+
+        if (htable_destroy(table)) {
+                printf("Failed to destroy.\n");
+                return -1;
+        }
+
+        return 0;
+}