N-sim Emulation and simulation of Wireless Sensor Networks    Home    Project Page    Download    CVS    Installation    Configuration    Plug-ins  Hosted by

/home/brennan/n-sim/OrbisQuartus/server/l4/patches/lwip-ore/sys_arch.c Go to the documentation of this file. /* * Copyright (c) 2001-2003 Swedish Institute of Computer Science. * * Copyright 2007. Los Alamos National Security, LLC. This material * was produced under U.S. Government contract DE-AC52-06NA25396 for * Los Alamos National Laboratory (LANL), which is operated by Los * Alamos National Security, LLC, for the Department of Energy. The * U.S. Government has rights to use, reproduce, and distribute this * software. NEITHER THE GOVERNMENT NOR LOS ALAMOS NATIONAL SECURITY, * LLC, MAKES ANY WARRANTY, EXPRESS OR IMPLIED, OR ASSUMES ANY LEGAL * LIABILITY FOR THE USE OF THIS SOFTWARE. If software is modified to * produce derivative works, such modified software should be clearly * marked, so as not to confuse it with the version available from LANL. * * Additionally, this program is free software; you can redistribute * it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation; version 2 of * the License. Accordingly, this program is distributed in the hope * it will be useful, but WITHOUT ANY WARRANTY; without even the * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR * PURPOSE. See the GNU General Public License for more details. */ #include <string.h> #include <sys/time.h> #include <sys/types.h> #include <stdlib.h> #include <unistd.h> #include <l4/thread/thread.h> #include <l4/lock/lock.h> #include <l4/semaphore/semaphore.h> #include "lwip/sys.h" #include "lwip/opt.h" #include "lwip/stats.h" #include "lwip/debug.h" #define UMAX(a, b) ((a) > (b) ? (a) : (b)) static struct sys_thread *threads = NULL; static l4lock_t threads_mutex = L4LOCK_UNLOCKED; 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; l4semaphore_t cond; l4lock_t mutex; }; struct sys_thread { struct sys_thread *next; struct sys_timeouts timeouts; l4thread_t thread; }; static struct timeval starttime; static l4lock_t lwprot_mutex = L4LOCK_UNLOCKED; static l4thread_t lwprot_thread = (l4thread_t) 0xDEAD; 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(l4semaphore_t * cond, l4lock_t * mutex, u32_t timeout); sys_prot_t sys_arch_protect(void); void sys_arch_unprotect(sys_prot_t pval); unsigned long sys_unix_now(void); /*-----------------------------------------------------------------------------------*/ static struct sys_thread * introduce_thread(l4thread_t id) { struct sys_thread *thread; thread = malloc(sizeof(struct sys_thread)); if (thread != NULL) { l4lock_lock(&threads_mutex); thread->next = threads; thread->timeouts.next = NULL; thread->thread = id; threads = thread; l4lock_unlock(&threads_mutex); } return thread; } /*-----------------------------------------------------------------------------------*/ static struct sys_thread * current_thread(void) { struct sys_thread *st; l4thread_t pt; pt = l4thread_myself(); l4lock_lock(&threads_mutex); for(st = threads; st != NULL; st = st->next) { if (l4thread_equal(st->thread, pt)) { l4lock_unlock(&threads_mutex); return st; } } l4lock_unlock(&threads_mutex); st = introduce_thread(pt); if (!st) { printf("current_thread???\n"); abort(); } return st; } /*-----------------------------------------------------------------------------------*/ sys_thread_t sys_thread_new(void (*function)(void *arg), void *arg, int prio) { struct sys_thread *st = NULL; l4thread_t tmp = l4thread_create(function, arg, prio); if (tmp > 0) { st = introduce_thread(tmp); } if (NULL == st) { LWIP_DEBUGF(SYS_DEBUG, ("sys_thread_new: l4thread_create %d, st = 0x%x", code, (int)st)); abort(); } return st; } /*-----------------------------------------------------------------------------------*/ struct sys_mbox * sys_mbox_new() { struct sys_mbox *mbox; 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); } } /*-----------------------------------------------------------------------------------*/ 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_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 = malloc(sizeof(struct sys_sem)); if (sem != NULL) { sem->c = count; sem->cond = L4SEMAPHORE_UNLOCKED; sem->mutex = L4LOCK_UNLOCKED; } return sem; } /*-----------------------------------------------------------------------------------*/ static u32_t cond_wait(l4semaphore_t *cond, l4lock_t *mutex, u32_t timeout) { int tdiff; struct timeval rtime1, rtime2; int retval; if (timeout > 0) { /* Get a timestamp. */ gettimeofday(&rtime1, NULL); l4lock_unlock(mutex); retval = l4semaphore_down_timed(cond, timeout); l4lock_lock(mutex); if (retval < 0) { return SYS_ARCH_TIMEOUT; } else { /* Calculate for how long we waited for the cond. */ gettimeofday(&rtime2, NULL); tdiff = (rtime2.tv_sec - rtime1.tv_sec) * 1000 + (rtime2.tv_usec - rtime1.tv_usec) / 1000; if (tdiff <= 0) { return 0; } return tdiff; } } else { l4lock_unlock(mutex); l4semaphore_down(cond); l4lock_lock(mutex); return SYS_ARCH_TIMEOUT; } } /*-----------------------------------------------------------------------------------*/ u32_t sys_arch_sem_wait(struct sys_sem *sem, u32_t timeout) { u32_t time = 0; l4lock_lock(&(sem->mutex)); while (sem->c <= 0) { if (timeout > 0) { time = cond_wait(&(sem->cond), &(sem->mutex), timeout); if (time == SYS_ARCH_TIMEOUT) { l4lock_unlock(&(sem->mutex)); return SYS_ARCH_TIMEOUT; } /* l4lock_unlock(&(sem->mutex)); return time; */ } else { cond_wait(&(sem->cond), &(sem->mutex), 0); } } sem->c--; l4lock_unlock(&(sem->mutex)); return time; } /*-----------------------------------------------------------------------------------*/ void sys_sem_signal(struct sys_sem *sem) { l4lock_lock(&(sem->mutex)); sem->c++; if (sem->c > 1) { sem->c = 1; } l4semaphore_up(&(sem->cond)); l4lock_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) { free(sem); } /*-----------------------------------------------------------------------------------*/ unsigned long sys_unix_now(void) { 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; } /*-----------------------------------------------------------------------------------*/ void sys_init() { struct timezone tz; gettimeofday(&starttime, &tz); } /*-----------------------------------------------------------------------------------*/ struct sys_timeouts * sys_arch_timeouts(void) { struct sys_thread *thread; thread = current_thread(); return &thread->timeouts; } /*-----------------------------------------------------------------------------------*/ 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 != l4thread_myself()) { /* We are locking the mutex where it has not been locked before * * or is being locked by another thread */ l4lock_lock(&lwprot_mutex); lwprot_thread = l4thread_myself(); lwprot_count = 1; } else /* It is already locked by THIS thread */ lwprot_count++; return 0; } /*-----------------------------------------------------------------------------------*/ void sys_arch_unprotect(sys_prot_t pval) { if (lwprot_thread == l4thread_myself()) { if (--lwprot_count == 0) { lwprot_thread = (l4thread_t) 0xDEAD; l4lock_unlock(&lwprot_mutex); } } } /*-----------------------------------------------------------------------------------*/ #ifndef MAX_JIFFY_OFFSET #define MAX_JIFFY_OFFSET ((~0UL >> 1)-1) #endif #ifndef HZ #define HZ 100 #endif 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; } #if PPP_DEBUG #include <stdarg.h> void ppp_trace(int level, const char *format, ...) { va_list args; (void)level; va_start(args, format); vprintf(format, args); va_end(args); } #endif

© 2007, Los Alamos National Security, LLC.