Merge pull request #5 from project-rig/add-source-field

Add `source' field to routing table entries

Author: mundya

desktop/mtrie.c

@@ -71,6 +71,7 @@ int main(int argc, char *argv[])
       table.entries[i].keymask.key = t.key;
       table.entries[i].keymask.mask = t.mask;
       table.entries[i].route = t.route;
+      table.entries[i].source = t.source;
     }
 
     // Perform the minimisation
@@ -88,7 +89,7 @@ int main(int argc, char *argv[])
         // Copy relevant fields across
         table.entries[i].keymask.key,
         table.entries[i].keymask.mask,
-        0x0,  // No source
+        table.entries[i].source,
         table.entries[i].route,
       };
       fwrite(&t, sizeof(fentry_t), 1, out_file);

desktop/ordered_covering.c

@@ -121,6 +121,7 @@ int main(int argc, char *argv[])
       table.entries[i].keymask.key = t.key;
       table.entries[i].keymask.mask = t.mask;
       table.entries[i].route = t.route;
+      table.entries[i].source = t.source;
     }
 
     // Sort the table
@@ -141,7 +142,7 @@ int main(int argc, char *argv[])
         // Copy relevant fields across
         table.entries[i].keymask.key,
         table.entries[i].keymask.mask,
-        0x0,  // No source
+        table.entries[i].source,
         table.entries[i].route,
       };
       fwrite(&t, sizeof(fentry_t), 1, out_file);

include/aliases.h

@@ -12,13 +12,20 @@
 /* Vector-like object ********************************************************/
 
 
+typedef struct _alias_element_t  // Element of an alias list
+{
+  keymask_t keymask;  // Keymask of the element
+  uint32_t source;    // Source of packets matching the element
+} alias_element_t;
+
+
 typedef struct _alias_list_t
 {
   // Linked list of arrays
   unsigned int n_elements;     // Elements in this instance
   unsigned int max_size;       // Max number of elements in this instance
   struct _alias_list_t *next;  // Next element in list of lists
-  keymask_t data;              // Data region
+  alias_element_t data;        // Data region
 } alias_list_t;
 
 
@@ -27,7 +34,7 @@ static inline alias_list_t* alias_list_new(unsigned int max_size)
 {
   // Compute how much memory to allocate
   unsigned int size = sizeof(alias_list_t) +
-                      (max_size - 1)*sizeof(keymask_t);
+                      (max_size - 1)*sizeof(alias_element_t);
 
   // Allocate and then fill in values
   alias_list_t *as = MALLOC(size);
@@ -40,11 +47,14 @@ static inline alias_list_t* alias_list_new(unsigned int max_size)
 
 
 // Append an element to a list
-static inline bool alias_list_append(alias_list_t *as, keymask_t val)
+static inline bool alias_list_append(alias_list_t *as,
+                                     keymask_t val,
+                                     uint32_t source)
 {
   if (as->n_elements < as->max_size)
   {
-    (&as->data)[as->n_elements] = val;
+    (&as->data)[as->n_elements].keymask = val;
+    (&as->data)[as->n_elements].source = source;
     as->n_elements++;
 
     return true;
@@ -58,7 +68,7 @@ static inline bool alias_list_append(alias_list_t *as, keymask_t val)
 
 
 // Get an element from the list
-static inline keymask_t alias_list_get(alias_list_t *as, unsigned int i)
+static inline alias_element_t alias_list_get(alias_list_t *as, unsigned int i)
 {
   return (&as->data)[i];
 }

include/merge.h

@@ -10,6 +10,7 @@ typedef struct _merge_t
 
   keymask_t keymask; // Keymask resulting from the merge
   uint32_t route;    // Route taken by entries in the merge
+  uint32_t source;   // Collective source of entries in the route
 } merge_t;
 
 
@@ -23,6 +24,7 @@ static inline void merge_clear(merge_t* m)
   m->keymask.key  = 0xffffffff;  // !!!...
   m->keymask.mask = 0x00000000;  // Matches nothing
   m->route = 0x0;
+  m->source = 0x0;
 }
 
 
@@ -76,6 +78,7 @@ static inline void merge_add(merge_t* m, unsigned int i)
 
     // Add the route
     m->route |= e.route;
+    m->source |= e.source;
   }
 }
 
@@ -95,6 +98,7 @@ static inline void merge_remove(merge_t* m, unsigned int i)
   {
     // Rebuild the key and mask from scratch
     m->route = 0x0;
+    m->source = 0x0;
     m->keymask.key  = 0xffffffff;
     m->keymask.mask = 0x000000000;
     for (unsigned int j = 0; j < m->table->size; j++)
@@ -104,6 +108,7 @@ static inline void merge_remove(merge_t* m, unsigned int i)
       if (bitset_contains(&(m->entries), j))
       {
         m->route |= e.route;
+        m->source |= e.source;
         if (m->keymask.key  == 0xffffffff && m->keymask.mask == 0x00000000)
         {
           // Initialise the keymask

include/mtrie.h

@@ -6,12 +6,20 @@
 
 #ifndef __MTRIE_H__
 
+// Short routing table entry resulting from an m-trie
+typedef struct _mtrie_entry_t
+{
+  keymask_t keymask;  // Keymask of the entry
+  uint32_t source;    // Sources of packets in the entry
+} mtrie_entry_t;
+
 // m-Trie structure
 typedef struct _mtrie_node_t
 {
   struct _mtrie_node_t *parent;  // Our parent
   uint32_t bit;  // Bit represented by this Node
   struct _mtrie_node_t *child_0, *child_1, *child_X;  // Children of this Node
+  uint32_t source;  // Source(s) of packets which "reach" this node
 } mtrie_t;
 
 // Create a new (empty) node
@@ -23,6 +31,7 @@ static inline mtrie_t *mtrie_new_node(mtrie_t *parent, uint32_t bit)
   node->parent = parent;
   node->bit = bit;
   node->child_0 = node->child_1 = node->child_X = NULL;
+  node->source = 0x0;
 
   return node;
 }
@@ -69,8 +78,8 @@ static inline unsigned int mtrie_count(mtrie_t *node)
 }
 
 // Extract routing table entries from a trie
-static inline keymask_t* _get_entries(
-  mtrie_t *node, keymask_t *table, uint32_t pkey, uint32_t pmask
+static inline mtrie_entry_t* _get_entries(
+  mtrie_t *node, mtrie_entry_t *table, uint32_t pkey, uint32_t pmask
 )
 {
   if (node == NULL)
@@ -81,8 +90,9 @@ static inline keymask_t* _get_entries(
   {
     // If this is a leaf then add an entry to the table representing this entry
     // and return a pointer to the next entry in the table.
-    table->key = pkey;
-    table->mask = pmask;
+    table->keymask.key = pkey;
+    table->keymask.mask = pmask;
+    table->source = node->source;
 
     // Point to the next table entry
     table++;
@@ -99,7 +109,7 @@ static inline keymask_t* _get_entries(
   return table;
 }
 
-static inline void mtrie_get_entries(mtrie_t *node, keymask_t *table)
+static inline void mtrie_get_entries(mtrie_t *node, mtrie_entry_t *table)
 {
   _get_entries(node, table, 0x0, 0x0);
 }
@@ -132,7 +142,7 @@ static inline mtrie_t** get_child(mtrie_t *node, uint32_t key, uint32_t mask)
 }
 
 // Traverse a path through the tree, adding elements as necessary
-static inline mtrie_t* mtrie_traverse(mtrie_t *node, uint32_t key, uint32_t mask)
+static inline mtrie_t* mtrie_traverse(mtrie_t *node, uint32_t key, uint32_t mask, uint32_t source)
 {
   if (node->bit)  // If not a leaf
   {
@@ -152,11 +162,12 @@ static inline mtrie_t* mtrie_traverse(mtrie_t *node, uint32_t key, uint32_t mask
     }
 
     // Delegate the traversal to the child
-    return mtrie_traverse(*child, key, mask);
+    return mtrie_traverse(*child, key, mask, source);
   }
   else
   {
-    // If we are a leaf then return our parent
+    // If we are a leaf then update our source and return our parent
+    node->source |= source;
     return node->parent;
   }
 }
@@ -220,6 +231,59 @@ static inline bool mtrie_untraverse(mtrie_t *node, uint32_t key, uint32_t mask)
   }
 }
 
+static inline uint32_t get_source_from_child(mtrie_t *node,
+                                             uint32_t key,
+                                             uint32_t mask)
+{
+  if (node->bit)  // If not a leaf
+  {
+    // See where to turn at this node
+    mtrie_t **child = get_child(node, key, mask);
+
+    // If there is no child then the path does not exist or the given path was
+    // invalid.
+    if (!child || !*child)
+    {
+      return false;
+    }
+
+    // Delegate the traversal to the child
+    return get_source_from_child(*child, key, mask);
+  }
+  else
+  {
+    // If we are a leaf then return the source
+    return node->source;
+  }
+}
+
+static inline void add_source_to_child(mtrie_t *node,
+                                       uint32_t key,
+                                       uint32_t mask,
+                                       uint32_t source)
+{
+  if (node->bit)  // If not a leaf
+  {
+    // See where to turn at this node
+    mtrie_t **child = get_child(node, key, mask);
+
+    // If there is no child then the path does not exist or the given path was
+    // invalid.
+    if (!child || !*child)
+    {
+      return;
+    }
+
+    // Delegate the traversal to the child
+    add_source_to_child(*child, key, mask, source);
+  }
+  else
+  {
+    // If we are a leaf then modify the source
+    node->source |= source;
+  }
+}
+
 static inline void untraverse_in_child(mtrie_t **child, uint32_t key, uint32_t mask)
 {
   if (mtrie_untraverse(*child, key, mask))
@@ -229,10 +293,13 @@ static inline void untraverse_in_child(mtrie_t **child, uint32_t key, uint32_t m
 }
 
 // Insert a new entry into the trie
-static inline void mtrie_insert(mtrie_t *root, uint32_t key, uint32_t mask)
+static inline void mtrie_insert(mtrie_t *root,
+                                uint32_t key,
+                                uint32_t mask,
+                                uint32_t source)
 {
   // Traverse a path through the trie and keep a reference to the leaf we reach
-  mtrie_t *leaf = mtrie_traverse(root, key, mask);
+  mtrie_t *leaf = mtrie_traverse(root, key, mask, source);
 
   // Attempt to find overlapping paths
   while (leaf)
@@ -244,12 +311,16 @@ static inline void mtrie_insert(mtrie_t *root, uint32_t key, uint32_t mask)
     if (*child_0 != NULL && path_exists(*child_0, key, mask) &&
         *child_1 != NULL && path_exists(*child_1, key, mask))
     {
+      // Get the combined sources from the existing children
+      source = get_source_from_child(*child_0, key, mask) |
+               get_source_from_child(*child_1, key, mask);
+
       // Traverse the path in X and then untraverse in 0 and 1
       if (*child_X == NULL)
       {
         *child_X = mtrie_new_node(leaf, leaf->bit >> 1);
       }
-      mtrie_traverse(*child_X, key, mask);
+      mtrie_traverse(*child_X, key, mask, source);
 
       // Untraverse in `0' and `1'
       untraverse_in_child(child_0, key, mask);
@@ -262,19 +333,31 @@ static inline void mtrie_insert(mtrie_t *root, uint32_t key, uint32_t mask)
     else if (*child_X != NULL && path_exists(*child_X, key, mask) &&
              *child_0 != NULL && path_exists(*child_0, key, mask))
     {
+      // Get the source for packets matching the `0'
+      source = get_source_from_child(*child_0, key, mask);
+
       // Untraverse in `0'
       untraverse_in_child(child_0, key, mask);
 
+      // Add the sources to X
+      add_source_to_child(*child_X, key, mask, source);
+
       // Update the key and mask
       key &= ~(leaf->bit);
       mask &= ~(leaf->bit);
     }
     else if (*child_X != NULL && path_exists(*child_X, key, mask) &&
              *child_1 != NULL && path_exists(*child_1, key, mask))
     {
+      // Get the source for packets matching the `1'
+      source = get_source_from_child(*child_1, key, mask);
+
       // Untraverse in `1'
       untraverse_in_child(child_1, key, mask);
 
+      // Add the sources to X
+      add_source_to_child(*child_X, key, mask, source);
+
       // Update the key and mask
       key &= ~(leaf->bit);
       mask &= ~(leaf->bit);
@@ -290,7 +373,7 @@ typedef struct _subtable
 {
   unsigned int n_entries;  // Number of entries in the subtable
   uint32_t route;          // Route of all entries in the subtable
-  keymask_t *entries;      // Entries in the subtable
+  mtrie_entry_t *entries;  // Entries in the subtable
 
   struct _subtable *next;  // Next subtable in the chain
 } subtable_t;
@@ -308,7 +391,7 @@ static inline subtable_t* subtable_new(
 
   // Create a new subtable of the desired size
   *sb = MALLOC(sizeof(subtable_t));
-  (*sb)->entries = MALLOC(sizeof(keymask_t) * size);
+  (*sb)->entries = MALLOC(sizeof(mtrie_entry_t) * size);
   (*sb)->n_entries = size;
   (*sb)->route = route;
   (*sb)->next = NULL;
@@ -329,8 +412,9 @@ static inline void subtable_expand(subtable_t *sb, table_t *table)
     // Expand the current subtable
     for (unsigned int i = 0; i < sb->n_entries; i++)
     {
-      next->keymask.key = sb->entries[i].key;
-      next->keymask.mask = sb->entries[i].mask;
+      next->keymask.key = sb->entries[i].keymask.key;
+      next->keymask.mask = sb->entries[i].keymask.mask;
+      next->source = sb->entries[i].source;
       next->route = sb->route;
 
       next++;
@@ -401,7 +485,8 @@ static inline void mtrie_minimise(table_t *table)
         // Add to the trie
         uint32_t key = table->entries[j].keymask.key;
         uint32_t mask = table->entries[j].keymask.mask;
-        mtrie_insert(trie, key, mask);
+        uint32_t source = table->entries[j].source;
+        mtrie_insert(trie, key, mask, source);
       }
     }