stv0g/metalsvm
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

extending the functionality and increasing the compatability of the Socket API

Browse source 
- removing some minor bugs (races)
- increasing the readability
This commit is contained in:
Stefan Lankes 2011-10-19 04:48:16 -07:00
parent 62f2038a6e
commit 5f84a93c01
2 changed files with 158 additions and 173 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

296
drivers/net/mmnif.c
View file

@ -18,29 +18,34 @@
* *
* mmnif.c --- memmory mapped interface * mmnif.c --- memmory mapped interface
* *
* Virutal IP Interface for the concept processor SCC * Virtual IP Interface for the concept processor SCC
* *
*/ */
/*
* 15th October 2011:
* - Redesign of the interrupt handling (by Stefan Lankes)
* - Add iRCCE support (by Stefan Lankes)
* - Extending the BSD socket interface
*/
#include <metalsvm/stddef.h> #include <metalsvm/stddef.h>
#if defined(CONFIG_LWIP) && defined(CONFIG_ROCKCREEK) #if defined(CONFIG_LWIP) && defined(CONFIG_ROCKCREEK)
#include "mmnif.h" /* definitions */
#include <lwip/netif.h> /* lwip netif */ #include <lwip/netif.h> /* lwip netif */
#include <lwip/stats.h> /* inteface stats */ #include <lwip/stats.h> /* inteface stats */
#include <netif/etharp.h> /* ethernet arp packets */ #include <netif/etharp.h> /* ethernet arp packets */
#include <lwip/ip.h> /* struct iphdr */ #include <lwip/ip.h> /* struct iphdr */
#include <lwip/tcpip.h> /* tcpip_input() */ #include <lwip/tcpip.h> /* tcpip_input() */
#include <lwip/sockets.h> #include <lwip/sockets.h>
#include <lwip/ip_addr.h>
//#include <asm/page.h>
#include <metalsvm/mailbox.h> /* mailbox_ptr_t */ #include <metalsvm/mailbox.h> /* mailbox_ptr_t */
#include <metalsvm/semaphore.h> #include <metalsvm/semaphore.h>
#include <metalsvm/spinlock.h> #include <metalsvm/spinlock.h>
#include <metalsvm/page.h> #include <metalsvm/page.h>
#include <metalsvm/time.h>
#include <asm/irq.h> #include <asm/irq.h>
#include <asm/RCCE.h> #include <asm/RCCE.h>
@ -51,7 +56,7 @@
#include <asm/SCC_API.h> #include <asm/SCC_API.h>
#include <asm/scc_memcpy.h> #include <asm/scc_memcpy.h>
#include <metalsvm/time.h> #include <net/mmnif.h>
#define TRUE 1 #define TRUE 1
#define FALSE 0 #define FALSE 0
@ -80,7 +85,7 @@
#define MMNIF_AUTO_SOCKET_TIMEOUT 500 #define MMNIF_AUTO_SOCKET_TIMEOUT 500
#define MMNIF_FAST_SOCKET_BLOCK 1 #define MMNIF_FAST_SOCKET_BLOCK 0
#ifdef DEBUG_MMNIF #ifdef DEBUG_MMNIF
#include "util.h" /* hex dump */ #include "util.h" /* hex dump */
@ -120,11 +125,6 @@
static int npseudosocket = MMNIF_PSEUDO_SOCKET_START; static int npseudosocket = MMNIF_PSEUDO_SOCKET_START;
static spinlock_t pseudolock; static spinlock_t pseudolock;
/* IP address of the local core and the router core to get packets forwarded
*/
static unsigned int own_ip_address = 0xC0A80000; /* 192.168.0.0 */
static unsigned int router_ip_address = 0xC0A80001; /* 192.168.0.1 */
/* "message passing buffer" specific constants: /* "message passing buffer" specific constants:
* - start address * - start address
* - size * - size
@ -152,7 +152,6 @@ typedef struct acceptor {
uint8_t stat; uint8_t stat;
uint8_t src_ip; uint8_t src_ip;
uint16_t port; uint16_t port;
spinlock_t alock;
int nsock; int nsock;
int rsock; int rsock;
} acceptor_t; } acceptor_t;
@ -222,7 +221,6 @@ typedef struct mm_rx_buffer {
*/ */
uint16_t head; uint16_t head;
uint16_t tail; uint16_t tail;
spinlock_t rlock;
/* descritpor queue /* descritpor queue
* desc_table : descriptor table * desc_table : descriptor table
@ -261,10 +259,6 @@ typedef struct mmnif {
mm_rx_buffer_t *rx_buff; mm_rx_buffer_t *rx_buff;
uint8_t *rx_heap; uint8_t *rx_heap;
/* lock to protect members
*/
spinlock_t lock;
/* semaphore to regulate polling vs. interrupts /* semaphore to regulate polling vs. interrupts
*/ */
sem_t com_poll; sem_t com_poll;
@ -343,10 +337,10 @@ inline static int mmnif_trigger_irq(dest_ip)
addr = CRB_ADDR(x, y) + (z == 0 ? GLCFG0 : GLCFG1); addr = CRB_ADDR(x, y) + (z == 0 ? GLCFG0 : GLCFG1);
// send interrupt to ue // send interrupt to ue
do { //do {
NOP1; // NOP1;
tmp = ReadConfigReg(addr); tmp = ReadConfigReg(addr);
} while (tmp & 1); //} while (tmp & 1);
tmp |= 1; tmp |= 1;
SetConfigReg(addr, tmp); SetConfigReg(addr, tmp);
@ -437,35 +431,28 @@ void mmnif_print_driver_status(void)
static uint8_t mmnif_get_destination(struct netif *netif, struct pbuf *p) static uint8_t mmnif_get_destination(struct netif *netif, struct pbuf *p)
{ {
struct ip_hdr *iphdr; struct ip_hdr *iphdr;
ip_addr_p_t ip;
uint8_t core; uint8_t core;
uint8_t *ip4addr;
uint8_t addr[4];
uint32_t netmask = 0xFFFFFF00;
/* grab the destination ip address out of the ip header /* grab the destination ip address out of the ip header
* for internal routing the last ocet is interpreted as core ID. * for internal routing the last ocet is interpreted as core ID.
*/ */
iphdr = (struct ip_hdr *)(p->payload); iphdr = (struct ip_hdr *)(p->payload);
ip4addr = (uint8_t*) &iphdr->dest.addr; ip = iphdr->dest;
/* revert the address to host format */
addr[3] = ip4addr[0];
addr[2] = ip4addr[1];
addr[1] = ip4addr[2];
addr[0] = ip4addr[3];
/* check if the ip address is in the Local Area Network of the 48 cores */ /* check if the ip address is in the Local Area Network of the 48 cores */
/* if it's not the same network the router core is addressed /* if it's not the same network the router core is addressed
* Note: the router core is core 1 * Note: the router core is core 1
*/ */
if (!((netmask & *(uint32_t *) addr) == (netmask & own_ip_address))) if (ip_addr_netcmp(&ip, &netif->ip_addr, &netif->netmask))
return 1; return 1;
core = addr[0]; core = ip4_addr4(&ip);
/* check if the address is legitimata else return router core again */ /* check if the address is legitimata else return router core again */
if ((core) < 1 || (core > MMNIF_CORES)) if ((core) < 1 || (core > MMNIF_CORES))
core = 1; core = 1;
kprintf("core %d\n", (int) core);
return core; return core;
} }
@ -477,7 +464,7 @@ static uint8_t mmnif_get_destination(struct netif *netif, struct pbuf *p)
static uint32_t mmnif_rxbuff_alloc(uint8_t dest, uint16_t len) static uint32_t mmnif_rxbuff_alloc(uint8_t dest, uint16_t len)
{ {
uint32_t ret = 0; uint32_t ret = 0;
mm_rx_buffer_t *rb = (mm_rx_buffer_t *) ((char *)header_start_address + (dest - 1) * header_size); volatile mm_rx_buffer_t *rb = (mm_rx_buffer_t *) ((char *)header_start_address + (dest - 1) * header_size);
#if MMNIF_USE_MPB #if MMNIF_USE_MPB
char* memblock = (char*)heap_start_address + (dest-1)/2*16*1024*1024 + (dest-1)%2 * 0x2000; char* memblock = (char*)heap_start_address + (dest-1)/2*16*1024*1024 + (dest-1)%2 * 0x2000;
@ -492,7 +479,7 @@ static uint32_t mmnif_rxbuff_alloc(uint8_t dest, uint16_t len)
// if ((rb->head - rb->tail < len)&&(rb->tail != rb->head)) // if ((rb->head - rb->tail < len)&&(rb->tail != rb->head))
// return NULL; // return NULL;
RCCE_acquire_lock(dest-1); RCCE_acquire_lock(RC_COREID[dest-1]);
if (rb->dcount) if (rb->dcount)
{ {
if (rb->tail > rb->head) if (rb->tail > rb->head)
@ -542,9 +529,8 @@ static uint32_t mmnif_rxbuff_alloc(uint8_t dest, uint16_t len)
} }
} }
} }
RCCE_release_lock(RC_COREID[dest-1]);
out:
RCCE_release_lock(dest-1);
return ret; return ret;
} }
@ -554,7 +540,7 @@ out:
*/ */
static int mmnif_commit_packet(uint8_t dest, uint32_t addr) static int mmnif_commit_packet(uint8_t dest, uint32_t addr)
{ {
mm_rx_buffer_t *rb = (mm_rx_buffer_t *) ((char *)header_start_address + (dest - 1) * header_size); volatile mm_rx_buffer_t *rb = (mm_rx_buffer_t *) ((char *)header_start_address + (dest - 1) * header_size);
uint32_t i; uint32_t i;
for (i = 0; i < MMNIF_MAX_DESCRIPTORS; i++) for (i = 0; i < MMNIF_MAX_DESCRIPTORS; i++)
@ -564,6 +550,7 @@ static int mmnif_commit_packet(uint8_t dest, uint32_t addr)
{ {
rb->desc_table[i].stat = MMNIF_STATUS_RDY; rb->desc_table[i].stat = MMNIF_STATUS_RDY;
rb->desc_table[i].fast_sock = -1; rb->desc_table[i].fast_sock = -1;
return 0; return 0;
} }
} }
@ -577,7 +564,7 @@ static int mmnif_commit_packet(uint8_t dest, uint32_t addr)
*/ */
static int mmnif_commit_packet_bypass(uint8_t dest, uint32_t addr, int dest_socket) static int mmnif_commit_packet_bypass(uint8_t dest, uint32_t addr, int dest_socket)
{ {
mm_rx_buffer_t* rb = (mm_rx_buffer_t *) ((char *)header_start_address + (dest - 1) * header_size); volatile mm_rx_buffer_t* rb = (mm_rx_buffer_t *) ((char *)header_start_address + (dest - 1) * header_size);
uint32_t i; uint32_t i;
for (i = 0; i < MMNIF_MAX_DESCRIPTORS; i++) for (i = 0; i < MMNIF_MAX_DESCRIPTORS; i++)
@ -600,11 +587,11 @@ static int mmnif_commit_packet_bypass(uint8_t dest, uint32_t addr, int dest_sock
static void mmnif_rxbuff_free(void) static void mmnif_rxbuff_free(void)
{ {
mmnif_t *mmnif = mmnif_dev->state; mmnif_t *mmnif = mmnif_dev->state;
mm_rx_buffer_t *b = mmnif->rx_buff; volatile mm_rx_buffer_t *b = mmnif->rx_buff;
uint32_t i, j; uint32_t i, j;
uint32_t rpos; uint32_t rpos;
RCCE_acquire_lock(RCCE_IAM); RCCE_acquire_lock(RC_MY_COREID);
rpos = b->dread; rpos = b->dread;
for (i = 0, j = rpos; i < MMNIF_MAX_DESCRIPTORS; i++) for (i = 0, j = rpos; i < MMNIF_MAX_DESCRIPTORS; i++)
@ -631,7 +618,7 @@ static void mmnif_rxbuff_free(void)
break; break;
} }
RCCE_release_lock(RCCE_IAM); RCCE_release_lock(RC_MY_COREID);
} }
/* /*
@ -703,6 +690,7 @@ realloc:
LINK_STATS_INC(link.xmit); LINK_STATS_INC(link.xmit);
mmnif->stats.tx++; mmnif->stats.tx++;
mmnif->stats.tx_bytes += p->tot_len; mmnif->stats.tx_bytes += p->tot_len;
mmnif_trigger_irq(dest_ip); mmnif_trigger_irq(dest_ip);
return ERR_OK; return ERR_OK;
@ -756,6 +744,7 @@ static int mmnif_hashadd(int sock, int rsock, uint8_t dest_ip)
p->socket = sock; p->socket = sock;
p->remote_socket = rsock; p->remote_socket = rsock;
p->dest_ip = dest_ip; p->dest_ip = dest_ip;
return 0; return 0;
} }
} }
@ -783,6 +772,7 @@ static int mmnif_hashdelete(int sock)
p->socket = -1; p->socket = -1;
p->remote_socket = 0; p->remote_socket = 0;
p->dest_ip = 0; p->dest_ip = 0;
return 0; return 0;
} }
} }
@ -801,19 +791,9 @@ static err_t mmnif_tx_bypass(struct netif * netif, void *pbuff, uint16_t size, i
//uint32_t exp_delay = 2; //uint32_t exp_delay = 2;
//mm_rx_buffer_t *rb = (mm_rx_buffer_t *) ((char *)header_start_address + (dest->dest_ip - 1) * header_size); //mm_rx_buffer_t *rb = (mm_rx_buffer_t *) ((char *)header_start_address + (dest->dest_ip - 1) * header_size);
/* Perform serveral sanity checks on the packet and the buffers:
* - is the output packet to big?
*/
// if (size > MMNIF_TX_BUFFERLEN)
// {
// DEBUGPRINTF("mmnif_tx(): packet is longer than %d bytes\n",MMNIF_TX_BUFFERLEN);
// goto drop_packet;
// }
/* allocate memory for the packet in the remote buffer */ /* allocate memory for the packet in the remote buffer */
realloc: realloc:
write_address = mmnif_rxbuff_alloc(dest->dest_ip, CLINE_ALIGN(size)); write_address = mmnif_rxbuff_alloc(dest->dest_ip, size);
if (!write_address) if (!write_address)
{ {
@ -821,14 +801,7 @@ realloc:
// udelay(exp_delay); // udelay(exp_delay);
// exp_delay << 1; // exp_delay << 1;
// reschedule(); // reschedule();
NOP8; NOP8;NOP8;NOP8;NOP8;NOP8;NOP8;NOP8;NOP8;
NOP8;
NOP8;
NOP8;
NOP8;
NOP8;
NOP8;
NOP8;
goto realloc; goto realloc;
} }
@ -854,7 +827,7 @@ realloc:
if (mmnif_commit_packet_bypass(dest->dest_ip, write_address, dest->remote_socket)) if (mmnif_commit_packet_bypass(dest->dest_ip, write_address, dest->remote_socket))
{ {
DEBUGPRINTF("mmnif_tx(): packet somehow lost during commit\n"); DEBUGPRINTF("mmnif_tx_bypass(): packet somehow lost during commit\n");
} }
#ifdef DEBUG_MMNIF_PACKET #ifdef DEBUG_MMNIF_PACKET
// DEBUGPRINTF("\n SEND %p with length: %d\n",(char*)mpb_start_address + (dest_ip -1)*mpb_size + pos * 1792,p->tot_len +2); // DEBUGPRINTF("\n SEND %p with length: %d\n",(char*)mpb_start_address + (dest_ip -1)*mpb_size + pos * 1792,p->tot_len +2);
@ -865,7 +838,9 @@ realloc:
LINK_STATS_INC(link.xmit); LINK_STATS_INC(link.xmit);
mmnif->stats.tx++; mmnif->stats.tx++;
mmnif->stats.tx_bytes += size; mmnif->stats.tx_bytes += size;
mmnif_trigger_irq(dest->dest_ip); mmnif_trigger_irq(dest->dest_ip);
return ERR_OK; return ERR_OK;
drop_packet: drop_packet:
@ -882,27 +857,30 @@ drop_packet:
int mmnif_send(int s, void *data, size_t size, int flags) int mmnif_send(int s, void *data, size_t size, int flags)
{ {
bypass_rxdesc_t *p = mmnif_hashlookup(s); bypass_rxdesc_t *p = mmnif_hashlookup(s);
uint32_t i, j, k, ret; uint32_t i, j, k;
int total_size = 0;
if (p != 0) if (p != 0)
{ {
if (size < ((MMNIF_RX_BUFFERLEN / 2) - 1)) if (size < ((MMNIF_RX_BUFFERLEN / 2) - 1)) {
return mmnif_tx_bypass(mmnif_dev, data, size, s); if (mmnif_tx_bypass(mmnif_dev, data, size, s) == ERR_OK)
return size;
else else
{ return -1;
} else {
j = size / (((MMNIF_RX_BUFFERLEN / 2) - 1)); j = size / (((MMNIF_RX_BUFFERLEN / 2) - 1));
k = size - (j * (((MMNIF_RX_BUFFERLEN / 2) - 1))); k = size - (j * (((MMNIF_RX_BUFFERLEN / 2) - 1)));
for (i = 0; i < j; i++) for (i = 0; i < j; i++)
{ {
ret = mmnif_tx_bypass(mmnif_dev, data + i * ((MMNIF_RX_BUFFERLEN / 2) - 1), ((MMNIF_RX_BUFFERLEN / 2) - 1), s); if (mmnif_tx_bypass(mmnif_dev, data + i * ((MMNIF_RX_BUFFERLEN / 2) - 1), ((MMNIF_RX_BUFFERLEN / 2) - 1), s) != ERR_OK)
return total_size;
if (ret < 0) total_size += (MMNIF_RX_BUFFERLEN / 2) - 1;
return ret;
} }
ret = mmnif_tx_bypass(mmnif_dev, data + (j - 1) * ((MMNIF_RX_BUFFERLEN / 2) - 1), k, s);
return ret; if (mmnif_tx_bypass(mmnif_dev, data + (j - 1) * ((MMNIF_RX_BUFFERLEN / 2) - 1), k, s) != ERR_OK)
return total_size;
return total_size + k;
} }
} }
@ -914,8 +892,7 @@ int mmnif_send(int s, void *data, size_t size, int flags)
* because we have no link layer and everything is reliable we don't need * because we have no link layer and everything is reliable we don't need
* to add anything so we just pass it to our tx function * to add anything so we just pass it to our tx function
*/ */
static err_t static err_t mmnif_link_layer(struct netif *netif, struct pbuf *q, ip_addr_t * ipaddr)
mmnif_link_layer(struct netif *netif, struct pbuf *q, ip_addr_t * ipaddr)
{ {
return netif->linkoutput(netif, q); return netif->linkoutput(netif, q);
} }
@ -934,7 +911,6 @@ err_t mmnif_init(struct netif *netif)
DEBUGPRINTF("mmnif init attempt\n"); DEBUGPRINTF("mmnif init attempt\n");
mmnif_dev = netif; mmnif_dev = netif;
own_ip_address += RCCE_ue() + 1;
/* Alloc and clear memory for the device struct /* Alloc and clear memory for the device struct
*/ */
@ -959,7 +935,7 @@ err_t mmnif_init(struct netif *netif)
// map physical address in the virtual address space // map physical address in the virtual address space
header_start_address = (void*) map_region(0, (size_t) header_start_address, (MMNIF_CORES * header_size) >> PAGE_SHIFT, MAP_KERNEL_SPACE | MAP_WT | MAP_NO_CACHE); header_start_address = (void*) map_region(0, (size_t) header_start_address, (MMNIF_CORES * header_size) >> PAGE_SHIFT, MAP_KERNEL_SPACE | MAP_WT | MAP_NO_CACHE);
DEBUGPRINTF("map_region : %p\n", header_start_address); DEBUGPRINTF("map_region : %p\n", header_start_address);
mmnif->rx_buff = (mm_rx_buffer_t *) (header_start_address + (header_size) * (own_ip_address - router_ip_address)); mmnif->rx_buff = (mm_rx_buffer_t *) (header_start_address + header_size * RCCE_IAM);
/* Alloc and clear shared memory for rx_buff /* Alloc and clear shared memory for rx_buff
*/ */
@ -980,25 +956,25 @@ err_t mmnif_init(struct netif *netif)
// align size to the granularity of a page size // align size to the granularity of a page size
heap_size = (heap_size + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1); heap_size = (heap_size + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1);
heap_start_address = (void*) RCCE_shmalloc(heap_size * MMNIF_CORES); heap_start_address = (void*) RCCE_shmalloc(heap_size * MMNIF_CORES);
DEBUGPRINTF("RCCE_shmalloc : %p (size %u)\n", header_start_address, MMNIF_CORES * header_size); DEBUGPRINTF("RCCE_shmalloc : %p (size %u)\n", heap_start_address, MMNIF_CORES * header_size);
// map physical address in the virtual address space // map physical address in the virtual address space
#if USE_CACHE #if USE_CACHE
uint32_t n = (uint32_t) heap_start_address; uint32_t n = (uint32_t) heap_start_address;
heap_start_address = map_region(0, heap_start_address, (MMNIF_CORES * heap_size) >> PAGE_SHIFT, MAP_KERNEL_SPACE | MAP_NO_CACHE | MAP_MPE | MAP_WT); heap_start_address = map_region(0, heap_start_address, (MMNIF_CORES * heap_size) >> PAGE_SHIFT, MAP_KERNEL_SPACE | MAP_NO_CACHE | MAP_MPE | MAP_WT);
map_region(heap_start_address + (heap_size) * (own_ip_address - router_ip_address), n + (heap_size) * (own_ip_address - router_ip_address), header_size >> PAGE_SHIFT, MAP_KERNEL_SPACE | MAP_MPE | MAP_WT | MAP_REMAP); map_region(heap_start_address + (heap_size) * RCCE_IAM, n + (heap_size) * RCCE_IAM, header_size >> PAGE_SHIFT, MAP_KERNEL_SPACE | MAP_MPE | MAP_WT | MAP_REMAP);
#else #else
heap_start_address = (void*) map_region(0, (size_t) heap_start_address, (MMNIF_CORES * heap_size) >> PAGE_SHIFT, MAP_KERNEL_SPACE | MAP_NO_CACHE | MAP_MPE | MAP_WT); heap_start_address = (void*) map_region(0, (size_t) heap_start_address, (MMNIF_CORES * heap_size) >> PAGE_SHIFT, MAP_KERNEL_SPACE | MAP_NO_CACHE | MAP_MPE | MAP_WT);
#endif // USE_CACHE #endif // USE_CACHE
#endif // MMNIF_USE_MPB #endif // MMNIF_USE_MPB
DEBUGPRINTF("map_region : %p\n", header_start_address); DEBUGPRINTF("map_region : %p\n", heap_start_address);
#if MMNIF_USE_MPB #if MMNIF_USE_MPB
mmnif->rx_heap = heap_start_address; mmnif->rx_heap = heap_start_address;
heap_start_address = heap_start_address - (RC_MY_COREID/2 * 16*1024*1024 ) - (RC_MY_COREID%2 * 0x2000); heap_start_address = heap_start_address - (RC_MY_COREID/2 * 16*1024*1024 ) - (RC_MY_COREID%2 * 0x2000);
DEBUGPRINTF("heap_start_address : %p\n", heap_start_address); DEBUGPRINTF("heap_start_address : %p\n", heap_start_address);
#else #else
mmnif->rx_heap = heap_start_address + (heap_size) * (own_ip_address - router_ip_address); mmnif->rx_heap = heap_start_address + heap_size * RCCE_IAM;
#endif #endif
if (!(heap_start_address)) if (!(heap_start_address))
@ -1007,13 +983,9 @@ err_t mmnif_init(struct netif *netif)
return ERR_MEM; return ERR_MEM;
} }
#if !MMNIF_USE_MPB #if MMNIF_USE_MPB
memset(mmnif->rx_buff, 0x00, header_size);
memset(mmnif->rx_heap, 0x00, heap_size);
*((int *)RCCE_fool_write_combine_buffer) = 1;
#else
asm volatile (".byte 0x0f; .byte 0x0a;\n"); asm volatile (".byte 0x0f; .byte 0x0a;\n");
#endif
for(i=0; i<header_size; i++) for(i=0; i<header_size; i++)
((uint8_t*)mmnif->rx_buff)[i] = 0x00; ((uint8_t*)mmnif->rx_buff)[i] = 0x00;
@ -1021,6 +993,7 @@ err_t mmnif_init(struct netif *netif)
((uint8_t*)mmnif->rx_heap)[i] = 0x00; ((uint8_t*)mmnif->rx_heap)[i] = 0x00;
*((int *)RCCE_fool_write_combine_buffer) = 1; *((int *)RCCE_fool_write_combine_buffer) = 1;
#if MMNIF_USE_MPB
asm volatile (".byte 0x0f; .byte 0x0a;\n"); asm volatile (".byte 0x0f; .byte 0x0a;\n");
#endif #endif
@ -1030,9 +1003,7 @@ err_t mmnif_init(struct netif *netif)
/* init the lock's for the hdr /* init the lock's for the hdr
*/ */
spinlock_init(&mmnif->rx_buff->rlock);
spinlock_init(&pseudolock); spinlock_init(&pseudolock);
spinlock_init(&mmnif->lock);
/* init the sems for communication art /* init the sems for communication art
*/ */
@ -1056,9 +1027,6 @@ err_t mmnif_init(struct netif *netif)
mmnif->rx_buff->acceptors[i].rsock = -1; mmnif->rx_buff->acceptors[i].rsock = -1;
mmnif->rx_buff->acceptors[i].src_ip = 0; mmnif->rx_buff->acceptors[i].src_ip = 0;
mmnif->rx_buff->acceptors[i].port = 0; mmnif->rx_buff->acceptors[i].port = 0;
spinlock_init(&mmnif->rx_buff->acceptors[i].alock);
spinlock_lock(&mmnif->rx_buff->acceptors[i].alock);
spinlock_unlock(&mmnif->rx_buff->acceptors[i].alock);
} }
/* pass the device state to lwip */ /* pass the device state to lwip */
@ -1100,7 +1068,7 @@ err_t mmnif_init(struct netif *netif)
static void mmnif_rx(struct netif *netif) static void mmnif_rx(struct netif *netif)
{ {
mmnif_t *mmnif = netif->state; mmnif_t *mmnif = netif->state;
mm_rx_buffer_t *b = mmnif->rx_buff; volatile mm_rx_buffer_t *b = mmnif->rx_buff;
uint16_t length = 0; uint16_t length = 0;
struct pbuf *p; struct pbuf *p;
struct pbuf *q; struct pbuf *q;
@ -1112,13 +1080,11 @@ static void mmnif_rx(struct netif *netif)
anotherpacket: anotherpacket:
rdesc = 0xFF; rdesc = 0xFF;
spinlock_lock(&b->rlock);
/* check if this call to mmnif_rx makes any sense /* check if this call to mmnif_rx makes any sense
*/ */
if (b->desc_table[b->dread].stat == MMNIF_STATUS_FREE) if (b->desc_table[b->dread].stat == MMNIF_STATUS_FREE)
{ {
spinlock_unlock(&b->rlock);
goto out; goto out;
} }
@ -1142,6 +1108,7 @@ anotherpacket:
DEBUGPRINTF("mmnif_rx(): no fast socket associated with %d", b->desc_table[rdesc].fast_sock); DEBUGPRINTF("mmnif_rx(): no fast socket associated with %d", b->desc_table[rdesc].fast_sock);
mmnif->rx_buff->desc_table[rdesc].stat = MMNIF_STATUS_PROC; mmnif->rx_buff->desc_table[rdesc].stat = MMNIF_STATUS_PROC;
mmnif_rxbuff_free(); mmnif_rxbuff_free();
goto out;
} else { } else {
b->desc_table[rdesc].stat = MMNIF_STATUS_INPROC; b->desc_table[rdesc].stat = MMNIF_STATUS_INPROC;
#if MMNIF_FAST_SOCKET_BLOCK #if MMNIF_FAST_SOCKET_BLOCK
@ -1149,19 +1116,16 @@ anotherpacket:
#else #else
atomic_int32_inc(&bp->cnt); atomic_int32_inc(&bp->cnt);
#endif #endif
goto anotherpacket;
} }
spinlock_unlock(&b->rlock);
goto out;
} }
} }
if (b->desc_table[(j + i) % MMNIF_MAX_DESCRIPTORS].stat == MMNIF_STATUS_FREE) if (b->desc_table[(j + i) % MMNIF_MAX_DESCRIPTORS].stat == MMNIF_STATUS_FREE)
{ {
spinlock_unlock(&b->rlock);
goto out; goto out;
} }
} }
spinlock_unlock(&b->rlock);
/* if there is no packet finished we encountered a random error /* if there is no packet finished we encountered a random error
*/ */
@ -1265,19 +1229,15 @@ out:
static int mmnif_rx_bypass(struct netif *netif, int s, void *data, uint32_t len) static int mmnif_rx_bypass(struct netif *netif, int s, void *data, uint32_t len)
{ {
mmnif_t *mmnif = netif->state; mmnif_t *mmnif = netif->state;
mm_rx_buffer_t *b = mmnif->rx_buff; volatile mm_rx_buffer_t *b = mmnif->rx_buff;
uint16_t length; uint16_t length = 0;
char *packet; char *packet = NULL;
uint32_t i, j; uint32_t i, j;
uint8_t rdesc = 0xFF; uint8_t rdesc = 0xFF;
// spinlock_lock(&b->rlock);
/* check if this call to mmnif_rx makes any sense /* check if this call to mmnif_rx makes any sense
*/ */
if (b->desc_table[b->dread].stat == MMNIF_STATUS_FREE) if (b->desc_table[b->dread].stat == MMNIF_STATUS_FREE) {
{
// spinlock_unlock(&b->rlock);
return -1; return -1;
} }
@ -1296,14 +1256,10 @@ static int mmnif_rx_bypass(struct netif *netif, int s, void *data, uint32_t len)
} }
} }
// spinlock_unlock(&b->rlock);
/* if there is no packet finished we encountered a random error /* if there is no packet finished we encountered a random error
*/ */
if (rdesc == 0xFF) if (rdesc == 0xFF)
{
return -1; return -1;
}
/* If length is zero return silently /* If length is zero return silently
*/ */
@ -1320,13 +1276,28 @@ static int mmnif_rx_bypass(struct netif *netif, int s, void *data, uint32_t len)
#ifdef DEBUG_MMNIF_PACKET #ifdef DEBUG_MMNIF_PACKET
DEBUGPRINTF("\n RECIEVED - %p with legth: %d\n", packet, length); DEBUGPRINTF("\n RECIEVED - %p with legth: %d\n", packet, length);
hex_dump(length, packet); hex_dump(length, packet);
#endif #endif
if (len >= length)
memcpy(data, (void*) mmnif->rx_buff->desc_table[rdesc].addr, mmnif->rx_buff->desc_table[rdesc].len); if (BUILTIN_EXPECT(len < length, 0))
else
goto drop_packet; goto drop_packet;
#if USE_CACHE || MMNIF_USE_MPB
asm volatile (".byte 0x0f; .byte 0x0a;\n");
#endif
#if !USE_CACHE && !MMNIF_USE_MBP
memcpy_from_nc(data, (void*) mmnif->rx_buff->desc_table[rdesc].addr, mmnif->rx_buff->desc_table[rdesc].len);
#elif MMNIF_USE_MPB
memcpy_get(data, (void*) mmnif->rx_buff->desc_table[rdesc].addr, mmnif->rx_buff->desc_table[rdesc].len);
#else
memcpy(data, (void*) mmnif->rx_buff->desc_table[rdesc].addr, mmnif->rx_buff->desc_table[rdesc].len);
#endif
*((int *)RCCE_fool_write_combine_buffer) = 1;
#if MMNIF_USE_MPB
asm volatile (".byte 0x0f; .byte 0x0a;\n");
#endif
/* indicate that the copy process is done and the packet can be freed /* indicate that the copy process is done and the packet can be freed
* note that we did not lock here because we are the only one editing this value * note that we did not lock here because we are the only one editing this value
*/ */
@ -1345,10 +1316,6 @@ static int mmnif_rx_bypass(struct netif *netif, int s, void *data, uint32_t len)
return length; return length;
drop_packet: drop_packet:
//spinlock_lock(&mmnif->rx_buff->rlock);
/*error handling */
//spinlock_unlock(&mmnif->rx_buff->rlock);
LINK_STATS_INC(link.drop); LINK_STATS_INC(link.drop);
mmnif->stats.rx_err++; mmnif->stats.rx_err++;
@ -1375,7 +1342,6 @@ int mmnif_recv(int s, void *data, uint32_t len, int flags)
//reschedule(); //reschedule();
NOP8; NOP8;
} }
#endif #endif
ret = mmnif_rx_bypass(mmnif_dev, s, data, len); ret = mmnif_rx_bypass(mmnif_dev, s, data, len);
@ -1407,27 +1373,30 @@ int mmnif_socket(int domain, int type, int protocol)
*/ */
int mmnif_accept(int s, struct sockaddr *addr, socklen_t * addrlen) int mmnif_accept(int s, struct sockaddr *addr, socklen_t * addrlen)
{ {
struct sockaddr_in *bp = (struct sockaddr_in*)addr; struct sockaddr_in *client = (struct sockaddr_in*)addr;
uint16_t port = bp->sin_port; volatile mm_rx_buffer_t *b = ((mmnif_t *) mmnif_dev->state)->rx_buff;
mm_rx_buffer_t *b = ((mmnif_t *) mmnif_dev->state)->rx_buff;
int i;
bypass_rxdesc_t *p; bypass_rxdesc_t *p;
int tmp1 = get_clock_tick(); int tmp1 = get_clock_tick();
int tmp2 = 0; int i, tmp2 = 0;
uint16_t port;
// TODO: Bug, not compatible with BSD sockets
port = client->sin_port;
if ((unsigned int)s >= MMNIF_PSEUDO_SOCKET_START) if ((unsigned int)s >= MMNIF_PSEUDO_SOCKET_START)
{ {
for (i = 0; i < MMNIF_MAX_ACCEPTORS; i++) for (i = 0; i < MMNIF_MAX_ACCEPTORS; i++)
{ {
if (b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].stat == MMNIF_ACC_STAT_CLOSED) if (b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].stat == MMNIF_ACC_STAT_CLOSED)
{ {
spinlock_lock(&b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].alock); RCCE_acquire_lock(RC_MY_COREID);
b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].port = port; b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].port = port;
b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].stat = MMNIF_ACC_STAT_ACCEPTING; b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].stat = MMNIF_ACC_STAT_ACCEPTING;
spinlock_lock(&pseudolock); spinlock_lock(&pseudolock);
mmnif_hashadd(npseudosocket, -1, 0); mmnif_hashadd(npseudosocket, -1, 0);
b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].nsock = npseudosocket++; b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].nsock = npseudosocket++;
spinlock_unlock(&pseudolock); spinlock_unlock(&pseudolock);
spinlock_unlock(&b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].alock); RCCE_release_lock(RC_MY_COREID);
while (b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].stat != MMNIF_ACC_STAT_ACCEPT_ME) while (b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].stat != MMNIF_ACC_STAT_ACCEPT_ME)
NOP8; NOP8;
@ -1435,48 +1404,46 @@ int mmnif_accept(int s, struct sockaddr *addr, socklen_t * addrlen)
p = mmnif_hashlookup(b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].nsock); p = mmnif_hashlookup(b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].nsock);
p->dest_ip = b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].src_ip; p->dest_ip = b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].src_ip;
p->remote_socket = b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].rsock; p->remote_socket = b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].rsock;
spinlock_lock(&b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].alock); RCCE_acquire_lock(RC_MY_COREID);
b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].stat = MMNIF_ACC_STAT_ACCEPTED; b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].stat = MMNIF_ACC_STAT_ACCEPTED;
i = b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].nsock; i = b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].nsock;
spinlock_unlock(&b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].alock); RCCE_release_lock(RC_MY_COREID);
return i; return i;
} }
} }
return -1;
}
else return -1;
{ } else {
for (i = 0; i < MMNIF_MAX_ACCEPTORS; i++) for (i = 0; i < MMNIF_MAX_ACCEPTORS; i++)
{ {
if (b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].stat == MMNIF_ACC_STAT_CLOSED) if (b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].stat == MMNIF_ACC_STAT_CLOSED)
{ {
spinlock_lock(&b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].alock); RCCE_acquire_lock(RC_MY_COREID);
b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].port = port; b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].port = port;
b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].stat = MMNIF_ACC_STAT_ACCEPTING; b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].stat = MMNIF_ACC_STAT_ACCEPTING;
spinlock_lock(&pseudolock); spinlock_lock(&pseudolock);
mmnif_hashadd(npseudosocket, -1, 0); mmnif_hashadd(npseudosocket, -1, 0);
b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].nsock = npseudosocket++; b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].nsock = npseudosocket++;
spinlock_unlock(&pseudolock); spinlock_unlock(&pseudolock);
spinlock_unlock(&b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].alock); RCCE_release_lock(RC_MY_COREID);
while (b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].stat != MMNIF_ACC_STAT_ACCEPT_ME) while (b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].stat != MMNIF_ACC_STAT_ACCEPT_ME)
{ {
tmp2 = get_clock_tick(); tmp2 = get_clock_tick();
if (tmp2 - tmp1 > MMNIF_AUTO_SOCKET_TIMEOUT) if (tmp2 - tmp1 > MMNIF_AUTO_SOCKET_TIMEOUT)
{ {
spinlock_lock(&b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].alock); RCCE_acquire_lock(RC_MY_COREID);
if (b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].stat == MMNIF_ACC_STAT_ACCEPT_ME) if (b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].stat == MMNIF_ACC_STAT_ACCEPT_ME)
{ {
spinlock_unlock(&b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].alock); RCCE_acquire_lock(RC_MY_COREID);
break; break;
} }
DEBUGPRINTF("mmnif_accept(): Timout occoured, switching to normal accept()"); DEBUGPRINTF("mmnif_accept(): Timout occoured, switching to normal accept()");
mmnif_hashdelete(b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].nsock); mmnif_hashdelete(b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].nsock);
b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].stat = MMNIF_ACC_STAT_CLOSED; b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].stat = MMNIF_ACC_STAT_CLOSED;
spinlock_unlock(&b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].alock); RCCE_release_lock(RC_MY_COREID);
goto normalaccept; goto normalaccept;
} }
NOP8; NOP8;
@ -1485,14 +1452,15 @@ int mmnif_accept(int s, struct sockaddr *addr, socklen_t * addrlen)
p = mmnif_hashlookup(b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].nsock); p = mmnif_hashlookup(b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].nsock);
p->dest_ip = b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].src_ip; p->dest_ip = b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].src_ip;
p->remote_socket = b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].rsock; p->remote_socket = b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].rsock;
spinlock_lock(&b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].alock); RCCE_acquire_lock(RC_MY_COREID);
b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].stat = MMNIF_ACC_STAT_ACCEPTED; b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].stat = MMNIF_ACC_STAT_ACCEPTED;
i = b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].nsock; i = b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].nsock;
spinlock_unlock(&b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].alock); RCCE_release_lock(RC_MY_COREID);
return i; return i;
} }
} }
return -1; return -1;
} }
@ -1507,48 +1475,29 @@ int mmnif_connect(int s, const struct sockaddr *name, socklen_t namelen)
{ {
struct sockaddr_in *p = (struct sockaddr_in*) name; struct sockaddr_in *p = (struct sockaddr_in*) name;
uint16_t port = p->sin_port; uint16_t port = p->sin_port;
mm_rx_buffer_t *b; volatile mm_rx_buffer_t *b;
int i; int i;
//int tmp1 = get_clock_tick(); //int tmp1 = get_clock_tick();
//int tmp2 = 0; //int tmp2 = 0;
uint8_t core; uint8_t core;
uint8_t *ip4addr;
uint8_t addr[4];
//uint32_t netmask = 0xFFFFFF00;
/* grab the destination ip address out of the ip header core = ip4_addr4(&p->sin_addr.s_addr);
* for internal routing the last ocet is interpreted as core ID.
*/
ip4addr = (uint8_t*) &p->sin_addr.s_addr;
/* revert the address to host format */
addr[3] = ip4addr[0];
addr[2] = ip4addr[1];
addr[1] = ip4addr[2];
addr[0] = ip4addr[3];
/* check if the ip address is in the Local Area Network of the 48 cores */
// if (!((netmask & *(uint32_t*)addr) == (netmask & own_ip_address) ))
// return -1;
core = addr[0];
if ((core) < 1 || (core > MMNIF_CORES)) if ((core) < 1 || (core > MMNIF_CORES))
return lwip_connect(s, name, namelen); return lwip_connect(s, name, namelen);
b = (mm_rx_buffer_t *) ((char *)header_start_address + b = (volatile mm_rx_buffer_t *) ((char *)header_start_address + (core - 1) * header_size);
(core - 1) * header_size);
for (i = 0; i < MMNIF_MAX_ACCEPTORS; i++) for (i = 0; i < MMNIF_MAX_ACCEPTORS; i++)
{ {
if (b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].stat == MMNIF_ACC_STAT_ACCEPTING if (b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].stat == MMNIF_ACC_STAT_ACCEPTING
&& b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].port == port) && b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].port == port)
{ {
spinlock_lock(&b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].alock); RCCE_acquire_lock(RC_COREID[core-1]);
b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].stat = MMNIF_ACC_STAT_ACCEPT_ME; b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].stat = MMNIF_ACC_STAT_ACCEPT_ME;
b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].rsock = s; b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].rsock = s;
b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].src_ip = own_ip_address & 0xFF; b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].src_ip = ip4_addr4(&mmnif_dev->ip_addr);
mmnif_hashadd(s, mmnif_hashadd(s, b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].nsock, core);
b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].nsock, core); RCCE_release_lock(RC_COREID[core-1]);
spinlock_unlock(&b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].alock);
while (b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].stat != MMNIF_ACC_STAT_ACCEPTED) while (b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].stat != MMNIF_ACC_STAT_ACCEPTED)
{ {
@ -1563,9 +1512,11 @@ int mmnif_connect(int s, const struct sockaddr *name, socklen_t namelen)
// } // }
NOP8; NOP8;
} }
spinlock_lock(&b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].alock);
RCCE_acquire_lock(RC_COREID[core-1]);
b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].stat = MMNIF_ACC_STAT_CLOSED; b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].stat = MMNIF_ACC_STAT_CLOSED;
spinlock_unlock(&b->acceptors[(i + port) % MMNIF_MAX_ACCEPTORS].alock); RCCE_release_lock(RC_COREID[core-1]);
return 0; return 0;
} }
} }
@ -1589,6 +1540,13 @@ int mmnif_bind(int s, const struct sockaddr *name, socklen_t namelen)
return 0; return 0;
} }
int mmnif_setsockopt(int s, int level, int optname, const void *optval, socklen_t optlen)
{
if ((unsigned int)s < MMNIF_PSEUDO_SOCKET_START)
return lwip_setsockopt(s, level, optname, optval, optlen);
return 0;
}
/* mmnif_closesocket(): replacement if lwip_close for /* mmnif_closesocket(): replacement if lwip_close for
* fast_sockets * fast_sockets
*/ */

33
drivers/net/mmnif.h
View file

@ -24,26 +24,53 @@
#ifdef CONFIG_LWIP #ifdef CONFIG_LWIP
#include <lwip/err.h> #include <lwip/err.h>
#include <lwip/netif.h> /* lwip netif */ #include <lwip/netif.h> /* lwip netif */
#include <lwip/sockets.h>
#define AF_MMNIF_NET 0x1337 #define AF_MMNIF_NET 0x42
#define MMNIF_AUTOACTIVATE_FAST_SOCKETS 0 #define MMNIF_AUTOACTIVATE_FAST_SOCKETS 1
#if MMNIF_AUTOACTIVATE_FAST_SOCKETS #if MMNIF_AUTOACTIVATE_FAST_SOCKETS
//#ifndef socklen_t
//# define socklen_t u32_t
//#endif
int mmnif_socket(int domain, int type, int protocol);
int mmnif_send(int s, void *data, size_t size, int flags);
int mmnif_recv(int s, void *data, uint32_t len, int flags);
int mmnif_accept(int s, struct sockaddr *addr, socklen_t * addrlen);
int mmnif_connect(int s, const struct sockaddr *name, socklen_t namelen);
int mmnif_listen(int s, int backlog);
int mmnif_bind(int s, const struct sockaddr *name, socklen_t namelen);
int mmnif_closesocket(int s);
int mmnif_getsockopt (int s, int level, int optname, void *optval, socklen_t *optlen);
int mmnif_setsockopt (int s, int level, int optname, const void *optval, socklen_t optlen);
#undef accept
#define accept(a,b,c) mmnif_accept(a,b,c) #define accept(a,b,c) mmnif_accept(a,b,c)
#undef closesocket
#define closesocket(s) mmnif_closesocket(s) #define closesocket(s) mmnif_closesocket(s)
#undef connect
#define connect(a,b,c) mmnif_connect(a,b,c) #define connect(a,b,c) mmnif_connect(a,b,c)
#undef recv
#define recv(a,b,c,d) mmnif_recv(a,b,c,d) #define recv(a,b,c,d) mmnif_recv(a,b,c,d)
#undef send
#define send(a,b,c,d) mmnif_send(a,b,c,d) #define send(a,b,c,d) mmnif_send(a,b,c,d)
#undef socket
#define socket(a,b,c) mmnif_socket(a,b,c) #define socket(a,b,c) mmnif_socket(a,b,c)
#undef bind
#define bind(a,b,c) mmnif_bind(a,b,c) #define bind(a,b,c) mmnif_bind(a,b,c)
#undef listen
#define listen(a,b) mmnif_listen(a,b) #define listen(a,b) mmnif_listen(a,b)
#undef setsockopt
#define setsockopt(a,b,c,d,e) mmnif_setsockopt(a,b,c,d,e)
#undef select
#endif #endif
err_t mmnif_init(struct netif*); err_t mmnif_init(struct netif*);
err_t mmnif_shutdown(void); err_t mmnif_shutdown(void);
int mmnif_worker(void *e); int mmnif_worker(void *e);
void mmnif_print_driver_status(); void mmnif_print_driver_status(void);
#endif #endif