2009-03-10 12:41:20 +01:00
|
|
|
/****************************************************************************
|
2014-08-08 21:53:29 +02:00
|
|
|
* sched/semaphore/sem_holder.c
|
2009-03-10 12:41:20 +01:00
|
|
|
*
|
2020-03-09 15:12:25 +01:00
|
|
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
|
|
* contributor license agreements. See the NOTICE file distributed with
|
|
|
|
* this work for additional information regarding copyright ownership. The
|
|
|
|
* ASF licenses this file to you under the Apache License, Version 2.0 (the
|
|
|
|
* "License"); you may not use this file except in compliance with the
|
|
|
|
* License. You may obtain a copy of the License at
|
|
|
|
*
|
|
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
*
|
|
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
|
|
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
|
|
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
|
|
* License for the specific language governing permissions and limitations
|
|
|
|
* under the License.
|
2009-03-10 12:41:20 +01:00
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Included Files
|
|
|
|
****************************************************************************/
|
|
|
|
|
2009-12-14 19:39:29 +01:00
|
|
|
#include <nuttx/config.h>
|
|
|
|
|
2009-03-10 12:41:20 +01:00
|
|
|
#include <sched.h>
|
2009-03-12 02:53:20 +01:00
|
|
|
#include <assert.h>
|
2009-03-10 12:41:20 +01:00
|
|
|
#include <debug.h>
|
|
|
|
#include <nuttx/arch.h>
|
|
|
|
|
2014-08-09 01:53:55 +02:00
|
|
|
#include "sched/sched.h"
|
2014-08-08 21:53:29 +02:00
|
|
|
#include "semaphore/semaphore.h"
|
2009-03-10 12:41:20 +01:00
|
|
|
|
|
|
|
#ifdef CONFIG_PRIORITY_INHERITANCE
|
|
|
|
|
|
|
|
/****************************************************************************
|
2015-04-08 14:47:36 +02:00
|
|
|
* Pre-processor Definitions
|
2009-03-10 12:41:20 +01:00
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
/* Configuration ************************************************************/
|
|
|
|
|
|
|
|
#ifndef CONFIG_SEM_PREALLOCHOLDERS
|
2009-03-11 00:52:46 +01:00
|
|
|
# define CONFIG_SEM_PREALLOCHOLDERS 0
|
2009-03-10 12:41:20 +01:00
|
|
|
#endif
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Private Type Declarations
|
|
|
|
****************************************************************************/
|
|
|
|
|
2012-07-14 21:30:31 +02:00
|
|
|
typedef int (*holderhandler_t)(FAR struct semholder_s *pholder,
|
|
|
|
FAR sem_t *sem, FAR void *arg);
|
2009-03-12 02:53:20 +01:00
|
|
|
|
2009-03-10 12:41:20 +01:00
|
|
|
/****************************************************************************
|
2015-12-22 18:48:17 +01:00
|
|
|
* Private Data
|
2009-03-10 12:41:20 +01:00
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
/* Preallocated holder structures */
|
|
|
|
|
|
|
|
#if CONFIG_SEM_PREALLOCHOLDERS > 0
|
|
|
|
static struct semholder_s g_holderalloc[CONFIG_SEM_PREALLOCHOLDERS];
|
|
|
|
static FAR struct semholder_s *g_freeholders;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/****************************************************************************
|
2017-10-03 20:51:15 +02:00
|
|
|
* Name: nxsem_allocholder
|
2009-03-10 12:41:20 +01:00
|
|
|
****************************************************************************/
|
|
|
|
|
2017-10-03 20:51:15 +02:00
|
|
|
static inline FAR struct semholder_s *nxsem_allocholder(sem_t *sem)
|
2009-03-10 12:41:20 +01:00
|
|
|
{
|
|
|
|
FAR struct semholder_s *pholder;
|
|
|
|
|
|
|
|
/* Check if the "built-in" holder is being used. We have this built-in
|
|
|
|
* holder to optimize for the simplest case where semaphores are only
|
|
|
|
* used to implement mutexes.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#if CONFIG_SEM_PREALLOCHOLDERS > 0
|
2012-08-26 23:35:14 +02:00
|
|
|
pholder = g_freeholders;
|
2017-03-10 15:54:50 +01:00
|
|
|
if (pholder != NULL)
|
2012-08-26 23:35:14 +02:00
|
|
|
{
|
2014-10-07 02:03:01 +02:00
|
|
|
/* Remove the holder from the free list an put it into the semaphore's
|
|
|
|
* holder list
|
|
|
|
*/
|
2009-03-10 12:41:20 +01:00
|
|
|
|
2012-08-26 23:35:14 +02:00
|
|
|
g_freeholders = pholder->flink;
|
|
|
|
pholder->flink = sem->hhead;
|
|
|
|
sem->hhead = pholder;
|
2009-03-10 12:41:20 +01:00
|
|
|
|
2012-08-26 23:35:14 +02:00
|
|
|
/* Make sure the initial count is zero */
|
2009-03-10 12:41:20 +01:00
|
|
|
|
2012-08-26 23:35:14 +02:00
|
|
|
pholder->counts = 0;
|
|
|
|
}
|
2009-03-10 12:41:20 +01:00
|
|
|
#else
|
2017-03-10 16:30:15 +01:00
|
|
|
if (sem->holder[0].htcb == NULL)
|
2012-08-26 23:35:14 +02:00
|
|
|
{
|
2017-03-10 16:30:15 +01:00
|
|
|
pholder = &sem->holder[0];
|
|
|
|
pholder->counts = 0;
|
|
|
|
}
|
|
|
|
else if (sem->holder[1].htcb == NULL)
|
|
|
|
{
|
|
|
|
pholder = &sem->holder[1];
|
2012-08-26 23:35:14 +02:00
|
|
|
pholder->counts = 0;
|
|
|
|
}
|
2009-03-10 12:41:20 +01:00
|
|
|
#endif
|
2012-08-26 23:35:14 +02:00
|
|
|
else
|
|
|
|
{
|
2016-06-12 00:42:42 +02:00
|
|
|
serr("ERROR: Insufficient pre-allocated holders\n");
|
2017-03-10 16:30:15 +01:00
|
|
|
pholder = NULL;
|
2009-03-10 12:41:20 +01:00
|
|
|
}
|
2012-07-14 21:30:31 +02:00
|
|
|
|
2017-03-13 23:54:13 +01:00
|
|
|
DEBUGASSERT(pholder != NULL);
|
2009-03-10 12:41:20 +01:00
|
|
|
return pholder;
|
|
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************
|
2017-10-03 20:51:15 +02:00
|
|
|
* Name: nxsem_findholder
|
2009-03-10 12:41:20 +01:00
|
|
|
****************************************************************************/
|
|
|
|
|
2017-10-03 20:51:15 +02:00
|
|
|
static FAR struct semholder_s *nxsem_findholder(sem_t *sem,
|
|
|
|
FAR struct tcb_s *htcb)
|
2009-03-10 12:41:20 +01:00
|
|
|
{
|
|
|
|
FAR struct semholder_s *pholder;
|
|
|
|
|
2017-03-10 16:30:15 +01:00
|
|
|
#if CONFIG_SEM_PREALLOCHOLDERS > 0
|
2014-10-07 02:03:01 +02:00
|
|
|
/* Try to find the holder in the list of holders associated with this
|
|
|
|
* semaphore
|
|
|
|
*/
|
2009-03-10 12:41:20 +01:00
|
|
|
|
2017-03-10 16:30:15 +01:00
|
|
|
for (pholder = sem->hhead; pholder != NULL; pholder = pholder->flink)
|
|
|
|
{
|
|
|
|
if (pholder->htcb == htcb)
|
|
|
|
{
|
|
|
|
/* Got it! */
|
|
|
|
|
|
|
|
return pholder;
|
|
|
|
}
|
|
|
|
}
|
2012-08-26 23:35:14 +02:00
|
|
|
#else
|
2017-03-10 16:30:15 +01:00
|
|
|
int i;
|
2017-03-13 22:56:31 +01:00
|
|
|
pholder = NULL;
|
2017-03-10 16:30:15 +01:00
|
|
|
|
2017-03-21 19:03:06 +01:00
|
|
|
/* We have two hard-allocated holder structures in sem_t */
|
2017-03-10 16:30:15 +01:00
|
|
|
|
|
|
|
for (i = 0; i < 2; i++)
|
2009-03-10 12:41:20 +01:00
|
|
|
{
|
2017-03-10 17:37:46 +01:00
|
|
|
pholder = &sem->holder[i];
|
2012-08-26 23:35:14 +02:00
|
|
|
if (pholder->htcb == htcb)
|
2009-03-10 12:41:20 +01:00
|
|
|
{
|
|
|
|
/* Got it! */
|
|
|
|
|
|
|
|
return pholder;
|
|
|
|
}
|
|
|
|
}
|
2017-03-10 16:30:15 +01:00
|
|
|
#endif
|
2009-03-10 12:41:20 +01:00
|
|
|
|
|
|
|
/* The holder does not appear in the list */
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************
|
2017-10-03 20:51:15 +02:00
|
|
|
* Name: nxsem_findorallocateholder
|
2009-03-10 12:41:20 +01:00
|
|
|
****************************************************************************/
|
|
|
|
|
2013-02-04 19:46:28 +01:00
|
|
|
static inline FAR struct semholder_s *
|
2017-10-03 20:51:15 +02:00
|
|
|
nxsem_findorallocateholder(sem_t *sem, FAR struct tcb_s *htcb)
|
2009-03-10 12:41:20 +01:00
|
|
|
{
|
2017-10-03 20:51:15 +02:00
|
|
|
FAR struct semholder_s *pholder = nxsem_findholder(sem, htcb);
|
2009-03-10 12:41:20 +01:00
|
|
|
if (!pholder)
|
|
|
|
{
|
2017-10-03 20:51:15 +02:00
|
|
|
pholder = nxsem_allocholder(sem);
|
2009-03-10 12:41:20 +01:00
|
|
|
}
|
2012-07-14 21:30:31 +02:00
|
|
|
|
2009-03-10 12:41:20 +01:00
|
|
|
return pholder;
|
|
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************
|
2017-10-03 20:51:15 +02:00
|
|
|
* Name: nxsem_freeholder
|
2009-03-10 12:41:20 +01:00
|
|
|
****************************************************************************/
|
|
|
|
|
2017-10-03 20:51:15 +02:00
|
|
|
static inline void nxsem_freeholder(sem_t *sem,
|
|
|
|
FAR struct semholder_s *pholder)
|
2009-03-10 12:41:20 +01:00
|
|
|
{
|
|
|
|
#if CONFIG_SEM_PREALLOCHOLDERS > 0
|
|
|
|
FAR struct semholder_s *curr;
|
|
|
|
FAR struct semholder_s *prev;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* Release the holder and counts */
|
|
|
|
|
2012-08-26 23:35:14 +02:00
|
|
|
pholder->htcb = NULL;
|
2009-03-10 12:41:20 +01:00
|
|
|
pholder->counts = 0;
|
|
|
|
|
|
|
|
#if CONFIG_SEM_PREALLOCHOLDERS > 0
|
2012-08-26 23:35:14 +02:00
|
|
|
/* Search the list for the matching holder */
|
2009-03-10 12:41:20 +01:00
|
|
|
|
2012-08-26 23:35:14 +02:00
|
|
|
for (prev = NULL, curr = sem->hhead;
|
|
|
|
curr && curr != pholder;
|
|
|
|
prev = curr, curr = curr->flink);
|
2009-03-10 12:41:20 +01:00
|
|
|
|
2017-03-10 15:54:50 +01:00
|
|
|
if (curr != NULL)
|
2012-08-26 23:35:14 +02:00
|
|
|
{
|
|
|
|
/* Remove the holder from the list */
|
2009-03-10 12:41:20 +01:00
|
|
|
|
2017-03-10 15:54:50 +01:00
|
|
|
if (prev != NULL)
|
2009-03-10 12:41:20 +01:00
|
|
|
{
|
|
|
|
prev->flink = pholder->flink;
|
2012-08-26 23:35:14 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
sem->hhead = pholder->flink;
|
|
|
|
}
|
2009-03-10 12:41:20 +01:00
|
|
|
|
2012-08-26 23:35:14 +02:00
|
|
|
/* And put it in the free list */
|
2009-03-10 12:41:20 +01:00
|
|
|
|
2012-08-26 23:35:14 +02:00
|
|
|
pholder->flink = g_freeholders;
|
|
|
|
g_freeholders = pholder;
|
2009-03-10 12:41:20 +01:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2017-03-16 01:02:55 +01:00
|
|
|
/****************************************************************************
|
2017-10-03 20:51:15 +02:00
|
|
|
* Name: nxsem_findandfreeholder
|
2017-03-16 01:02:55 +01:00
|
|
|
****************************************************************************/
|
|
|
|
|
2020-03-09 15:12:25 +01:00
|
|
|
static inline void nxsem_findandfreeholder(sem_t *sem,
|
|
|
|
FAR struct tcb_s *htcb)
|
2017-03-16 01:02:55 +01:00
|
|
|
{
|
2017-10-03 20:51:15 +02:00
|
|
|
FAR struct semholder_s *pholder = nxsem_findholder(sem, htcb);
|
2017-03-16 01:02:55 +01:00
|
|
|
|
|
|
|
/* When no more counts are held, remove the holder from the list. The
|
2017-10-03 20:51:15 +02:00
|
|
|
* count was decremented in nxsem_releaseholder.
|
2017-03-16 01:02:55 +01:00
|
|
|
*/
|
|
|
|
|
|
|
|
if (pholder != NULL && pholder->counts <= 0)
|
|
|
|
{
|
2017-10-03 20:51:15 +02:00
|
|
|
nxsem_freeholder(sem, pholder);
|
2017-03-16 01:02:55 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-03-12 02:53:20 +01:00
|
|
|
/****************************************************************************
|
2017-10-03 20:51:15 +02:00
|
|
|
* Name: nxsem_foreachholder
|
2009-03-12 02:53:20 +01:00
|
|
|
****************************************************************************/
|
|
|
|
|
2017-10-03 20:51:15 +02:00
|
|
|
static int nxsem_foreachholder(FAR sem_t *sem, holderhandler_t handler,
|
|
|
|
FAR void *arg)
|
2009-03-12 02:53:20 +01:00
|
|
|
{
|
2012-08-26 23:35:14 +02:00
|
|
|
FAR struct semholder_s *pholder;
|
2009-03-12 02:53:20 +01:00
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
#if CONFIG_SEM_PREALLOCHOLDERS > 0
|
2017-03-10 16:30:15 +01:00
|
|
|
FAR struct semholder_s *next;
|
|
|
|
|
2012-08-26 23:35:14 +02:00
|
|
|
for (pholder = sem->hhead; pholder && ret == 0; pholder = next)
|
2009-03-12 02:53:20 +01:00
|
|
|
{
|
|
|
|
/* In case this holder gets deleted */
|
|
|
|
|
|
|
|
next = pholder->flink;
|
2017-03-10 16:30:15 +01:00
|
|
|
|
|
|
|
/* Check if there is a handler... there should always be one
|
|
|
|
* in this configuration.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (pholder->htcb != NULL)
|
|
|
|
{
|
|
|
|
/* Call the handler */
|
|
|
|
|
|
|
|
ret = handler(pholder, sem, arg);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* We have two hard-allocated holder structures in sem_t */
|
|
|
|
|
|
|
|
for (i = 0; i < 2; i++)
|
|
|
|
{
|
|
|
|
pholder = &sem->holder[i];
|
|
|
|
|
|
|
|
/* The hard-allocated containers may hold a NULL holder */
|
2009-03-12 02:53:20 +01:00
|
|
|
|
2017-03-10 15:54:50 +01:00
|
|
|
if (pholder->htcb != NULL)
|
2009-03-12 02:53:20 +01:00
|
|
|
{
|
|
|
|
/* Call the handler */
|
|
|
|
|
|
|
|
ret = handler(pholder, sem, arg);
|
|
|
|
}
|
|
|
|
}
|
2017-03-10 16:30:15 +01:00
|
|
|
#endif
|
2012-07-14 21:30:31 +02:00
|
|
|
|
2009-03-12 02:53:20 +01:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-03-13 12:27:34 +01:00
|
|
|
/****************************************************************************
|
2017-10-03 20:51:15 +02:00
|
|
|
* Name: nxsem_recoverholders
|
2009-03-13 12:27:34 +01:00
|
|
|
****************************************************************************/
|
|
|
|
|
2011-03-27 17:03:49 +02:00
|
|
|
#if CONFIG_SEM_PREALLOCHOLDERS > 0
|
2017-10-03 20:51:15 +02:00
|
|
|
static int nxsem_recoverholders(FAR struct semholder_s *pholder,
|
|
|
|
FAR sem_t *sem, FAR void *arg)
|
2009-03-13 12:27:34 +01:00
|
|
|
{
|
2017-10-03 20:51:15 +02:00
|
|
|
nxsem_freeholder(sem, pholder);
|
2009-03-13 23:35:23 +01:00
|
|
|
return 0;
|
2009-03-13 12:27:34 +01:00
|
|
|
}
|
2011-03-27 17:03:49 +02:00
|
|
|
#endif
|
2009-03-13 12:27:34 +01:00
|
|
|
|
2009-03-12 11:55:26 +01:00
|
|
|
/****************************************************************************
|
2017-10-03 20:51:15 +02:00
|
|
|
* Name: nxsem_boostholderprio
|
2009-03-12 11:55:26 +01:00
|
|
|
****************************************************************************/
|
|
|
|
|
2017-10-03 20:51:15 +02:00
|
|
|
static int nxsem_boostholderprio(FAR struct semholder_s *pholder,
|
|
|
|
FAR sem_t *sem, FAR void *arg)
|
2009-03-12 11:55:26 +01:00
|
|
|
{
|
2013-02-04 19:46:28 +01:00
|
|
|
FAR struct tcb_s *htcb = (FAR struct tcb_s *)pholder->htcb;
|
|
|
|
FAR struct tcb_s *rtcb = (FAR struct tcb_s *)arg;
|
2009-03-12 11:55:26 +01:00
|
|
|
|
2012-08-28 16:40:12 +02:00
|
|
|
/* Make sure that the holder thread is still active. If it exited without
|
2014-10-07 02:03:01 +02:00
|
|
|
* releasing its counts, then that would be a bad thing. But we can take
|
2020-03-16 20:42:34 +01:00
|
|
|
* no real action because we don't know what the program is doing.
|
2014-10-07 02:03:01 +02:00
|
|
|
* Perhaps its plan is to kill a thread, then destroy the semaphore.
|
2009-03-12 11:55:26 +01:00
|
|
|
*/
|
|
|
|
|
|
|
|
if (!sched_verifytcb(htcb))
|
2015-10-08 03:59:14 +02:00
|
|
|
{
|
2019-07-29 16:14:30 +02:00
|
|
|
#if 0 /* DSA: sometimes crashes when Telnet calls external cmd (i.e. 'i2c') */
|
2016-06-12 00:42:42 +02:00
|
|
|
serr("ERROR: TCB 0x%08x is a stale handle, counts lost\n", htcb);
|
2017-03-21 20:34:17 +01:00
|
|
|
DEBUGPANIC();
|
2019-07-29 16:14:30 +02:00
|
|
|
#endif
|
2017-10-03 20:51:15 +02:00
|
|
|
nxsem_freeholder(sem, pholder);
|
2015-10-08 03:59:14 +02:00
|
|
|
}
|
2009-03-12 11:55:26 +01:00
|
|
|
|
|
|
|
#if CONFIG_SEM_NNESTPRIO > 0
|
2014-10-07 02:03:01 +02:00
|
|
|
/* If the priority of the thread that is waiting for a count is greater
|
|
|
|
* than the base priority of the thread holding a count, then we may need
|
|
|
|
* to adjust the holder's priority now or later to that priority.
|
2009-03-12 11:55:26 +01:00
|
|
|
*/
|
|
|
|
|
|
|
|
else if (rtcb->sched_priority > htcb->base_priority)
|
|
|
|
{
|
|
|
|
/* If the new priority is greater than the current, possibly already
|
|
|
|
* boosted priority of the holder thread, then we will have to raise
|
|
|
|
* the holder's priority now.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (rtcb->sched_priority > htcb->sched_priority)
|
|
|
|
{
|
2012-08-28 16:40:12 +02:00
|
|
|
/* If the current priority of holder thread has already been
|
|
|
|
* boosted, then add the boost priority to the list of restoration
|
|
|
|
* priorities. When the higher priority waiter thread gets its
|
|
|
|
* count, then we need to revert the holder thread to this saved
|
|
|
|
* priority (not to its base priority).
|
2009-03-12 11:55:26 +01:00
|
|
|
*/
|
|
|
|
|
|
|
|
if (htcb->sched_priority > htcb->base_priority)
|
|
|
|
{
|
2012-08-28 16:40:12 +02:00
|
|
|
/* Save the current, boosted priority of the holder thread. */
|
2009-03-12 11:55:26 +01:00
|
|
|
|
|
|
|
if (htcb->npend_reprio < CONFIG_SEM_NNESTPRIO)
|
|
|
|
{
|
2020-03-09 15:12:25 +01:00
|
|
|
htcb->pend_reprios[htcb->npend_reprio] =
|
|
|
|
htcb->sched_priority;
|
2009-03-12 11:55:26 +01:00
|
|
|
htcb->npend_reprio++;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2016-06-12 00:42:42 +02:00
|
|
|
serr("ERROR: CONFIG_SEM_NNESTPRIO exceeded\n");
|
2017-03-13 21:46:26 +01:00
|
|
|
DEBUGASSERT(htcb->npend_reprio < CONFIG_SEM_NNESTPRIO);
|
2014-04-13 22:32:20 +02:00
|
|
|
}
|
2009-03-12 11:55:26 +01:00
|
|
|
}
|
|
|
|
|
2012-08-28 16:40:12 +02:00
|
|
|
/* Raise the priority of the thread holding of the semaphore.
|
|
|
|
* This cannot cause a context switch because we have preemption
|
|
|
|
* disabled. The holder thread may be marked "pending" and the
|
|
|
|
* switch may occur during up_block_task() processing.
|
2009-03-12 11:55:26 +01:00
|
|
|
*/
|
|
|
|
|
2020-01-02 17:49:34 +01:00
|
|
|
nxsched_setpriority(htcb, rtcb->sched_priority);
|
2009-03-12 11:55:26 +01:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* The new priority is above the base priority of the holder,
|
|
|
|
* but not as high as its current working priority. Just put it
|
|
|
|
* in the list of pending restoration priorities so that when the
|
|
|
|
* higher priority thread gets its count, we can revert to this
|
|
|
|
* saved priority and not to the base priority.
|
|
|
|
*/
|
|
|
|
|
2017-03-13 23:34:39 +01:00
|
|
|
if (htcb->npend_reprio < CONFIG_SEM_NNESTPRIO)
|
|
|
|
{
|
|
|
|
htcb->pend_reprios[htcb->npend_reprio] = rtcb->sched_priority;
|
|
|
|
htcb->npend_reprio++;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
serr("ERROR: CONFIG_SEM_NNESTPRIO exceeded\n");
|
|
|
|
DEBUGASSERT(htcb->npend_reprio < CONFIG_SEM_NNESTPRIO);
|
|
|
|
}
|
2009-03-12 11:55:26 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#else
|
|
|
|
/* If the priority of the thread that is waiting for a count is less than
|
2020-03-16 20:42:34 +01:00
|
|
|
* or equal to the priority of the thread holding a count, then do nothing
|
2009-03-12 11:55:26 +01:00
|
|
|
* because the thread is already running at a sufficient priority.
|
|
|
|
*/
|
|
|
|
|
2012-07-14 21:30:31 +02:00
|
|
|
else if (rtcb->sched_priority > htcb->sched_priority)
|
|
|
|
{
|
|
|
|
/* Raise the priority of the holder of the semaphore. This
|
|
|
|
* cannot cause a context switch because we have preemption
|
|
|
|
* disabled. The task will be marked "pending" and the switch
|
|
|
|
* will occur during up_block_task() processing.
|
|
|
|
*/
|
2009-03-12 11:55:26 +01:00
|
|
|
|
2020-01-02 17:49:34 +01:00
|
|
|
nxsched_setpriority(htcb, rtcb->sched_priority);
|
2009-03-12 11:55:26 +01:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-03-12 02:53:20 +01:00
|
|
|
/****************************************************************************
|
2017-10-03 20:51:15 +02:00
|
|
|
* Name: nxsem_verifyholder
|
2009-03-12 02:53:20 +01:00
|
|
|
****************************************************************************/
|
|
|
|
|
2016-06-12 00:42:42 +02:00
|
|
|
#ifdef CONFIG_DEBUG_ASSERTIONS
|
2017-10-03 20:51:15 +02:00
|
|
|
static int nxsem_verifyholder(FAR struct semholder_s *pholder,
|
|
|
|
FAR sem_t *sem, FAR void *arg)
|
2009-03-12 02:53:20 +01:00
|
|
|
{
|
2020-03-09 15:12:25 +01:00
|
|
|
/* Need to revisit this, but these assumptions seem to be untrue -- OR
|
|
|
|
* there is a bug???
|
|
|
|
*/
|
|
|
|
|
|
|
|
#if 0
|
2013-02-04 19:46:28 +01:00
|
|
|
FAR struct tcb_s *htcb = (FAR struct tcb_s *)pholder->htcb;
|
2009-03-12 02:53:20 +01:00
|
|
|
|
2009-03-13 12:27:34 +01:00
|
|
|
/* Called after a semaphore has been released (incremented), the semaphore
|
2020-03-16 20:42:34 +01:00
|
|
|
* could be non-negative, and there is no thread waiting for the count.
|
2009-03-13 12:27:34 +01:00
|
|
|
* In this case, the priority of the holder should not be boosted.
|
|
|
|
*/
|
|
|
|
|
2009-03-12 02:53:20 +01:00
|
|
|
#if CONFIG_SEM_NNESTPRIO > 0
|
2009-03-13 01:54:10 +01:00
|
|
|
DEBUGASSERT(htcb->npend_reprio == 0);
|
2009-03-12 02:53:20 +01:00
|
|
|
#endif
|
|
|
|
DEBUGASSERT(htcb->sched_priority == htcb->base_priority);
|
2009-03-14 01:46:02 +01:00
|
|
|
#endif
|
2009-03-12 02:53:20 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2009-03-13 23:35:23 +01:00
|
|
|
/****************************************************************************
|
2017-10-03 20:51:15 +02:00
|
|
|
* Name: nxsem_dumpholder
|
2009-03-13 23:35:23 +01:00
|
|
|
****************************************************************************/
|
|
|
|
|
2016-06-12 00:42:42 +02:00
|
|
|
#if defined(CONFIG_DEBUG_INFO) && defined(CONFIG_SEM_PHDEBUG)
|
2017-10-03 20:51:15 +02:00
|
|
|
static int nxsem_dumpholder(FAR struct semholder_s *pholder, FAR sem_t *sem,
|
|
|
|
FAR void *arg)
|
2009-03-13 23:35:23 +01:00
|
|
|
{
|
|
|
|
#if CONFIG_SEM_PREALLOCHOLDERS > 0
|
2016-06-16 20:33:32 +02:00
|
|
|
_info(" %08x: %08x %08x %04x\n",
|
2017-08-15 01:19:27 +02:00
|
|
|
pholder, pholder->flink, pholder->htcb, pholder->counts);
|
2009-03-13 23:35:23 +01:00
|
|
|
#else
|
2016-06-16 20:33:32 +02:00
|
|
|
_info(" %08x: %08x %04x\n", pholder, pholder->htcb, pholder->counts);
|
2009-03-13 23:35:23 +01:00
|
|
|
#endif
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2009-03-12 02:53:20 +01:00
|
|
|
/****************************************************************************
|
2017-10-03 20:51:15 +02:00
|
|
|
* Name: nxsem_restoreholderprio
|
2009-03-12 02:53:20 +01:00
|
|
|
****************************************************************************/
|
|
|
|
|
2017-10-03 20:51:15 +02:00
|
|
|
static int nxsem_restoreholderprio(FAR struct tcb_s *htcb,
|
|
|
|
FAR sem_t *sem, FAR void *arg)
|
2009-03-12 02:53:20 +01:00
|
|
|
{
|
2017-03-16 01:02:55 +01:00
|
|
|
FAR struct semholder_s *pholder = 0;
|
2009-03-12 02:53:20 +01:00
|
|
|
#if CONFIG_SEM_NNESTPRIO > 0
|
2013-02-04 19:46:28 +01:00
|
|
|
FAR struct tcb_s *stcb = (FAR struct tcb_s *)arg;
|
2009-03-12 02:53:20 +01:00
|
|
|
int rpriority;
|
|
|
|
int i;
|
|
|
|
int j;
|
|
|
|
#endif
|
|
|
|
|
2014-10-07 02:03:01 +02:00
|
|
|
/* Make sure that the holder thread is still active. If it exited without
|
|
|
|
* releasing its counts, then that would be a bad thing. But we can take
|
2020-03-16 20:42:34 +01:00
|
|
|
* no real action because we don't know what the program is doing.
|
2014-10-07 02:03:01 +02:00
|
|
|
* Perhaps its plan is to kill a thread, then destroy the semaphore.
|
2009-03-12 02:53:20 +01:00
|
|
|
*/
|
|
|
|
|
|
|
|
if (!sched_verifytcb(htcb))
|
2015-10-08 03:59:14 +02:00
|
|
|
{
|
2016-06-12 00:42:42 +02:00
|
|
|
serr("ERROR: TCB 0x%08x is a stale handle, counts lost\n", htcb);
|
2017-03-21 20:34:17 +01:00
|
|
|
DEBUGPANIC();
|
2017-10-03 20:51:15 +02:00
|
|
|
pholder = nxsem_findholder(sem, htcb);
|
2017-03-16 01:02:55 +01:00
|
|
|
if (pholder != NULL)
|
|
|
|
{
|
2017-10-03 20:51:15 +02:00
|
|
|
nxsem_freeholder(sem, pholder);
|
2017-03-16 01:02:55 +01:00
|
|
|
}
|
2015-10-08 03:59:14 +02:00
|
|
|
}
|
2009-03-12 02:53:20 +01:00
|
|
|
|
2012-08-28 16:40:12 +02:00
|
|
|
/* Was the priority of the holder thread boosted? If so, then drop its
|
|
|
|
* priority back to the correct level. What is the correct level?
|
2009-03-12 02:53:20 +01:00
|
|
|
*/
|
|
|
|
|
|
|
|
else if (htcb->sched_priority != htcb->base_priority)
|
|
|
|
{
|
|
|
|
#if CONFIG_SEM_NNESTPRIO > 0
|
|
|
|
/* Are there other, pending priority levels to revert to? */
|
|
|
|
|
|
|
|
if (htcb->npend_reprio < 1)
|
|
|
|
{
|
2013-06-03 00:49:41 +02:00
|
|
|
/* No... the holder thread has only been boosted once.
|
|
|
|
* npend_reprio should be 0 and the boosted priority should be the
|
|
|
|
* priority of the task that just got the semaphore
|
|
|
|
* (stcb->sched_priority)
|
|
|
|
*
|
|
|
|
* That latter assumption may not be true if the stcb's priority
|
|
|
|
* was also boosted so that it no longer matches the htcb's
|
|
|
|
* sched_priority. Or if CONFIG_SEM_NNESTPRIO is too small (so
|
|
|
|
* that we do not have a proper record of the reprioritizations).
|
2009-03-14 01:46:02 +01:00
|
|
|
*/
|
2009-03-12 02:53:20 +01:00
|
|
|
|
2013-06-03 00:49:41 +02:00
|
|
|
DEBUGASSERT(/* htcb->sched_priority == stcb->sched_priority && */
|
2017-08-15 01:19:27 +02:00
|
|
|
htcb->npend_reprio == 0);
|
2013-06-03 00:49:41 +02:00
|
|
|
|
|
|
|
/* Reset the holder's priority back to the base priority. */
|
|
|
|
|
2020-01-02 17:49:34 +01:00
|
|
|
nxsched_reprioritize(htcb, htcb->base_priority);
|
2012-07-14 21:30:31 +02:00
|
|
|
}
|
2009-03-12 02:53:20 +01:00
|
|
|
|
2014-10-07 02:03:01 +02:00
|
|
|
/* There are multiple pending priority levels. The holder thread's
|
|
|
|
* "boosted" priority could greater than or equal to
|
2020-03-16 20:42:34 +01:00
|
|
|
* "stcb->sched_priority" (it could be greater if its priority was
|
2014-10-07 02:03:01 +02:00
|
|
|
* boosted because it also holds another semaphore).
|
2009-03-12 02:53:20 +01:00
|
|
|
*/
|
|
|
|
|
|
|
|
else if (htcb->sched_priority <= stcb->sched_priority)
|
|
|
|
{
|
2014-10-07 02:03:01 +02:00
|
|
|
/* The holder thread has been boosted to the same priority as the
|
|
|
|
* waiter thread that just received the count. We will simply
|
|
|
|
* reprioritize to the next highest priority that we have in
|
|
|
|
* rpriority.
|
2009-03-12 02:53:20 +01:00
|
|
|
*/
|
|
|
|
|
|
|
|
/* Find the highest pending priority and remove it from the list */
|
|
|
|
|
|
|
|
for (i = 1, j = 0; i < htcb->npend_reprio; i++)
|
|
|
|
{
|
|
|
|
if (htcb->pend_reprios[i] > htcb->pend_reprios[j])
|
|
|
|
{
|
|
|
|
j = i;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Remove the highest priority pending priority from the list */
|
|
|
|
|
|
|
|
rpriority = htcb->pend_reprios[j];
|
|
|
|
i = htcb->npend_reprio - 1;
|
|
|
|
if (i > 0)
|
|
|
|
{
|
|
|
|
htcb->pend_reprios[j] = htcb->pend_reprios[i];
|
|
|
|
}
|
2012-07-14 21:30:31 +02:00
|
|
|
|
2009-03-12 02:53:20 +01:00
|
|
|
htcb->npend_reprio = i;
|
|
|
|
|
2014-10-07 02:03:01 +02:00
|
|
|
/* And apply that priority to the thread (while retaining the
|
|
|
|
* base_priority)
|
|
|
|
*/
|
2009-03-12 02:53:20 +01:00
|
|
|
|
2018-01-30 18:07:36 +01:00
|
|
|
nxsched_setpriority(htcb, rpriority);
|
2014-04-13 22:32:20 +02:00
|
|
|
}
|
2009-03-12 02:53:20 +01:00
|
|
|
else
|
|
|
|
{
|
2012-08-28 16:40:12 +02:00
|
|
|
/* The holder thread has been boosted to a higher priority than the
|
2014-10-07 02:03:01 +02:00
|
|
|
* waiter task. The pending priority should be in the list (unless
|
2020-03-16 20:42:34 +01:00
|
|
|
* it was lost because of list overflow or because the holder
|
2014-10-07 02:03:01 +02:00
|
|
|
* was reprioritized again unbeknownst to the priority inheritance
|
|
|
|
* logic).
|
2009-03-12 02:53:20 +01:00
|
|
|
*
|
|
|
|
* Search the list for the matching priority.
|
|
|
|
*/
|
|
|
|
|
|
|
|
for (i = 0; i < htcb->npend_reprio; i++)
|
|
|
|
{
|
|
|
|
/* Does this pending priority match the priority of the thread
|
2014-04-13 22:32:20 +02:00
|
|
|
* that just received the count?
|
2009-03-12 02:53:20 +01:00
|
|
|
*/
|
|
|
|
|
|
|
|
if (htcb->pend_reprios[i] == stcb->sched_priority)
|
|
|
|
{
|
|
|
|
/* Yes, remove it from the list */
|
|
|
|
|
|
|
|
j = htcb->npend_reprio - 1;
|
|
|
|
if (j > 0)
|
|
|
|
{
|
|
|
|
htcb->pend_reprios[i] = htcb->pend_reprios[j];
|
|
|
|
}
|
2012-08-26 23:35:14 +02:00
|
|
|
|
2017-08-15 01:19:27 +02:00
|
|
|
htcb->npend_reprio = j;
|
|
|
|
break;
|
2009-03-12 02:53:20 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
/* There is no alternative restore priorities, drop the priority
|
2012-08-28 16:40:12 +02:00
|
|
|
* of the holder thread all the way back to the threads "base"
|
|
|
|
* priority.
|
2009-03-12 02:53:20 +01:00
|
|
|
*/
|
|
|
|
|
2020-01-02 17:49:34 +01:00
|
|
|
nxsched_reprioritize(htcb, htcb->base_priority);
|
2009-03-12 02:53:20 +01:00
|
|
|
#endif
|
|
|
|
}
|
2012-07-14 21:30:31 +02:00
|
|
|
|
2009-03-12 02:53:20 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-03-16 01:02:55 +01:00
|
|
|
/****************************************************************************
|
2017-10-03 20:51:15 +02:00
|
|
|
* Name: nxsem_restoreholderprioall
|
2017-03-16 01:02:55 +01:00
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Reprioritize all holders
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
2017-10-03 20:51:15 +02:00
|
|
|
static int nxsem_restoreholderprioall(FAR struct semholder_s *pholder,
|
|
|
|
FAR sem_t *sem, FAR void *arg)
|
2017-03-16 01:02:55 +01:00
|
|
|
{
|
2017-10-03 20:51:15 +02:00
|
|
|
return nxsem_restoreholderprio(pholder->htcb, sem, arg);
|
2017-03-16 01:02:55 +01:00
|
|
|
}
|
|
|
|
|
2009-03-14 01:46:02 +01:00
|
|
|
/****************************************************************************
|
2020-03-09 15:12:25 +01:00
|
|
|
* Name: nxsem_restoreholderprio_others
|
2012-08-28 16:40:12 +02:00
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Reprioritize all holders except the currently executing task
|
|
|
|
*
|
2009-03-14 01:46:02 +01:00
|
|
|
****************************************************************************/
|
|
|
|
|
2020-03-09 15:12:25 +01:00
|
|
|
static int nxsem_restoreholderprio_others(FAR struct semholder_s *pholder,
|
|
|
|
FAR sem_t *sem, FAR void *arg)
|
2009-03-14 01:46:02 +01:00
|
|
|
{
|
2016-02-07 00:44:41 +01:00
|
|
|
FAR struct tcb_s *rtcb = this_task();
|
2012-08-26 23:35:14 +02:00
|
|
|
if (pholder->htcb != rtcb)
|
2009-03-14 01:46:02 +01:00
|
|
|
{
|
2017-10-03 20:51:15 +02:00
|
|
|
return nxsem_restoreholderprio(pholder->htcb, sem, arg);
|
2009-03-14 01:46:02 +01:00
|
|
|
}
|
2012-07-14 21:30:31 +02:00
|
|
|
|
2009-03-14 01:46:02 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-08-28 16:40:12 +02:00
|
|
|
/****************************************************************************
|
2020-03-09 15:12:25 +01:00
|
|
|
* Name: nxsem_restoreholderprio_self
|
2012-08-28 16:40:12 +02:00
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Reprioritize only the currently executing task
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
2020-03-09 15:12:25 +01:00
|
|
|
static int nxsem_restoreholderprio_self(FAR struct semholder_s *pholder,
|
|
|
|
FAR sem_t *sem, FAR void *arg)
|
2009-03-14 01:46:02 +01:00
|
|
|
{
|
2016-02-07 00:44:41 +01:00
|
|
|
FAR struct tcb_s *rtcb = this_task();
|
2017-03-16 01:02:55 +01:00
|
|
|
|
2012-08-26 23:35:14 +02:00
|
|
|
if (pholder->htcb == rtcb)
|
2009-03-14 01:46:02 +01:00
|
|
|
{
|
2017-08-15 01:19:27 +02:00
|
|
|
/* The running task has given up a count on the semaphore */
|
2017-03-17 01:16:18 +01:00
|
|
|
|
|
|
|
#if CONFIG_SEM_PREALLOCHOLDERS == 0
|
|
|
|
/* In the case where there are only 2 holders. This step
|
2020-03-16 20:42:34 +01:00
|
|
|
* is necessary to ensure we have space. Release the holder
|
|
|
|
* if all counts have been given up before reprioritizing
|
2017-03-17 01:16:18 +01:00
|
|
|
* causes a context switch.
|
2017-03-16 01:02:55 +01:00
|
|
|
*/
|
|
|
|
|
2017-10-03 20:51:15 +02:00
|
|
|
nxsem_findandfreeholder(sem, rtcb);
|
2017-03-17 01:16:18 +01:00
|
|
|
#endif
|
2020-01-02 17:49:34 +01:00
|
|
|
nxsem_restoreholderprio(rtcb, sem, arg);
|
2009-03-14 01:46:02 +01:00
|
|
|
return 1;
|
|
|
|
}
|
2012-07-14 21:30:31 +02:00
|
|
|
|
2009-03-14 01:46:02 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-08-28 16:40:12 +02:00
|
|
|
/****************************************************************************
|
2017-10-03 20:51:15 +02:00
|
|
|
* Name: nxsem_restorebaseprio_irq
|
2012-08-28 16:40:12 +02:00
|
|
|
*
|
|
|
|
* Description:
|
2020-03-16 20:42:34 +01:00
|
|
|
* This function is called after an interrupt handler posts a count on
|
2012-08-28 16:40:12 +02:00
|
|
|
* the semaphore. It will check if we need to drop the priority of any
|
|
|
|
* threads holding a count on the semaphore. Their priority could have
|
|
|
|
* been boosted while they held the count.
|
|
|
|
*
|
2018-03-13 16:52:27 +01:00
|
|
|
* Input Parameters:
|
2012-08-28 16:40:12 +02:00
|
|
|
* stcb - The TCB of the task that was just started (if any). If the
|
|
|
|
* post action caused a count to be given to another thread, then stcb
|
|
|
|
* is the TCB that received the count. Note, just because stcb received
|
2020-03-16 20:42:34 +01:00
|
|
|
* the count, it does not mean that it is higher priority than other
|
2012-08-28 16:40:12 +02:00
|
|
|
* threads.
|
|
|
|
* sem - A reference to the semaphore being posted.
|
|
|
|
* - If the semaphore count is <0 then there are still threads waiting
|
|
|
|
* for a count. stcb should be non-null and will be higher priority
|
|
|
|
* than all of the other threads still waiting.
|
|
|
|
* - If it is ==0 then stcb refers to the thread that got the last count;
|
|
|
|
* no other threads are waiting.
|
|
|
|
* - If it is >0 then there should be no threads waiting for counts and
|
|
|
|
* stcb should be null.
|
|
|
|
*
|
2018-02-01 17:00:02 +01:00
|
|
|
* Returned Value:
|
2012-08-28 16:40:12 +02:00
|
|
|
* None
|
|
|
|
*
|
|
|
|
* Assumptions:
|
|
|
|
* The scheduler is locked.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
2017-10-03 20:51:15 +02:00
|
|
|
static inline void nxsem_restorebaseprio_irq(FAR struct tcb_s *stcb,
|
|
|
|
FAR sem_t *sem)
|
2012-08-28 16:40:12 +02:00
|
|
|
{
|
2014-10-07 02:03:01 +02:00
|
|
|
/* Perform the following actions only if a new thread was given a count.
|
2012-08-28 16:40:12 +02:00
|
|
|
* The thread that received the count should be the highest priority
|
2014-08-08 21:53:29 +02:00
|
|
|
* of all threads waiting for a count from the semaphore. So in that
|
2012-08-28 16:40:12 +02:00
|
|
|
* case, the priority of all holder threads should be dropped to the
|
|
|
|
* next highest pending priority.
|
|
|
|
*/
|
|
|
|
|
2017-03-10 15:54:50 +01:00
|
|
|
if (stcb != NULL)
|
2012-08-28 16:40:12 +02:00
|
|
|
{
|
|
|
|
/* Drop the priority of all holder threads */
|
|
|
|
|
2020-01-02 17:49:34 +01:00
|
|
|
nxsem_foreachholder(sem, nxsem_restoreholderprioall, stcb);
|
2012-08-28 16:40:12 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* If there are no tasks waiting for available counts, then all holders
|
|
|
|
* should be at their base priority.
|
|
|
|
*/
|
|
|
|
|
2016-06-12 00:42:42 +02:00
|
|
|
#ifdef CONFIG_DEBUG_ASSERTIONS
|
2012-08-28 16:40:12 +02:00
|
|
|
else
|
|
|
|
{
|
2020-01-02 17:49:34 +01:00
|
|
|
nxsem_foreachholder(sem, nxsem_verifyholder, NULL);
|
2012-08-28 16:40:12 +02:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************
|
2017-10-03 20:51:15 +02:00
|
|
|
* Name: nxsem_restorebaseprio_task
|
2012-08-28 16:40:12 +02:00
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* This function is called after the current running task releases a
|
|
|
|
* count on the semaphore. It will check if we need to drop the priority
|
|
|
|
* of any threads holding a count on the semaphore. Their priority could
|
|
|
|
* have been boosted while they held the count.
|
|
|
|
*
|
2018-03-13 16:52:27 +01:00
|
|
|
* Input Parameters:
|
2012-08-28 16:40:12 +02:00
|
|
|
* stcb - The TCB of the task that was just started (if any). If the
|
|
|
|
* post action caused a count to be given to another thread, then stcb
|
|
|
|
* is the TCB that received the count. Note, just because stcb received
|
2020-03-16 20:42:34 +01:00
|
|
|
* the count, it does not mean that it is higher priority than other
|
2012-08-28 16:40:12 +02:00
|
|
|
* threads.
|
|
|
|
* sem - A reference to the semaphore being posted.
|
|
|
|
* - If the semaphore count is <0 then there are still threads waiting
|
|
|
|
* for a count. stcb should be non-null and will be higher priority
|
|
|
|
* than all of the other threads still waiting.
|
|
|
|
* - If it is ==0 then stcb refers to the thread that got the last count;
|
|
|
|
* no other threads are waiting.
|
|
|
|
* - If it is >0 then there should be no threads waiting for counts and
|
|
|
|
* stcb should be null.
|
|
|
|
*
|
2018-02-01 17:00:02 +01:00
|
|
|
* Returned Value:
|
2012-08-28 16:40:12 +02:00
|
|
|
* None
|
|
|
|
*
|
|
|
|
* Assumptions:
|
|
|
|
* The scheduler is locked.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
2017-10-03 20:51:15 +02:00
|
|
|
static inline void nxsem_restorebaseprio_task(FAR struct tcb_s *stcb,
|
|
|
|
FAR sem_t *sem)
|
2012-08-28 16:40:12 +02:00
|
|
|
{
|
2016-02-07 00:44:41 +01:00
|
|
|
FAR struct tcb_s *rtcb = this_task();
|
2012-08-28 16:40:12 +02:00
|
|
|
|
2014-10-07 02:03:01 +02:00
|
|
|
/* Perform the following actions only if a new thread was given a count.
|
2012-08-28 16:40:12 +02:00
|
|
|
* The thread that received the count should be the highest priority
|
2014-08-08 21:53:29 +02:00
|
|
|
* of all threads waiting for a count from the semaphore. So in that
|
2012-08-28 16:40:12 +02:00
|
|
|
* case, the priority of all holder threads should be dropped to the
|
|
|
|
* next highest pending priority.
|
|
|
|
*/
|
|
|
|
|
2017-03-10 15:54:50 +01:00
|
|
|
if (stcb != NULL)
|
2012-08-28 16:40:12 +02:00
|
|
|
{
|
|
|
|
/* The currently executed thread should be the lower priority
|
|
|
|
* thread that just posted the count and caused this action.
|
|
|
|
* However, we cannot drop the priority of the currently running
|
2014-10-07 02:03:01 +02:00
|
|
|
* thread -- because that will cause it to be suspended.
|
2012-08-28 16:40:12 +02:00
|
|
|
*
|
|
|
|
* So, do this in two passes. First, reprioritizing all holders
|
|
|
|
* except for the running thread.
|
|
|
|
*/
|
|
|
|
|
2020-03-09 15:12:25 +01:00
|
|
|
nxsem_foreachholder(sem, nxsem_restoreholderprio_others, stcb);
|
2012-08-28 16:40:12 +02:00
|
|
|
|
|
|
|
/* Now, find an reprioritize only the ready to run task */
|
|
|
|
|
2020-03-09 15:12:25 +01:00
|
|
|
nxsem_foreachholder(sem, nxsem_restoreholderprio_self, stcb);
|
2012-08-28 16:40:12 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* If there are no tasks waiting for available counts, then all holders
|
|
|
|
* should be at their base priority.
|
|
|
|
*/
|
|
|
|
|
2016-06-12 00:42:42 +02:00
|
|
|
#ifdef CONFIG_DEBUG_ASSERTIONS
|
2012-08-28 16:40:12 +02:00
|
|
|
else
|
|
|
|
{
|
2020-01-02 17:49:34 +01:00
|
|
|
nxsem_foreachholder(sem, nxsem_verifyholder, NULL);
|
2012-08-28 16:40:12 +02:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2014-04-13 22:32:20 +02:00
|
|
|
/* In any case, the currently executing task should have an entry in the
|
2012-08-28 16:40:12 +02:00
|
|
|
* list. Its counts were previously decremented; if it now holds no
|
|
|
|
* counts, then we need to remove it from the list of holders.
|
|
|
|
*/
|
|
|
|
|
2017-10-03 20:51:15 +02:00
|
|
|
nxsem_findandfreeholder(sem, rtcb);
|
2012-08-28 16:40:12 +02:00
|
|
|
}
|
|
|
|
|
2009-03-10 12:41:20 +01:00
|
|
|
/****************************************************************************
|
|
|
|
* Public Functions
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
/****************************************************************************
|
2017-10-03 20:51:15 +02:00
|
|
|
* Name: nxsem_initholders
|
2009-03-10 12:41:20 +01:00
|
|
|
*
|
|
|
|
* Description:
|
2017-10-03 20:51:15 +02:00
|
|
|
* Called from nxsem_initialize() to set up semaphore holder information.
|
2009-03-10 12:41:20 +01:00
|
|
|
*
|
2018-03-13 16:52:27 +01:00
|
|
|
* Input Parameters:
|
2009-03-10 12:41:20 +01:00
|
|
|
* None
|
|
|
|
*
|
2018-02-01 17:00:02 +01:00
|
|
|
* Returned Value:
|
2009-03-10 12:41:20 +01:00
|
|
|
* None
|
|
|
|
*
|
|
|
|
* Assumptions:
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
2017-10-03 20:51:15 +02:00
|
|
|
void nxsem_initholders(void)
|
2009-03-10 12:41:20 +01:00
|
|
|
{
|
2009-03-11 00:52:46 +01:00
|
|
|
#if CONFIG_SEM_PREALLOCHOLDERS > 0
|
2015-10-04 23:04:00 +02:00
|
|
|
int i;
|
2009-03-10 12:41:20 +01:00
|
|
|
|
2014-10-07 02:03:01 +02:00
|
|
|
/* Put all of the pre-allocated holder structures into the free list */
|
2009-03-10 12:41:20 +01:00
|
|
|
|
|
|
|
g_freeholders = g_holderalloc;
|
2017-08-15 01:19:27 +02:00
|
|
|
for (i = 0; i < (CONFIG_SEM_PREALLOCHOLDERS - 1); i++)
|
2009-03-10 12:41:20 +01:00
|
|
|
{
|
2017-08-15 01:19:27 +02:00
|
|
|
g_holderalloc[i].flink = &g_holderalloc[i + 1];
|
2009-03-10 12:41:20 +01:00
|
|
|
}
|
2012-08-26 23:35:14 +02:00
|
|
|
|
2017-08-15 01:19:27 +02:00
|
|
|
g_holderalloc[CONFIG_SEM_PREALLOCHOLDERS - 1].flink = NULL;
|
2009-03-10 12:41:20 +01:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************
|
2017-10-03 20:51:15 +02:00
|
|
|
* Name: nxsem_destroyholder
|
2009-03-10 12:41:20 +01:00
|
|
|
*
|
|
|
|
* Description:
|
2019-06-29 05:47:32 +02:00
|
|
|
* Called from nxsem_destroy() to handle any holders of a semaphore
|
2017-10-03 20:51:15 +02:00
|
|
|
* when it is destroyed.
|
2009-03-10 12:41:20 +01:00
|
|
|
*
|
2018-03-13 16:52:27 +01:00
|
|
|
* Input Parameters:
|
2009-03-10 12:41:20 +01:00
|
|
|
* sem - A reference to the semaphore being destroyed
|
|
|
|
*
|
2018-02-01 17:00:02 +01:00
|
|
|
* Returned Value:
|
2009-03-10 12:41:20 +01:00
|
|
|
* None
|
|
|
|
*
|
|
|
|
* Assumptions:
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
2017-10-03 20:51:15 +02:00
|
|
|
void nxsem_destroyholder(FAR sem_t *sem)
|
2009-03-10 12:41:20 +01:00
|
|
|
{
|
2019-06-29 05:47:32 +02:00
|
|
|
/* It might be an error if a semaphore is destroyed while there are any
|
|
|
|
* holders of the semaphore (except perhaps the thread that release the
|
|
|
|
* semaphore itself). We actually have to assume that the caller knows
|
|
|
|
* what it is doing because could have killed another thread that is the
|
|
|
|
* actual holder of the semaphore.
|
2009-03-13 12:27:34 +01:00
|
|
|
*
|
2019-06-29 05:47:32 +02:00
|
|
|
* It is also a standard practice to destroy the semaphore while the
|
|
|
|
* caller holds it. Of course, the caller MUST assure that there are no
|
|
|
|
* other holders of the semaphore in this case. This occurs, for example,
|
|
|
|
* when a driver is unlink'ed and the driver instance must be destroyed.
|
|
|
|
*
|
|
|
|
* Therefore, we cannot make any assumptions about the state of the
|
|
|
|
* semaphore or the state of any of the holder threads. So just recover
|
|
|
|
* any stranded holders and hope the task knows what it is doing.
|
2009-03-10 12:41:20 +01:00
|
|
|
*/
|
|
|
|
|
|
|
|
#if CONFIG_SEM_PREALLOCHOLDERS > 0
|
2017-03-10 15:54:50 +01:00
|
|
|
if (sem->hhead != NULL)
|
2009-03-13 12:27:34 +01:00
|
|
|
{
|
2019-06-29 05:47:32 +02:00
|
|
|
/* There may be an issue if there are multiple holders of
|
|
|
|
* the semaphore.
|
|
|
|
*/
|
|
|
|
|
|
|
|
DEBUGASSERT(sem->hhead->flink == NULL);
|
2020-01-02 17:49:34 +01:00
|
|
|
nxsem_foreachholder(sem, nxsem_recoverholders, NULL);
|
2009-03-13 12:27:34 +01:00
|
|
|
}
|
2017-03-21 20:47:56 +01:00
|
|
|
|
2009-03-10 12:41:20 +01:00
|
|
|
#else
|
2019-06-29 05:47:32 +02:00
|
|
|
/* There may be an issue if there are multiple holders of the semaphore. */
|
|
|
|
|
|
|
|
DEBUGASSERT(sem->holder[0].htcb == NULL || sem->holder[1].htcb == NULL);
|
2012-07-14 21:30:31 +02:00
|
|
|
|
2017-03-10 16:30:15 +01:00
|
|
|
sem->holder[0].htcb = NULL;
|
|
|
|
sem->holder[1].htcb = NULL;
|
2009-03-13 12:27:34 +01:00
|
|
|
#endif
|
2009-03-10 12:41:20 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************
|
2017-10-03 20:51:15 +02:00
|
|
|
* Name: nxsem_addholder_tcb
|
2009-03-10 12:41:20 +01:00
|
|
|
*
|
|
|
|
* Description:
|
2017-10-04 23:22:27 +02:00
|
|
|
* Called from nxsem_wait() when the calling thread obtains the semaphore;
|
2016-10-26 15:23:15 +02:00
|
|
|
* Called from sem_post() when the waiting thread obtains the semaphore.
|
2009-03-10 12:41:20 +01:00
|
|
|
*
|
2018-03-13 16:52:27 +01:00
|
|
|
* Input Parameters:
|
2016-10-26 15:23:15 +02:00
|
|
|
* htcb - TCB of the thread that just obtained the semaphore
|
|
|
|
* sem - A reference to the incremented semaphore
|
2009-03-10 12:41:20 +01:00
|
|
|
*
|
2018-02-01 17:00:02 +01:00
|
|
|
* Returned Value:
|
2009-03-10 12:41:20 +01:00
|
|
|
* 0 (OK) or -1 (ERROR) if unsuccessful
|
|
|
|
*
|
|
|
|
* Assumptions:
|
2016-10-26 15:23:15 +02:00
|
|
|
* Interrupts are disabled.
|
2009-03-10 12:41:20 +01:00
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
2017-10-03 20:51:15 +02:00
|
|
|
void nxsem_addholder_tcb(FAR struct tcb_s *htcb, FAR sem_t *sem)
|
2009-03-10 12:41:20 +01:00
|
|
|
{
|
|
|
|
FAR struct semholder_s *pholder;
|
|
|
|
|
2016-11-02 16:05:18 +01:00
|
|
|
/* If priority inheritance is disabled for this thread, then do not add
|
|
|
|
* the holder. If there are never holders of the semaphore, the priority
|
|
|
|
* inheritance is effectively disabled.
|
|
|
|
*/
|
2009-03-10 12:41:20 +01:00
|
|
|
|
2016-11-02 16:05:18 +01:00
|
|
|
if ((sem->flags & PRIOINHERIT_FLAGS_DISABLE) == 0)
|
2009-03-10 12:41:20 +01:00
|
|
|
{
|
2016-11-02 16:05:18 +01:00
|
|
|
/* Find or allocate a container for this new holder */
|
|
|
|
|
2017-10-03 20:51:15 +02:00
|
|
|
pholder = nxsem_findorallocateholder(sem, htcb);
|
2016-11-02 16:05:18 +01:00
|
|
|
if (pholder != NULL)
|
|
|
|
{
|
2020-03-09 15:12:25 +01:00
|
|
|
/* Then set the holder and increment the number of counts held by
|
|
|
|
* this holder
|
2016-11-02 16:05:18 +01:00
|
|
|
*/
|
2009-03-10 12:41:20 +01:00
|
|
|
|
2016-11-02 16:05:18 +01:00
|
|
|
pholder->htcb = htcb;
|
|
|
|
pholder->counts++;
|
|
|
|
}
|
2009-03-10 12:41:20 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-26 15:23:15 +02:00
|
|
|
/****************************************************************************
|
2017-10-03 20:51:15 +02:00
|
|
|
* Name: nxsem_addholder
|
2016-10-26 15:23:15 +02:00
|
|
|
*
|
|
|
|
* Description:
|
2017-10-04 23:22:27 +02:00
|
|
|
* Called from nxsem_wait() when the calling thread obtains the semaphore
|
2016-10-26 15:23:15 +02:00
|
|
|
*
|
2018-03-13 16:52:27 +01:00
|
|
|
* Input Parameters:
|
2016-10-26 15:23:15 +02:00
|
|
|
* sem - A reference to the incremented semaphore
|
|
|
|
*
|
2018-02-01 17:00:02 +01:00
|
|
|
* Returned Value:
|
2016-10-26 15:23:15 +02:00
|
|
|
* 0 (OK) or -1 (ERROR) if unsuccessful
|
|
|
|
*
|
|
|
|
* Assumptions:
|
|
|
|
* Interrupts are disabled.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
2017-10-03 20:51:15 +02:00
|
|
|
void nxsem_addholder(FAR sem_t *sem)
|
2016-10-26 15:23:15 +02:00
|
|
|
{
|
2017-10-03 20:51:15 +02:00
|
|
|
nxsem_addholder_tcb(this_task(), sem);
|
2016-10-26 15:23:15 +02:00
|
|
|
}
|
|
|
|
|
2009-03-10 12:41:20 +01:00
|
|
|
/****************************************************************************
|
2017-10-03 20:51:15 +02:00
|
|
|
* Name: void nxsem_boostpriority(sem_t *sem)
|
2009-03-10 12:41:20 +01:00
|
|
|
*
|
|
|
|
* Description:
|
2014-04-13 22:32:20 +02:00
|
|
|
*
|
2009-03-10 12:41:20 +01:00
|
|
|
*
|
2018-03-13 16:52:27 +01:00
|
|
|
* Input Parameters:
|
2009-03-10 12:41:20 +01:00
|
|
|
* None
|
|
|
|
*
|
2018-02-01 17:00:02 +01:00
|
|
|
* Returned Value:
|
2009-03-10 12:41:20 +01:00
|
|
|
* 0 (OK) or -1 (ERROR) if unsuccessful
|
|
|
|
*
|
|
|
|
* Assumptions:
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
2017-10-03 20:51:15 +02:00
|
|
|
void nxsem_boostpriority(FAR sem_t *sem)
|
2009-03-10 12:41:20 +01:00
|
|
|
{
|
2016-02-07 00:44:41 +01:00
|
|
|
FAR struct tcb_s *rtcb = this_task();
|
2009-03-10 12:41:20 +01:00
|
|
|
|
2009-03-12 11:55:26 +01:00
|
|
|
/* Boost the priority of every thread holding counts on this semaphore
|
|
|
|
* that are lower in priority than the new thread that is waiting for a
|
|
|
|
* count.
|
|
|
|
*/
|
2009-03-10 12:41:20 +01:00
|
|
|
|
2020-01-02 17:49:34 +01:00
|
|
|
nxsem_foreachholder(sem, nxsem_boostholderprio, rtcb);
|
2009-03-10 12:41:20 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************
|
2017-10-03 20:51:15 +02:00
|
|
|
* Name: nxsem_releaseholder
|
2009-03-10 12:41:20 +01:00
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Called from sem_post() after a thread releases one count on the
|
|
|
|
* semaphore.
|
|
|
|
*
|
2018-03-13 16:52:27 +01:00
|
|
|
* Input Parameters:
|
2009-03-10 12:41:20 +01:00
|
|
|
* sem - A reference to the semaphore being posted
|
|
|
|
*
|
2018-02-01 17:00:02 +01:00
|
|
|
* Returned Value:
|
2009-03-10 12:41:20 +01:00
|
|
|
* None
|
|
|
|
*
|
|
|
|
* Assumptions:
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
2017-10-03 20:51:15 +02:00
|
|
|
void nxsem_releaseholder(FAR sem_t *sem)
|
2009-03-10 12:41:20 +01:00
|
|
|
{
|
2016-02-07 00:44:41 +01:00
|
|
|
FAR struct tcb_s *rtcb = this_task();
|
2009-03-10 12:41:20 +01:00
|
|
|
FAR struct semholder_s *pholder;
|
|
|
|
|
|
|
|
/* Find the container for this holder */
|
|
|
|
|
2017-10-03 20:51:15 +02:00
|
|
|
pholder = nxsem_findholder(sem, rtcb);
|
2017-03-10 15:54:50 +01:00
|
|
|
if (pholder != NULL && pholder->counts > 0)
|
2009-03-10 12:41:20 +01:00
|
|
|
{
|
2009-03-12 11:55:26 +01:00
|
|
|
/* Decrement the counts on this holder -- the holder will be freed
|
2017-10-03 20:51:15 +02:00
|
|
|
* later in nxsem_restorebaseprio.
|
2009-03-12 11:55:26 +01:00
|
|
|
*/
|
2009-03-10 12:41:20 +01:00
|
|
|
|
|
|
|
pholder->counts--;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************
|
2017-10-03 20:51:15 +02:00
|
|
|
* Name: nxsem_restorebaseprio
|
2009-03-10 12:41:20 +01:00
|
|
|
*
|
|
|
|
* Description:
|
2009-03-12 02:53:20 +01:00
|
|
|
* This function is called after the current running task releases a
|
2012-08-28 16:40:12 +02:00
|
|
|
* count on the semaphore or an interrupt handler posts a new count. It
|
|
|
|
* will check if we need to drop the priority of any threads holding a
|
|
|
|
* count on the semaphore. Their priority could have been boosted while
|
|
|
|
* they held the count.
|
2009-03-10 12:41:20 +01:00
|
|
|
*
|
2018-03-13 16:52:27 +01:00
|
|
|
* Input Parameters:
|
2009-03-12 02:53:20 +01:00
|
|
|
* stcb - The TCB of the task that was just started (if any). If the
|
|
|
|
* post action caused a count to be given to another thread, then stcb
|
|
|
|
* is the TCB that received the count. Note, just because stcb received
|
2020-03-16 20:42:34 +01:00
|
|
|
* the count, it does not mean that it is higher priority than other
|
2010-10-02 02:55:32 +02:00
|
|
|
* threads.
|
2009-03-12 02:53:20 +01:00
|
|
|
* sem - A reference to the semaphore being posted.
|
|
|
|
* - If the semaphore count is <0 then there are still threads waiting
|
2010-10-02 02:55:32 +02:00
|
|
|
* for a count. stcb should be non-null and will be higher priority
|
|
|
|
* than all of the other threads still waiting.
|
|
|
|
* - If it is ==0 then stcb refers to the thread that got the last count;
|
|
|
|
* no other threads are waiting.
|
2009-03-12 02:53:20 +01:00
|
|
|
* - If it is >0 then there should be no threads waiting for counts and
|
|
|
|
* stcb should be null.
|
2009-03-10 12:41:20 +01:00
|
|
|
*
|
2018-02-01 17:00:02 +01:00
|
|
|
* Returned Value:
|
2012-08-28 16:40:12 +02:00
|
|
|
* None
|
2009-03-10 12:41:20 +01:00
|
|
|
*
|
|
|
|
* Assumptions:
|
2009-03-14 01:46:02 +01:00
|
|
|
* The scheduler is locked.
|
2009-03-10 12:41:20 +01:00
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
2017-10-03 20:51:15 +02:00
|
|
|
void nxsem_restorebaseprio(FAR struct tcb_s *stcb, FAR sem_t *sem)
|
2009-03-10 12:41:20 +01:00
|
|
|
{
|
2019-07-29 16:14:30 +02:00
|
|
|
#if 0 /* DSA: sometimes crashes when Telnet calls external cmd (i.e. 'i2c') */
|
2009-03-12 02:53:20 +01:00
|
|
|
/* Check our assumptions */
|
|
|
|
|
|
|
|
DEBUGASSERT((sem->semcount > 0 && stcb == NULL) ||
|
|
|
|
(sem->semcount <= 0 && stcb != NULL));
|
2019-07-29 16:14:30 +02:00
|
|
|
#endif
|
2009-03-12 02:53:20 +01:00
|
|
|
|
2012-08-28 16:40:12 +02:00
|
|
|
/* Handler semaphore counts posed from an interrupt handler differently
|
2012-08-28 21:01:14 +02:00
|
|
|
* from interrupts posted from threads. The primary difference is that
|
2012-08-28 16:40:12 +02:00
|
|
|
* if the semaphore is posted from a thread, then the poster thread is
|
|
|
|
* a player in the priority inheritance scheme. The interrupt handler
|
2012-08-28 21:01:14 +02:00
|
|
|
* externally injects the new count without otherwise participating
|
|
|
|
* itself.
|
2009-03-12 02:53:20 +01:00
|
|
|
*/
|
2009-03-10 12:41:20 +01:00
|
|
|
|
2012-08-28 16:40:12 +02:00
|
|
|
if (up_interrupt_context())
|
2009-03-12 02:53:20 +01:00
|
|
|
{
|
2017-10-03 20:51:15 +02:00
|
|
|
nxsem_restorebaseprio_irq(stcb, sem);
|
2009-03-12 02:53:20 +01:00
|
|
|
}
|
2012-08-28 16:40:12 +02:00
|
|
|
else
|
2009-03-12 02:53:20 +01:00
|
|
|
{
|
2017-10-03 20:51:15 +02:00
|
|
|
nxsem_restorebaseprio_task(stcb, sem);
|
2009-03-10 12:41:20 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-03-12 02:53:20 +01:00
|
|
|
/****************************************************************************
|
2017-10-03 20:51:15 +02:00
|
|
|
* Name: nxsem_canceled
|
2009-03-12 02:53:20 +01:00
|
|
|
*
|
|
|
|
* Description:
|
2020-03-09 15:12:25 +01:00
|
|
|
* Called from nxsem_wait_irq() after a thread that was waiting for a
|
|
|
|
* semaphore count was awakened because of a signal and the semaphore wait
|
|
|
|
* has been canceled. This function restores the correct thread priority
|
|
|
|
* of each holder of the semaphore.
|
2009-03-12 02:53:20 +01:00
|
|
|
*
|
2018-03-13 16:52:27 +01:00
|
|
|
* Input Parameters:
|
2009-03-12 02:53:20 +01:00
|
|
|
* sem - A reference to the semaphore no longer being waited for
|
|
|
|
*
|
2018-02-01 17:00:02 +01:00
|
|
|
* Returned Value:
|
2009-03-12 02:53:20 +01:00
|
|
|
* None
|
|
|
|
*
|
|
|
|
* Assumptions:
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
2017-10-03 20:51:15 +02:00
|
|
|
void nxsem_canceled(FAR struct tcb_s *stcb, FAR sem_t *sem)
|
2009-03-12 02:53:20 +01:00
|
|
|
{
|
|
|
|
/* Check our assumptions */
|
|
|
|
|
|
|
|
DEBUGASSERT(sem->semcount <= 0);
|
|
|
|
|
|
|
|
/* Adjust the priority of every holder as necessary */
|
|
|
|
|
2020-01-02 17:49:34 +01:00
|
|
|
nxsem_foreachholder(sem, nxsem_restoreholderprioall, stcb);
|
2009-03-12 02:53:20 +01:00
|
|
|
}
|
|
|
|
|
2009-03-13 23:35:23 +01:00
|
|
|
/****************************************************************************
|
2012-07-14 21:30:31 +02:00
|
|
|
* Name: sem_enumholders
|
2009-03-13 23:35:23 +01:00
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Show information about threads currently waiting on this semaphore
|
|
|
|
*
|
2018-03-13 16:52:27 +01:00
|
|
|
* Input Parameters:
|
2009-03-13 23:35:23 +01:00
|
|
|
* sem - A reference to the semaphore
|
|
|
|
*
|
2018-02-01 17:00:02 +01:00
|
|
|
* Returned Value:
|
2009-03-13 23:35:23 +01:00
|
|
|
* None
|
|
|
|
*
|
|
|
|
* Assumptions:
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
2016-06-11 22:14:08 +02:00
|
|
|
#if defined(CONFIG_DEBUG_FEATURES) && defined(CONFIG_SEM_PHDEBUG)
|
2009-03-13 23:35:23 +01:00
|
|
|
void sem_enumholders(FAR sem_t *sem)
|
|
|
|
{
|
2016-06-12 00:42:42 +02:00
|
|
|
#ifdef CONFIG_DEBUG_INFO
|
2020-01-02 17:49:34 +01:00
|
|
|
nxsem_foreachholder(sem, nxsem_dumpholder, NULL);
|
2016-06-12 00:42:42 +02:00
|
|
|
#endif
|
2009-03-13 23:35:23 +01:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/****************************************************************************
|
2017-10-03 20:51:15 +02:00
|
|
|
* Name: nxsem_nfreeholders
|
2009-03-13 23:35:23 +01:00
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Return the number of available holder containers. This is a good way
|
|
|
|
* to find out which threads are not calling sem_destroy.
|
|
|
|
*
|
2018-03-13 16:52:27 +01:00
|
|
|
* Input Parameters:
|
2009-03-13 23:35:23 +01:00
|
|
|
* sem - A reference to the semaphore
|
|
|
|
*
|
2018-02-01 17:00:02 +01:00
|
|
|
* Returned Value:
|
2009-03-13 23:35:23 +01:00
|
|
|
* The number of available holder containers
|
|
|
|
*
|
|
|
|
* Assumptions:
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
2016-06-11 22:14:08 +02:00
|
|
|
#if defined(CONFIG_DEBUG_FEATURES) && defined(CONFIG_SEM_PHDEBUG)
|
2017-10-03 20:51:15 +02:00
|
|
|
int nxsem_nfreeholders(void)
|
2009-03-13 23:35:23 +01:00
|
|
|
{
|
|
|
|
#if CONFIG_SEM_PREALLOCHOLDERS > 0
|
|
|
|
FAR struct semholder_s *pholder;
|
|
|
|
int n;
|
2014-04-13 22:32:20 +02:00
|
|
|
|
2017-08-15 01:19:27 +02:00
|
|
|
for (pholder = g_freeholders, n = 0; pholder; pholder = pholder->flink)
|
|
|
|
{
|
|
|
|
n++;
|
|
|
|
}
|
|
|
|
|
2009-03-13 23:35:23 +01:00
|
|
|
return n;
|
|
|
|
#else
|
|
|
|
return 0;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2009-03-10 12:41:20 +01:00
|
|
|
#endif /* CONFIG_PRIORITY_INHERITANCE */
|