--- /dev/null
+/*
+ * Copyright (c) 2001-2003 Swedish Institute of Computer Science.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
+ * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+ * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+ * OF SUCH DAMAGE.
+ *
+ * This file is part of the lwIP TCP/IP stack.
+ *
+ * Author: Adam Dunkels <adam@sics.se>
+ *
+ */
+
+/*
+ * Wed Apr 17 16:05:29 EDT 2002 (James Roth)
+ *
+ * - Fixed an unlikely sys_thread_new() race condition.
+ *
+ * - Made current_thread() work with threads which where
+ * not created with sys_thread_new(). This includes
+ * the main thread and threads made with pthread_create().
+ *
+ * - Catch overflows where more than SYS_MBOX_SIZE messages
+ * are waiting to be read. The sys_mbox_post() routine
+ * will block until there is more room instead of just
+ * leaking messages.
+ */
+/*
+ * Modified by Lei Xia (lxia@northwestern.edu) to fit to Palacios, 9/29/2008
+ */
+#include "lwip/debug.h"
+
+#include <string.h>
+
+//#include <palacios/vmm.h>
+#include <geekos/synch.h>
+#include <geekos/kthread.h>
+#include <geekos/debug.h>
+#include <geekos/timer.h>
+#include <geekos/malloc.h>
+
+#include "lwip/sys.h"
+#include "lwip/opt.h"
+#include "lwip/stats.h"
+
+#define UMAX(a, b) ((a) > (b) ? (a) : (b))
+
+static struct sys_thread *threads = NULL;
+
+//static pthread_mutex_t threads_mutex = PTHREAD_MUTEX_INITIALIZER;
+static struct Mutex threads_mutex; // !!!! need to be initiated, void Mutex_Init(struct Mutex* mutex);
+
+struct sys_mbox_msg {
+ struct sys_mbox_msg *next;
+ void *msg;
+};
+
+#define SYS_MBOX_SIZE 128
+
+struct sys_mbox {
+ int first, last;
+ void *msgs[SYS_MBOX_SIZE];
+ struct sys_sem *mail;
+ struct sys_sem *mutex;
+ int wait_send;
+};
+
+struct sys_sem {
+ unsigned int c;
+
+ //pthread_cond_t cond;
+ struct Condition cond;
+
+ //pthread_mutex_t mutex;
+ struct Mutex mutex;
+};
+
+struct sys_thread {
+ struct sys_thread *next;
+ struct sys_timeouts timeouts;
+
+ // pthread_t pthread;
+ struct Kernel_Thread *pthread;
+};
+
+
+//static struct timeval starttime;
+
+//static pthread_mutex_t lwprot_mutex = PTHREAD_MUTEX_INITIALIZER;
+static struct Mutex lwprot_mutex; // !!!! need to be initiated, void Mutex_Init(struct Mutex* mutex);
+
+//static pthread_t lwprot_thread = (pthread_t) 0xDEAD;
+//static struct Kernel_Thread lwprot_thread = (struct Kernel_Thread) 0xDEAD; //!!!!! how to set it to a NULL thread?
+
+//static int lwprot_count = 0;
+
+static struct sys_sem *sys_sem_new_(u8_t count);
+static void sys_sem_free_(struct sys_sem *sem);
+
+static u32_t cond_wait(struct Condition *cond, struct Mutex *mutex, u32_t timeout);
+
+
+/*-----------------------------------------------------------------------------------*/
+static struct sys_thread *
+introduce_thread(struct Kernel_Thread *id /*pthread_t id*/)
+{
+ struct sys_thread *thread;
+
+ thread = (struct sys_thread *)Malloc(sizeof(struct sys_thread));
+
+ if (thread != NULL) {
+ //pthread_mutex_lock(&threads_mutex);
+ Mutex_Lock(&threads_mutex);
+
+ thread->next = threads;
+ thread->timeouts.next = NULL;
+ thread->pthread = id;
+ threads = thread;
+
+ //pthread_mutex_unlock(&threads_mutex);
+ Mutex_Unlock(&threads_mutex);
+ }
+
+ return thread;
+}
+
+static int thread_equal(struct Kernel_Thread *kth1, struct Kernel_Thread *kth2){ //added
+
+ return (kth1->pid == kth2->pid);
+
+}
+
+/*-----------------------------------------------------------------------------------*/
+static struct sys_thread *
+current_thread(void)
+{
+ struct sys_thread *st;
+
+ //pthread_t pt;
+ struct Kernel_Thread *pt;
+
+ //pt = pthread_self();
+ //!!!!!!!!!!!Do these have the same means? Not sure
+ pt = Get_Current();
+
+ //pthread_mutex_lock(&threads_mutex);
+ Mutex_Lock(&threads_mutex);
+
+ for(st = threads; st != NULL; st = st->next) {
+ if (thread_equal(st->pthread, pt)) {
+ //pthread_mutex_unlock(&threads_mutex);
+ Mutex_Unlock(&threads_mutex);
+
+ return st;
+ }
+ }
+
+ //pthread_mutex_unlock(&threads_mutex);
+ Mutex_Unlock(&threads_mutex);
+
+ st = introduce_thread(pt);
+
+ if (!st) {
+ PrintBoth("lwIP error: In current_thread: Can not get current_thread\n");
+ abort();
+ }
+
+ return st;
+}
+
+
+/*-----------------------------------------------------------------------------------*/
+sys_thread_t
+sys_thread_new(char *name, void (* function)(void *arg), void *arg, int stacksize, int prio)
+{
+ //int code;
+ //pthread_t tmp;
+ struct Kernel_Thread *tmp;
+ struct sys_thread *st = NULL;
+
+ //tmp = (struct Kernel_Thread *)Malloc(sizeof(struct Kernel_Thread));
+
+ /* code = pthread_create(&tmp,
+ NULL,
+ (void *(*)(void *))
+ function,
+ arg); */
+
+ tmp = Start_Kernel_Thread(function, arg, PRIORITY_NORMAL , false); //did not consider the priority here
+
+ if (tmp != NULL) {
+ st = introduce_thread(tmp);
+ }
+
+ if (NULL == st) {
+ LWIP_DEBUGF(SYS_DEBUG, ("sys_thread_new: pthread_create: 0x%x, st = 0x%x",
+ (int)tmp, (int)st));
+ abort();
+ }
+ return st;
+}
+
+
+/*-----------------------------------------------------------------------------------*/
+struct sys_mbox *
+sys_mbox_new(int size)
+{
+ struct sys_mbox *mbox;
+
+ mbox = (struct sys_mbox *)Malloc(sizeof(struct sys_mbox));
+ if (mbox != NULL) {
+ mbox->first = mbox->last = 0;
+ mbox->mail = sys_sem_new_(0);
+ mbox->mutex = sys_sem_new_(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 */
+ }
+ return mbox;
+}
+/*-----------------------------------------------------------------------------------*/
+void
+sys_mbox_free(struct sys_mbox *mbox)
+{
+ if (mbox != SYS_MBOX_NULL) {
+#if SYS_STATS
+ lwip_stats.sys.mbox.used--;
+#endif /* SYS_STATS */
+ sys_sem_wait(mbox->mutex);
+
+ sys_sem_free_(mbox->mail);
+ sys_sem_free_(mbox->mutex);
+ mbox->mail = mbox->mutex = NULL;
+ /* LWIP_DEBUGF("sys_mbox_free: mbox 0x%lx\n", mbox); */
+
+ Free(mbox);
+ }
+}
+/*-----------------------------------------------------------------------------------*/
+err_t
+sys_mbox_trypost(struct sys_mbox *mbox, void *msg)
+{
+ u8_t first;
+
+ sys_sem_wait(mbox->mutex);
+
+ 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))
+ return ERR_MEM;
+
+ mbox->msgs[mbox->last % SYS_MBOX_SIZE] = msg;
+
+ if (mbox->last == mbox->first) {
+ first = 1;
+ } else {
+ first = 0;
+ }
+
+ mbox->last++;
+
+ if (first) {
+ sys_sem_signal(mbox->mail);
+ }
+
+ sys_sem_signal(mbox->mutex);
+
+ return ERR_OK;
+}
+/*-----------------------------------------------------------------------------------*/
+void
+sys_mbox_post(struct sys_mbox *mbox, void *msg)
+{
+ u8_t first;
+
+ sys_sem_wait(mbox->mutex);
+
+ 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->mail, 0);
+ sys_arch_sem_wait(mbox->mutex, 0);
+ mbox->wait_send--;
+ }
+
+ mbox->msgs[mbox->last % SYS_MBOX_SIZE] = msg;
+
+ if (mbox->last == mbox->first) {
+ first = 1;
+ } else {
+ first = 0;
+ }
+
+ mbox->last++;
+
+ if (first) {
+ sys_sem_signal(mbox->mail);
+ }
+
+ sys_sem_signal(mbox->mutex);
+}
+/*-----------------------------------------------------------------------------------*/
+u32_t
+sys_arch_mbox_tryfetch(struct sys_mbox *mbox, void **msg)
+{
+ sys_arch_sem_wait(mbox->mutex, 0);
+
+ if (mbox->first == mbox->last) {
+ sys_sem_signal(mbox->mutex);
+ return SYS_MBOX_EMPTY;
+ }
+
+ if (msg != NULL) {
+ LWIP_DEBUGF(SYS_DEBUG, ("sys_mbox_tryfetch: mbox %p msg %p\n", (void *)mbox, *msg));
+ *msg = mbox->msgs[mbox->first % SYS_MBOX_SIZE];
+ }
+ else{
+ LWIP_DEBUGF(SYS_DEBUG, ("sys_mbox_tryfetch: mbox %p, null msg\n", (void *)mbox));
+ }
+
+ mbox->first++;
+
+ if (mbox->wait_send) {
+ sys_sem_signal(mbox->mail);
+ }
+
+ sys_sem_signal(mbox->mutex);
+
+ return 0;
+}
+/*-----------------------------------------------------------------------------------*/
+u32_t
+sys_arch_mbox_fetch(struct sys_mbox *mbox, void **msg, u32_t timeout)
+{
+ u32_t time = 0;
+
+ /* The mutex lock is quick so we don't bother with the timeout
+ stuff here. */
+ sys_arch_sem_wait(mbox->mutex, 0);
+
+ while (mbox->first == mbox->last) {
+ 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 = sys_arch_sem_wait(mbox->mail, timeout);
+
+ if (time == SYS_ARCH_TIMEOUT) {
+ return SYS_ARCH_TIMEOUT;
+ }
+ } else {
+ sys_arch_sem_wait(mbox->mail, 0);
+ }
+
+ sys_arch_sem_wait(mbox->mutex, 0);
+ }
+
+ if (msg != NULL) {
+ LWIP_DEBUGF(SYS_DEBUG, ("sys_mbox_fetch: mbox %p msg %p\n", (void *)mbox, *msg));
+ *msg = mbox->msgs[mbox->first % SYS_MBOX_SIZE];
+ }
+ else{
+ LWIP_DEBUGF(SYS_DEBUG, ("sys_mbox_fetch: mbox %p, null msg\n", (void *)mbox));
+ }
+
+ mbox->first++;
+
+ if (mbox->wait_send) {
+ sys_sem_signal(mbox->mail);
+ }
+
+ sys_sem_signal(mbox->mutex);
+
+ return time;
+}
+/*-----------------------------------------------------------------------------------*/
+struct sys_sem *
+sys_sem_new(u8_t count)
+{
+#if SYS_STATS
+ lwip_stats.sys.sem.used++;
+ if (lwip_stats.sys.sem.used > lwip_stats.sys.sem.max) {
+ lwip_stats.sys.sem.max = lwip_stats.sys.sem.used;
+ }
+#endif /* SYS_STATS */
+ return sys_sem_new_(count);
+}
+
+/*-----------------------------------------------------------------------------------*/
+static struct sys_sem *
+sys_sem_new_(u8_t count)
+{
+ struct sys_sem *sem;
+
+ sem = (struct sys_sem *)Malloc(sizeof(struct sys_sem));
+ if (sem != NULL) {
+ sem->c = count;
+
+ //pthread_cond_init(&(sem->cond), NULL);
+ Cond_Init(&(sem->cond));
+
+ //pthread_mutex_init(&(sem->mutex), NULL);
+ Mutex_Init(&(sem->mutex));
+ }
+ return sem;
+}
+
+
+/*-----------------------------------------------------------------------------------*/
+static u32_t
+cond_wait(struct Condition *cond, struct Mutex *mutex, u32_t timeout /* timeout is in miliseconds *//* pthread_cond_t *cond, pthread_mutex_t *mutex, u32_t timeout */)
+{
+ ulong_t tdiff, msec;
+
+ /*
+ struct timeval rtime1, rtime2;
+ struct timespec ts;
+ struct timezone tz;
+ */
+ int retval;
+
+ if (timeout > 0) {
+
+ /* Get a timestamp and add the timeout value. */
+ /*gettimeofday(&rtime1, &tz);
+ sec = rtime1.tv_sec;
+ usec = rtime1.tv_usec;
+ usec += timeout % 1000 * 1000;
+ sec += (int)(timeout / 1000) + (int)(usec / 1000000);
+ usec = usec % 1000000;
+ ts.tv_nsec = usec * 1000;
+ ts.tv_sec = sec;
+ */
+ msec = clock_time();
+
+ if (Cond_Wait_Timeout(cond, mutex, timeout) == 1) //return due to timeout
+ retval = ETIMEDOUT;
+
+ //retval = pthread_cond_timedwait(cond, mutex, &ts);
+
+ if (retval == ETIMEDOUT) {
+ return SYS_ARCH_TIMEOUT;
+ } else {
+ /* Calculate for how long we waited for the cond. */
+
+ /*
+ gettimeofday(&rtime2, &tz);
+ tdiff = (rtime2.tv_sec - rtime1.tv_sec) * 1000 +
+ (rtime2.tv_usec - rtime1.tv_usec) / 1000;
+ */
+ tdiff = clock_time();
+
+ tdiff -= msec;
+
+ if (tdiff <= 0) {
+ return 0;
+ }
+
+ return tdiff;
+ }
+ } else {
+ //pthread_cond_wait(cond, mutex);
+ Cond_Wait(cond, mutex);
+
+ return SYS_ARCH_TIMEOUT;
+ }
+}
+/*-----------------------------------------------------------------------------------*/
+u32_t
+sys_arch_sem_wait(struct sys_sem *sem, u32_t timeout)
+{
+ u32_t time = 0;
+
+ //pthread_mutex_lock(&(sem->mutex));
+ Mutex_Lock(&(sem->mutex));
+
+ while (sem->c <= 0) {
+ if (timeout > 0) {
+ time = cond_wait(&(sem->cond), &(sem->mutex), timeout);
+
+ if (time == SYS_ARCH_TIMEOUT) {
+ //pthread_mutex_unlock(&(sem->mutex));
+ Mutex_Unlock(&(sem->mutex));
+
+ return SYS_ARCH_TIMEOUT;
+ }
+ /* pthread_mutex_unlock(&(sem->mutex));
+ return time; */
+ } else { // if timeout = 0
+ cond_wait(&(sem->cond), &(sem->mutex), 0);
+ }
+ }
+ sem->c--;
+ //pthread_mutex_unlock(&(sem->mutex));
+ Mutex_Unlock(&(sem->mutex));
+
+ return time;
+}
+/*-----------------------------------------------------------------------------------*/
+void
+sys_sem_signal(struct sys_sem *sem)
+{
+ //pthread_mutex_lock(&(sem->mutex));
+ Mutex_Lock(&(sem->mutex));
+
+ sem->c++;
+
+ if (sem->c > 1) {
+ sem->c = 1;
+ }
+
+ //pthread_cond_broadcast(&(sem->cond));
+ Cond_Broadcast(&(sem->cond));
+
+ //pthread_mutex_unlock(&(sem->mutex));
+ Mutex_Unlock(&(sem->mutex));
+
+}
+/*-----------------------------------------------------------------------------------*/
+void
+sys_sem_free(struct sys_sem *sem)
+{
+ if (sem != SYS_SEM_NULL) {
+#if SYS_STATS
+ lwip_stats.sys.sem.used--;
+#endif /* SYS_STATS */
+ sys_sem_free_(sem);
+ }
+}
+
+/*-----------------------------------------------------------------------------------*/
+static void
+sys_sem_free_(struct sys_sem *sem)
+{
+ //pthread_cond_destroy(&(sem->cond));
+ Cond_Destroy(&(sem->cond));
+
+ //pthread_mutex_destroy(&(sem->mutex));
+ Mutex_Destroy(&(sem->mutex));
+
+ Free(sem);
+}
+
+#if 0
+//return time, we do not need this
+/*-----------------------------------------------------------------------------------*/
+unsigned long
+sys_unix_now()
+{
+ struct timeval tv;
+ struct timezone tz;
+ long sec, usec;
+ unsigned long msec;
+ gettimeofday(&tv, &tz);
+
+ sec = tv.tv_sec - starttime.tv_sec;
+ usec = tv.tv_usec - starttime.tv_usec;
+ msec = sec * 1000 + usec / 1000;
+
+ return msec;
+}
+#endif
+
+/*-----------------------------------------------------------------------------------*/
+void
+sys_init()
+{
+ //struct timezone tz;
+ //gettimeofday(&starttime, &tz);
+
+ Mutex_Init(&threads_mutex);
+ Mutex_Init(&lwprot_mutex);
+
+}
+/*-----------------------------------------------------------------------------------*/
+struct sys_timeouts *
+sys_arch_timeouts(void)
+{
+ struct sys_thread *thread;
+
+ thread = current_thread();
+ return &thread->timeouts;
+}
+
+
+/*-----------------------------------------------------------------------------------*/
+/** sys_prot_t sys_arch_protect(void)
+
+This optional function does a "fast" critical region protection and returns
+the previous protection level. This function is only called during very short
+critical regions. An embedded system which supports ISR-based drivers might
+want to implement this function by disabling interrupts. Task-based systems
+might want to implement this by using a mutex or disabling tasking. This
+function should support recursive calls from the same task or interrupt. In
+other words, sys_arch_protect() could be called while already protected. In
+that case the return value indicates that it is already protected.
+
+sys_arch_protect() is only required if your port is supporting an operating
+system.
+*/
+
+#if 0
+sys_prot_t
+sys_arch_protect(void)
+{
+ /* Note that for the UNIX port, we are using a lightweight mutex, and our
+ * own counter (which is locked by the mutex). The return code is not actually
+ * used. */
+ if (lwprot_thread != current_thread() /*lwprot_thread != pthread_self()*/)
+ {
+ /* We are locking the mutex where it has not been locked before *
+ * or is being locked by another thread */
+ Mutex_Lock(&lwprot_mutex);
+ lwprot_thread = current_thread();
+ lwprot_count = 1;
+ }
+ else
+ /* It is already locked by THIS thread */
+ lwprot_count++;
+ return 0;
+}
+/*-----------------------------------------------------------------------------------*/
+/** void sys_arch_unprotect(sys_prot_t pval)
+
+This optional function does a "fast" set of critical region protection to the
+value specified by pval. See the documentation for sys_arch_protect() for
+more information. This function is only required if your port is supporting
+an operating system.
+*/
+void
+sys_arch_unprotect(sys_prot_t pval)
+{
+ if (lwprot_thread == current_thread())
+ {
+ if (--lwprot_count == 0)
+ {
+ lwprot_thread = (struc Kernel_Thread) 0xDEAD;
+ Mutex_Unlock(&lwprot_mutex);
+ }
+ }
+}
+#endif
+
+/*-----------------------------------------------------------------------------------*/
+
+#ifndef MAX_JIFFY_OFFSET
+#define MAX_JIFFY_OFFSET ((~0UL >> 1)-1)
+#endif
+
+#ifndef HZ
+#define HZ 100
+#endif
+
+#if 0
+unsigned long
+sys_jiffies(void)
+{
+ struct timeval tv;
+ unsigned long sec = tv.tv_sec;
+ long usec = tv.tv_usec;
+
+ gettimeofday(&tv,NULL);
+
+ if (sec >= (MAX_JIFFY_OFFSET / HZ))
+ return MAX_JIFFY_OFFSET;
+ usec += 1000000L / HZ - 1;
+ usec /= 1000000L / HZ;
+ return HZ * sec + usec;
+}
+#endif
+
+#if PPP_DEBUG
+
+#include <geekos/serial.h>
+
+void ppp_trace(int level, const char *format, ...)
+{
+ va_list args;
+
+ (void)level;
+ va_start(args, format);
+
+ //vprintf(format, args);
+ PrintDebug(format, args);
+
+ va_end(args);
+}
+#endif
