Fixed SYS_ARCH_PROTECT macros when NO_SYS is not defined.

Added documentation for lightweight protection.

Fixed debug statement in ip.c.

Removed tabs in files I changed.

diff --git a/doc/sys_arch.txt b/doc/sys_arch.txt
index 6568a77571d50f9e4eb2efd955ae3a394ef3955c..4b0a34234413a30e1077df658e5d54a8b5625794 100644 (file)
--- a/doc/sys_arch.txt
+++ b/doc/sys_arch.txt
@@ -121,3 +121,26 @@ to be implemented as well:
   "thread()". The "arg" argument will be passed as an argument to the
   thread() function. The id of the new thread is returned.
 
+- 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.
+
+- 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.
+
+
+

diff --git a/src/core/ipv4/ip.c b/src/core/ipv4/ip.c
index e7a324ef11ea091f61acdb8d7b5d53bf051e1de4..09876e2614277ddcbd03e4d24a6e937a7e53088d 100644 (file)
--- a/src/core/ipv4/ip.c
+++ b/src/core/ipv4/ip.c
@@ -164,7 +164,7 @@ ip_forward(struct pbuf *p, struct ip_hdr *iphdr, struct netif *inp)
   netif = ip_route((struct ip_addr *)&(iphdr->dest));
   if(netif == NULL) {
     DEBUGF(IP_DEBUG, ("ip_forward: no forwarding route for 0x%lx found\n",
-                     iphdr->dest.addr));
+                      iphdr->dest.addr));
     snmp_inc_ipnoroutes();
     return;
   }
@@ -196,7 +196,7 @@ ip_forward(struct pbuf *p, struct ip_hdr *iphdr, struct netif *inp)
   }
 
   DEBUGF(IP_DEBUG, ("ip_forward: forwarding packet to 0x%lx\n",
-                   iphdr->dest.addr));
+                    iphdr->dest.addr));
 
 #ifdef IP_STATS
   ++lwip_stats.ip.fw;
@@ -290,10 +290,10 @@ ip_input(struct pbuf *p, struct netif *inp) {
   for(netif = netif_list; netif != NULL; netif = netif->next) {
 
     DEBUGF(IP_DEBUG, ("ip_input: iphdr->dest 0x%lx netif->ip_addr 0x%lx (0x%lx, 0x%lx, 0x%lx)\n",
-                     iphdr->dest.addr, netif->ip_addr.addr,
-                     iphdr->dest.addr & netif->netmask.addr,
-                     netif->ip_addr.addr & netif->netmask.addr,
-                     iphdr->dest.addr & ~(netif->netmask.addr)));
+                      iphdr->dest.addr, netif->ip_addr.addr,
+                      iphdr->dest.addr & netif->netmask.addr,
+                      netif->ip_addr.addr & netif->netmask.addr,
+                      iphdr->dest.addr & ~(netif->netmask.addr)));
 
     /* interface configured? */
     if(!ip_addr_isany(&(netif->ip_addr)))
@@ -306,7 +306,7 @@ ip_input(struct pbuf *p, struct netif *inp) {
          /* or restricted broadcast? */
          ip_addr_cmp(&(iphdr->dest), IP_ADDR_BROADCAST)) {
          DEBUGF(IP_DEBUG, ("ip_input: packet accepted on interface %c%c\n",
-                      netif->name[0], netif->name[1]));
+                       netif->name[0], netif->name[1]));
          /* break out of for loop */
          break;
       }
@@ -328,7 +328,7 @@ ip_input(struct pbuf *p, struct netif *inp) {
     }
   }
 #endif /* LWIP_DHCP */
-       /* packet not for us? */  
+        /* packet not for us? */  
   if(netif == NULL) {
     /* packet not for us, route or discard */
     DEBUGF(IP_DEBUG, ("ip_input: packet not for us.\n"));
@@ -349,7 +349,7 @@ ip_input(struct pbuf *p, struct netif *inp) {
 
 #if IP_REASSEMBLY
   if((IPH_OFFSET(iphdr) & htons(IP_OFFMASK | IP_MF)) != 0) {
-    DEBUGF(IP_DEBUG, ("IP packet is a fragment (id=0x%04x tot_len=%u len=%u MF=%u offset=%u), calling ip_reass()\n", ntohs(IPH_ID(iphdr)), p->tot_len, ntohs(IPH_LEN(iphdr)), !!(IPH_OFFSET(iphdr) & htons(IP_MF)), (ntohs(IPH_OFFSET(iphdr)) & IP_OFFMASK))*8);
+    DEBUGF(IP_DEBUG, ("IP packet is a fragment (id=0x%04x tot_len=%u len=%u MF=%u offset=%u), calling ip_reass()\n", ntohs(IPH_ID(iphdr)), p->tot_len, ntohs(IPH_LEN(iphdr)), !!(IPH_OFFSET(iphdr) & htons(IP_MF)), (ntohs(IPH_OFFSET(iphdr)) & IP_OFFMASK)*8));
     p = ip_reass(p);
     if(p == NULL) {
       return ERR_OK;
@@ -360,7 +360,7 @@ ip_input(struct pbuf *p, struct netif *inp) {
   if((IPH_OFFSET(iphdr) & htons(IP_OFFMASK | IP_MF)) != 0) {
     pbuf_free(p);
     DEBUGF(IP_DEBUG, ("IP packet dropped since it was fragmented (0x%x) (while IP_REASSEMBLY == 0).\n",
-                 ntohs(IPH_OFFSET(iphdr))));
+                  ntohs(IPH_OFFSET(iphdr))));
 #ifdef IP_STATS
     ++lwip_stats.ip.opterr;
     ++lwip_stats.ip.drop;
@@ -439,8 +439,8 @@ ip_input(struct pbuf *p, struct netif *inp) {
 /*-----------------------------------------------------------------------------------*/
 err_t
 ip_output_if(struct pbuf *p, struct ip_addr *src, struct ip_addr *dest,
-            u8_t ttl,
-            u8_t proto, struct netif *netif)
+             u8_t ttl,
+             u8_t proto, struct netif *netif)
 {
   static struct ip_hdr *iphdr;
   static u16_t ip_id = 0;
@@ -484,7 +484,7 @@ ip_output_if(struct pbuf *p, struct ip_addr *src, struct ip_addr *dest,
     dest = &(iphdr->dest);
   }
 
-#if IP_FRAG    
+#if IP_FRAG     
   /* don't fragment if interface has mtu set to 0 [loopif] */
   if (netif->mtu && (p->tot_len > netif->mtu))
     return ip_frag(p,netif,dest);
@@ -511,7 +511,7 @@ ip_output_if(struct pbuf *p, struct ip_addr *src, struct ip_addr *dest,
 /*-----------------------------------------------------------------------------------*/
 err_t
 ip_output(struct pbuf *p, struct ip_addr *src, struct ip_addr *dest,
-         u8_t ttl, u8_t proto)
+          u8_t ttl, u8_t proto)
 {
   struct netif *netif;
   
@@ -540,34 +540,34 @@ ip_debug_print(struct pbuf *p)
   DEBUGF(IP_DEBUG, ("IP header:\n"));
   DEBUGF(IP_DEBUG, ("+-------------------------------+\n"));
   DEBUGF(IP_DEBUG, ("|%2d |%2d |   %2u  |      %4u     | (v, hl, tos, len)\n",
-                   IPH_V(iphdr),
-                   IPH_HL(iphdr),
-                   IPH_TOS(iphdr),
-                   ntohs(IPH_LEN(iphdr))));
+                    IPH_V(iphdr),
+                    IPH_HL(iphdr),
+                    IPH_TOS(iphdr),
+                    ntohs(IPH_LEN(iphdr))));
   DEBUGF(IP_DEBUG, ("+-------------------------------+\n"));
   DEBUGF(IP_DEBUG, ("|    %5u      |%u%u%u|    %4u   | (id, flags, offset)\n",
-                   ntohs(IPH_ID(iphdr)),
-                   ntohs(IPH_OFFSET(iphdr)) >> 15 & 1,
-                   ntohs(IPH_OFFSET(iphdr)) >> 14 & 1,
-                   ntohs(IPH_OFFSET(iphdr)) >> 13 & 1,
-                   ntohs(IPH_OFFSET(iphdr)) & IP_OFFMASK));
+                    ntohs(IPH_ID(iphdr)),
+                    ntohs(IPH_OFFSET(iphdr)) >> 15 & 1,
+                    ntohs(IPH_OFFSET(iphdr)) >> 14 & 1,
+                    ntohs(IPH_OFFSET(iphdr)) >> 13 & 1,
+                    ntohs(IPH_OFFSET(iphdr)) & IP_OFFMASK));
   DEBUGF(IP_DEBUG, ("+-------------------------------+\n"));
   DEBUGF(IP_DEBUG, ("|   %2u  |   %2u  |    0x%04x     | (ttl, proto, chksum)\n",
-                   IPH_TTL(iphdr),
-                   IPH_PROTO(iphdr),
-                   ntohs(IPH_CHKSUM(iphdr))));
+                    IPH_TTL(iphdr),
+                    IPH_PROTO(iphdr),
+                    ntohs(IPH_CHKSUM(iphdr))));
   DEBUGF(IP_DEBUG, ("+-------------------------------+\n"));
   DEBUGF(IP_DEBUG, ("|  %3ld  |  %3ld  |  %3ld  |  %3ld  | (src)\n",
-                   ntohl(iphdr->src.addr) >> 24 & 0xff,
-                   ntohl(iphdr->src.addr) >> 16 & 0xff,
-                   ntohl(iphdr->src.addr) >> 8 & 0xff,
-                   ntohl(iphdr->src.addr) & 0xff));
+                    ntohl(iphdr->src.addr) >> 24 & 0xff,
+                    ntohl(iphdr->src.addr) >> 16 & 0xff,
+                    ntohl(iphdr->src.addr) >> 8 & 0xff,
+                    ntohl(iphdr->src.addr) & 0xff));
   DEBUGF(IP_DEBUG, ("+-------------------------------+\n"));
   DEBUGF(IP_DEBUG, ("|  %3ld  |  %3ld  |  %3ld  |  %3ld  | (dest)\n",
-                   ntohl(iphdr->dest.addr) >> 24 & 0xff,
-                   ntohl(iphdr->dest.addr) >> 16 & 0xff,
-                   ntohl(iphdr->dest.addr) >> 8 & 0xff,
-                   ntohl(iphdr->dest.addr) & 0xff));
+                    ntohl(iphdr->dest.addr) >> 24 & 0xff,
+                    ntohl(iphdr->dest.addr) >> 16 & 0xff,
+                    ntohl(iphdr->dest.addr) >> 8 & 0xff,
+                    ntohl(iphdr->dest.addr) & 0xff));
   DEBUGF(IP_DEBUG, ("+-------------------------------+\n"));
 }
 #endif /* IP_DEBUG */

diff --git a/src/include/lwip/sys.h b/src/include/lwip/sys.h
index 0caceea90dc3ea3648c3526739c4683ca774b3a6..753fcadc51ef23a09fb231d17469dee0686c5c46 100644 (file)
--- a/src/include/lwip/sys.h
+++ b/src/include/lwip/sys.h
@@ -36,9 +36,6 @@
 
 #include "lwip/opt.h"
 
-#define SYS_ARCH_DECL_PROTECT(lev)
-#define SYS_ARCH_PROTECT(lev)
-#define SYS_ARCH_UNPROTECT(lev)
 
 #if NO_SYS
 
@@ -61,6 +58,11 @@ struct sys_timeout {u8_t dummy;};
 
 #define sys_thread_new(t,a)
 
+/* We don't need protection if there is no OS */
+#define SYS_ARCH_DECL_PROTECT(lev)
+#define SYS_ARCH_PROTECT(lev)
+#define SYS_ARCH_UNPROTECT(lev)
+
 #else /* NO_SYS */
 
 #include "arch/sys_arch.h"
@@ -115,13 +117,37 @@ void sys_mbox_fetch(sys_mbox_t mbox, void **msg);
    mechanism than using semaphores. Otherwise semaphores can be used for
    implementation */
 #ifndef SYS_ARCH_PROTECT
+/** SYS_LIGHTWEIGHT_PROT
+ * define SYS_LIGHTWEIGHT_PROT in lwipopts.h if you want inter-task protection
+ * for certain critical regions during buffer allocation, deallocation and memory
+ * allocation and deallocation.
+ */
 #ifdef SYS_LIGHTWEIGHT_PROT
 
-#undef SYS_ARCH_DECL_PROTECT
+/** SYS_ARCH_DECL_PROTECT
+ * declare a protection variable. This macro will default to defining a variable of
+ * type sys_prot_t. If a particular port needs a different implementation, then
+ * this macro may be defined in sys_arch.h.
+ */
 #define SYS_ARCH_DECL_PROTECT(lev) sys_prot_t lev
-#undef SYS_ARCH_PROTECT
+/** SYS_ARCH_PROTECT
+ * Perform a "fast" protect. This could be implemented by
+ * disabling interrupts for an embedded system or by using a semaphore or
+ * mutex. The implementation should allow calling SYS_ARCH_PROTECT when
+ * already protected. The old protection level is returned in the variable
+ * "lev". This macro will default to calling the sys_arch_protect() function
+ * which should be implemented in sys_arch.c. If a particular port needs a
+ * different implementation, then this macro may be defined in sys_arch.h
+ */
 #define SYS_ARCH_PROTECT(lev) lev = sys_arch_protect()
-#undef SYS_ARCH_UNPROTECT
+/** SYS_ARCH_UNPROTECT
+ * Perform a "fast" set of the protection level to "lev". This could be
+ * implemented by setting the interrupt level to "lev" within the MACRO or by
+ * using a semaphore or mutex.  This macro will default to calling the
+ * sys_arch_unprotect() function which should be implemented in
+ * sys_arch.c. If a particular port needs a different implementation, then
+ * this macro may be defined in sys_arch.h
+ */
 #define SYS_ARCH_UNPROTECT(lev) sys_arch_unprotect(lev)
 sys_prot_t sys_arch_protect(void);
 void sys_arch_unprotect(sys_prot_t pval);