int sched_getparam (pid_t pid, FAR struct sched_param *param)
{
FAR struct tcb_s *rtcb;
FAR struct tcb_s *tcb;
int ret = OK;
if (!param)
{
return ERROR;
}
/* Check if the task to restart is the calling task */
rtcb = (FAR struct tcb_s *)g_readytorun.head;
if ((pid == 0) || (pid == rtcb->pid))
{
/* Return the priority if the calling task. */
param->sched_priority = (int)rtcb->sched_priority;
}
/* Ths pid is not for the calling task, we will have to look it up */
else
{
/* Get the TCB associated with this pid */
sched_lock();
tcb = sched_gettcb(pid);
if (!tcb)
{
/* This pid does not correspond to any known task */
ret = ERROR;
}
else
{
#ifdef CONFIG_SCHED_SPORADIC
#endif
/* Return the priority of the task */
param->sched_priority = (int)tcb->sched_priority;
#ifdef CONFIG_SCHED_SPORADIC
if ((tcb->flags & TCB_FLAG_POLICY_MASK) == TCB_FLAG_SCHED_SPORADIC)
{
FAR struct sporadic_s *sporadic = tcb->sporadic;
DEBUGASSERT(sporadic != NULL);
/* Return parameters associated with SCHED_SPORADIC */
param->sched_ss_low_priority = (int)sporadic->low_priority;
param->sched_ss_max_repl = (int)sporadic->max_repl;
clock_ticks2time((int)sporadic->repl_period, ¶m->sched_ss_repl_period);
clock_ticks2time((int)sporadic->budget, ¶m->sched_ss_init_budget);
}
else
{
param->sched_ss_low_priority = 0;
param->sched_ss_max_repl = 0;
param->sched_ss_repl_period.tv_sec = 0;
param->sched_ss_repl_period.tv_nsec = 0;
param->sched_ss_init_budget.tv_sec = 0;
param->sched_ss_init_budget.tv_nsec = 0;
}
#endif
}
sched_unlock();
}
return ret;
}
int nanosleep(FAR const struct timespec *rqtp, FAR struct timespec *rmtp)
{
irqstate_t flags;
systime_t starttick;
sigset_t set;
struct siginfo value;
int errval;
#ifdef CONFIG_DEBUG_ASSERTIONS /* Warning avoidance */
int ret;
#endif
/* nanosleep() is a cancellation point */
(void)enter_cancellation_point();
if (!rqtp || rqtp->tv_nsec < 0 || rqtp->tv_nsec >= 1000000000)
{
errval = EINVAL;
goto errout;
}
/* Get the start time of the wait. Interrupts are disabled to prevent
* timer interrupts while we do tick-related calculations before and
* after the wait.
*/
flags = enter_critical_section();
starttick = clock_systimer();
/* Set up for the sleep. Using the empty set means that we are not
* waiting for any particular signal. However, any unmasked signal can
* still awaken sigtimedwait().
*/
(void)sigemptyset(&set);
/* nanosleep is a simple application of sigtimedwait. */
#ifdef CONFIG_DEBUG_ASSERTIONS /* Warning avoidance */
ret = sigtimedwait(&set, &value, rqtp);
#else
(void)sigtimedwait(&set, &value, rqtp);
#endif
/* sigtimedwait() cannot succeed. It should always return error with
* either (1) EAGAIN meaning that the timeout occurred, or (2) EINTR
* meaning that some other unblocked signal was caught.
*/
errval = get_errno();
DEBUGASSERT(ret < 0 && (errval == EAGAIN || errval == EINTR));
if (errval == EAGAIN)
{
/* The timeout "error" is the normal, successful result */
leave_critical_section(flags);
leave_cancellation_point();
return OK;
}
/* If we get there, the wait has failed because we were awakened by a
* signal. Return the amount of "unwaited" time if rmtp is non-NULL.
*/
if (rmtp)
{
systime_t elapsed;
systime_t remaining;
int ticks;
/* REVISIT: The conversion from time to ticks and back could
* be avoided. clock_timespec_subtract() would be used instead
* to get the time difference.
*/
/* First get the number of clock ticks that we were requested to
* wait.
*/
(void)clock_time2ticks(rqtp, &ticks);
/* Get the number of ticks that we actually waited */
elapsed = clock_systimer() - starttick;
/* The difference between the number of ticks that we were requested
* to wait and the number of ticks that we actualy waited is that
* amount of time that we failed to wait.
*/
if (elapsed >= (uint32_t)ticks)
{
remaining = 0;
}
else
{
remaining = (uint32_t)ticks - elapsed;
}
(void)clock_ticks2time((int)remaining, rmtp);
}
leave_critical_section(flags);
errout:
set_errno(errval);
leave_cancellation_point();
return ERROR;
}
