int sched_setscheduler(pid_t pid, int policy,
const struct sched_param *param)
{
FAR struct tcb_s *tcb;
#if CONFIG_RR_INTERVAL > 0
irqstate_t saved_state;
#endif
int ret;
/* Check for supported scheduling policy */
#if CONFIG_RR_INTERVAL > 0
if (policy != SCHED_FIFO && policy != SCHED_RR)
#else
if (policy != SCHED_FIFO)
#endif
{
errno = EINVAL;
return ERROR;
}
/* Check if the task to modify the calling task */
if (pid == 0 )
{
pid = getpid();
}
/* Verify that the pid corresponds to a real task */
tcb = sched_gettcb(pid);
if (!tcb)
{
errno = ESRCH;
return ERROR;
}
/* Prohibit any context switches while we muck with priority and scheduler
* settings.
*/
sched_lock();
#if CONFIG_RR_INTERVAL > 0
/* Further, disable timer interrupts while we set up scheduling policy. */
saved_state = irqsave();
if (policy == SCHED_RR)
{
/* Set round robin scheduling */
tcb->flags |= TCB_FLAG_ROUND_ROBIN;
tcb->timeslice = CONFIG_RR_INTERVAL / MSEC_PER_TICK;
}
else
{
/* Set FIFO scheduling */
tcb->flags &= ~TCB_FLAG_ROUND_ROBIN;
tcb->timeslice = 0;
}
irqrestore(saved_state);
#endif
/* Set the new priority */
ret = sched_reprioritize(tcb, param->sched_priority);
sched_unlock();
if (ret != OK)
{
return ERROR;
}
else
{
return OK;
}
}
static int sem_restoreholderprio(FAR struct semholder_s *pholder, FAR sem_t *sem, FAR void *arg)
{
FAR struct tcb_s *htcb = (FAR struct tcb_s *)pholder->htcb;
#if CONFIG_SEM_NNESTPRIO > 0
FAR struct tcb_s *stcb = (FAR struct tcb_s *)arg;
int rpriority;
int i;
int j;
#endif
/* Make sure that the hdoler thread is still active. If it exited without
* releasing its counts, then that would be a bad thing. But we can take no
* real action because we don't know know that the program is doing. Perhaps
* its plan is to kill a thread, then destroy the semaphore.
*/
if (!sched_verifytcb(htcb))
{
sdbg("TCB 0x%08x is a stale handle, counts lost\n", htcb);
sem_freeholder(sem, pholder);
}
/* Was the priority of the holder thread boosted? If so, then drop its
* priority back to the correct level. What is the correct level?
*/
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)
{
/* 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).
*/
DEBUGASSERT(/* htcb->sched_priority == stcb->sched_priority && */
htcb->npend_reprio == 0);
/* Reset the holder's priority back to the base priority. */
sched_reprioritize(htcb, htcb->base_priority);
}
/* There are multiple pending priority levels. The holder thread's "boosted"
* priority could greater than or equal to "stcb->sched_priority" (it could be
* greater if its priority we boosted becuase it also holds another semaphore).
*/
else if (htcb->sched_priority <= stcb->sched_priority)
{
/* 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.
*/
/* 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];
}
htcb->npend_reprio = i;
/* And apply that priority to the thread (while retaining the base_priority) */
sched_setpriority(htcb, rpriority);
}
else
{
/* The holder thread has been boosted to a higher priority than the
* waiter task. The pending priority should be in the list (unless it
* was lost because of of list overflow or because the holder was
* reprioritize again unbeknownst to the priority inheritance logic).
*
* 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
* that just received the count?
*/
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];
}
htcb->npend_reprio = j;
break;
}
}
}
#else
/* There is no alternative restore priorities, drop the priority
* of the holder thread all the way back to the threads "base"
* priority.
*/
sched_reprioritize(htcb, htcb->base_priority);
#endif
}
return 0;
}
int sched_setparam(pid_t pid, FAR const struct sched_param *param)
{
FAR struct tcb_s *rtcb;
FAR struct tcb_s *tcb;
int errcode;
int ret;
/* Verify that the requested priority is in the valid range */
if (!param)
{
errcode = EINVAL;
goto errout_with_errcode;
}
/* Prohibit modifications to the head of the ready-to-run task
* list while adjusting the priority
*/
sched_lock();
/* Check if the task to reprioritize is the calling task */
rtcb = this_task();
if (pid == 0 || pid == rtcb->pid)
{
tcb = rtcb;
}
/* The PID is not the calling task, we will have to search for it */
else
{
tcb = sched_gettcb(pid);
if (!tcb)
{
/* No task with this PID was found */
errcode = ESRCH;
goto errout_with_lock;
}
}
#ifdef CONFIG_SCHED_SPORADIC
/* Update parameters associated with SCHED_SPORADIC */
if ((rtcb->flags & TCB_FLAG_POLICY_MASK) == TCB_FLAG_SCHED_SPORADIC)
{
FAR struct sporadic_s *sporadic;
irqstate_t flags;
int repl_ticks;
int budget_ticks;
if (param->sched_ss_max_repl < 1 ||
param->sched_ss_max_repl > CONFIG_SCHED_SPORADIC_MAXREPL)
{
errcode = EINVAL;
goto errout_with_lock;
}
/* Convert timespec values to system clock ticks */
(void)clock_time2ticks(¶m->sched_ss_repl_period, &repl_ticks);
(void)clock_time2ticks(¶m->sched_ss_init_budget, &budget_ticks);
/* Avoid zero/negative times */
if (repl_ticks < 1)
{
repl_ticks = 1;
}
if (budget_ticks < 1)
{
budget_ticks = 1;
}
/* The replenishment period must be greater than or equal to the
* budget period.
*/
#if 1
/* REVISIT: In the current implementation, the budget cannot exceed
* half the duty.
*/
if (repl_ticks < (2 * budget_ticks))
#else
if (repl_ticks < budget_ticks)
#endif
{
errcode = EINVAL;
goto errout_with_lock;
}
/* Stop/reset current sporadic scheduling */
flags = enter_critical_section();
ret = sched_sporadic_reset(tcb);
if (ret >= 0)
{
/* Save the sporadic scheduling parameters and reset to the
* beginning to the replenishment interval.
*/
tcb->timeslice = budget_ticks;
sporadic = rtcb->sporadic;
DEBUGASSERT(sporadic != NULL);
sporadic->hi_priority = param->sched_priority;
sporadic->low_priority = param->sched_ss_low_priority;
sporadic->max_repl = param->sched_ss_max_repl;
sporadic->repl_period = repl_ticks;
sporadic->budget = budget_ticks;
/* And restart at the next replenishment interval */
ret = sched_sporadic_start(tcb);
}
/* Restore interrupts and handler errors */
leave_critical_section(flags);
if (ret < 0)
{
errcode = -ret;
goto errout_with_lock;
}
}
#endif
/* Then perform the reprioritization */
ret = sched_reprioritize(tcb, param->sched_priority);
sched_unlock();
return ret;
errout_with_lock:
set_errno(errcode);
sched_unlock();
return ERROR;
errout_with_errcode:
set_errno(errcode);
return ERROR;
}
