Macintosh-SW
/
lwip-contrib-mac
mirror of https://github.com/ep00ch/lwip-contrib-mac.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Adapted win32- and unix-port to changes in sys layer

This commit is contained in:
goldsimon 2010-02-12 13:57:58 +00:00
parent a139f72602
commit eda6db6ebc
14 changed files with 215 additions and 138 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
ports/unix/include/arch/sys_arch.h
View File

@ -41,9 +41,16 @@ typedef u32_t sys_prot_t;
struct sys_sem;
typedef struct sys_sem * sys_sem_t;
#define sys_sem_valid(sem) (((sem) != NULL) && (*(sem) != NULL))
#define sys_sem_set_invalid(sem) do { if((sem) != NULL) { *(sem) = NULL; }}while(0)
/* let sys.h use binary semaphores for mutexes */
#define LWIP_COMPAT_MUTEX 1
struct sys_mbox;
typedef struct sys_mbox *sys_mbox_t;
#define sys_mbox_valid(mbox) (((mbox) != NULL) && (*(mbox) != NULL))
#define sys_mbox_set_invalid(mbox) do { if((mbox) != NULL) { *(mbox) = NULL; }}while(0)
struct sys_thread;
typedef struct sys_thread * sys_thread_t;

6
ports/unix/netif/delif.c
View File

@ -284,8 +284,10 @@ delif_thread(void *arg)
sys_timeout(DELIF_TIMEOUT, delif_input_timeout, netif);
sys_timeout(DELIF_TIMEOUT, delif_output_timeout, netif);
sem = sys_sem_new(0);
sys_sem_wait(sem);
if(sys_sem_new(&sem, 0) != ERR_OK) {
LWIP_ASSERT("Failed to create semaphore", 0);
}
sys_sem_wait(&sem);
}
/*-----------------------------------------------------------------------------------*/

30
ports/unix/netif/fifo.c
View File

@ -22,14 +22,14 @@ u8_t fifoGet(fifo_t * fifo)
{
u8_t c;
sys_sem_wait(fifo->sem); /* enter critical section */
sys_sem_wait(&fifo->sem); /* enter critical section */
if (fifo->dataslot == fifo->emptyslot)
{
fifo->getWaiting = TRUE; /* tell putFifo to signal us when data is available */
sys_sem_signal(fifo->sem); /* leave critical section (allow input from serial port..) */
sys_sem_wait(fifo->getSem); /* wait 4 data */
sys_sem_wait(fifo->sem); /* reenter critical section */
sys_sem_signal(&fifo->sem); /* leave critical section (allow input from serial port..) */
sys_sem_wait(&fifo->getSem); /* wait 4 data */
sys_sem_wait(&fifo->sem); /* reenter critical section */
}
c = fifo->data[fifo->dataslot++];
@ -39,7 +39,7 @@ u8_t fifoGet(fifo_t * fifo)
{
fifo->dataslot = 0;
}
sys_sem_signal(fifo->sem); /* leave critical section */
sys_sem_signal(&fifo->sem); /* leave critical section */
return c;
}
@ -48,7 +48,7 @@ s16_t fifoGetNonBlock(fifo_t * fifo)
{
u16_t c;
sys_sem_wait(fifo->sem); /* enter critical section */
sys_sem_wait(&fifo->sem); /* enter critical section */
if (fifo->dataslot == fifo->emptyslot)
{
@ -65,7 +65,7 @@ s16_t fifoGetNonBlock(fifo_t * fifo)
fifo->dataslot = 0;
}
}
sys_sem_signal(fifo->sem); /* leave critical section */
sys_sem_signal(&fifo->sem); /* leave critical section */
return c;
}
@ -75,7 +75,7 @@ void fifoPut(fifo_t * fifo, int fd)
/* FIXME: mutex around struct data.. */
int cnt=0;
sys_sem_wait( fifo->sem ); /* enter critical */
sys_sem_wait(&fifo->sem ); /* enter critical */
LWIP_DEBUGF( SIO_FIFO_DEBUG,("fifoput: len%d dat%d empt%d --> ", fifo->len, fifo->dataslot, fifo->emptyslot ) );
@ -105,17 +105,17 @@ void fifoPut(fifo_t * fifo, int fd)
fifo->emptyslot = 0;
LWIP_DEBUGF( SIO_FIFO_DEBUG, ("(WRAP) ") );
sys_sem_signal( fifo->sem ); /* leave critical */
sys_sem_signal(&fifo->sem ); /* leave critical */
fifoPut( fifo, fd );
return;
}
if ( fifo->getWaiting )
{
fifo->getWaiting = FALSE;
sys_sem_signal( fifo->getSem );
sys_sem_signal(&fifo->getSem );
}
sys_sem_signal( fifo->sem ); /* leave critical */
sys_sem_signal(&fifo->sem ); /* leave critical */
return;
}
@ -125,7 +125,11 @@ void fifoInit(fifo_t * fifo)
fifo->dataslot = 0;
fifo->emptyslot = 0;
fifo->len = 0;
fifo->sem = sys_sem_new(1); /* critical section 1=free to enter */
fifo->getSem = sys_sem_new(0); /* 0 = no one waiting */
if(sys_sem_new(&fifo->sem, 1) != ERR_OK) { /* critical section 1=free to enter */
LWIP_ASSERT("Failed to create semaphore", 0);
}
if(sys_sem_new(&fifo->getSem, 0) != ERR_OK) { /* 0 = no one waiting */
LWIP_ASSERT("Failed to create semaphore", 0);
}
fifo->getWaiting = FALSE;
}

8
ports/unix/netif/pcapif.c
View File

@ -141,7 +141,7 @@ timeout(void *arg)
printf("ip_lookup dropped\n");
}
sys_sem_signal(pcapif->sem);
sys_sem_signal(&pcapif->sem);
}
/*-----------------------------------------------------------------------------------*/
static void
@ -181,7 +181,7 @@ pcapif_thread(void *arg)
while (1) {
pcap_loop(pcapif->pd, 1, callback, (u_char *)netif);
sys_sem_wait(pcapif->sem);
sys_sem_wait(&pcapif->sem);
if (pcapif->p != NULL) {
netif->input(pcapif->p, netif);
}
@ -207,7 +207,9 @@ pcapif_init(struct netif *netif)
return ERR_IF;
}
p->sem = sys_sem_new(0);
if(sys_sem_new(&p->sem, 0) != ERR_OK) {
LWIP_ASSERT("Failed to create semaphore", 0);
}
p->p = NULL;
p->lasttime = 0;

12
ports/unix/netif/unixif.c
View File

@ -251,7 +251,7 @@ unixif_thread(void *arg)
while (1) {
sys_sem_wait(unixif->sem);
sys_sem_wait(&unixif->sem);
unixif_input_handler(netif);
}
@ -274,7 +274,7 @@ unixif_thread2(void *arg)
FD_SET(unixif->fd, &fdset);
if (select(unixif->fd + 1, &fdset, NULL, NULL, NULL) > 0) {
sys_sem_signal(unixif->sem);
sys_sem_signal(&unixif->sem);
}
}
}
@ -453,7 +453,9 @@ unixif_init_server(struct netif *netif)
LWIP_DEBUGF(UNIXIF_DEBUG, ("unixif_accept: %d\n", fd2));
unixif->fd = fd2;
unixif->sem = sys_sem_new(0);
if(sys_sem_new(&unixif->sem, 0) != ERR_OK) {
LWIP_ASSERT("Failed to create semaphore", 0);
}
sys_thread_new("unixif_thread", unixif_thread, netif, DEFAULT_THREAD_STACKSIZE, DEFAULT_THREAD_PRIO);
sys_thread_new("unixif_thread2", unixif_thread2, netif, DEFAULT_THREAD_STACKSIZE, DEFAULT_THREAD_PRIO);
return ERR_OK;
@ -477,7 +479,9 @@ unixif_init_client(struct netif *netif)
abort();
}
unixif->q = list_new(UNIXIF_QUEUELEN);
unixif->sem = sys_sem_new(0);
if(sys_sem_new(&unixif->sem, 0) != ERR_OK) {
LWIP_ASSERT("Failed to create semaphore", 0);
}
sys_thread_new("unixif_thread", unixif_thread, netif, DEFAULT_THREAD_STACKSIZE, DEFAULT_THREAD_PRIO);
sys_thread_new("unixif_thread2", unixif_thread2, netif, DEFAULT_THREAD_STACKSIZE, DEFAULT_THREAD_PRIO);
return ERR_OK;

2
ports/unix/proj/lib/Makefile
View File

@ -39,7 +39,7 @@ LWIPDIR=$(CONTRIBDIR)/../lwip/src
CCDEP=gcc
CC=gcc
CFLAGS=-g -Wall -fPIC -DIPv4 -DLWIP_DEBUG
CFLAGS=-g -Wall -DIPv4 -DLWIP_DEBUG
CFLAGS:=$(CFLAGS) \
-I$(LWIPDIR)/include -I$(LWIPARCH)/include -I$(LWIPDIR)/include/ipv4 \

10
ports/unix/proj/lib/unixlib.c
View File

@ -26,7 +26,7 @@
*
* Author: Kieran Mansley <kjm25@cam.ac.uk>
*
* $Id: unixlib.c,v 1.8 2010/02/09 13:19:01 goldsimon Exp $
* $Id: unixlib.c,v 1.9 2010/02/12 13:57:58 goldsimon Exp $
*/
/*-----------------------------------------------------------------------------------*/
@ -79,10 +79,12 @@ tcpip_init_done(void *arg)
void _init(void){
sys_sem_t sem;
sem = sys_sem_new(0);
if(sys_sem_new(&sem, 0) != ERR_OK) {
LWIP_ASSERT("failed to create semaphore", 0);
}
tcpip_init(tcpip_init_done, &sem);
sys_sem_wait(sem);
sys_sem_free(sem);
sys_sem_wait(&sem);
sys_sem_free(&sem);
}
void _fini(void){

12
ports/unix/proj/unixsim/simhost.c
View File

@ -382,10 +382,11 @@ main_thread(void *arg)
netif_init();
sem = sys_sem_new(0);
if(sys_sem_new(&sem, 0) != ERR_OK) {
LWIP_ASSERT("Failed to create semaphore", 0);
}
tcpip_init(tcpip_init_done, &sem);
sys_sem_wait(sem);
sys_sem_free(sem);
sys_sem_wait(&sem);
printf("TCP/IP initialized.\n");
#if LWIP_RAW
@ -404,9 +405,8 @@ main_thread(void *arg)
#if 0
stats_display();
#endif
/* Block for ever. */
sem = sys_sem_new(0);
sys_sem_wait(sem);
/* Block forever. */
sys_sem_wait(&sem);
}
/*-----------------------------------------------------------------------------------*/
int

12
ports/unix/proj/unixsim/simnode.c
View File

@ -109,19 +109,19 @@ main_thread(void *arg)
{
sys_sem_t sem;
sem = sys_sem_new(0);
if(sys_sem_new(&sem, 0) != ERR_OK) {
LWIP_ASSERT("Failed to create semaphore", 0);
}
tcpip_init(tcpip_init_done, &sem);
sys_sem_wait(sem);
sys_sem_free(sem);
sys_sem_wait(&sem);
printf("TCP/IP initialized.\n");
#ifdef MEM_PERF
mem_perf_init("/tmp/memstats.client");
#endif /* MEM_PERF */
sem = sys_sem_new(0);
sys_sem_wait(sem);
/* Block forever. */
sys_sem_wait(&sem);
}
/*-----------------------------------------------------------------------------------*/
int

11
ports/unix/proj/unixsim/simrouter.c
View File

@ -124,17 +124,18 @@ main_thread(void *arg)
{
sys_sem_t sem;
sem = sys_sem_new(0);
if(sys_sem_new(&sem, 0) != ERR_OK) {
LWIP_ASSERT("Failed to create semaphore", 0);
}
tcpip_init(tcpip_init_done, &sem);
sys_sem_wait(sem);
sys_sem_free(sem);
sys_sem_wait(&sem);
printf("TCP/IP initialized.\n");
#ifdef MEM_PERF
mem_perf_init("/tmp/memstats.client");
#endif /* MEM_PERF */
sem = sys_sem_new(0);
sys_sem_wait(sem);
/* Block forever. */
sys_sem_wait(&sem);
}
/*-----------------------------------------------------------------------------------*/
int

139
ports/unix/sys_arch.c
View File

@ -94,7 +94,7 @@ struct sys_thread {
};
static pthread_mutex_t lwprot_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_t lwprot_thread = (pthread_t) 0xDEAD;
static pthread_t lwprot_thread = (pthread_t)0xDEAD;
static int lwprot_count = 0;
static struct sys_sem *sys_sem_new_internal(u8_t count);
@ -150,38 +150,41 @@ sys_thread_new(char *name, void (* function)(void *arg), void *arg, int stacksiz
return st;
}
/*-----------------------------------------------------------------------------------*/
struct sys_mbox *
sys_mbox_new(int size)
err_t
sys_mbox_new(struct sys_mbox **mb, int size)
{
struct sys_mbox *mbox;
LWIP_UNUSED_ARG(size);
mbox = malloc(sizeof(struct sys_mbox));
if (mbox != NULL) {
mbox->first = mbox->last = 0;
mbox->not_empty = sys_sem_new_internal(0);
mbox->not_full = sys_sem_new_internal(0);
mbox->mutex = sys_sem_new_internal(1);
mbox->wait_send = 0;
#if SYS_STATS
lwip_stats.sys.mbox.used++;
if (lwip_stats.sys.mbox.used > lwip_stats.sys.mbox.max) {
lwip_stats.sys.mbox.max = lwip_stats.sys.mbox.used;
}
#endif /* SYS_STATS */
if (mbox == NULL) {
return ERR_MEM;
}
return mbox;
mbox->first = mbox->last = 0;
mbox->not_empty = sys_sem_new_internal(0);
mbox->not_full = sys_sem_new_internal(0);
mbox->mutex = sys_sem_new_internal(1);
mbox->wait_send = 0;
#if SYS_STATS
lwip_stats.sys.mbox.used++;
if (lwip_stats.sys.mbox.used > lwip_stats.sys.mbox.max) {
lwip_stats.sys.mbox.max = lwip_stats.sys.mbox.used;
}
#endif /* SYS_STATS */
*mb = mbox;
return ERR_OK;
}
/*-----------------------------------------------------------------------------------*/
void
sys_mbox_free(struct sys_mbox *mbox)
sys_mbox_free(struct sys_mbox **mb)
{
if (mbox != SYS_MBOX_NULL) {
if ((mb != NULL) && (*mb != SYS_MBOX_NULL)) {
struct sys_mbox *mbox = *mb;
#if SYS_STATS
lwip_stats.sys.mbox.used--;
#endif /* SYS_STATS */
sys_arch_sem_wait(mbox->mutex, 0);
sys_arch_sem_wait(&mbox->mutex, 0);
sys_sem_free_internal(mbox->not_empty);
sys_sem_free_internal(mbox->not_full);
@ -193,17 +196,20 @@ sys_mbox_free(struct sys_mbox *mbox)
}
/*-----------------------------------------------------------------------------------*/
err_t
sys_mbox_trypost(struct sys_mbox *mbox, void *msg)
sys_mbox_trypost(struct sys_mbox **mb, void *msg)
{
u8_t first;
struct sys_mbox *mbox;
LWIP_ASSERT("invalid mbox", (mb != NULL) && (*mb != NULL));
mbox = *mb;
sys_arch_sem_wait(mbox->mutex, 0);
sys_arch_sem_wait(&mbox->mutex, 0);
LWIP_DEBUGF(SYS_DEBUG, ("sys_mbox_trypost: mbox %p msg %p\n",
(void *)mbox, (void *)msg));
if ((mbox->last + 1) >= (mbox->first + SYS_MBOX_SIZE)) {
sys_sem_signal(mbox->mutex);
sys_sem_signal(&mbox->mutex);
return ERR_MEM;
}
@ -218,28 +224,31 @@ sys_mbox_trypost(struct sys_mbox *mbox, void *msg)
mbox->last++;
if (first) {
sys_sem_signal(mbox->not_empty);
sys_sem_signal(&mbox->not_empty);
}
sys_sem_signal(mbox->mutex);
sys_sem_signal(&mbox->mutex);
return ERR_OK;
}
/*-----------------------------------------------------------------------------------*/
void
sys_mbox_post(struct sys_mbox *mbox, void *msg)
sys_mbox_post(struct sys_mbox **mb, void *msg)
{
u8_t first;
sys_arch_sem_wait(mbox->mutex, 0);
struct sys_mbox *mbox;
LWIP_ASSERT("invalid mbox", (mb != NULL) && (*mb != NULL));
mbox = *mb;
sys_arch_sem_wait(&mbox->mutex, 0);
LWIP_DEBUGF(SYS_DEBUG, ("sys_mbox_post: mbox %p msg %p\n", (void *)mbox, (void *)msg));
while ((mbox->last + 1) >= (mbox->first + SYS_MBOX_SIZE)) {
mbox->wait_send++;
sys_sem_signal(mbox->mutex);
sys_arch_sem_wait(mbox->not_full, 0);
sys_arch_sem_wait(mbox->mutex, 0);
sys_sem_signal(&mbox->mutex);
sys_arch_sem_wait(&mbox->not_full, 0);
sys_arch_sem_wait(&mbox->mutex, 0);
mbox->wait_send--;
}
@ -254,19 +263,23 @@ sys_mbox_post(struct sys_mbox *mbox, void *msg)
mbox->last++;
if (first) {
sys_sem_signal(mbox->not_empty);
sys_sem_signal(&mbox->not_empty);
}
sys_sem_signal(mbox->mutex);
sys_sem_signal(&mbox->mutex);
}
/*-----------------------------------------------------------------------------------*/
u32_t
sys_arch_mbox_tryfetch(struct sys_mbox *mbox, void **msg)
sys_arch_mbox_tryfetch(struct sys_mbox **mb, void **msg)
{
sys_arch_sem_wait(mbox->mutex, 0);
struct sys_mbox *mbox;
LWIP_ASSERT("invalid mbox", (mb != NULL) && (*mb != NULL));
mbox = *mb;
sys_arch_sem_wait(&mbox->mutex, 0);
if (mbox->first == mbox->last) {
sys_sem_signal(mbox->mutex);
sys_sem_signal(&mbox->mutex);
return SYS_MBOX_EMPTY;
}
@ -281,39 +294,42 @@ sys_arch_mbox_tryfetch(struct sys_mbox *mbox, void **msg)
mbox->first++;
if (mbox->wait_send) {
sys_sem_signal(mbox->not_full);
sys_sem_signal(&mbox->not_full);
}
sys_sem_signal(mbox->mutex);
sys_sem_signal(&mbox->mutex);
return 0;
}
/*-----------------------------------------------------------------------------------*/
u32_t
sys_arch_mbox_fetch(struct sys_mbox *mbox, void **msg, u32_t timeout)
sys_arch_mbox_fetch(struct sys_mbox **mb, void **msg, u32_t timeout)
{
u32_t time_needed = 0;
struct sys_mbox *mbox;
LWIP_ASSERT("invalid mbox", (mb != NULL) && (*mb != NULL));
mbox = *mb;
/* The mutex lock is quick so we don't bother with the timeout
stuff here. */
sys_arch_sem_wait(mbox->mutex, 0);
sys_arch_sem_wait(&mbox->mutex, 0);
while (mbox->first == mbox->last) {
sys_sem_signal(mbox->mutex);
sys_sem_signal(&mbox->mutex);
/* We block while waiting for a mail to arrive in the mailbox. We
must be prepared to timeout. */
if (timeout != 0) {
time_needed = sys_arch_sem_wait(mbox->not_empty, timeout);
time_needed = sys_arch_sem_wait(&mbox->not_empty, timeout);
if (time_needed == SYS_ARCH_TIMEOUT) {
return SYS_ARCH_TIMEOUT;
}
} else {
sys_arch_sem_wait(mbox->not_empty, 0);
sys_arch_sem_wait(&mbox->not_empty, 0);
}
sys_arch_sem_wait(mbox->mutex, 0);
sys_arch_sem_wait(&mbox->mutex, 0);
}
if (msg != NULL) {
@ -327,10 +343,10 @@ sys_arch_mbox_fetch(struct sys_mbox *mbox, void **msg, u32_t timeout)
mbox->first++;
if (mbox->wait_send) {
sys_sem_signal(mbox->not_full);
sys_sem_signal(&mbox->not_full);
}
sys_sem_signal(mbox->mutex);
sys_sem_signal(&mbox->mutex);
return time_needed;
}
@ -349,8 +365,8 @@ sys_sem_new_internal(u8_t count)
return sem;
}
/*-----------------------------------------------------------------------------------*/
struct sys_sem *
sys_sem_new(u8_t count)
err_t
sys_sem_new(struct sys_sem **sem, u8_t count)
{
#if SYS_STATS
lwip_stats.sys.sem.used++;
@ -358,7 +374,11 @@ sys_sem_new(u8_t count)
lwip_stats.sys.sem.max = lwip_stats.sys.sem.used;
}
#endif /* SYS_STATS */
return sys_sem_new_internal(count);
*sem = sys_sem_new_internal(count);
if (*sem == NULL) {
return ERR_MEM;
}
return ERR_OK;
}
/*-----------------------------------------------------------------------------------*/
static u32_t
@ -405,10 +425,13 @@ cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex, u32_t timeout)
}
/*-----------------------------------------------------------------------------------*/
u32_t
sys_arch_sem_wait(struct sys_sem *sem, u32_t timeout)
sys_arch_sem_wait(struct sys_sem **s, u32_t timeout)
{
u32_t time_needed = 0;
struct sys_sem *sem;
LWIP_ASSERT("invalid sem", (s != NULL) && (*s != NULL));
sem = *s;
pthread_mutex_lock(&(sem->mutex));
while (sem->c <= 0) {
if (timeout > 0) {
@ -430,8 +453,12 @@ sys_arch_sem_wait(struct sys_sem *sem, u32_t timeout)
}
/*-----------------------------------------------------------------------------------*/
void
sys_sem_signal(struct sys_sem *sem)
sys_sem_signal(struct sys_sem **s)
{
struct sys_sem *sem;
LWIP_ASSERT("invalid sem", (s != NULL) && (*s != NULL));
sem = *s;
pthread_mutex_lock(&(sem->mutex));
sem->c++;
@ -452,13 +479,13 @@ sys_sem_free_internal(struct sys_sem *sem)
}
/*-----------------------------------------------------------------------------------*/
void
sys_sem_free(struct sys_sem *sem)
sys_sem_free(struct sys_sem **sem)
{
if (sem != SYS_SEM_NULL) {
if ((sem != NULL) && (*sem != SYS_SEM_NULL)) {
#if SYS_STATS
lwip_stats.sys.sem.used--;
#endif /* SYS_STATS */
sys_sem_free_internal(sem);
sys_sem_free_internal(*sem);
}
}
#endif /* !NO_SYS */

7
ports/win32/include/arch/sys_arch.h
View File

@ -35,10 +35,17 @@
/* HANDLE is used for sys_sem_t but we won't include windows.h */
typedef void* sys_sem_t;
#define SYS_SEM_NULL NULL
#define sys_sem_valid(sem) (((sem) != NULL) && (*(sem) != NULL))
#define sys_sem_set_invalid(sem) do { if((sem) != NULL) { *(sem) = NULL; }}while(0)
/* let sys.h use binary semaphores for mutexes */
#define LWIP_COMPAT_MUTEX 1
struct lwip_mbox;
typedef struct lwip_mbox* sys_mbox_t;
#define SYS_MBOX_NULL NULL
#define sys_mbox_valid(mbox) (((mbox) != NULL) && (*(mbox) != NULL))
#define sys_mbox_set_invalid(mbox) do { if((mbox) != NULL) { *(mbox) = NULL; }}while(0)
/* DWORD (thread id) is used for sys_thread_t but we won't include windows.h */
typedef u32_t sys_thread_t;

84
ports/win32/sys_arch.c
View File

@ -121,7 +121,7 @@ void do_sleep(int ms)
Sleep(ms);
}
sys_sem_t sys_sem_new(u8_t count)
err_t sys_sem_new(sys_sem_t *sem, u8_t count)
{
HANDLE new_sem = NULL;
new_sem = CreateSemaphore(0, count, 100000, 0);
@ -134,22 +134,25 @@ sys_sem_t sys_sem_new(u8_t count)
lwip_stats.sys.sem.max = lwip_stats.sys.sem.used;
}
#endif /* LWIP_STATS */
return new_sem;
*sem = new_sem;
return ERR_OK;
}
/* failed to allocate memory... */
#if LWIP_STATS
SYS_STATS_INC(sem.err);
#endif /* LWIP_STATS */
return SYS_SEM_NULL;
*sem = SYS_SEM_NULL;
return ERR_MEM;
}
void sys_sem_free(sys_sem_t sem)
void sys_sem_free(sys_sem_t *sem)
{
/* parameter check */
LWIP_ASSERT("sem != NULL", sem != NULL);
LWIP_ASSERT("sem != INVALID_HANDLE_VALUE", sem != INVALID_HANDLE_VALUE);
CloseHandle(sem);
LWIP_ASSERT("*sem != NULL", *sem != NULL);
LWIP_ASSERT("*sem != INVALID_HANDLE_VALUE", *sem != INVALID_HANDLE_VALUE);
CloseHandle(*sem);
#if LWIP_STATS
SYS_STATS_DEC(sem.used);
@ -157,17 +160,18 @@ void sys_sem_free(sys_sem_t sem)
#endif /* LWIP_STATS */
}
u32_t sys_arch_sem_wait(sys_sem_t sem, u32_t timeout)
u32_t sys_arch_sem_wait(sys_sem_t *sem, u32_t timeout)
{
DWORD ret;
LONGLONG starttime, endtime;
LWIP_ASSERT("sem != NULL", sem != NULL);
LWIP_ASSERT("sem != INVALID_HANDLE_VALUE", sem != INVALID_HANDLE_VALUE);
LWIP_ASSERT("*sem != NULL", *sem != NULL);
LWIP_ASSERT("*sem != INVALID_HANDLE_VALUE", *sem != INVALID_HANDLE_VALUE);
if(!timeout)
{
/* wait infinite */
starttime = sys_get_ms_longlong();
ret = WaitForSingleObject(sem, INFINITE);
ret = WaitForSingleObject(*sem, INFINITE);
LWIP_ASSERT("Error waiting for mutex", ret == WAIT_OBJECT_0);
endtime = sys_get_ms_longlong();
/* return the time we waited for the sem */
@ -177,7 +181,7 @@ u32_t sys_arch_sem_wait(sys_sem_t sem, u32_t timeout)
{
int ret;
starttime = sys_get_ms_longlong();
ret = WaitForSingleObject(sem, timeout);
ret = WaitForSingleObject(*sem, timeout);
LWIP_ASSERT("Error waiting for mutex", (ret == WAIT_OBJECT_0) || (ret == WAIT_TIMEOUT));
if(ret == WAIT_OBJECT_0)
{
@ -193,12 +197,13 @@ u32_t sys_arch_sem_wait(sys_sem_t sem, u32_t timeout)
}
}
void sys_sem_signal(sys_sem_t sem)
void sys_sem_signal(sys_sem_t *sem)
{
DWORD ret;
LWIP_ASSERT("sem != NULL", sem != NULL);
LWIP_ASSERT("sem != INVALID_HANDLE_VALUE", sem != INVALID_HANDLE_VALUE);
ret = ReleaseSemaphore(sem, 1, NULL);
LWIP_ASSERT("*sem != NULL", *sem != NULL);
LWIP_ASSERT("*sem != INVALID_HANDLE_VALUE", *sem != INVALID_HANDLE_VALUE);
ret = ReleaseSemaphore(*sem, 1, NULL);
LWIP_ASSERT("Error releasing mutex", ret != 0);
}
@ -229,19 +234,20 @@ sys_thread_t sys_thread_new(char *name, lwip_thread_fn function, void *arg, int
return 0;
}
sys_mbox_t sys_mbox_new(int size)
err_t sys_mbox_new(sys_mbox_t *mbox, int size)
{
struct lwip_mbox *new_mbox;
LWIP_UNUSED_ARG(size);
*mbox = SYS_SEM_NULL;
new_mbox = (struct lwip_mbox*)malloc(sizeof(struct lwip_mbox));
LWIP_ASSERT("new_mbox != NULL", new_mbox != NULL);
if(new_mbox == NULL) {
#if LWIP_STATS
SYS_STATS_INC(mbox.err);
#endif /* LWIP_STATS */
return SYS_SEM_NULL;
return ERR_MEM;
}
new_mbox->sem = CreateSemaphore(0, 0, MAX_QUEUE_ENTRIES, 0);
LWIP_ASSERT("Error creating semaphore", new_mbox->sem != NULL);
@ -250,8 +256,7 @@ sys_mbox_t sys_mbox_new(int size)
SYS_STATS_INC(mbox.err);
#endif /* LWIP_STATS */
free(new_mbox);
new_mbox = NULL;
return SYS_SEM_NULL;
return ERR_MEM;
}
memset(&new_mbox->q_mem, 0, sizeof(u32_t)*MAX_QUEUE_ENTRIES);
new_mbox->head = 0;
@ -263,32 +268,38 @@ sys_mbox_t sys_mbox_new(int size)
lwip_stats.sys.mbox.max = lwip_stats.sys.mbox.used;
}
#endif /* LWIP_STATS */
return new_mbox;
*mbox = new_mbox;
return ERR_OK;
}
void sys_mbox_free(sys_mbox_t mbox)
void sys_mbox_free(sys_mbox_t *mbox)
{
/* parameter check */
LWIP_ASSERT("sys_mbox_free ", mbox != SYS_MBOX_NULL );
LWIP_ASSERT("mbox->sem != NULL", mbox->sem != NULL);
LWIP_ASSERT("mbox->sem != INVALID_HANDLE_VALUE", mbox->sem != INVALID_HANDLE_VALUE);
LWIP_ASSERT("mbox != NULL", mbox != NULL);
LWIP_ASSERT("*mbox != NULL", *mbox != NULL);
LWIP_ASSERT("(*mbox)->sem != NULL", (*mbox)->sem != NULL);
LWIP_ASSERT("(*mbox)->sem != INVALID_HANDLE_VALUE", (*mbox)->sem != INVALID_HANDLE_VALUE);
CloseHandle(mbox->sem);
free(mbox);
CloseHandle((*mbox)->sem);
free(*mbox);
#if LWIP_STATS
SYS_STATS_DEC(mbox.used);
LWIP_ASSERT( "sys_mbox_free() ", lwip_stats.sys.mbox.used!= (u16_t)-1 );
#endif /* LWIP_STATS */
*mbox = NULL;
}
void sys_mbox_post(sys_mbox_t q, void *msg)
void sys_mbox_post(sys_mbox_t *mbox, void *msg)
{
DWORD ret;
struct lwip_mbox* q;
SYS_ARCH_DECL_PROTECT(lev);
/* parameter check */
LWIP_ASSERT("sys_mbox_free ", q != SYS_MBOX_NULL );
LWIP_ASSERT("mbox != NULL", mbox != NULL);
q = *mbox;
LWIP_ASSERT("q != NULL", q != NULL);
LWIP_ASSERT("q->sem != NULL", q->sem != NULL);
LWIP_ASSERT("q->sem != INVALID_HANDLE_VALUE", q->sem != INVALID_HANDLE_VALUE);
@ -305,14 +316,17 @@ void sys_mbox_post(sys_mbox_t q, void *msg)
SYS_ARCH_UNPROTECT(lev);
}
err_t sys_mbox_trypost(sys_mbox_t q, void *msg)
err_t sys_mbox_trypost(sys_mbox_t *mbox, void *msg)
{
u32_t new_head;
DWORD ret;
struct lwip_mbox *q;
SYS_ARCH_DECL_PROTECT(lev);
/* parameter check */
LWIP_ASSERT("sys_mbox_free ", q != SYS_MBOX_NULL );
LWIP_ASSERT("mbox != NULL", mbox != NULL);
q = *mbox;
LWIP_ASSERT("q != NULL", q != NULL);
LWIP_ASSERT("q->sem != NULL", q->sem != NULL);
LWIP_ASSERT("q->sem != INVALID_HANDLE_VALUE", q->sem != INVALID_HANDLE_VALUE);
@ -337,14 +351,17 @@ err_t sys_mbox_trypost(sys_mbox_t q, void *msg)
return ERR_OK;
}
u32_t sys_arch_mbox_fetch(sys_mbox_t q, void **msg, u32_t timeout)
u32_t sys_arch_mbox_fetch(sys_mbox_t *mbox, void **msg, u32_t timeout)
{
DWORD ret;
LONGLONG starttime, endtime;
struct lwip_mbox *q;
SYS_ARCH_DECL_PROTECT(lev);
/* parameter check */
LWIP_ASSERT("sys_mbox_free ", q != SYS_MBOX_NULL );
LWIP_ASSERT("mbox != NULL", mbox != NULL);
q = *mbox;
LWIP_ASSERT("q != NULL", q != NULL);
LWIP_ASSERT("q->sem != NULL", q->sem != NULL);
LWIP_ASSERT("q->sem != INVALID_HANDLE_VALUE", q->sem != INVALID_HANDLE_VALUE);
@ -377,13 +394,16 @@ u32_t sys_arch_mbox_fetch(sys_mbox_t q, void **msg, u32_t timeout)
}
}
u32_t sys_arch_mbox_tryfetch(sys_mbox_t q, void **msg)
u32_t sys_arch_mbox_tryfetch(sys_mbox_t *mbox, void **msg)
{
DWORD ret;
struct lwip_mbox *q;
SYS_ARCH_DECL_PROTECT(lev);
/* parameter check */
LWIP_ASSERT("sys_mbox_free ", q != SYS_MBOX_NULL );
LWIP_ASSERT("mbox != NULL", mbox != NULL);
q = *mbox;
LWIP_ASSERT("q != NULL", q != NULL);
LWIP_ASSERT("q->sem != NULL", q->sem != NULL);
LWIP_ASSERT("q->sem != INVALID_HANDLE_VALUE", q->sem != INVALID_HANDLE_VALUE);

13
ports/win32/test.c
View File

@ -358,9 +358,9 @@ test_init(void * arg)
#if NO_SYS
LWIP_UNUSED_ARG(arg);
#else /* NO_SYS */
sys_sem_t init_sem;
sys_sem_t *init_sem;
LWIP_ASSERT("arg != NULL", arg != NULL);
init_sem = (sys_sem_t)arg;
init_sem = (sys_sem_t*)arg;
#endif /* NO_SYS */
/* init network interfaces */
@ -389,6 +389,7 @@ static void pppCloseCallback(void *arg)
void main_loop()
{
#if !NO_SYS
err_t err;
sys_sem_t init_sem;
#endif /* NO_SYS */
#if PPP_SUPPORT
@ -404,12 +405,12 @@ void main_loop()
lwip_init();
test_init(NULL);
#else /* NO_SYS */
init_sem = sys_sem_new(0);
tcpip_init(test_init, init_sem);
err = sys_sem_new(&init_sem, 0);
tcpip_init(test_init, &init_sem);
/* we have to wait for initialization to finish before
* calling update_adapter()! */
sys_sem_wait(init_sem);
sys_sem_free(init_sem);
sys_sem_wait(&init_sem);
sys_sem_free(&init_sem);
#endif /* NO_SYS */
/* MAIN LOOP for driver update (and timers if NO_SYS) */