Hi All,
I am new here. I've been working on a ARM32 32F417 project for a
couple of years. Someone else, working 1 day a week, implemented
FreeRTOS, LWIP and MbedTLS and I am now revisiting these issues which
I don't think were looked at in detail originally.
Specifically I would like to know what LWIP settings are needed to
achieve thread safety.
For example I have one thread doing NTP (socket() call to get a UDP
socket) and another thread doing a simple HTTP server (using the
netconn API which seems to end up in the same "socket" API as the
foregoing).
Reading the vast number of mostly inconclusive posts on the internet,
there appear to be two classes of API functions, and thread safety is
more easily achieved if you restrict yourself to just one of these
classes. But the advice is ambiguous.
It looks like the implementer is required to provide a mutex set/reset
function, although the need for this depends on which of the two above
API sections one is using. I also appears that if you use just one
class, the mutex is not necessary and just using the "critical
section" macros (which basically just disable interrupts) is
sufficient.
OTOH a lot of online text says that LWIP is thread safe "out of the
box" in some cases...
I am using Cube IDE and have been stepping through the code but I am
not much wiser.
===
The idea appears to have
NO_SYS 0
LWIP_TCPIP_CORE_LOCKING 1
but that crashes the whole thing, presumably because nobody has
implemented any of the above mentioned hooks.
FreeRTOS can supply mutexes and these work very well. I use them all
over the place.
Looks like you have to implement these functions
#define LWIP_MEM_FREE_PROTECT() sys_mutex_lock(&mem_mutex)
#define LWIP_MEM_FREE_UNPROTECT() sys_mutex_unlock(&mem_mutex)
There are what appear to be example functions in sys_arch.c under
Mutexes.
I find all this very confusing because e.g. here
https://www.nongnu.org/lwip/2_0_x/pitfalls.html
it states that
In OS mode, Callback-style APIs AND Sequential-style APIs can be used.
Sequential-style APIs are designed to be called from threads other
than the TCPIP thread, so there is nothing to consider here. The
implication is that these do not need mutex protection. And indeed
stepping through code such as
fd = socket(AF_INET, SOCK_DGRAM, 0);
does find that a mutex is used, deep down.
it calls conn = (struct netconn *)memp_malloc(MEMP_NETCONN);
which does SYS_ARCH_PROTECT(old_level);
but I can't see that defined anywhere so that is probably what needs
to be done if you are setting
LWIP_TCPIP_CORE_LOCKING 1
What I can't find anywhere is whether the "sequential" functions are
thread-safe with or without LWIP_TCPIP_CORE_LOCKING.
And where does SYS_ARCH_PROTECT come into all this, since it seems
unrelated to LWIP_TCPIP_CORE_LOCKING.
There is also a subtle issue which I am sure is unrelated to thread
safety whereby if a single UDP socket is opened, it causes the HTTP
server to be unable to transmit packets (lots of LWIP error
counters++) when TLS is doing to crypto handshake (2-3 secs). This
happens on the mere allocation of the UDP socket; no data being sent.
Debugging this is too complicated because nobody I know knows where to
look. It makes no difference what values one puts in the lwipopts.h
file. I could post the file here but it would make a long post amd
those tend to not produce replies :)
Thank you in advance for any help.
Peter
_______________________________________________
lwip-users mailing list
lwip-users@nongnu.org
https://lists.nongnu.org/mailman/listinfo/lwip-users