ipcpd: Add congestion avoidance policies

This adds congestion avoidance policies to the unicast IPCP.  The
default policy is a multi-bit explicit congestion avoidance algorithm
based on data-center TCP congestion avoidance (DCTCP) to relay
information about the maximum queue depth that packets experienced to
the receiver. There's also a "nop" policy to disable congestion
avoidance for testing and benchmarking purposes.

The (initial) API for congestion avoidance policies is:

        void *   (* ctx_create)(void);

        void     (* ctx_destroy)(void * ctx);

These calls create / and or destroy a context for congestion control
for a specific flow. Thread-safety of the context is the
responsability of the flow allocator (operations on the ctx should be
performed under a lock).

        ca_wnd_t (* ctx_update_snd)(void * ctx,
                                    size_t len);

This is the sender call to update the context, and should be called
for every packet that is sent on the flow. The len parameter in this
API is the packet length, which allows calculating the bandwidth. It
returns an opaque union type that is used for the call to check/wait
if the congestion window is open or closed (and allowing to release
locks before waiting).

        bool     (* ctx_update_rcv)(void *     ctx,
                                    size_t     len,
                                    uint8_t    ecn,
                                    uint16_t * ece);

This is the call to update the flow congestion context on the receiver
side. It should be called for every received packet.  It gets the ecn
value from the packet and its length, and returns the ECE (explicit
congestion experienced) value to be sent to the sender in case of
congestion. The boolean returned signals whether or not a congestion
update needs to be sent.

        void     (* ctx_update_ece)(void *   ctx,
                                    uint16_t ece);

This is the call for the sending side top update the context when it
receives an ECE update from the receiver.

        void     (* wnd_wait)(ca_wnd_t wnd);

This is a (blocking) call that waits for the congestion window to
clear. It should be stateless (to avoid waiting under locks). This may
change later on if passing the context is needed for different algorithms.

        uint8_t  (* calc_ecn)(int    fd,
                              size_t len);

This is the call that intermediate IPCPs(routers) should use to update
the ECN field on passing packets.

The multi-bit ECN policy bases the value for the ECN field on the
depth of the rbuff queue packets will be sent on. I created another
call to grab the queue depth as fccntl is write-locking the
application. We can further optimize this to avoid most locking on the
rbuff.

Signed-off-by: Dimitri Staessens <dimitri@ouroboros.rocks>
Signed-off-by: Sander Vrijders <sander@ouroboros.rocks>

2 files changed, 41 insertions, 33 deletions

diff --git a/include/ouroboros/ipcp-dev.h b/include/ouroboros/ipcp-dev.h
index d60e0b45..b57cec0d 100644
--- a/include/ouroboros/ipcp-dev.h
+++ b/include/ouroboros/ipcp-dev.h
@@ -26,33 +26,35 @@
 #ifndef OUROBOROS_IPCP_DEV_H
 #define OUROBOROS_IPCP_DEV_H
 
-int  ipcp_create_r(int result);
+int   ipcp_create_r(int result);
 
-int  ipcp_flow_req_arr(const uint8_t * dst,
-                       size_t          len,
-                       qosspec_t       qs,
-                       const void *    data,
-                       size_t          dlen);
+int   ipcp_flow_req_arr(const uint8_t * dst,
+                        size_t           len,
+                        qosspec_t        qs,
+                        const void *     data,
+                        size_t           dlen);
 
-int  ipcp_flow_alloc_reply(int          fd,
-                           int          response,
-                           const void * data,
-                           size_t       len);
+int    ipcp_flow_alloc_reply(int        fd,
+                             int          response,
+                             const void * data,
+                             size_t       len);
 
-int  ipcp_flow_read(int                   fd,
-                    struct shm_du_buff ** sdb);
+int    ipcp_flow_read(int                   fd,
+                      struct shm_du_buff ** sdb);
 
-int  ipcp_flow_write(int                  fd,
-                     struct shm_du_buff * sdb);
+int    ipcp_flow_write(int                  fd,
+                       struct shm_du_buff * sdb);
 
-int  ipcp_flow_fini(int fd);
+int    ipcp_flow_fini(int fd);
 
-int  ipcp_flow_get_qoscube(int         fd,
-                           qoscube_t * cube);
+int    ipcp_flow_get_qoscube(int         fd,
+                             qoscube_t * cube);
 
-int  ipcp_sdb_reserve(struct shm_du_buff ** sdb,
-                      size_t                len);
+size_t ipcp_flow_queued(int fd);
 
-void ipcp_sdb_release(struct shm_du_buff * sdb);
+int    ipcp_sdb_reserve(struct shm_du_buff ** sdb,
+                        size_t                len);
+
+void   ipcp_sdb_release(struct shm_du_buff * sdb);
 
 #endif /* OUROBOROS_IPCP_DEV_H */
diff --git a/include/ouroboros/ipcp.h b/include/ouroboros/ipcp.h
index 6494d9b7..86dfd2da 100644
--- a/include/ouroboros/ipcp.h
+++ b/include/ouroboros/ipcp.h
@@ -55,6 +55,11 @@ enum pol_routing {
         ROUTING_LINK_STATE_ECMP
 };
 
+enum pol_cong_avoid {
+        CA_NONE = 0,
+        CA_MB_ECN
+};
+
 enum pol_dir_hash {
         DIR_HASH_SHA3_224 = 0,
         DIR_HASH_SHA3_256,
@@ -70,29 +75,30 @@ struct layer_info {
 
 /* Structure to configure the first IPCP */
 struct ipcp_config {
-        struct layer_info  layer_info;
+        struct layer_info   layer_info;
 
-        enum ipcp_type     type;
+        enum ipcp_type      type;
 
         /* Unicast */
-        uint8_t            addr_size;
-        uint8_t            eid_size;
-        uint8_t            max_ttl;
+        uint8_t             addr_size;
+        uint8_t             eid_size;
+        uint8_t             max_ttl;
 
-        enum pol_addr_auth addr_auth_type;
-        enum pol_routing   routing_type;
+        enum pol_addr_auth  addr_auth_type;
+        enum pol_routing    routing_type;
+        enum pol_cong_avoid cong_avoid;
 
         /* UDP */
-        uint32_t           ip_addr;
-        uint32_t           dns_addr;
-        uint16_t           clt_port;
-        uint16_t           srv_port;
+        uint32_t            ip_addr;
+        uint32_t            dns_addr;
+        uint16_t            clt_port;
+        uint16_t            srv_port;
 
         /* Ethernet */
-        char *             dev;
+        char *              dev;
 
         /* Ethernet DIX */
-        uint16_t           ethertype;
+        uint16_t            ethertype;
 };
 
 #endif /* OUROBOROS_IPCP_H */