task #10139 (Prefer statically allocated memory): converted mbox and semaphore functions to take pointers to sys_mbox_t/sys_sem_t; converted sys_mbox_new/sys_sem_new to take pointers and return err_t; task #7212: Add Mutex concept in sys_arch (define LWIP_COMPAT_MUTEX to let sys.h use binary semaphores instead of mutexes - as before)

src/include/lwip/sys.h

@@ -80,26 +80,74 @@ typedef void (*lwip_thread_fn)(void *arg);
 /* Function prototypes for functions to be implemented by platform ports
    (in sys_arch.c) */
 
+/* Mutex functions: */
+
+/** Define LWIP_COMPAT_MUTEX if the port has no mutexes and binary semaphores
+    should be used instead */
+#if LWIP_COMPAT_MUTEX
+/* for old ports that don't have mutexes: define them to binary semaphores */
+#define sys_mutex_t                   sys_sem_t
+#define sys_mutex_new(mutex)          sys_sem_new(mutex, 1)
+#define sys_mutex_lock(mutex)         sys_sem_wait(mutex)
+#define sys_mutex_unlock(mutex)       sys_sem_signal(mutex)
+#define sys_mutex_free(mutex)         sys_sem_free(mutex)
+#define sys_mutex_valid(mutex)        sys_sem_valid(mutex)
+#define sys_mutex_set_invalid(mutex)  sys_sem_set_invalid(mutex)
+
+#else /* LWIP_HAVE_MUTEX */
+
+/** Create a new mutex
+ * @param mutex pointer to the mutex to create
+ * @return a new 
+err_t sys_mutex_new(sys_mutex_t *mutex);
+/** Lock a mutex
+ * @param mutex the mutex to lock */
+void sys_mutex_lock(sys_mutex_t *mutex);
+/** Unlock a mutex
+ * @param mutex the mutex to unlock */
+void sys_mutex_unlock(sys_mutex_t *mutex);
+/** Delete a semaphore
+ * @param mutex the mutex to delete */
+void sys_mutex_free(sys_mutex_t *mutex); 
+#ifndef sys_mutex_valid
+/** Check if a mutex is valid/allocated: return 1 for valid, 0 for invalid */
+int sys_mutex_valid(sys_mutex_t *mutex);
+#endif
+#ifndef sys_mutex_set_invalid
+/** Set a mutex invalid so that sys_mutex_valid returns 0 */
+void sys_mutex_set_invalid(sys_mutex_t *mutex);
+#endif
+#endif /* LWIP_HAVE_MUTEX */
+
 /* Semaphore functions: */
 
 /** Create a new semaphore
+ * @param sem pointer to the semaphore to create
  * @param count initial count of the semaphore
- * @return a new semaphore */
-sys_sem_t sys_sem_new(u8_t count);
+ * @return ERR_OK if successful, another err_t otherwise */
+err_t sys_sem_new(sys_sem_t *sem, u8_t count);
 /** Signals a semaphore
  * @param sem the semaphore to signal */
-void sys_sem_signal(sys_sem_t sem);
+void sys_sem_signal(sys_sem_t *sem);
 /** Wait for a semaphore for the specified timeout
  * @param sem the semaphore to wait for
  * @param timeout timeout in miliseconds to wait (0 = wait forever)
  * @return time (in miliseconds) waited for the semaphore
  *         or SYS_ARCH_TIMEOUT on timeout */
-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);
 /** Delete a semaphore
  * @param sem semaphore to delete */
-void sys_sem_free(sys_sem_t sem);
+void sys_sem_free(sys_sem_t *sem);
 /** Wait for a semaphore - forever/no timeout */
 #define sys_sem_wait(sem)                  sys_arch_sem_wait(sem, 0)
+#ifndef sys_sem_valid
+/** Check if a sempahore is valid/allocated: return 1 for valid, 0 for invalid */
+int sys_sem_valid(sys_sem_t *sem);
+#endif
+#ifndef sys_sem_set_invalid
+/** Set a semaphore invalid so that sys_sem_valid returns 0 */
+void sys_sem_set_invalid(sys_sem_t *sem);
+#endif
 
 /* Time functions. */
 #ifndef sys_msleep
@@ -109,18 +157,19 @@ void sys_msleep(u32_t ms); /* only has a (close to) 1 jiffy resolution. */
 /* Mailbox functions. */
 
 /** Create a new mbox of specified size
+ * @param mbox pointer to the mbox to create
  * @param size (miminum) number of messages in this mbox
- * @return a new mbox */
-sys_mbox_t sys_mbox_new(int size);
+ * @return ERR_OK if successful, another err_t otherwise */
+err_t sys_mbox_new(sys_mbox_t *mbox, int size);
 /** Post a message to an mbox - may not fail
  * -> blocks if full, only used from tasks not from ISR
  * @param mbox mbox to posts the message
  * @param msg message to post (ATTENTION: can be NULL) */
-void sys_mbox_post(sys_mbox_t mbox, void *msg);
+void sys_mbox_post(sys_mbox_t *mbox, void *msg);
 /** Try to post a message to an mbox - may fail if full or ISR
  * @param mbox mbox to posts the message
  * @param msg message to post (ATTENTION: can be NULL) */
-err_t sys_mbox_trypost(sys_mbox_t mbox, void *msg);
+err_t sys_mbox_trypost(sys_mbox_t *mbox, void *msg);
 /** Wait for a new message to arrive in the mbox
  * @param mbox mbox to get a message from
  * @param msg pointer where the message is stored
@@ -128,7 +177,7 @@ err_t sys_mbox_trypost(sys_mbox_t mbox, void *msg);
  * @return time (in miliseconds) waited for a message, may be 0 if not waited
            or SYS_ARCH_TIMEOUT on timeout
  *         The returned time has to be accurate to prevent timer jitter! */
-u32_t sys_arch_mbox_fetch(sys_mbox_t mbox, void **msg, u32_t timeout);
+u32_t sys_arch_mbox_fetch(sys_mbox_t *mbox, void **msg, u32_t timeout);
 /* Allow port to override with a macro, e.g. special timout for sys_arch_mbox_fetch() */
 #ifndef sys_arch_mbox_tryfetch
 /** Wait for a new message to arrive in the mbox
@@ -137,14 +186,22 @@ u32_t sys_arch_mbox_fetch(sys_mbox_t mbox, void **msg, u32_t timeout);
  * @param timeout maximum time (in miliseconds) to wait for a message
  * @return 0 (miliseconds) if a message has been received
  *         or SYS_MBOX_EMPTY if the mailbox is empty */
-u32_t sys_arch_mbox_tryfetch(sys_mbox_t mbox, void **msg);
+u32_t sys_arch_mbox_tryfetch(sys_mbox_t *mbox, void **msg);
 #endif
 /** For now, we map straight to sys_arch implementation. */
 #define sys_mbox_tryfetch(mbox, msg) sys_arch_mbox_tryfetch(mbox, msg)
 /** Delete an mbox
  * @param mbox mbox to delete */
-void sys_mbox_free(sys_mbox_t mbox);
+void sys_mbox_free(sys_mbox_t *mbox);
 #define sys_mbox_fetch(mbox, msg) sys_arch_mbox_fetch(mbox, msg, 0)
+#ifndef sys_mbox_valid
+/** Check if an mbox is valid/allocated: return 1 for valid, 0 for invalid */
+int sys_mbox_valid(sys_mbox_t *mbox);
+#endif
+#ifndef sys_mbox_set_invalid
+/** Set an mbox invalid so that sys_mbox_valid returns 0 */
+void sys_mbox_set_invalid(sys_mbox_t *mbox);
+#endif
 
 /** The only thread function:
  * Creates a new thread

src/include/lwip/tcpip.h

@@ -50,9 +50,9 @@ extern "C" {
 
 #if LWIP_TCPIP_CORE_LOCKING
 /** The global semaphore to lock the stack. */
-extern sys_sem_t lock_tcpip_core;
-#define LOCK_TCPIP_CORE()     sys_sem_wait(lock_tcpip_core)
-#define UNLOCK_TCPIP_CORE()   sys_sem_signal(lock_tcpip_core)
+extern sys_mutex_t lock_tcpip_core;
+#define LOCK_TCPIP_CORE()     sys_mutex_lock(&lock_tcpip_core)
+#define UNLOCK_TCPIP_CORE()   sys_mutex_unlock(&lock_tcpip_core)
 #define TCPIP_APIMSG(m)       tcpip_apimsg_lock(m)
 #define TCPIP_APIMSG_ACK(m)
 #define TCPIP_NETIFAPI(m)     tcpip_netifapi_lock(m)
@@ -61,9 +61,9 @@ extern sys_sem_t lock_tcpip_core;
 #define LOCK_TCPIP_CORE()
 #define UNLOCK_TCPIP_CORE()
 #define TCPIP_APIMSG(m)       tcpip_apimsg(m)
-#define TCPIP_APIMSG_ACK(m)   sys_sem_signal(m->conn->op_completed)
+#define TCPIP_APIMSG_ACK(m)   sys_sem_signal(&m->conn->op_completed)
 #define TCPIP_NETIFAPI(m)     tcpip_netifapi(m)
-#define TCPIP_NETIFAPI_ACK(m) sys_sem_signal(m->sem)
+#define TCPIP_NETIFAPI_ACK(m) sys_sem_signal(&m->sem)
 #endif /* LWIP_TCPIP_CORE_LOCKING */
 
 /** Function prototype for the init_done function passed to tcpip_init */

src/include/lwip/timers.h

@@ -81,7 +81,7 @@ void sys_untimeout(sys_timeout_handler h, void *arg);
 void sys_check_timeouts(void);
 void sys_restart_timeouts(void);
 #else /* NO_SYS */
-void sys_timeouts_mbox_fetch(sys_mbox_t mbox, void **msg);
+void sys_timeouts_mbox_fetch(sys_mbox_t *mbox, void **msg);
 #endif /* NO_SYS */