libnet: libnet now uses queue creation library
authorRoni Häcki <roni.haecki@inf.ethz.ch>
Mon, 14 Aug 2017 07:46:12 +0000 (09:46 +0200)
committerRoni Häcki <roni.haecki@inf.ethz.ch>
Mon, 14 Aug 2017 07:46:12 +0000 (09:46 +0200)
Signed-off-by: Roni Häcki <roni.haecki@inf.ethz.ch>

lib/net/net.c
lib/net/net_queue.c
lib/net/net_queue_internal.h [new file with mode: 0644]

index 8eb6af0..345f9e9 100644 (file)
@@ -27,6 +27,7 @@
 #include <net/net_filter.h>
 #include <net_interfaces/flags.h>
 #include "networking_internal.h"
+#include "net_queue_internal.h"
 
 struct net_state state = {0};
 struct waitset_chanstate net_loopback_poll_channel;
@@ -97,116 +98,6 @@ void net_lwip_timeout(void)
     }
 }
 
-static errval_t create_loopback_queue (struct net_state *st, uint64_t* queueid,
-                                       struct devq **retqueue)
-{
-    errval_t err;
-
-    debug_printf("net: creating loopback queue.\n");
-
-    *queueid = 0;
-    err = loopback_queue_create((struct loopback_queue **)retqueue);
-    if (err_is_fail(err)) {
-        return err;
-    }
-
-    return SYS_ERR_OK;
-}
-
-static errval_t create_driver_queue (struct net_state *st, uint64_t* queueid,
-                                     struct devq **retqueue)
-{
-    *queueid = 0;
-    return SYS_ERR_OK;
-}
-
-// cardname - "e1000:vendor:deviceid:bus:device:function"
-static errval_t create_e1000_queue(struct net_state *st, uint64_t *queueid,
-                                   struct devq **retqueue)
-{
-    if (st->cardname[5] != ':') {
-        return SYS_ERR_OK;
-    }
-    uint32_t vendor, deviceid, bus, device, function;
-    unsigned parsed = sscanf(st->cardname + 6, "%x:%x:%x:%x:%x", &vendor,
-                             &deviceid, &bus, &device, &function);
-    if (parsed != 5) {
-        return SYS_ERR_OK;
-    }
-
-    return e1000_queue_create((struct e1000_queue**)retqueue, vendor, deviceid,
-                              bus, device, function, 1, int_handler);
-}
-
-static errval_t create_e10k_queue (struct net_state *st, uint64_t* queueid,
-                                   struct devq **retqueue)
-{
-    errval_t err;
-    err = e10k_queue_create((struct e10k_queue**)retqueue, int_handler,
-                            false /*virtual functions*/,
-                            !(st->flags & NET_FLAGS_POLLING), /* user interrupts*/
-                            (st->flags & NET_FLAGS_DEFAULT_QUEUE));
-    *queueid = e10k_queue_get_id((struct e10k_queue*)*retqueue);
-    return err;
-}
-
-static errval_t create_sfn5122f_queue (struct net_state *st, uint64_t* queueid,
-                                       struct devq **retqueue)
-{
-    errval_t err;
-    err = sfn5122f_queue_create((struct sfn5122f_queue**)retqueue, int_handler,
-                                false /*userlevel network feature*/,
-                                !(st->flags & NET_FLAGS_POLLING) /* user interrupts*/,
-                                (st->flags & NET_FLAGS_DEFAULT_QUEUE));
-    *queueid = sfn5122f_queue_get_id((struct sfn5122f_queue*)*retqueue);
-    return err;
-}
-
-
-typedef errval_t (*queue_create_fn)(struct net_state *, uint64_t*, struct devq **);
-struct networking_card
-{
-    char *cardname;
-    queue_create_fn createfn;
-} networking_cards [] = {
-    { "loopback", create_loopback_queue},
-    { "driver", create_driver_queue},
-    { "e1000", create_e1000_queue},
-    { "e10k", create_e10k_queue},
-    { "sfn5122f", create_sfn5122f_queue},
-    { NULL, NULL}
-};
-
-
-/**
- * @brief creates a queue to the given card and the queueid
- *
- * @param cardname  network card to create the queue for
- * @param queueid   queueid of the network card
- * @param retqueue  returns the pointer to the queue
- *
- * @return SYS_ERR_OK on success, errval on failure
- */
-static errval_t net_create_queue(struct net_state *st, const char *cardname,
-                                 uint64_t* queueid, struct devq **retqueue)
-{
-    debug_printf("net: creating queue for card='%s'...\n",
-                  cardname);
-
-    struct networking_card *nc = networking_cards;
-    while(nc->cardname != NULL) {
-        if (strncmp(cardname, nc->cardname, strlen(nc->cardname)) == 0) {
-            return nc->createfn(st, queueid, retqueue);
-        }
-        nc++;
-    }
-
-    debug_printf("net: ERROR unknown queue. card='%s', queueid=%" PRIu64 "\n",
-                  cardname, *queueid);
-
-    return -1;
-}
-
 /**
  * @brief creates a queue to the given card and the queueid
  *
@@ -220,12 +111,11 @@ errval_t networking_create_queue(const char *cardname, uint64_t* queueid,
                                  struct devq **retqueue)
 {
     struct net_state *st = get_default_net_state();
-
-    return net_create_queue(st, cardname, queueid, retqueue);
+    return net_queue_internal_create(int_handler, cardname, queueid, st->flags & NET_FLAGS_DEFAULT_QUEUE,
+                                     st->flags & NET_FLAGS_POLLING, retqueue); 
 }
 
 
-
 static errval_t networking_poll_st(struct net_state *st)
 {
     event_dispatch_non_block(get_default_waitset());
@@ -236,9 +126,6 @@ static errval_t networking_poll_st(struct net_state *st)
     }
 }
 
-
-
-
 /**
  * @brief initializes the networking library with a given device queue
  *
@@ -385,11 +272,13 @@ static errval_t networking_init_st(struct net_state *st, const char *nic,
     st->flags = flags;
 
     /* create the queue wit the given nic and card name */
-    err = networking_create_queue(st->cardname, &st->queueid, &st->queue);
+    err = networking_create_queue(nic, &st->queueid, &st->queue);
     if (err_is_fail(err)) {
         return err;
     }
 
+    assert(st->queue != NULL);
+
     err = networking_init_with_queue_st(st, st->queue, flags);
     if (err_is_fail(err)) {
        // devq_destroy(st->queue);
index 38e77e4..34d22f5 100644 (file)
 #include <barrelfish/barrelfish.h>
 #include <net/net_queue.h>
 #include "networking_internal.h"
+#include "net_queue_internal.h"
+
+static errval_t create_loopback_queue(const char* cardname, inthandler_t interrupt, uint64_t *queueid,
+                                      bool default_q, bool poll, struct devq **retqueue)
+{
+    errval_t err;
+
+    debug_printf("net: creating loopback queue.\n");
+
+    *queueid = 0;
+    err = loopback_queue_create((struct loopback_queue **)retqueue);
+    if (err_is_fail(err)) {
+        return err;
+    }
+
+    return SYS_ERR_OK;
+}
+
+static errval_t create_driver_queue(const char* cardname, inthandler_t interrupt, uint64_t *queueid,
+                                    bool default_q, bool poll, struct devq **retqueue)
+{
+    *queueid = 0;
+    return SYS_ERR_OK;
+}
 
 // cardname - "e1000:vendor:deviceid:bus:device:function"
-static errval_t create_e1000_queue(char* cardname, inthandler_t interrupt, uint64_t *queueid,
-                                   bool poll, struct devq **retqueue)
+static errval_t create_e1000_queue(const char* cardname, inthandler_t interrupt, uint64_t *queueid,
+                                   bool default_q, bool poll, struct devq **retqueue)
 {
     if (cardname[5] != ':') {
         return SYS_ERR_OK;
@@ -24,42 +48,44 @@ static errval_t create_e1000_queue(char* cardname, inthandler_t interrupt, uint6
     if (parsed != 5) {
         return SYS_ERR_OK;
     }
-
     return e1000_queue_create((struct e1000_queue**)retqueue, vendor, deviceid,
                               bus, device, function, 1, interrupt);
 }
 
-static errval_t create_e10k_queue(char* cardname, inthandler_t interrupt, uint64_t *queueid,
-                                  bool poll, struct devq **retqueue)
+static errval_t create_e10k_queue(const char* cardname, inthandler_t interrupt, uint64_t *queueid,
+                                  bool default_q, bool poll, struct devq **retqueue)
 {
     errval_t err;
     err = e10k_queue_create((struct e10k_queue**)retqueue, interrupt,
                             false /*virtual functions*/,
                             poll, /* user interrupts*/
-                            false);
+                            default_q);
     *queueid = e10k_queue_get_id((struct e10k_queue*)*retqueue);
+    assert(retqueue != NULL);
     return err;
 }
 
-static errval_t create_sfn5122f_queue(char* cardname, inthandler_t interrupt, uint64_t *queueid,
-                                      bool poll, struct devq **retqueue)
+static errval_t create_sfn5122f_queue(const char* cardname, inthandler_t interrupt, uint64_t *queueid,
+                                      bool default_q, bool poll, struct devq **retqueue)
 {
     errval_t err;
     err = sfn5122f_queue_create((struct sfn5122f_queue**)retqueue, interrupt,
                                 false /*userlevel network feature*/,
                                 poll /* user interrupts*/,
-                                false);
+                                default_q);
     *queueid = sfn5122f_queue_get_id((struct sfn5122f_queue*)*retqueue);
     return err;
 }
 
 
-typedef errval_t (*queue_create_fn)(char*, inthandler_t, uint64_t*, bool, struct devq **);
+typedef errval_t (*queue_create_fn)(const char*, inthandler_t, uint64_t*, bool, bool, struct devq **);
 struct networking_card
 {
     char *cardname;
     queue_create_fn createfn;
 } networking_cards [] = {
+    { "loopback", create_loopback_queue},
+    { "driver", create_driver_queue},
     { "e1000", create_e1000_queue},
     { "e10k", create_e10k_queue},
     { "sfn5122f", create_sfn5122f_queue},
@@ -73,18 +99,20 @@ struct networking_card
  * @param interrupt interrupt handler 
  * @param cardname  network card to create the queue for
  * @param queueid   queueid of the network card
+ * @param default_q get the default queue (most of the time queue 0)
  * @param poll      Is the queue polled or are interrupts used
  * @param retqueue  returns the pointer to the queue
  *
  * @return SYS_ERR_OK on success, errval on failure
  */
-errval_t net_queue_create(inthandler_t interrupt, const char *cardname,
-                          uint64_t* queueid, bool poll, struct devq **retqueue)
+errval_t net_queue_internal_create(inthandler_t interrupt, const char *cardname,
+                                   uint64_t* queueid, bool default_q, bool poll, struct devq **retqueue)
 {
     struct networking_card *nc = networking_cards;
     while(nc->cardname != NULL) {
         if (strncmp(cardname, nc->cardname, strlen(nc->cardname)) == 0) {
-            return nc->createfn(nc->cardname, interrupt, queueid, poll, retqueue);
+            return nc->createfn(cardname, interrupt, queueid, default_q, 
+                                poll, retqueue);
         }
         nc++;
     }
@@ -94,3 +122,21 @@ errval_t net_queue_create(inthandler_t interrupt, const char *cardname,
 
     return -1;
 }
+
+
+/**
+ * @brief creates a queue to the given card and the queueid
+ *
+ * @param interrupt interrupt handler 
+ * @param cardname  network card to create the queue for
+ * @param queueid   queueid of the network card
+ * @param poll      Is the queue polled or are interrupts used
+ * @param retqueue  returns the pointer to the queue
+ *
+ * @return SYS_ERR_OK on success, errval on failure
+ */
+errval_t net_queue_create(inthandler_t interrupt, const char *cardname,
+                          uint64_t* queueid, bool poll, struct devq **retqueue)
+{
+    return net_queue_internal_create(interrupt, cardname, queueid, false, poll, retqueue);
+}
diff --git a/lib/net/net_queue_internal.h b/lib/net/net_queue_internal.h
new file mode 100644 (file)
index 0000000..7ea3603
--- /dev/null
@@ -0,0 +1,40 @@
+/**
+ * @brief
+ *  net_queue_internal.h
+ */
+
+/*
+ * Copyright (c) 2017, ETH Zurich.
+ * All rights reserved.
+ *
+ * This file is distributed under the terms in the attached LICENSE file.
+ * If you do not find this file, copies can be found by writing to:
+ * ETH Zurich D-INFK, Universitaetsstrasse 6, CH-8092 Zurich. Attn: Systems Group.
+ */
+
+
+#ifndef LIB_NETQUEUE_INTERNAL_INCLUDE_NETWORKING_H_
+#define LIB_NETQUEUE_INTERNAL_INCLUDE_NETWORKING_H_
+
+#include <errors/errno.h>
+
+struct devq;
+
+typedef void (*inthandler_t)(void*);
+
+/**
+ * @brief creates a queue to the given card
+ *
+ * @param interrupt interrupt handler 
+ * @param cardname  network card to create the queue for
+ * @param queueid   queueid of the network card
+ * @param default_q Request access to default queue (only used by driver)
+ * @param poll      Is the queue polled or are interrupts used
+ * @param retqueue  returns the pointer to the queue
+ *
+ * @return SYS_ERR_OK on success, errval on failure
+ */
+errval_t net_queue_internal_create(inthandler_t interrupt, const char *cardname,
+                                   uint64_t* queueid, bool default_q, bool poll, 
+                                   struct devq **retqueue);
+#endif /* LIB_NETQUEUE_INTERNAL_INCLUDE_NETWORKING_H_ */