diff --git a/mm/iob/iob.h b/mm/iob/iob.h index d5fe93dc91..e63dc08155 100644 --- a/mm/iob/iob.h +++ b/mm/iob/iob.h @@ -33,6 +33,7 @@ #include #include +#include #ifdef CONFIG_MM_IOB @@ -76,14 +77,29 @@ extern FAR struct iob_qentry_s *g_iob_qcommitted; /* Counting semaphores that tracks the number of free IOBs/qentries */ -extern sem_t g_iob_sem; /* Counts free I/O buffers */ +extern sem_t g_iob_sem; + +/* Counts free I/O buffers */ + +extern volatile int16_t g_iob_count; + #if CONFIG_IOB_THROTTLE > 0 -extern sem_t g_throttle_sem; /* Counts available I/O buffers when throttled */ +extern sem_t g_throttle_sem; + +/* Counts available I/O buffers when throttled */ + +extern volatile int16_t g_throttle_count; #endif #if CONFIG_IOB_NCHAINS > 0 -extern sem_t g_qentry_sem; /* Counts free I/O buffer queue containers */ +extern sem_t g_qentry_sem; + +/* Counts free I/O buffer queue containers */ + +extern volatile int16_t g_qentry_count; #endif +extern volatile spinlock_t g_iob_lock; + /**************************************************************************** * Public Function Prototypes ****************************************************************************/ diff --git a/mm/iob/iob_add_queue.c b/mm/iob/iob_add_queue.c index 38a641d023..7d0d153865 100644 --- a/mm/iob/iob_add_queue.c +++ b/mm/iob/iob_add_queue.c @@ -63,7 +63,6 @@ static int iob_add_queue_internal(FAR struct iob_s *iob, qentry->qe_flink = NULL; - irqstate_t flags = enter_critical_section(); if (!iobq->qh_head) { iobq->qh_head = qentry; @@ -76,8 +75,6 @@ static int iob_add_queue_internal(FAR struct iob_s *iob, iobq->qh_tail = qentry; } - leave_critical_section(flags); - return 0; } diff --git a/mm/iob/iob_alloc.c b/mm/iob/iob_alloc.c index 42cafee97c..d3768173d0 100644 --- a/mm/iob/iob_alloc.c +++ b/mm/iob/iob_alloc.c @@ -78,7 +78,7 @@ static FAR struct iob_s *iob_alloc_committed(void) * to protect the committed list: We disable interrupts very briefly. */ - flags = enter_critical_section(); + flags = spin_lock_irqsave(&g_iob_lock); /* Take the I/O buffer from the head of the committed list */ @@ -97,10 +97,82 @@ static FAR struct iob_s *iob_alloc_committed(void) iob->io_pktlen = 0; /* Total length of the packet */ } - leave_critical_section(flags); + spin_unlock_irqrestore(&g_iob_lock, flags); return iob; } +static FAR struct iob_s *iob_tryalloc_internal(bool throttled) +{ + FAR struct iob_s *iob; +#if CONFIG_IOB_THROTTLE > 0 + int16_t count; +#endif + +#if CONFIG_IOB_THROTTLE > 0 + /* Select the count to check. */ + + count = (throttled ? g_throttle_count : g_iob_count); +#endif + + /* 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. + */ + +#if CONFIG_IOB_THROTTLE > 0 + /* If there are free I/O buffers for this allocation */ + + if (count > 0) +#endif + { + /* Take the I/O buffer from the head of the free list */ + + iob = g_iob_freelist; + if (iob != NULL) + { + /* Remove the I/O buffer from the free list and decrement the + * counting semaphore(s) that tracks the number of available + * IOBs. + */ + + g_iob_freelist = iob->io_flink; + + /* Take a semaphore count. Note that we cannot do this in + * in the orthodox way by calling nxsem_wait() or nxsem_trywait() + * because this function may be called from an interrupt + * handler. Fortunately we know at at least one free buffer + * so a simple decrement is all that is needed. + */ + + g_iob_count--; + DEBUGASSERT(g_iob_count >= 0); + +#if CONFIG_IOB_THROTTLE > 0 + /* The throttle semaphore is used to throttle the number of + * free buffers that are available. It is used to prevent + * the overrunning of the free buffer list. Please note that + * it can only be decremented to zero, which indicates no + * throttled buffers are available. + */ + + if (g_throttle_count > 0) + { + g_throttle_count--; + } +#endif + + /* Put the I/O buffer in a known state */ + + iob->io_flink = NULL; /* Not in a chain */ + iob->io_len = 0; /* Length of the data in the entry */ + iob->io_offset = 0; /* Offset to the beginning of data */ + iob->io_pktlen = 0; /* Total length of the packet */ + return iob; + } + } + + return NULL; +} + /**************************************************************************** * Name: iob_allocwait * @@ -113,6 +185,7 @@ static FAR struct iob_s *iob_alloc_committed(void) static FAR struct iob_s *iob_allocwait(bool throttled, unsigned int timeout) { FAR struct iob_s *iob; + FAR volatile int16_t *count; irqstate_t flags; FAR sem_t *sem; clock_t start; @@ -121,8 +194,10 @@ static FAR struct iob_s *iob_allocwait(bool throttled, unsigned int timeout) #if CONFIG_IOB_THROTTLE > 0 /* Select the semaphore count to check. */ + count = (throttled ? &g_throttle_count : &g_iob_count); sem = (throttled ? &g_throttle_sem : &g_iob_sem); #else + count = &g_iob_count; sem = &g_iob_sem; #endif @@ -132,15 +207,14 @@ static FAR struct iob_s *iob_allocwait(bool throttled, unsigned int timeout) * we are waiting for I/O buffers to become free. */ - flags = enter_critical_section(); + flags = spin_lock_irqsave(&g_iob_lock); /* Try to get an I/O buffer. If successful, the semaphore count will be * decremented atomically. */ - start = clock_systime_ticks(); - iob = iob_tryalloc(throttled); - while (ret == OK && iob == NULL) + iob = iob_tryalloc_internal(throttled); + if (iob == NULL) { /* If not successful, then the semaphore count was less than or equal * to zero (meaning that there are no free buffers). We need to wait @@ -148,12 +222,17 @@ static FAR struct iob_s *iob_allocwait(bool throttled, unsigned int timeout) * list. */ + (*count)--; + + spin_unlock_irqrestore(&g_iob_lock, flags); + if (timeout == UINT_MAX) { ret = nxsem_wait_uninterruptible(sem); } else { + start = clock_systime_ticks(); ret = nxsem_tickwait_uninterruptible(sem, iob_allocwait_gettimeout(start, timeout)); } @@ -165,10 +244,13 @@ static FAR struct iob_s *iob_allocwait(bool throttled, unsigned int timeout) */ iob = iob_alloc_committed(); + DEBUGASSERT(iob != NULL); } + + return iob; } - leave_critical_section(flags); + spin_unlock_irqrestore(&g_iob_lock, flags); return iob; } @@ -250,78 +332,15 @@ FAR struct iob_s *iob_tryalloc(bool throttled) { FAR struct iob_s *iob; irqstate_t flags; -#if CONFIG_IOB_THROTTLE > 0 - FAR sem_t *sem; -#endif - -#if CONFIG_IOB_THROTTLE > 0 - /* Select the semaphore count to check. */ - - sem = (throttled ? &g_throttle_sem : &g_iob_sem); -#endif /* 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. */ - flags = enter_critical_section(); - -#if CONFIG_IOB_THROTTLE > 0 - /* If there are free I/O buffers for this allocation */ - - if (sem->semcount > 0) -#endif - { - /* Take the I/O buffer from the head of the free list */ - - iob = g_iob_freelist; - if (iob != NULL) - { - /* Remove the I/O buffer from the free list and decrement the - * counting semaphore(s) that tracks the number of available - * IOBs. - */ - - g_iob_freelist = iob->io_flink; - - /* Take a semaphore count. Note that we cannot do this in - * in the orthodox way by calling nxsem_wait() or nxsem_trywait() - * because this function may be called from an interrupt - * handler. Fortunately we know at at least one free buffer - * so a simple decrement is all that is needed. - */ - - g_iob_sem.semcount--; - DEBUGASSERT(g_iob_sem.semcount >= 0); - -#if CONFIG_IOB_THROTTLE > 0 - /* The throttle semaphore is used to throttle the number of - * free buffers that are available. It is used to prevent - * the overrunning of the free buffer list. Please note that - * it can only be decremented to zero, which indicates no - * throttled buffers are available. - */ - - if (g_throttle_sem.semcount > 0) - { - g_throttle_sem.semcount--; - } -#endif - - leave_critical_section(flags); - - /* Put the I/O buffer in a known state */ - - iob->io_flink = NULL; /* Not in a chain */ - iob->io_len = 0; /* Length of the data in the entry */ - iob->io_offset = 0; /* Offset to the beginning of data */ - iob->io_pktlen = 0; /* Total length of the packet */ - return iob; - } - } - - leave_critical_section(flags); - return NULL; + flags = spin_lock_irqsave(&g_iob_lock); + iob = iob_tryalloc_internal(throttled); + spin_unlock_irqrestore(&g_iob_lock, flags); + return iob; } #ifdef CONFIG_IOB_ALLOC diff --git a/mm/iob/iob_alloc_qentry.c b/mm/iob/iob_alloc_qentry.c index 82c8393c44..b2f682ddd3 100644 --- a/mm/iob/iob_alloc_qentry.c +++ b/mm/iob/iob_alloc_qentry.c @@ -59,7 +59,7 @@ static FAR struct iob_qentry_s *iob_alloc_qcommitted(void) * to protect the committed list: We disable interrupts very briefly. */ - flags = enter_critical_section(); + flags = spin_lock_irqsave(&g_iob_lock); /* Take the I/O buffer from the head of the committed list */ @@ -75,7 +75,43 @@ static FAR struct iob_qentry_s *iob_alloc_qcommitted(void) iobq->qe_head = NULL; /* Nothing is contained */ } - leave_critical_section(flags); + spin_unlock_irqrestore(&g_iob_lock, flags); + return iobq; +} + +static FAR struct iob_qentry_s *iob_tryalloc_qentry_internal(void) +{ + FAR struct iob_qentry_s *iobq; + + /* 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. + */ + + iobq = g_iob_freeqlist; + if (iobq) + { + /* Remove the I/O buffer chain container from the free list and + * decrement the counting semaphore that tracks the number of free + * containers. + */ + + g_iob_freeqlist = iobq->qe_flink; + + /* Take a semaphore count. Note that we cannot do this in + * in the orthodox way by calling nxsem_wait() or nxsem_trywait() + * because this function may be called from an interrupt + * handler. Fortunately we know at at least one free buffer + * so a simple decrement is all that is needed. + */ + + g_qentry_count--; + DEBUGASSERT(g_qentry_count >= 0); + + /* Put the I/O buffer in a known state */ + + iobq->qe_head = NULL; /* Nothing is contained */ + } + return iobq; } @@ -101,14 +137,14 @@ static FAR struct iob_qentry_s *iob_allocwait_qentry(void) * re-enabled while we are waiting for I/O buffers to become free. */ - flags = enter_critical_section(); + flags = spin_lock_irqsave(&g_iob_lock); /* Try to get an I/O buffer chain container. If successful, the semaphore * count will bedecremented atomically. */ - qentry = iob_tryalloc_qentry(); - while (ret == OK && qentry == NULL) + qentry = iob_tryalloc_qentry_internal(); + if (qentry == NULL) { /* If not successful, then the semaphore count was less than or equal * to zero (meaning that there are no free buffers). We need to wait @@ -116,6 +152,8 @@ static FAR struct iob_qentry_s *iob_allocwait_qentry(void) * semaphore count will be incremented. */ + g_qentry_count--; + spin_unlock_irqrestore(&g_iob_lock, flags); ret = nxsem_wait_uninterruptible(&g_qentry_sem); if (ret >= 0) { @@ -127,26 +165,13 @@ static FAR struct iob_qentry_s *iob_allocwait_qentry(void) qentry = iob_alloc_qcommitted(); DEBUGASSERT(qentry != NULL); - - if (qentry == NULL) - { - /* This should not fail, but we allow for that possibility to - * handle any potential, non-obvious race condition. Perhaps - * the free IOB ended up in the g_iob_free list? - * - * We need release our count so that it is available to - * iob_tryalloc(), perhaps allowing another thread to take our - * count. In that event, iob_tryalloc() will fail above and - * we will have to wait again. - */ - - nxsem_post(&g_qentry_sem); - qentry = iob_tryalloc_qentry(); - } } + + return qentry; } - leave_critical_section(flags); + spin_unlock_irqrestore(&g_iob_lock, flags); + return qentry; } @@ -201,33 +226,9 @@ FAR struct iob_qentry_s *iob_tryalloc_qentry(void) * to protect the free list: We disable interrupts very briefly. */ - flags = enter_critical_section(); - iobq = g_iob_freeqlist; - if (iobq) - { - /* Remove the I/O buffer chain container from the free list and - * decrement the counting semaphore that tracks the number of free - * containers. - */ - - g_iob_freeqlist = iobq->qe_flink; - - /* Take a semaphore count. Note that we cannot do this in - * in the orthodox way by calling nxsem_wait() or nxsem_trywait() - * because this function may be called from an interrupt - * handler. Fortunately we know at at least one free buffer - * so a simple decrement is all that is needed. - */ - - g_qentry_sem.semcount--; - DEBUGASSERT(g_qentry_sem.semcount >= 0); - - /* Put the I/O buffer in a known state */ - - iobq->qe_head = NULL; /* Nothing is contained */ - } - - leave_critical_section(flags); + flags = spin_lock_irqsave(&g_iob_lock); + iobq = iob_tryalloc_qentry_internal(); + spin_unlock_irqrestore(&g_iob_lock, flags); return iobq; } diff --git a/mm/iob/iob_free.c b/mm/iob/iob_free.c index cec01c8295..bf506c1d0b 100644 --- a/mm/iob/iob_free.c +++ b/mm/iob/iob_free.c @@ -83,9 +83,6 @@ FAR struct iob_s *iob_free(FAR struct iob_s *iob) #ifdef CONFIG_IOB_NOTIFIER int16_t navail; #endif -#if CONFIG_IOB_THROTTLE > 0 - bool committed_thottled = false; -#endif iobinfo("iob=%p io_pktlen=%u io_len=%u next=%p\n", iob, iob->io_pktlen, iob->io_len, next); @@ -135,7 +132,7 @@ FAR struct iob_s *iob_free(FAR struct iob_s *iob) * interrupts very briefly. */ - flags = enter_critical_section(); + flags = spin_lock_irqsave(&g_iob_lock); /* Which list? If there is a task waiting for an IOB, then put * the IOB on either the free list or on the committed list where @@ -145,80 +142,58 @@ FAR struct iob_s *iob_free(FAR struct iob_s *iob) */ #if CONFIG_IOB_THROTTLE > 0 - if ((g_iob_sem.semcount < 0) || - ((g_iob_sem.semcount >= CONFIG_IOB_THROTTLE) && - (g_throttle_sem.semcount < 0))) + if ((g_iob_count < 0) || + ((g_iob_count >= CONFIG_IOB_THROTTLE) && + (g_throttle_count < 0))) #else - if (g_iob_sem.semcount < 0) + if (g_iob_count < 0) #endif { + FAR sem_t *sem; + iob->io_flink = g_iob_committed; g_iob_committed = iob; + #if CONFIG_IOB_THROTTLE > 0 - if ((g_iob_sem.semcount >= CONFIG_IOB_THROTTLE) && - (g_throttle_sem.semcount < 0)) + if (g_iob_count < 0) { - committed_thottled = true; + g_iob_count++; + sem = &g_iob_sem; } + else + { + g_throttle_count++; + sem = &g_throttle_sem; + } +#else + g_iob_count++; + sem = &g_iob_sem; #endif + spin_unlock_irqrestore(&g_iob_lock, flags); + nxsem_post(sem); } else { + g_iob_count++; +#if CONFIG_IOB_THROTTLE > 0 + if (g_iob_count > CONFIG_IOB_THROTTLE) + { + g_throttle_count++; + } +#endif + iob->io_flink = g_iob_freelist; g_iob_freelist = iob; + spin_unlock_irqrestore(&g_iob_lock, flags); } - leave_critical_section(flags); - - /* Signal that an IOB is available. This is done with schedule locked - * to make sure that both g_iob_sem and g_throttle_sem are incremented - * together (if applicable). After the schedule is unlocked, if there - * is a thread blocked, waiting for an IOB, this will wake up exactly - * one thread. The semaphore count will correctly indicate that the - * awakened task owns an IOB and should find it in the committed list. - */ - - sched_lock(); - - nxsem_post(&g_iob_sem); - DEBUGASSERT(g_iob_sem.semcount <= CONFIG_IOB_NBUFFERS); + DEBUGASSERT(g_iob_count <= CONFIG_IOB_NBUFFERS); #if CONFIG_IOB_THROTTLE > 0 - flags = enter_critical_section(); - - if (g_iob_sem.semcount > CONFIG_IOB_THROTTLE) - { - /* If posting to the the throttled semaphore is going to awake a - * waiting task, then the g_iob_sem count should be decremented - * because an I/O buffer (from the head of the g_iob_committed list) - * will be allocated to this waiting task. - * Decrementing the g_throttled_sem (when posting to the g_iob_sem) - * is not necessary because this condition can only occur when the - * g_throttled_sem is less or equal to zero. On the other hand, if - * the g_iob_sem is greater than the CONFIG_IOB_THROTTLE and there - * is a waiting thread, then the I/O buffer just freed will be - * committed to a waiting task and is not available for general use. - */ - - if (committed_thottled) - { - g_iob_sem.semcount--; - } - - leave_critical_section(flags); - - nxsem_post(&g_throttle_sem); - DEBUGASSERT(g_throttle_sem.semcount <= + DEBUGASSERT(g_throttle_count <= (CONFIG_IOB_NBUFFERS - CONFIG_IOB_THROTTLE)); - } - else - { - leave_critical_section(flags); - } #endif - sched_unlock(); - #ifdef CONFIG_IOB_NOTIFIER /* Check if the IOB was claimed by a thread that is blocked waiting * for an IOB. diff --git a/mm/iob/iob_free_qentry.c b/mm/iob/iob_free_qentry.c index f40e35d8b3..05e375574b 100644 --- a/mm/iob/iob_free_qentry.c +++ b/mm/iob/iob_free_qentry.c @@ -60,7 +60,7 @@ FAR struct iob_qentry_s *iob_free_qentry(FAR struct iob_qentry_s *iobq) * interrupts very briefly. */ - flags = enter_critical_section(); + flags = spin_lock_irqsave(&g_iob_lock); /* 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 @@ -68,27 +68,22 @@ FAR struct iob_qentry_s *iob_free_qentry(FAR struct iob_qentry_s *iobq) * iob_tryalloc_qentry()). */ - if (g_qentry_sem.semcount < 0) + if (g_qentry_count < 0) { iobq->qe_flink = g_iob_qcommitted; g_iob_qcommitted = iobq; + g_qentry_count++; + spin_unlock_irqrestore(&g_iob_lock, flags); + nxsem_post(&g_qentry_sem); } else { + g_qentry_count++; iobq->qe_flink = g_iob_freeqlist; g_iob_freeqlist = iobq; + spin_unlock_irqrestore(&g_iob_lock, flags); } - /* 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. - */ - - nxsem_post(&g_qentry_sem); - leave_critical_section(flags); - /* And return the I/O buffer chain container after the one that was freed */ return nextq; diff --git a/mm/iob/iob_free_queue_qentry.c b/mm/iob/iob_free_queue_qentry.c index 315b23b116..511355f048 100644 --- a/mm/iob/iob_free_queue_qentry.c +++ b/mm/iob/iob_free_queue_qentry.c @@ -53,7 +53,6 @@ void iob_free_queue_qentry(FAR struct iob_s *iob, FAR struct iob_qentry_s *prev = NULL; FAR struct iob_qentry_s *qentry; - irqstate_t flags = enter_critical_section(); for (qentry = iobq->qh_head; qentry != NULL; prev = qentry, qentry = qentry->qe_flink) { @@ -86,8 +85,6 @@ void iob_free_queue_qentry(FAR struct iob_s *iob, break; } } - - leave_critical_section(flags); } #endif /* CONFIG_IOB_NCHAINS > 0 */ diff --git a/mm/iob/iob_initialize.c b/mm/iob/iob_initialize.c index b37aef98c5..7e35d7427b 100644 --- a/mm/iob/iob_initialize.c +++ b/mm/iob/iob_initialize.c @@ -91,23 +91,32 @@ FAR struct iob_qentry_s *g_iob_freeqlist; FAR struct iob_qentry_s *g_iob_qcommitted; #endif +sem_t g_iob_sem = SEM_INITIALIZER(0); + /* Counting semaphores that tracks the number of free IOBs/qentries */ -sem_t g_iob_sem = SEM_INITIALIZER(CONFIG_IOB_NBUFFERS); +volatile int16_t g_iob_count = CONFIG_IOB_NBUFFERS; #if CONFIG_IOB_THROTTLE > 0 + +sem_t g_throttle_sem = SEM_INITIALIZER(0); + /* Counts available I/O buffers when throttled */ -sem_t g_throttle_sem = SEM_INITIALIZER(CONFIG_IOB_NBUFFERS - - CONFIG_IOB_THROTTLE); +volatile int16_t g_throttle_count = CONFIG_IOB_NBUFFERS - + CONFIG_IOB_THROTTLE; #endif #if CONFIG_IOB_NCHAINS > 0 +sem_t g_qentry_sem = SEM_INITIALIZER(0); + /* Counts free I/O buffer queue containers */ -sem_t g_qentry_sem = SEM_INITIALIZER(CONFIG_IOB_NCHAINS); +volatile int16_t g_qentry_count = CONFIG_IOB_NCHAINS; #endif +volatile spinlock_t g_iob_lock = SP_UNLOCKED; + /**************************************************************************** * Public Functions ****************************************************************************/ diff --git a/mm/iob/iob_navail.c b/mm/iob/iob_navail.c index b387d35003..68ee073717 100644 --- a/mm/iob/iob_navail.c +++ b/mm/iob/iob_navail.c @@ -46,34 +46,27 @@ int iob_navail(bool throttled) { - int navail = 0; int ret; #if CONFIG_IOB_NBUFFERS > 0 - /* Get the value of the IOB counting semaphores */ - - ret = nxsem_get_value(&g_iob_sem, &navail); - if (ret >= 0) - { - ret = navail; + ret = g_iob_count; #if CONFIG_IOB_THROTTLE > 0 - /* Subtract the throttle value is so requested */ + /* Subtract the throttle value is so requested */ - if (throttled) - { - ret -= CONFIG_IOB_THROTTLE; - } + if (throttled) + { + ret -= CONFIG_IOB_THROTTLE; + } #endif - if (ret < 0) - { - ret = 0; - } + if (ret < 0) + { + ret = 0; } #else - ret = navail; + ret = 0; #endif return ret; @@ -89,24 +82,18 @@ int iob_navail(bool throttled) int iob_qentry_navail(void) { - int navail = 0; int ret; #if CONFIG_IOB_NCHAINS > 0 /* Get the value of the IOB chain qentry counting semaphores */ - ret = nxsem_get_value(&g_qentry_sem, &navail); - if (ret >= 0) + ret = g_qentry_count; + if (ret < 0) { - ret = navail; - if (ret < 0) - { - ret = 0; - } + ret = 0; } - #else - ret = navail; + ret = 0; #endif return ret; diff --git a/mm/iob/iob_remove_queue.c b/mm/iob/iob_remove_queue.c index 25a8679cbf..fe09f4bc3f 100644 --- a/mm/iob/iob_remove_queue.c +++ b/mm/iob/iob_remove_queue.c @@ -58,7 +58,6 @@ FAR struct iob_s *iob_remove_queue(FAR struct iob_queue_s *iobq) /* Remove the I/O buffer chain from the head of the queue */ - irqstate_t flags = enter_critical_section(); qentry = iobq->qh_head; if (qentry) { @@ -76,7 +75,6 @@ FAR struct iob_s *iob_remove_queue(FAR struct iob_queue_s *iobq) iob_free_qentry(qentry); } - leave_critical_section(flags); return iob; } diff --git a/mm/iob/iob_statistics.c b/mm/iob/iob_statistics.c index f08535eb38..16fae3cc7f 100644 --- a/mm/iob/iob_statistics.c +++ b/mm/iob/iob_statistics.c @@ -56,7 +56,7 @@ void iob_getstats(FAR struct iob_stats_s *stats) { stats->ntotal = CONFIG_IOB_NBUFFERS; - nxsem_get_value(&g_iob_sem, &stats->nfree); + stats->nfree = g_iob_count; if (stats->nfree < 0) { stats->nwait = -stats->nfree; @@ -68,7 +68,7 @@ void iob_getstats(FAR struct iob_stats_s *stats) } #if CONFIG_IOB_THROTTLE > 0 - nxsem_get_value(&g_throttle_sem, &stats->nthrottle); + stats->nthrottle = g_throttle_count; if (stats->nthrottle < 0) { stats->nthrottle = -stats->nthrottle;