static int srp_exceeds_ceiling(struct task_struct* first,
struct srp* srp)
{
return list_empty(&srp->ceiling) ||
get_rt_period(first) < system_ceiling(srp)->period ||
(get_rt_period(first) == system_ceiling(srp)->period &&
first->pid < system_ceiling(srp)->pid) ||
ceiling2sem(system_ceiling(srp))->owner == first;
}
feather_callback void do_sched_trace_task_param(unsigned long id, unsigned long _task)
{
struct task_struct *t = (struct task_struct*) _task;
struct st_event_record* rec = get_record(ST_PARAM, t);
if (rec) {
rec->data.param.wcet = get_exec_cost(t);
rec->data.param.period = get_rt_period(t);
rec->data.param.phase = get_rt_phase(t);
rec->data.param.partition = get_partition(t);
put_record(rec);
}
}
void prepare_for_next_period(struct task_struct *t)
{
BUG_ON(!t);
/* prepare next release */
t->rt_param.job_params.release = t->rt_param.job_params.deadline;
t->rt_param.job_params.deadline += get_rt_period(t);
t->rt_param.job_params.exec_time = 0;
/* update job sequence number */
t->rt_param.job_params.job_no++;
/* don't confuse Linux */
t->rt.time_slice = 1;
}
static unsigned int psnedf_get_srp_prio(struct task_struct* t)
{
/* assumes implicit deadlines */
return get_rt_period(t);
}
static long pfair_admit_task(struct task_struct* t)
{
lt_t quanta;
lt_t period;
s64 quantum_length = ktime_to_ns(tick_period);
struct pfair_param* param;
unsigned long i;
/* Pfair is a tick-based method, so the time
* of interest is jiffies. Calculate tick-based
* times for everything.
* (Ceiling of exec cost, floor of period.)
*/
quanta = get_exec_cost(t);
period = get_rt_period(t);
quanta = time2quanta(get_exec_cost(t), CEIL);
if (do_div(period, quantum_length))
printk(KERN_WARNING
"The period of %s/%d is not a multiple of %llu.\n",
t->comm, t->pid, (unsigned long long) quantum_length);
if (period >= PFAIR_MAX_PERIOD) {
printk(KERN_WARNING
"PFAIR: Rejecting task %s/%d; its period is too long.\n",
t->comm, t->pid);
return -EINVAL;
}
if (quanta == period) {
/* special case: task has weight 1.0 */
printk(KERN_INFO
"Admitting weight 1.0 task. (%s/%d, %llu, %llu).\n",
t->comm, t->pid, quanta, period);
quanta = 1;
period = 1;
}
param = kmalloc(sizeof(*param) +
quanta * sizeof(struct subtask), GFP_ATOMIC);
if (!param)
return -ENOMEM;
param->quanta = quanta;
param->cur = 0;
param->release = 0;
param->period = period;
for (i = 0; i < quanta; i++)
init_subtask(param->subtasks + i, i, quanta, period);
if (t->rt_param.pfair)
/* get rid of stale allocation */
kfree(t->rt_param.pfair);
t->rt_param.pfair = param;
/* spew out some debug info */
dump_subtasks(t);
return 0;
}
