OrgApache/incubator-nuttx
OrgApache
/
incubator-nuttx
mirror of https://github.com/apache/incubator-nuttx.git
1
0
Fork 0
Code Issues Releases Wiki Activity
incubator-nuttx/mm/iob/iob_free_qentry.c

111 lines
4.0 KiB
C
Raw Normal View History

Add iob_freechain
2014-06-06 03:26:38 +08:00
/****************************************************************************
IOBs: Move from driver/iob to a better location in mm/iob
2017-05-09 21:34:59 +08:00
* mm/iob/iob_free_qentry.c
Add iob_freechain
2014-06-06 03:26:38 +08:00
*
There can be a failure in IOB allocation to some asynchronous behavior caused by the use of sem_post(). Consider this scenario: Task A holds an IOB.  There are no further IOBs.  The value of semcount is zero. Task B calls iob_alloc().  Since there are not IOBs, it calls sem_wait().  The v alue of semcount is now -1. Task A frees the IOB.  iob_free() adds the IOB to the free list and calls sem_post() this makes Task B ready to run and sets semcount to zero NOT 1.  There is one IOB in the free list and semcount is zero.  When Task B wakes up it would increment the sem_count back to the correct value. But an interrupt or another task runs occurs before Task B executes.  The interrupt or other tak takes the IOB off of the free list and decrements the semcount.  But since semcount is then < 0, this causes the assertion because that is an invalid state in the interrupt handler. So I think that the root cause is that there the asynchrony between incrementing the semcount. This change separates the list of IOBs: Currently there is only a free list of IOBs. The problem, I believe, is because of asynchronies due sem_post() post cause the semcount and the list content to become out of sync. This change adds a new 'committed' list: When there is a task waiting for an IOB, it will go into the committed list rather than the free list before the semaphore is posted. On the waiting side, when awakened from the semaphore wait, it will expect to find its IOB in the committed list, rather than free list. In this way, the content of the free list and the value of the semaphore count always remain in sync.
2017-05-17 01:03:35 +08:00
* Copyright (C) 2014, 2016-2017 Gregory Nutt. All rights reserved.
Add iob_freechain
2014-06-06 03:26:38 +08:00
* Author: Gregory Nutt <gnutt@nuttx.org>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name NuttX nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
IOB: Add queue handling interfaces; improve lists
2014-06-06 23:35:31 +08:00
#include <assert.h>
Add iob_freechain
2014-06-06 03:26:38 +08:00
nuttx/net: Replace irqsave() with enter_critical_section(); replace irqrestore() with leave_critical_section()
2016-02-14 22:38:44 +08:00
#include <nuttx/irq.h>
IOB: Add queue handling interfaces; improve lists
2014-06-06 23:35:31 +08:00
#include <nuttx/arch.h>
IOBs: Move from driver/iob to a better location in mm/iob
2017-05-09 21:34:59 +08:00
#include <nuttx/mm/iob.h>
Add iob_freechain
2014-06-06 03:26:38 +08:00
#include "iob.h"
First cut at conversion of write-buffering to use I/O buffer chaings (IOBs)
2014-06-23 01:27:57 +08:00
#if CONFIG_IOB_NCHAINS > 0
Add iob_freechain
2014-06-06 03:26:38 +08:00
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
IOB: Add queue handling interfaces; improve lists
2014-06-06 23:35:31 +08:00
* Name: iob_free_qentry
Add iob_freechain
2014-06-06 03:26:38 +08:00
*
* Description:
First cut at conversion of write-buffering to use I/O buffer chaings (IOBs)
2014-06-23 01:27:57 +08:00
* Free the I/O buffer chain container by returning it to the free list.
IOB: Add queue handling interfaces; improve lists
2014-06-06 23:35:31 +08:00
* The link to the next I/O buffer in the chain is return.
Add iob_freechain
2014-06-06 03:26:38 +08:00
*
****************************************************************************/
IOB: Add queue handling interfaces; improve lists
2014-06-06 23:35:31 +08:00
FAR struct iob_qentry_s *iob_free_qentry(FAR struct iob_qentry_s *iobq)
Add iob_freechain
2014-06-06 03:26:38 +08:00
{
IOB: Add queue handling interfaces; improve lists
2014-06-06 23:35:31 +08:00
FAR struct iob_qentry_s *nextq = iobq->qe_flink;
irqstate_t flags;
Add iob_freechain
2014-06-06 03:26:38 +08:00
There can be a failure in IOB allocation to some asynchronous behavior caused by the use of sem_post(). Consider this scenario: Task A holds an IOB.  There are no further IOBs.  The value of semcount is zero. Task B calls iob_alloc().  Since there are not IOBs, it calls sem_wait().  The v alue of semcount is now -1. Task A frees the IOB.  iob_free() adds the IOB to the free list and calls sem_post() this makes Task B ready to run and sets semcount to zero NOT 1.  There is one IOB in the free list and semcount is zero.  When Task B wakes up it would increment the sem_count back to the correct value. But an interrupt or another task runs occurs before Task B executes.  The interrupt or other tak takes the IOB off of the free list and decrements the semcount.  But since semcount is then < 0, this causes the assertion because that is an invalid state in the interrupt handler. So I think that the root cause is that there the asynchrony between incrementing the semcount. This change separates the list of IOBs: Currently there is only a free list of IOBs. The problem, I believe, is because of asynchronies due sem_post() post cause the semcount and the list content to become out of sync. This change adds a new 'committed' list: When there is a task waiting for an IOB, it will go into the committed list rather than the free list before the semaphore is posted. On the waiting side, when awakened from the semaphore wait, it will expect to find its IOB in the committed list, rather than free list. In this way, the content of the free list and the value of the semaphore count always remain in sync.
2017-05-17 01:03:35 +08:00
/* Free the I/O buffer chain container by adding it to the head of the
* free or the committed list. We don't know what context we are called
* from so we use extreme measures to protect the free list: We disable
* interrupts very briefly.
Add iob_freechain
2014-06-06 03:26:38 +08:00
*/
nuttx/net: Replace irqsave() with enter_critical_section(); replace irqrestore() with leave_critical_section()
2016-02-14 22:38:44 +08:00
flags = enter_critical_section();
First cut at conversion of write-buffering to use I/O buffer chaings (IOBs)
2014-06-23 01:27:57 +08:00
mm/iob: Miscellaneous changes and fixes from code review.
2019-01-26 23:56:27 +08:00
/* Which list? If there is a task waiting for an IOB chain, then put
* the IOB chain on either the free list or on the committed list where
There can be a failure in IOB allocation to some asynchronous behavior caused by the use of sem_post(). Consider this scenario: Task A holds an IOB.  There are no further IOBs.  The value of semcount is zero. Task B calls iob_alloc().  Since there are not IOBs, it calls sem_wait().  The v alue of semcount is now -1. Task A frees the IOB.  iob_free() adds the IOB to the free list and calls sem_post() this makes Task B ready to run and sets semcount to zero NOT 1.  There is one IOB in the free list and semcount is zero.  When Task B wakes up it would increment the sem_count back to the correct value. But an interrupt or another task runs occurs before Task B executes.  The interrupt or other tak takes the IOB off of the free list and decrements the semcount.  But since semcount is then < 0, this causes the assertion because that is an invalid state in the interrupt handler. So I think that the root cause is that there the asynchrony between incrementing the semcount. This change separates the list of IOBs: Currently there is only a free list of IOBs. The problem, I believe, is because of asynchronies due sem_post() post cause the semcount and the list content to become out of sync. This change adds a new 'committed' list: When there is a task waiting for an IOB, it will go into the committed list rather than the free list before the semaphore is posted. On the waiting side, when awakened from the semaphore wait, it will expect to find its IOB in the committed list, rather than free list. In this way, the content of the free list and the value of the semaphore count always remain in sync.
2017-05-17 01:03:35 +08:00
* it is reserved for that allocation (and not available to
mm/iob: Miscellaneous changes and fixes from code review.
2019-01-26 23:56:27 +08:00
* iob_tryalloc_qentry()).
There can be a failure in IOB allocation to some asynchronous behavior caused by the use of sem_post(). Consider this scenario: Task A holds an IOB.  There are no further IOBs.  The value of semcount is zero. Task B calls iob_alloc().  Since there are not IOBs, it calls sem_wait().  The v alue of semcount is now -1. Task A frees the IOB.  iob_free() adds the IOB to the free list and calls sem_post() this makes Task B ready to run and sets semcount to zero NOT 1.  There is one IOB in the free list and semcount is zero.  When Task B wakes up it would increment the sem_count back to the correct value. But an interrupt or another task runs occurs before Task B executes.  The interrupt or other tak takes the IOB off of the free list and decrements the semcount.  But since semcount is then < 0, this causes the assertion because that is an invalid state in the interrupt handler. So I think that the root cause is that there the asynchrony between incrementing the semcount. This change separates the list of IOBs: Currently there is only a free list of IOBs. The problem, I believe, is because of asynchronies due sem_post() post cause the semcount and the list content to become out of sync. This change adds a new 'committed' list: When there is a task waiting for an IOB, it will go into the committed list rather than the free list before the semaphore is posted. On the waiting side, when awakened from the semaphore wait, it will expect to find its IOB in the committed list, rather than free list. In this way, the content of the free list and the value of the semaphore count always remain in sync.
2017-05-17 01:03:35 +08:00
*/
mm/iob: Miscellaneous changes and fixes from code review.
2019-01-26 23:56:27 +08:00
if (g_qentry_sem.semcount < 0)
There can be a failure in IOB allocation to some asynchronous behavior caused by the use of sem_post(). Consider this scenario: Task A holds an IOB.  There are no further IOBs.  The value of semcount is zero. Task B calls iob_alloc().  Since there are not IOBs, it calls sem_wait().  The v alue of semcount is now -1. Task A frees the IOB.  iob_free() adds the IOB to the free list and calls sem_post() this makes Task B ready to run and sets semcount to zero NOT 1.  There is one IOB in the free list and semcount is zero.  When Task B wakes up it would increment the sem_count back to the correct value. But an interrupt or another task runs occurs before Task B executes.  The interrupt or other tak takes the IOB off of the free list and decrements the semcount.  But since semcount is then < 0, this causes the assertion because that is an invalid state in the interrupt handler. So I think that the root cause is that there the asynchrony between incrementing the semcount. This change separates the list of IOBs: Currently there is only a free list of IOBs. The problem, I believe, is because of asynchronies due sem_post() post cause the semcount and the list content to become out of sync. This change adds a new 'committed' list: When there is a task waiting for an IOB, it will go into the committed list rather than the free list before the semaphore is posted. On the waiting side, when awakened from the semaphore wait, it will expect to find its IOB in the committed list, rather than free list. In this way, the content of the free list and the value of the semaphore count always remain in sync.
2017-05-17 01:03:35 +08:00
{
iobq->qe_flink = g_iob_qcommitted;
g_iob_qcommitted = iobq;
}
else
{
iobq->qe_flink = g_iob_freeqlist;
g_iob_freeqlist = iobq;
}
/* Signal that an I/O buffer chain container is available. If there
* is a thread waiting for an I/O buffer chain container, this will
* wake up exactly one thread. The semaphore count will correctly
* indicated that the awakened task owns an I/O buffer chain container
* and should find it in the committed list.
*/
First cut at conversion of write-buffering to use I/O buffer chaings (IOBs)
2014-06-23 01:27:57 +08:00
Squashed commit of the following: sched/semaphore: Add nxsem_post() which is identical to sem_post() except that it never modifies the errno variable. Changed all references to sem_post in the OS to nxsem_post(). sched/semaphore: Add nxsem_destroy() which is identical to sem_destroy() except that it never modifies the errno variable. Changed all references to sem_destroy() in the OS to nxsem_destroy(). libc/semaphore and sched/semaphore: Add nxsem_getprotocol() and nxsem_setprotocola which are identical to sem_getprotocol() and set_setprotocol() except that they never modifies the errno variable. Changed all references to sem_setprotocol in the OS to nxsem_setprotocol(). sem_getprotocol() was not used in the OS
2017-10-04 05:35:24 +08:00
nxsem_post(&g_qentry_sem);
nuttx/net: Replace irqsave() with enter_critical_section(); replace irqrestore() with leave_critical_section()
2016-02-14 22:38:44 +08:00
leave_critical_section(flags);
IOB: Add queue handling interfaces; improve lists
2014-06-06 23:35:31 +08:00
/* And return the I/O buffer chain container after the one that was freed */
Add iob_freechain
2014-06-06 03:26:38 +08:00
IOB: Add queue handling interfaces; improve lists
2014-06-06 23:35:31 +08:00
return nextq;
Add iob_freechain
2014-06-06 03:26:38 +08:00
}
First cut at conversion of write-buffering to use I/O buffer chaings (IOBs)
2014-06-23 01:27:57 +08:00
#endif /* CONFIG_IOB_NCHAINS > 0 */