//errors in Filter management
errors filter NET_FILTER_ERR_ {
+ failure NOT_INITIALIZED "Filter subsystem not yet initalized",
failure NOT_FOUND "Filter not found or not installed",
failure ALREADY_EXISTS "Filter already installed",
};
errval_t e10k_queue_create(struct e10k_queue** q, e10k_event_cb_t cb,
bool use_vf, bool interrupts);
errval_t e10k_queue_destroy(struct e10k_queue* q);
+
+uint64_t e10k_queue_get_id(struct e10k_queue* q);
#endif
errval_t sfn5122f_queue_create(struct sfn5122f_queue** q, sfn5122f_event_cb_t cb,
bool userspace, bool interrupts, bool default_q);
errval_t sfn5122f_queue_destroy(struct sfn5122f_queue* q);
+
+uint64_t sfn5122f_queue_get_id(struct sfn5122f_queue* q);
#endif
struct devq;
struct eth_addr;
-
/*
* ==============================================================================
* Networking Flags
///< the default network interface
#define NET_DEFAULT_NIC NULL
-
/*
* ==============================================================================
* Library Initialization
*
* @return SYS_ERR_OK on success, errval on failure
*/
-errval_t networking_create_queue(const char *cardname, uint64_t queueid,
+errval_t networking_create_queue(const char *cardname, uint64_t* queueid,
struct devq **retqueue);
/**
*/
errval_t networking_get_defaults(uint64_t *queue, const char **cardname, uint32_t *flags);
+/*
+ * ==============================================================================
+ * Installing filters
+ * ==============================================================================
+ */
+
+/**
+ * @brief Install L3/L4 filter
+ *
+ * @param tcp should TCP packets be filtered or UPD
+ * @param src_ip source ip of the filter, 0 for wildcard
+ * @param src_port source port of the filter, 0 for wildcard
+ * @param dst_port destination port fo the filter
+ *
+ * @return SYS_ERR_OK on success, NET_FILTER_ERR_* on failure
+ */
+errval_t networking_install_ip_filter(bool tcp, ip_addr_t* src,
+ uint16_t src_port, uint16_t dst_port);
+
+/**
+ * @brief Remove L3/L4 filter
+ *
+ * @param tcp should TCP packets be filtered or UPD
+ * @param src_ip source ip of the filter, 0 for wildcard
+ * @param src_port source port of the filter, 0 for wildcard
+ * @param dst_port destination port fo the filter
+ *
+ * @return SYS_ERR_OK on success, NET_FILTER_ERR_* on failure
+ */
+errval_t networking_remove_ip_filter(bool tcp, ip_addr_t* src,
+ uint16_t src_port, uint16_t dst_port);
#endif /* LIB_NET_INCLUDE_NETWORKING_H_ */
return SYS_ERR_OK;
}
+uint64_t e10k_queue_get_id(struct e10k_queue* q)
+{
+ return q->id;
+}
err = sfn5122f_queue_handle_rx_ev_devif(queue, rid, offset, length,
valid_data, valid_length,
flags);
+
DEBUG_QUEUE("RX_EV Q_ID: %d len %ld OK %s \n", queue->id, *valid_length,
err_getstring(err));
*
*/
-errval_t sfn5122f_queue_create(struct sfn5122f_queue** q, sfn5122f_event_cb_t cb,
+errval_t sfn5122f_queue_create(struct sfn5122f_queue** q, sfn5122f_event_cb_t cb,
bool userlevel, bool interrupts, bool qzero)
{
DEBUG_QUEUE("create called \n");
return SYS_ERR_OK;
}
+
+
+uint64_t sfn5122f_queue_get_id(struct sfn5122f_queue* q)
+{
+ return q->id;
+}
}
if (flags & NET_FLAGS_BLOCKING_INIT) {
- printf("waiting for DHCP to complete");
+ printf("waiting for DHCP to complete \n");
while(!dhcpd_has_ip()) {
networking_poll();
if (st->dhcp_ticks > DHCP_TIMEOUT_MSECS / DHCP_FINE_TIMER_MSECS) {
#include <barrelfish/barrelfish.h>
#define NET_FILTER_TCP 0
-#define NET_FILTER_UPD 1
+#define NET_FILTER_UDP 1
#define NET_FILTER_MAC 2
struct net_filter_ip {
uint64_t mac;
};
-errval_t net_filter_init(const char* cardname);
-errval_t net_filter_ip_install(struct net_filter_ip* filt);
-errval_t net_filter_mac_install(struct net_filter_mac* filt);
+struct net_filter_ele {
+ union {
+ struct net_filter_ip ip;
+ struct net_filter_mac mac;
+ } filter;
+ uint64_t filter_id;
+ struct net_filter_ele* next;
+ struct net_filter_ele* prev;
+};
+
+struct filter_list {
+ struct net_filter_ele* start;
+ uint64_t num_ele;
+};
+
+struct net_filter_state {
+ struct filter_list filters_ip;
+ struct filter_list filters_mac;
+ struct net_filter_binding* b;
+ volatile bool bound;
+};
+
+errval_t net_filter_init(struct net_filter_state** st,
+ const char* cardname);
+
+errval_t net_filter_ip_install(struct net_filter_state* st,
+ struct net_filter_ip* filt);
+
+errval_t net_filter_mac_install(struct net_filter_state* st,
+ struct net_filter_mac* filt);
-errval_t net_filter_ip_remove(struct net_filter_ip* filt);
-errval_t net_filter_mac_remove(struct net_filter_mac* filt);
+errval_t net_filter_ip_remove(struct net_filter_state* st,
+ struct net_filter_ip* filt);
+errval_t net_filter_mac_remove(struct net_filter_state* st,
+ struct net_filter_mac* filt);
#endif /* LIB_NET_INCLUDE_NETWORKING_FILTER_H_ */
net_if_poll(&st->netif);
}
-static errval_t create_loopback_queue (struct net_state *st, uint64_t queueid,
+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,
+static errval_t create_driver_queue (struct net_state *st, uint64_t* queueid,
struct devq **retqueue)
{
+ *queueid = 0;
return SYS_ERR_OK;
}
-static errval_t create_e10k_queue (struct net_state *st, uint64_t queueid,
+static errval_t create_e10k_queue (struct net_state *st, uint64_t* queueid,
struct devq **retqueue)
{
return SYS_ERR_OK;
}
-static errval_t create_sfn5122f_queue (struct net_state *st, uint64_t queueid, struct devq **retqueue)
+static errval_t create_sfn5122f_queue (struct net_state *st, uint64_t* queueid,
+ struct devq **retqueue)
{
-
- return sfn5122f_queue_create((struct sfn5122f_queue**)retqueue, int_handler,
+ 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 **);
+typedef errval_t (*queue_create_fn)(struct net_state *, uint64_t*, struct devq **);
struct networking_card
{
char *cardname;
* @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)
+ uint64_t* queueid, struct devq **retqueue)
{
- debug_printf("net: creating queue for card='%s', queueid=%" PRIu64 "...\n",
- cardname, queueid);
+ debug_printf("net: creating queue for card='%s'...\n",
+ cardname);
struct networking_card *nc = networking_cards;
while(nc->cardname != NULL) {
}
debug_printf("net: ERROR unknown queue. card='%s', queueid=%" PRIu64 "\n",
- cardname, queueid);
+ cardname, *queueid);
return -1;
}
*
* @return SYS_ERR_OK on success, errval on failure
*/
-errval_t networking_create_queue(const char *cardname, uint64_t queueid,
+errval_t networking_create_queue(const char *cardname, uint64_t* queueid,
struct devq **retqueue)
{
struct net_state *st = get_default_net_state();
NETDEBUG("initializing hw filter...\n");
- err = net_filter_init(st->cardname);
+ err = net_filter_init(&st->filter, st->cardname);
if (err_is_fail(err)) {
USER_PANIC("Init filter infrastructure failed: %s \n", err_getstring(err));
}
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(st->cardname, &st->queueid, &st->queue);
if (err_is_fail(err)) {
return err;
}
struct net_state *st = &state;
return networking_poll_st(st);
}
+
+
+/**
+ * @brief Install L3/L4 filter
+ *
+ * @param tcp should TCP packets be filtered or UPD
+ * @param src_ip source ip of the filter, 0 for wildcard
+ * @param src_port source port of the filter, 0 for wildcard
+ * @param dst_port destination port fo the filter
+ *
+ * @return SYS_ERR_OK on success, NET_FILTER_ERR_* on failure
+ */
+errval_t networking_install_ip_filter(bool tcp, ip_addr_t* src,
+ uint16_t src_port, uint16_t dst_port)
+{
+ errval_t err;
+ if (state.filter == NULL) {
+ return NET_FILTER_ERR_NOT_INITIALIZED;
+ }
+
+ struct net_filter_state *st = state.filter;
+
+ // get current config
+ ip_addr_t dst_ip;
+ err = dhcpd_get_ipconfig(&dst_ip, NULL, NULL);
+ if (err_is_fail(err)) {
+ return err;
+ }
+
+ struct net_filter_ip ip = {
+ .qid = state.queueid,
+ .ip_src = (uint32_t) src->addr,
+ .ip_dst = (uint32_t) dst_ip.addr,
+ .port_dst = dst_port,
+ .port_src = src_port,
+ };
+
+ if (tcp) {
+ ip.type = NET_FILTER_TCP;
+ } else {
+ ip.type = NET_FILTER_UDP;
+ }
+
+ return net_filter_ip_install(st, &ip);
+}
+
+/**
+ * @brief Remove L3/L4 filter
+ *
+ * @param tcp should TCP packets be filtered or UPD
+ * @param src_ip source ip of the filter, 0 for wildcard
+ * @param src_port source port of the filter, 0 for wildcard
+ * @param dst_port destination port fo the filter
+ *
+ * @return SYS_ERR_OK on success, NET_FILTER_ERR_* on failure
+ */
+errval_t networking_remove_ip_filter(bool tcp, ip_addr_t* src,
+ uint16_t src_port, uint16_t dst_port)
+{
+
+ errval_t err;
+ if (state.filter == NULL) {
+ return NET_FILTER_ERR_NOT_INITIALIZED;
+ }
+
+ struct net_filter_state *st = state.filter;
+
+ // get current config
+ ip_addr_t dst_ip;
+ err = dhcpd_get_ipconfig(&dst_ip, NULL, NULL);
+ if (err_is_fail(err)) {
+ return err;
+ }
+
+ struct net_filter_ip ip = {
+ .qid = state.queueid,
+ .ip_src = (uint32_t) src->addr,
+ .ip_dst = (uint32_t) dst_ip.addr,
+ .port_dst = dst_port,
+ .port_src = src_port,
+ };
+
+ if (tcp) {
+ ip.type = NET_FILTER_TCP;
+ } else {
+ ip.type = NET_FILTER_UDP;
+ }
+
+ return net_filter_ip_remove(st, &ip);
+}
#define NETDEBUG_SUBSYSTEM "filter"
-struct net_filter_ele {
- union {
- struct net_filter_ip ip;
- struct net_filter_mac mac;
- } filter;
- uint64_t filter_id;
- struct net_filter_ele* next;
- struct net_filter_ele* prev;
-};
-
-struct filter_list {
- struct net_filter_ele* start;
- uint64_t num_ele;
-};
-
-struct net_filter_state {
- struct filter_list filters_ip;
- struct filter_list filters_mac;
- struct net_filter_binding* b;
- volatile bool bound;
-};
-
-
-/******************************************************************************
- * Global state
- ******************************************************************************/
-
-static struct net_filter_state filter_state;
-
/******************************************************************************
* Connection setup
******************************************************************************/
// Callback for bind
static void bind_cb(void *st, errval_t err, struct net_filter_binding *b)
{
+ struct net_filter_state* filt = (struct net_filter_state*) st;
assert(err_is_ok(err));
NETDEBUG("Sucessfully connected to management interface\n");
- filter_state.b = b;
- net_filter_rpc_client_init(filter_state.b);
- filter_state.bound = true;
+ filt->b = b;
+ net_filter_rpc_client_init(filt->b);
+ filt->bound = true;
}
/** Open connection to management interface */
-static errval_t connect_to_net_filter(const char *dev_name)
+static errval_t connect_to_net_filter(struct net_filter_state* st,
+ const char *dev_name)
{
errval_t r;
iref_t iref;
}
NETDEBUG("Binding\n");
- r = net_filter_bind(iref, bind_cb, &filter_state, get_default_waitset(),
+ r = net_filter_bind(iref, bind_cb, st, get_default_waitset(),
IDC_BIND_FLAGS_DEFAULT);
if (err_is_fail(r)) {
return r;
}
NETDEBUG("Waiting to bind\n");
- while(filter_state.bound == false) {
+ while(st->bound == false) {
event_dispatch(get_default_waitset());
}
* @brief initalized network filtering. Sets up connection to drivers
* which support hardware filtering
*
- * @param cardname returns the card name to be used
+ * @param st returned net filter state;
+ * @param cardname the card name to be used
*
* @return SYS_ERR_OK on success, error on failure
*/
-errval_t net_filter_init(const char* cardname)
+errval_t net_filter_init(struct net_filter_state** st,
+ const char* cardname)
{
errval_t err;
- filter_state.filters_ip.start = NULL;
- filter_state.filters_ip.num_ele = 0;
- filter_state.filters_mac.start = NULL;
- filter_state.filters_mac.num_ele = 0;
+ struct net_filter_state* tmp = calloc(1, sizeof(struct net_filter_state));
+ assert(tmp != NULL);
+
+ tmp->filters_ip.start = NULL;
+ tmp->filters_ip.num_ele = 0;
+ tmp->filters_mac.start = NULL;
+ tmp->filters_mac.num_ele = 0;
- err = connect_to_net_filter(cardname);
+ err = connect_to_net_filter(tmp, cardname);
+ *st = tmp;
return err;
}
* @brief Installs an L3/L4 filter in the hardware filter
* tables
*
+ * @param st net filter state
* @param filt filter struct
*
* @return SYS_ERR_OK on success, error on failure
*/
-errval_t net_filter_ip_install(struct net_filter_ip* filt)
+errval_t net_filter_ip_install(struct net_filter_state* st,
+ struct net_filter_ip* filt)
{
- assert(filter_state.bound);
+ assert(st->bound);
errval_t err;
uint64_t filter_id;
- struct net_filter_ele* cur = filter_state.filters_ip.start;
+ struct net_filter_ele* cur = st->filters_ip.start;
struct net_filter_ele* prev = NULL;
/* go through linked list and find last element
(and check if filter is already installed) */
if (cur == NULL) {
- filter_state.filters_ip.start = malloc(sizeof(struct net_filter_ele));
- cur = filter_state.filters_ip.start;
+ st->filters_ip.start = malloc(sizeof(struct net_filter_ele));
+ cur = st->filters_ip.start;
} else {
while(cur->next != NULL) {
if (filter_cmp_ip(&cur->filter.ip, filt)) {
cur->next = NULL;
cur->prev = prev;
- filter_state.filters_ip.num_ele++;
+ st->filters_ip.num_ele++;
- err = filter_state.b->rpc_tx_vtbl.install_filter_ip(filter_state.b,
- filt->type,
- filt->qid,
- filt->ip_src,
- filt->ip_dst,
- filt->port_src,
- filt->port_dst,
- &filter_id);
+ err = st->b->rpc_tx_vtbl.install_filter_ip(st->b,
+ filt->type,
+ filt->qid,
+ filt->ip_src,
+ filt->ip_dst,
+ filt->port_src,
+ filt->port_dst,
+ &filter_id);
if (err_is_fail(err)) {
free(cur);
return err;
* @brief Removes an L3/L4 filter in the hardware filter
* tables
*
+ * @param st net filter state
* @param filt filter struct
*
* @return SYS_ERR_OK on success, error on failure
*/
-errval_t net_filter_ip_remove(struct net_filter_ip* filt)
+errval_t net_filter_ip_remove(struct net_filter_state* st,
+ struct net_filter_ip* filt)
{
- assert(filter_state.bound);
+ assert(st->bound);
errval_t err, err2;
uint64_t filter_id = (uint64_t)-1;
- struct net_filter_ele* cur = filter_state.filters_ip.start;
+ struct net_filter_ele* cur = st->filters_ip.start;
struct net_filter_ele* prev = NULL;
while(cur != NULL) {
if (filter_cmp_ip(&cur->filter.ip, filt)) {
filter_id = cur->filter_id;
- printf("Break \n");
break;
}
prev = cur;
return NET_FILTER_ERR_NOT_FOUND;
}
- err = filter_state.b->rpc_tx_vtbl.remove_filter(filter_state.b,
- filt->type,
- filter_id,
- &err2);
+ err = st->b->rpc_tx_vtbl.remove_filter(st->b,
+ filt->type,
+ filter_id,
+ &err2);
if (err_is_fail(err) || err_is_fail(err2)) {
return err_is_fail(err) ? err: err2;
}
prev->next = cur->next;
if (cur->next != NULL) { // check if last
cur->next->prev = prev;
- printf("cur->next->prev id %d \n", cur->next->prev->filter.ip.port_dst);
- printf("prev->next id %d \n", prev->next->filter.ip.port_dst);
}
} else {
- printf("start id %d \n", filter_state.filters_ip.start->filter.ip.port_dst);
- filter_state.filters_ip.start = cur->next;
+ st->filters_ip.start = cur->next;
}
free(cur);
- filter_state.filters_ip.num_ele--;
+ st->filters_ip.num_ele--;
return SYS_ERR_OK;
}
-errval_t net_filter_mac_install(struct net_filter_mac* filt)
+errval_t net_filter_mac_install(struct net_filter_state* st,
+ struct net_filter_mac* filt)
{
USER_PANIC("NYI \n");
}
-errval_t net_filter_mac_remove(struct net_filter_mac* filt)
+errval_t net_filter_mac_remove(struct net_filter_state* st,
+ struct net_filter_mac* filt)
{
USER_PANIC("NYI \n");
}
#include <lwip/netif.h>
+#include <net/net_filter.h>
#include <net/net.h>
#include <net/netbufs.h>
#include <net/netif.h>
struct devq *queue;
struct net_buf_pool *pool;
struct netif netif;
+ struct net_filter_state* filter;
// ip4_addr_t ipaddr, netmask, gw;
};
*/
#include <barrelfish/barrelfish.h>
+#include <barrelfish/deferred.h>
#include <lwip/ip.h>
#include <lwip/udp.h>
errval_t err;
debug_printf("UDP ECHO started.\n");
-
/* connect to the network */
err = networking_init_default();
if (err_is_fail(err)) {
return(r);
}
- struct net_filter_ip ip;
- ip.qid = 1;
- ip.ip_src = 0;
- // TODO 10.110.4.39 get this from somewhere
- ip.ip_dst = 0x2704710A;
- ip.port_dst = 7;
- ip.port_src = 0;
- ip.type = NET_FILTER_UPD;
-
- err = net_filter_ip_install(&ip);
+ err = networking_install_ip_filter(false, (ip_addr_t*) IP_ADDR_ANY,
+ 0, UDP_ECHOSERVER_PORT);
if (err_is_fail(err)) {
USER_PANIC("Adding filter failed %s \n", err_getstring(err));
}
addIncludes = [ "/lib/net/include/", "/lib/lwip-2.0.2/src/include/" ],
addLibraries = libDeps["netQmng", "pci", "contmng",
"net_device_manager", "bench", "trace", "skb",
- "spawndomain", "netd" , "net"]
+ "spawndomain", "netd" , "net", "lwip2"]
}
]
#include <barrelfish/nameservice_client.h>
#include <barrelfish/deferred.h>
#include <barrelfish/debug.h>
-#include <net/net.h>
#include <pci/pci.h>
// TODO only required for htonl
-#include <lwip/ip4_addr.h>
+#include <lwip/ip.h>
+#include <net/net.h>
#include <if/sfn5122f_defs.h>
#include <if/sfn5122f_devif_defs.h>
pci_device = PCI_DONT_CARE;
pci_function = 0;
} else {
- if ((pci_vendor != PCI_VENDOR_SOLARFLARE) || (pci_devid != DEVICE_ID) ||
- (pci_function != 0)) {
+ if ((pci_vendor != PCI_VENDOR_SOLARFLARE) || (pci_devid != DEVICE_ID)) {
printf("VENDOR/DEVICE ID MISMATCH: %x/%x %x/%x \n",
pci_vendor, PCI_VENDOR_SOLARFLARE, pci_devid, DEVICE_ID);
}
projects / barrelfish / commitdiff