sergiotarxz/nuttx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

networking: IGMP: Remove special support for interrupt level processing (there is none) and fix some timer cancellation logic. In many files, correct comments. There is no interrupt level processing in the networking layer.

Browse Source
This commit is contained in:
Gregory Nutt 2017-09-02 10:27:03 -06:00
parent 8c2e3a2d0a
commit 8ffb103adb
25 changed files with 115 additions and 346 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
net/igmp/Kconfig
View File

@ -3,8 +3,6 @@
# see the file kconfig-language.txt in the NuttX tools repository.
#
menu "IGMPv2 Client Support"
config NET_IGMP
bool "IGMPv2 client support"
default n
@ -14,12 +12,4 @@ config NET_IGMP
if NET_IGMP
config PREALLOC_IGMPGROUPS
int "Number of pre-allocated IGMP groups"
default 4
---help---
Pre-allocated IGMP groups are used only if needed from interrupt
level group created (by the IGMP server). Default: 4.
endif # NET_IGMP
endmenu # IGMPv2 Client Support

62
net/igmp/igmp.h
View File

@ -123,7 +123,6 @@ EXTERN in_addr_t g_ipv4_allrouters;
* Public Function Prototypes
****************************************************************************/
/* Defined in igmp_init.c ***************************************************/
/****************************************************************************
* Name: igmp_initialize
*
@ -145,42 +144,22 @@ void igmp_initialize(void);
void igmp_devinit(FAR struct net_driver_s *dev);
/* Defined in igmp_input.c **************************************************/
/****************************************************************************
* Name: igmp_input
*
* Description:
* An IGMP packet has been received.
*
* NOTE: This is most likely executing from an interrupt handler.
*
****************************************************************************/
void igmp_input(struct net_driver_s *dev);
/* Defined in igmp_group.c **************************************************/
/****************************************************************************
* Name: igmp_grpinit
*
* Description:
* One-time initialization of group data.
*
* Assumptions:
* Called only during early boot phases (pre-multitasking).
*
****************************************************************************/
void igmp_grpinit(void);
/****************************************************************************
* Name: igmp_grpalloc
*
* Description:
* Allocate a new group from heap memory.
*
* Assumptions:
* May be called from either user or interrupt level processing.
*
****************************************************************************/
FAR struct igmp_group_s *igmp_grpalloc(FAR struct net_driver_s *dev,
@ -192,9 +171,6 @@ FAR struct igmp_group_s *igmp_grpalloc(FAR struct net_driver_s *dev,
* Description:
* Find an existing group.
*
* Assumptions:
* May be called from either user or interrupt level processing.
*
****************************************************************************/
FAR struct igmp_group_s *igmp_grpfind(FAR struct net_driver_s *dev,
@ -207,9 +183,6 @@ FAR struct igmp_group_s *igmp_grpfind(FAR struct net_driver_s *dev,
* Find an existing group. If not found, create a new group for the
* address.
*
* Assumptions:
* May be called from either user or interrupt level processing.
*
****************************************************************************/
FAR struct igmp_group_s *igmp_grpallocfind(FAR struct net_driver_s *dev,
@ -221,24 +194,17 @@ FAR struct igmp_group_s *igmp_grpallocfind(FAR struct net_driver_s *dev,
* Description:
* Release a previously allocated group.
*
* Assumptions:
* May be called from either user or interrupt level processing.
*
****************************************************************************/
void igmp_grpfree(FAR struct net_driver_s *dev,
FAR struct igmp_group_s *group);
/* Defined in igmp_msg.c ****************************************************/
/****************************************************************************
* Name: igmp_schedmsg
*
* Description:
* Schedule a message to be send at the next driver polling interval.
*
* Assumptions:
* This function may be called in most any context.
*
****************************************************************************/
void igmp_schedmsg(FAR struct igmp_group_s *group, uint8_t msgid);
@ -250,15 +216,10 @@ void igmp_schedmsg(FAR struct igmp_group_s *group, uint8_t msgid);
* Schedule a message to be send at the next driver polling interval and
* block, waiting for the message to be sent.
*
* Assumptions:
* This function cannot be called from an interrupt handler (if you try it,
* net_lockedwait will assert).
*
****************************************************************************/
void igmp_waitmsg(FAR struct igmp_group_s *group, uint8_t msgid);
/* Defined in igmp_poll.c ***************************************************/
/****************************************************************************
* Name: igmp_poll
*
@ -269,15 +230,10 @@ void igmp_waitmsg(FAR struct igmp_group_s *group, uint8_t msgid);
* Returned Value:
* Returns a non-zero value if a IGP message is sent.
*
* Assumptions:
* This function is called from the driver polling logic... probably within
* an interrupt handler.
*
****************************************************************************/
void igmp_poll(FAR struct net_driver_s *dev);
/* Defined in igmp_send.c ***************************************************/
/****************************************************************************
* Name: igmp_send
*
@ -302,7 +258,6 @@ void igmp_poll(FAR struct net_driver_s *dev);
void igmp_send(FAR struct net_driver_s *dev, FAR struct igmp_group_s *group,
FAR in_addr_t *dest);
/* Defined in igmp_join.c ***************************************************/
/****************************************************************************
* Name: igmp_joingroup
*
@ -321,15 +276,11 @@ void igmp_send(FAR struct net_driver_s *dev, FAR struct igmp_group_s *group,
* as if a Group-Specific Query was received for that group, and set a
* timer appropriately)."
*
* Assumptions:
* This function cannot be called from interrupt handling logic!
*
****************************************************************************/
int igmp_joingroup(FAR struct net_driver_s *dev,
FAR const struct in_addr *grpaddr);
/* Defined in igmp_leave.c **************************************************/
/****************************************************************************
* Name: igmp_leavegroup
*
@ -353,24 +304,17 @@ int igmp_joingroup(FAR struct net_driver_s *dev,
* has left the group, but it does no harm to address the message to the
* group."
*
* Assumptions:
* This function cannot be called from interrupt handling logic!
*
****************************************************************************/
int igmp_leavegroup(FAR struct net_driver_s *dev,
FAR const struct in_addr *grpaddr);
/* Defined in igmp_timer.c **************************************************/
/****************************************************************************
* Name: igmp_startticks and igmp_starttimer
*
* Description:
* Start the IGMP timer with differing time units (ticks or deciseconds).
*
* Assumptions:
* This function may be called from most any context.
*
****************************************************************************/
void igmp_startticks(FAR struct igmp_group_s *group, unsigned int ticks);
@ -384,15 +328,13 @@ void igmp_starttimer(FAR struct igmp_group_s *group, uint8_t decisecs);
* value. If maxticks > ticks-remaining, then (1) cancel the timer (to
* avoid race conditions) and return true.
*
* Assumptions:
* This function may be called from most any context. If true is returned
* then the caller must call igmp_startticks() to restart the timer
* If true is returned then the caller must call igmp_startticks() to
* restart the timer
*
****************************************************************************/
bool igmp_cmptimer(FAR struct igmp_group_s *group, int maxticks);
/* Defined in igmp_mcastmac *************************************************/
/****************************************************************************
* Name: igmp_addmcastmac
*

147
net/igmp/igmp_group.c
View File

@ -75,10 +75,6 @@
# error "IGMP for IPv6 not supported"
#endif
#ifndef CONFIG_PREALLOC_IGMPGROUPS
# define CONFIG_PREALLOC_IGMPGROUPS 4
#endif
/* Debug ********************************************************************/
#undef IGMP_GRPDEBUG /* Define to enable detailed IGMP group debug */
@ -105,108 +101,16 @@
# endif
#endif
/****************************************************************************
* Private Data
****************************************************************************/
/* kmm_malloc() cannot be called from an interrupt handler. To work around this,
* a small number of IGMP groups are preallocated just for use in interrupt
* handling logic.
*/
#if CONFIG_PREALLOC_IGMPGROUPS > 0
static struct igmp_group_s g_preallocgrps[CONFIG_PREALLOC_IGMPGROUPS];
static FAR sq_queue_t g_freelist;
#endif
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Name: igmp_grpheapalloc
*
* Description:
* Allocate a new group from heap memory.
*
* Assumptions:
* Calls kmm_malloc and so cannot be called from an interrupt handler.
*
****************************************************************************/
static inline FAR struct igmp_group_s *igmp_grpheapalloc(void)
{
return (FAR struct igmp_group_s *)kmm_zalloc(sizeof(struct igmp_group_s));
}
/****************************************************************************
* Name: igmp_grpprealloc
*
* Description:
* Allocate a new group from the pre-allocated groups.
*
* Assumptions:
* This function should only be called from an interrupt handler (or with
* interrupts disabled).
*
****************************************************************************/
#if CONFIG_PREALLOC_IGMPGROUPS > 0
static inline FAR struct igmp_group_s *igmp_grpprealloc(void)
{
FAR struct igmp_group_s *group =
(FAR struct igmp_group_s *)sq_remfirst(&g_freelist);
if (group)
{
memset(group, 0, sizeof(struct igmp_group_s));
group->flags = IGMP_PREALLOCATED;
}
return group;
}
#endif
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: igmp_grpinit
*
* Description:
* One-time initialization of group data.
*
* Assumptions:
* Called only during early boot phases (pre-multitasking).
*
****************************************************************************/
void igmp_grpinit(void)
{
FAR struct igmp_group_s *group;
int i;
grpinfo("Initializing\n");
#if CONFIG_PREALLOC_IGMPGROUPS > 0
for (i = 0; i < CONFIG_PREALLOC_IGMPGROUPS; i++)
{
group = &g_preallocgrps[i];
sq_addfirst((FAR sq_entry_t *)group, &g_freelist);
}
#endif
}
/****************************************************************************
* Name: igmp_grpalloc
*
* Description:
* Allocate a new group from heap memory.
*
* Assumptions:
* May be called from either user or interrupt level processing.
*
****************************************************************************/
FAR struct igmp_group_s *igmp_grpalloc(FAR struct net_driver_s *dev,
@ -215,27 +119,13 @@ FAR struct igmp_group_s *igmp_grpalloc(FAR struct net_driver_s *dev,
FAR struct igmp_group_s *group;
ninfo("addr: %08x dev: %p\n", *addr, dev);
if (up_interrupt_context())
{
#if CONFIG_PREALLOC_IGMPGROUPS > 0
grpinfo("Use a pre-allocated group entry\n");
group = igmp_grpprealloc();
#else
grperr("ERROR: Cannot allocate from interrupt handler\n");
group = NULL;
#endif
}
else
{
grpinfo("Allocate from the heap\n");
group = igmp_grpheapalloc();
}
group = (FAR struct igmp_group_s *)kmm_zalloc(sizeof(struct igmp_group_s));
grpinfo("group: %p\n", group);
/* Check if we successfully allocated a group structure */
if (group)
if (group != NULL)
{
/* Initialize the non-zero elements of the group structure */
@ -272,9 +162,6 @@ FAR struct igmp_group_s *igmp_grpalloc(FAR struct net_driver_s *dev,
* Description:
* Find an existing group.
*
* Assumptions:
* May be called from either user or interrupt level processing.
*
****************************************************************************/
FAR struct igmp_group_s *igmp_grpfind(FAR struct net_driver_s *dev,
@ -284,10 +171,6 @@ FAR struct igmp_group_s *igmp_grpfind(FAR struct net_driver_s *dev,
grpinfo("Searching for addr %08x\n", (int)*addr);
/* We must disable interrupts because we don't which context we were
* called from.
*/
net_lock();
for (group = (FAR struct igmp_group_s *)dev->grplist.head;
group;
@ -312,9 +195,6 @@ FAR struct igmp_group_s *igmp_grpfind(FAR struct net_driver_s *dev,
* Find an existing group. If not found, create a new group for the
* address.
*
* Assumptions:
* May be called from either user or interrupt level processing.
*
****************************************************************************/
FAR struct igmp_group_s *igmp_grpallocfind(FAR struct net_driver_s *dev,
@ -338,9 +218,6 @@ FAR struct igmp_group_s *igmp_grpallocfind(FAR struct net_driver_s *dev,
* Description:
* Release a previously allocated group.
*
* Assumptions:
* May be called from either user or interrupt level processing.
*
****************************************************************************/
void igmp_grpfree(FAR struct net_driver_s *dev, FAR struct igmp_group_s *group)
@ -364,28 +241,12 @@ void igmp_grpfree(FAR struct net_driver_s *dev, FAR struct igmp_group_s *group)
wd_delete(group->wdog);
/* Then release the group structure resources. Check first if this is one
* of the pre-allocated group structures that we will retain in a free list.
*/
#if CONFIG_PREALLOC_IGMPGROUPS > 0
if (IS_PREALLOCATED(group->flags))
{
grpinfo("Put back on free list\n");
sq_addlast((FAR sq_entry_t *)group, &g_freelist);
net_unlock();
}
else
#endif
{
/* No.. deallocate the group structure. Use sched_kfree() just in case
* this function is executing within an interrupt handler.
*/
/* Then release the group structure resources. */
net_unlock();
grpinfo("Call sched_kfree()\n");
sched_kfree(group);
}
}
#endif /* CONFIG_NET_IGMP */

4
net/igmp/igmp_initialize.c
View File

@ -88,10 +88,6 @@ void igmp_initialize(void)
net_ipaddr(g_ipv4_allrouters, 224, 0, 0, 2);
net_ipaddr(g_ipv4_allsystems, 224, 0, 0, 1);
/* Initialize the group allocation logic */
igmp_grpinit();
}
/****************************************************************************

2
net/igmp/igmp_input.c
View File

@ -106,7 +106,7 @@
* | < current timer) |
* +-------------------+
*
* NOTE: This is most likely executing from an interrupt handler.
* NOTE: The network must be locked.
*
****************************************************************************/

3
net/igmp/igmp_join.c
View File

@ -111,9 +111,6 @@
* | < current timer) |
* +-------------------+
*
* Assumptions:
* This function cannot be called from interrupt handling logic!
*
****************************************************************************/
int igmp_joingroup(struct net_driver_s *dev, FAR const struct in_addr *grpaddr)

3
net/igmp/igmp_leave.c
View File

@ -119,9 +119,6 @@
* | < current timer) |
* +-------------------+
*
* Assumptions:
* This function cannot be called from interrupt handling logic!
*
****************************************************************************/
int igmp_leavegroup(struct net_driver_s *dev, FAR const struct in_addr *grpaddr)

4
net/igmp/igmp_msg.c
View File

@ -88,10 +88,6 @@ void igmp_schedmsg(FAR struct igmp_group_s *group, uint8_t msgid)
* Schedule a message to be send at the next driver polling interval and
* block, waiting for the message to be sent.
*
* Assumptions:
* This function cannot be called from an interrupt handler (if you try it,
* net_lockedwait will assert).
*
****************************************************************************/
void igmp_waitmsg(FAR struct igmp_group_s *group, uint8_t msgid)

6
net/igmp/igmp_poll.c
View File

@ -70,8 +70,7 @@
* Returns a non-zero value if an IGMP message is sent.
*
* Assumptions:
* This function is called from the driver polling logic... probably within
* an interrupt handler.
* This function ust be called with the network locked.
*
****************************************************************************/
@ -134,8 +133,7 @@ static inline void igmp_sched_send(FAR struct net_driver_s *dev,
* Returns a non-zero value if a IGP message is sent.
*
* Assumptions:
* This function is called from the driver polling logic... probably within
* an interrupt handler.
* This function must be called with the network locked.
*
****************************************************************************/

8
net/igmp/igmp_timer.c
View File

@ -48,6 +48,7 @@
#include <debug.h>
#include <nuttx/wdog.h>
#include <nuttx/irq.h>
#include <nuttx/net/netconfig.h>
#include <nuttx/net/net.h>
#include <nuttx/net/netstats.h>
@ -196,13 +197,14 @@ void igmp_starttimer(FAR struct igmp_group_s *group, uint8_t decisecs)
bool igmp_cmptimer(FAR struct igmp_group_s *group, int maxticks)
{
irqstate_t flags;
int remaining;
/* Disable interrupts so that there is no race condition with the actual
* timer expiration.
*/
net_lock();
flags = enter_critical_section();
/* Get the timer remaining on the watchdog. A time of <= zero means that
* the watchdog was never started.
@ -221,11 +223,11 @@ bool igmp_cmptimer(FAR struct igmp_group_s *group, int maxticks)
/* Cancel the watchdog timer and return true */
wd_cancel(group->wdog);
net_unlock();
leave_critical_section(flags);
return true;
}
net_unlock();
leave_critical_section(flags);
return false;
}

18
net/tcp/tcp_accept.c
View File

@ -62,7 +62,7 @@
struct accept_s
{
FAR struct socket *acpt_sock; /* The accepting socket */
sem_t acpt_sem; /* Wait for interrupt event */
sem_t acpt_sem; /* Wait for driver event */
FAR struct sockaddr *acpt_addr; /* Return connection address */
FAR socklen_t *acpt_addrlen; /* Return length of address */
FAR struct tcp_conn_s *acpt_newconn; /* The accepted connection */
@ -148,7 +148,7 @@ static inline void accept_tcpsender(FAR struct socket *psock,
* Name: accept_eventhandler
*
* Description:
* Receive interrupt level callbacks when connections occur
* Receive event callbacks when connections occur
*
* Parameters:
* listener The connection structure of the listener
@ -270,9 +270,9 @@ int psock_tcp_accept(FAR struct socket *psock, FAR struct sockaddr *addr,
/* Perform the TCP accept operation */
/* Initialize the state structure. This is done with interrupts
* disabled because we don't want anything to happen until we
* are ready.
/* Initialize the state structure. This is done with the network
* locked because we don't want anything to happen until we are
* ready.
*/
state.acpt_sock = psock;
@ -293,10 +293,8 @@ int psock_tcp_accept(FAR struct socket *psock, FAR struct sockaddr *addr,
conn->accept_private = (FAR void *)&state;
conn->accept = accept_eventhandler;
/* Wait for the send to complete or an error to occur: NOTES: (1)
* net_lockedwait will also terminate if a signal is received, (2)
* interrupts may be disabled! They will be re-enabled while the
* task sleeps and automatically re-enabled when the task restarts.
/* Wait for the send to complete or an error to occur: NOTES:
* net_lockedwait will also terminate if a signal is received.
*/
ret = net_lockedwait(&state.acpt_sem);
@ -315,7 +313,7 @@ int psock_tcp_accept(FAR struct socket *psock, FAR struct sockaddr *addr,
DEBUGASSERT(ret < 0);
}
/* Make sure that no further interrupts are processed */
/* Make sure that no further events are processed */
conn->accept_private = NULL;
conn->accept = NULL;

6
net/tcp/tcp_callback.c
View File

@ -67,7 +67,7 @@
* Assumptions:
* - The caller has checked that TCP_NEWDATA is set in flags and that is no
* other handler available to process the incoming data.
* - This function is called at the interrupt level with interrupts disabled.
* - This function must be called with the network locked.
*
****************************************************************************/
@ -139,7 +139,7 @@ tcp_data_event(FAR struct net_driver_s *dev, FAR struct tcp_conn_s *conn,
* Inform the application holding the TCP socket of a change in state.
*
* Assumptions:
* This function is called at the interrupt level with interrupts disabled.
* This function must be called with the network locked.
*
****************************************************************************/
@ -225,7 +225,7 @@ uint16_t tcp_callback(FAR struct net_driver_s *dev,
* Assumptions:
* - The caller has checked that TCP_NEWDATA is set in flags and that is no
* other handler available to process the incoming data.
* - This function is called at the interrupt level with interrupts disabled.
* - This function must be called with the network locked.
*
****************************************************************************/

29
net/tcp/tcp_conn.c
View File

@ -312,7 +312,7 @@ static int tcp_selectport(uint8_t domain, FAR const union ip_addr_u *ipaddr,
* connection to be used with the provided TCP/IP header
*
* Assumptions:
* This function is called from network logic at interrupt level
* This function is called from network logic with the nework locked.
*
****************************************************************************/
@ -379,8 +379,8 @@ static inline FAR struct tcp_conn_s *
* connection to be used with the provided TCP/IP header
*
* Assumptions:
* This function is called from network logic at interrupt level
*
* This function is called from network logic with the nework locked.
4 *
****************************************************************************/
#ifdef CONFIG_NET_IPv6
@ -611,8 +611,8 @@ void tcp_initialize(void)
* Description:
* Find a free TCP/IP connection structure and allocate it
* for use. This is normally something done by the implementation of the
* socket() API but is also called from the interrupt level when a TCP
* packet is received while "listening"
* socket() API but is also called from the even procressing lock when a
* TCP packet is received while "listening"
*
****************************************************************************/
@ -620,9 +620,9 @@ FAR struct tcp_conn_s *tcp_alloc(uint8_t domain)
{
FAR struct tcp_conn_s *conn;
/* Because this routine is called from both interrupt level and
* and from user level, we have not option but to disable interrupts
* while accessing g_free_tcp_connections[];
/* Because this routine is called from both event processing (with the
* network locked) and and from user level. Make sure that the network
* locked in any cased while accessing g_free_tcp_connections[];
*/
net_lock();
@ -737,8 +737,8 @@ void tcp_free(FAR struct tcp_conn_s *conn)
FAR struct tcp_wrbuffer_s *wrbuffer;
#endif
/* Because g_free_tcp_connections is accessed from user level and interrupt
* level, code, it is necessary to keep interrupts disabled during this
/* Because g_free_tcp_connections is accessed from user level and event
* processing logic, it is necessary to keep the newtork locked during this
* operation.
*/
@ -819,7 +819,7 @@ void tcp_free(FAR struct tcp_conn_s *conn)
* connection to be used with the provided TCP/IP header
*
* Assumptions:
* This function is called from network logic at interrupt level
* This function is called from network logic with the nework locked.
*
****************************************************************************/
@ -852,8 +852,7 @@ FAR struct tcp_conn_s *tcp_active(FAR struct net_driver_s *dev,
* Traverse the list of active TCP connections
*
* Assumptions:
* This function is called from network logic at interrupt level (or with
* interrupts disabled).
* This function is called from network logic with the nework locked.
*
****************************************************************************/
@ -873,12 +872,12 @@ FAR struct tcp_conn_s *tcp_nextconn(FAR struct tcp_conn_s *conn)
* Name: tcp_alloc_accept
*
* Description:
* Called when driver interrupt processing matches the incoming packet
* Called when driver event processing matches the incoming packet
* with a connection in LISTEN. In that case, this function will create
* a new connection and initialize it to send a SYNACK in return.
*
* Assumptions:
* This function is called from network logic at interrupt level
* This function is called from network logic with the nework locked.
*
****************************************************************************/

6
net/tcp/tcp_connect.c
View File

@ -362,10 +362,8 @@ int psock_tcp_connect(FAR struct socket *psock,
if (ret >= 0)
{
/* Wait for either the connect to complete or for an error/timeout
* to occur. NOTES: (1) net_lockedwait will also terminate if a signal
* is received, (2) interrupts may be disabled! They will be re-
* enabled while the task sleeps and automatically re-disabled
* when the task restarts.
* to occur. NOTES: net_lockedwait will also terminate if a signal
* is received.
*/
ret = net_lockedwait(&state.tc_sem);

14
net/tcp/tcp_listen.c
View File

@ -73,7 +73,7 @@ static FAR struct tcp_conn_s *tcp_listenports[CONFIG_NET_MAX_LISTENPORTS];
* Return the connection listener for connections on this port (if any)
*
* Assumptions:
* Called at interrupt level
* This function is called from network logic with the nework locked.
*
****************************************************************************/
@ -183,8 +183,8 @@ int tcp_listen(FAR struct tcp_conn_s *conn)
int ndx;
int ret;
/* This must be done with interrupts disabled because the listener table
* is accessed from interrupt level as well.
/* This must be done with network locked because the listener table
* is accessed from event processing logic as well.
*/
net_lock();
@ -237,7 +237,7 @@ int tcp_listen(FAR struct tcp_conn_s *conn)
* Return true is there is a listener for the specified port
*
* Assumptions:
* Called at interrupt level
* This function is called from network logic with the nework locked.
*
****************************************************************************/
@ -270,9 +270,9 @@ int tcp_accept_connection(FAR struct net_driver_s *dev,
FAR struct tcp_conn_s *listener;
int ret = ERROR;
/* The interrupt logic has already allocated and initialized a TCP
* connection -- now check there if is an application in place to accept the
* connection.
/* The event processing logic has already allocated and initialized a TCP
* connection -- now check there if is an application in place to accept
* the connection.
*/
#if defined(CONFIG_NET_IPv4) && defined(CONFIG_NET_IPv6)

2
net/tcp/tcp_netpoll.c
View File

@ -77,7 +77,7 @@ struct tcp_poll_s
* the device interface layer.
*
* Parameters:
* dev The structure of the network driver that caused the interrupt
* dev The structure of the network driver that caused the event
* conn The connection structure associated with the socket
* flags Set of events describing why the callback was invoked
*

13
net/tcp/tcp_send_buffered.c
View File

@ -216,7 +216,7 @@ static inline void psock_lost_connection(FAR struct socket *psock,
* nothing.
*
* Parameters:
* dev - The structure of the network driver that caused the interrupt
* dev - The structure of the network driver that caused the event
* psock - Socket state structure
*
* Returned Value:
@ -324,11 +324,11 @@ static inline bool psock_send_addrchck(FAR struct tcp_conn_s *conn)
* Name: psock_send_eventhandler
*
* Description:
* This function is called from the interrupt level to perform the actual
* send operation when polled by the lower, device interfacing layer.
* This function is called to perform the actual send operation when
* polled by the lower, device interfacing layer.
*
* Parameters:
* dev The structure of the network driver that caused the interrupt
* dev The structure of the network driver that caused the event
* conn The connection structure associated with the socket
* flags Set of events describing why the callback was invoked
*
@ -674,7 +674,7 @@ static uint16_t psock_send_eventhandler(FAR struct net_driver_s *dev,
}
/* Check if the outgoing packet is available (it may have been claimed
* by a sendto interrupt serving a different thread).
* by a sendto event serving a different thread).
*/
if (dev->d_sndlen > 0)
@ -1139,9 +1139,6 @@ errout:
* -ENOTCONN
* The socket is not connected.
*
* Assumptions:
* Not running at the interrupt level
*
****************************************************************************/
int psock_tcp_cansend(FAR struct socket *psock)

26
net/tcp/tcp_send_unbuffered.c
View File

@ -92,7 +92,7 @@
****************************************************************************/
/* This structure holds the state of the send operation until it can be
* operated upon from the interrupt level.
* operated upon when the TX poll event occurs.
*/
struct send_s
@ -167,7 +167,7 @@ static inline int send_timeout(FAR struct send_s *pstate)
* nothing.
*
* Parameters:
* dev - The structure of the network driver that caused the interrupt
* dev - The structure of the network driver that caused the event
* pstate - sendto state structure
*
* Returned Value:
@ -275,11 +275,11 @@ static inline bool psock_send_addrchck(FAR struct tcp_conn_s *conn)
* Name: tcpsend_eventhandler
*
* Description:
* This function is called from the interrupt level to perform the actual
* send operation when polled by the lower, device interfacing layer.
* This function is called to perform the actual send operation when
* polled by the lower, device interfacing layer.
*
* Parameters:
* dev The structure of the network driver that caused the interrupt
* dev The structure of the network driver that caused the event
* conn The connection structure associated with the socket
* flags Set of events describing why the callback was invoked
*
@ -406,7 +406,7 @@ static uint16_t tcpsend_eventhandler(FAR struct net_driver_s *dev,
}
/* Check if the outgoing packet is available (it may have been claimed
* by a sendto interrupt serving a different thread).
* by a sendto event serving a different thread).
*/
#if 0 /* We can't really support multiple senders on the same TCP socket */
@ -780,9 +780,9 @@ ssize_t psock_tcp_send(FAR struct socket *psock,
/* Perform the TCP send operation */
/* Initialize the state structure. This is done with interrupts
* disabled because we don't want anything to happen until we
* are ready.
/* Initialize the state structure. This is done with the network
* locked because we don't want anything to happen until we are
* ready.
*/
net_lock();
@ -832,15 +832,13 @@ ssize_t psock_tcp_send(FAR struct socket *psock,
send_txnotify(psock, conn);
/* Wait for the send to complete or an error to occur: NOTES: (1)
* net_lockedwait will also terminate if a signal is received, (2) interrupts
* may be disabled! They will be re-enabled while the task sleeps and
* automatically re-enabled when the task restarts.
/* Wait for the send to complete or an error to occur: NOTES:
* net_lockedwait will also terminate if a signal is received.
*/
ret = net_lockedwait(&state.snd_sem);
/* Make sure that no further interrupts are processed */
/* Make sure that no further events are processed */
tcp_callback_free(conn, state.snd_cb);
}

14
net/tcp/tcp_sendfile.c
View File

@ -90,7 +90,7 @@
****************************************************************************/
/* This structure holds the state of the send operation until it can be
* operated upon from the interrupt level.
* operated upon from the driver poll event.
*/
struct sendfile_s
@ -311,11 +311,11 @@ static inline bool sendfile_addrcheck(FAR struct tcp_conn_s *conn)
* Name: sendfile_eventhandler
*
* Description:
* This function is called from the interrupt level to perform the actual
* send operation when polled by the lower, device interfacing layer.
* This function is called to perform the actual send operation when
* polled by the lower, device interfacing layer.
*
* Parameters:
* dev The structure of the network driver that caused the interrupt
* dev The structure of the network driver that caused the event
* conn The connection structure associated with the socket
* flags Set of events describing why the callback was invoked
*
@ -609,9 +609,9 @@ ssize_t tcp_sendfile(FAR struct socket *psock, FAR struct file *infile,
psock->s_flags = _SS_SETSTATE(psock->s_flags, _SF_SEND);
/* Initialize the state structure. This is done with interrupts
* disabled because we don't want anything to happen until we
* are ready.
/* Initialize the state structure. This is done with the network
* locked because we don't want anything to happen until we are
* ready.
*/
net_lock();

14
net/tcp/tcp_seqno.c
View File

@ -70,7 +70,8 @@ static uint32_t g_tcpsequence;
* Set the TCP/IP sequence number
*
* Assumptions:
* This function may called from the interrupt level
* This function must be called with the network locked if seqno refers
* to a shared, global resource.
*
****************************************************************************/
@ -91,7 +92,8 @@ void tcp_setsequence(FAR uint8_t *seqno, uint32_t value)
* Get the TCP/IP sequence number
*
* Assumptions:
* This function may called from the interrupt level
* This function must be called with the network locked if seqno refers
* to a shared, global resource.
*
****************************************************************************/
@ -115,7 +117,8 @@ uint32_t tcp_getsequence(FAR uint8_t *seqno)
* Add the length to get the next TCP sequence number.
*
* Assumptions:
* This function may called from the interrupt level
* This function must be called with the network locked if seqno refers
* to a shared, global resource.
*
****************************************************************************/
@ -132,7 +135,8 @@ uint32_t tcp_addsequence(FAR uint8_t *seqno, uint16_t len)
* established.
*
* Assumptions:
* This function may called from the interrupt level
* This function must be called with the network locked if seqno refers
* to a shared, global resource.
*
****************************************************************************/
@ -148,7 +152,7 @@ void tcp_initsequence(FAR uint8_t *seqno)
* Increment the TCP/IP sequence number
*
* Assumptions:
* This function is called from the interrupt level
* This function must be called with the network locked.
*
****************************************************************************/

2
net/tcp/tcp_wrbuffer.c
View File

@ -177,7 +177,7 @@ FAR struct tcp_wrbuffer_s *tcp_wrbuffer_alloc(void)
* buffered data.
*
* Assumptions:
* Called from interrupt level with interrupts disabled.
* This function must be called with the network locked.
*
****************************************************************************/

2
net/udp/udp_callback.c
View File

@ -296,7 +296,7 @@ net_dataevent(FAR struct net_driver_s *dev, FAR struct udp_conn_s *conn,
* OK if packet has been processed, otherwise ERROR.
*
* Assumptions:
* This function is called at the interrupt level with interrupts disabled.
* This function must be called with the network locked.
*
****************************************************************************/

23
net/udp/udp_conn.c
View File

@ -125,8 +125,10 @@ static inline void _udp_semtake(FAR sem_t *sem)
* Name: udp_find_conn()
*
* Description:
* Find the UDP connection that uses this local port number. Called only
* from user user level code, but with interrupts disabled.
* Find the UDP connection that uses this local port number.
*
* Assumptions:
* This function must be called with the network locked.
*
****************************************************************************/
@ -245,7 +247,7 @@ static uint16_t udp_select_port(uint8_t domain, FAR union ip_binding_u *u)
* used within the provided UDP header
*
* Assumptions:
* This function is called from network logic at interrupt level
* This function must be called with the network locked.
*
****************************************************************************/
@ -337,7 +339,7 @@ static inline FAR struct udp_conn_s *
* used within the provided UDP header
*
* Assumptions:
* This function is called from network logic at interrupt level
* This function must be called with the network locked.
*
****************************************************************************/
@ -465,9 +467,7 @@ FAR struct udp_conn_s *udp_alloc(uint8_t domain)
{
FAR struct udp_conn_s *conn;
/* The free list is only accessed from user, non-interrupt level and
* is protected by a semaphore (that behaves like a mutex).
*/
/* The free list is protected by a semaphore (that behaves like a mutex). */
_udp_semtake(&g_free_sem);
conn = (FAR struct udp_conn_s *)dq_remfirst(&g_free_udp_connections);
@ -501,9 +501,7 @@ FAR struct udp_conn_s *udp_alloc(uint8_t domain)
void udp_free(FAR struct udp_conn_s *conn)
{
/* The free list is only accessed from user, non-interrupt level and
* is protected by a semaphore (that behaves like a mutex).
*/
/* The free list is protected by a semaphore (that behaves like a mutex). */
DEBUGASSERT(conn->crefs == 0);
@ -534,7 +532,7 @@ void udp_free(FAR struct udp_conn_s *conn)
* connection to be used within the provided UDP header
*
* Assumptions:
* This function is called from network logic at interrupt level
* This function must be called with the network locked.
*
****************************************************************************/
@ -567,8 +565,7 @@ FAR struct udp_conn_s *udp_active(FAR struct net_driver_s *dev,
* Traverse the list of allocated UDP connections
*
* Assumptions:
* This function is called from network logic at interrupt level (or with
* interrupts disabled).
* This function must be called with the network locked.
*
****************************************************************************/

8
net/udp/udp_netpoll.c
View File

@ -72,11 +72,11 @@ struct udp_poll_s
* Name: udp_poll_eventhandler
*
* Description:
* This function is called from the interrupt level to perform the actual
* UDP receive operation via by the device interface layer.
* This function is called to perform the actual UDP receive operation
* via the device interface layer.
*
* Parameters:
* dev The structure of the network driver that caused the interrupt
* dev The structure of the network driver that caused the event
* conn The connection structure associated with the socket
* flags Set of events describing why the callback was invoked
*
@ -84,7 +84,7 @@ struct udp_poll_s
* None
*
* Assumptions:
* The network is locked
* This function must be called with the network locked.
*
****************************************************************************/

29
net/udp/udp_psock_sendto.c
View File

@ -163,14 +163,14 @@ static inline int send_timeout(FAR struct sendto_s *pstate)
* nothing.
*
* Parameters:
* dev - The structure of the network driver that caused the interrupt
* dev - The structure of the network driver that caused the event
* pstate - sendto state structure
*
* Returned Value:
* None
*
* Assumptions:
* The network is locked
* This function must be called with the network locked.
*
****************************************************************************/
@ -203,11 +203,11 @@ static inline void sendto_ipselect(FAR struct net_driver_s *dev,
* Name: sendto_eventhandler
*
* Description:
* This function is called from the interrupt level to perform the actual
* send operation when polled by the lower, device interfacing layer.
* This function is called to perform the actual send operation when
* polled by the lower, device interfacing layer.
*
* Parameters:
* dev The structure of the network driver that caused the interrupt
* dev The structure of the network driver that caused the event
* conn An instance of the UDP connection structure cast to void *
* pvpriv An instance of struct sendto_s cast to void*
* flags Set of events describing why the callback was invoked
@ -216,7 +216,7 @@ static inline void sendto_ipselect(FAR struct net_driver_s *dev,
* Modified value of the input flags
*
* Assumptions:
* The network is locked
* This function must be called with the network locked.
*
****************************************************************************/
@ -242,7 +242,7 @@ static uint16_t sendto_eventhandler(FAR struct net_driver_s *dev,
}
/* Check if the outgoing packet is available. It may have been claimed
* by a sendto interrupt serving a different thread -OR- if the output
* by a sendto event serving a different thread -OR- if the output
* buffer currently contains unprocessed incoming data. In these cases
* we will just have to wait for the next polling cycle.
*/
@ -385,9 +385,9 @@ ssize_t psock_udp_sendto(FAR struct socket *psock, FAR const void *buf,
psock->s_flags = _SS_SETSTATE(psock->s_flags, _SF_SEND);
/* Initialize the state structure. This is done with interrupts
* disabled because we don't want anything to happen until we
* are ready.
/* Initialize the state structure. This is done with the network
* locked because we don't want anything to happen until we are
* ready.
*/
net_lock();
@ -456,15 +456,14 @@ ssize_t psock_udp_sendto(FAR struct socket *psock, FAR const void *buf,
netdev_txnotify_dev(dev);
/* Wait for either the receive to complete or for an error/timeout to occur.
* NOTES: (1) net_lockedwait will also terminate if a signal is received, (2)
* interrupts may be disabled! They will be re-enabled while the task sleeps
* and automatically re-enabled when the task restarts.
/* Wait for either the receive to complete or for an error/timeout to
* occur. NOTES: net_lockedwait will also terminate if a signal
* is received.
*/
net_lockedwait(&state.st_sem);
/* Make sure that no further interrupts are processed */
/* Make sure that no further events are processed */
udp_callback_free(dev, conn, state.st_cb);
}