void display_policy_by_id(afs_uint32 id, int format, int unroll, struct ubik_client *uc)
{
struct osddb_policy *pol;
if ( uc )
osddb_client = uc;
pol = get_pol(id);
if ( !pol ) {
printf("\tpolicy(id=%d) not found in database!\n", id);
return;
}
output_format = format;
print_policy(pol, unroll);
}
void print_test_results(struct switch_info *si, int size, test_task tasks[], int tasks_num)
{
printf("Test Results:\n");
printf("=============\n");
printf("Tested Processes:\n");
printf("-----------------\n");
int i;
for(i = 0; i < tasks_num; i++)
{
printf("pid: %d trials: %d fibonaci: %d\n", tasks[i].pid, tasks[i].trials, tasks[i].fnum);
}
printf("----------------------------------------\n");
printf("| previous_pid | next_pid | previous_policy | next_policy | time | reason\n");
for(i = 0; i < size; i++)
{
if(si[i].previous_pid != -1){
printf("|\t%d|\t%d|\t%s|\t%s|\t%lu|\t%s\n", si[i].previous_pid, si[i].next_pid, print_policy(si[i].previous_policy), print_policy(si[i].next_policy), si[i].time, SWITCH_REASONS_STR[si[i].reason]);
}
}
}
kern_return_t
set_sched_attr(
mach_port_t task,
mach_port_t thread,
struct policy_state *ps,
boolean_t print)
{
processor_set_control_port_t pset;
struct thread_basic_info thread_basic_info;
mach_msg_type_number_t info_count;
if ((task & thread) || ((!task) && (!thread)))
test_error("set_sched_attr", "invalid arguments");
MACH_FUNC(pset, get_processor_set, ());
if (ps->policy == -1) /* dont change it */
return(KERN_SUCCESS);
switch(ps->policy) {
case POLICY_TIMESHARE:
if (task) {
MACH_CALL(task_set_policy,
(task,
pset,
ps->policy,
&ps->base.tr_base,
POLICY_TIMESHARE_BASE_COUNT,
&ps->limit.tr_limit,
POLICY_TIMESHARE_LIMIT_COUNT,
TRUE));
} else {
MACH_CALL(thread_set_policy,
(thread,
pset,
ps->policy,
&ps->base.tr_base,
POLICY_TIMESHARE_BASE_COUNT,
&ps->limit.tr_limit,
POLICY_TIMESHARE_LIMIT_COUNT));
}
break;
case POLICY_RR:
if (get_quantum(ps) == -1) {
test_error("set_sched_attr", "invalid quantum value");
}
if (task) {
MACH_CALL(task_set_policy,
(task,
pset,
ps->policy,
&ps->base.rr_base,
POLICY_RR_BASE_COUNT,
&ps->limit.rr_limit,
POLICY_RR_LIMIT_COUNT,
TRUE));
} else {
MACH_CALL(thread_set_policy,
(thread,
pset,
ps->policy,
&ps->base.rr_base,
POLICY_RR_BASE_COUNT,
&ps->limit.rr_limit,
POLICY_RR_LIMIT_COUNT));
}
break;
case POLICY_FIFO:
if (task) {
MACH_CALL(task_set_policy,
(task,
pset,
ps->policy,
&ps->base.ff_base,
POLICY_FIFO_BASE_COUNT,
&ps->limit.ff_limit,
POLICY_FIFO_LIMIT_COUNT,
TRUE));
} else {
MACH_CALL(thread_set_policy,
(thread,
pset,
ps->policy,
&ps->base.ff_base,
POLICY_FIFO_BASE_COUNT,
&ps->limit.ff_limit,
POLICY_FIFO_LIMIT_COUNT));
}
break;
}
if (debug || print)
print_policy(ps);
return KERN_SUCCESS;
}
kern_return_t
get_sched_attr(
mach_port_t task,
mach_port_t thread,
struct policy_state *ps,
boolean_t print)
{
struct thread_basic_info thread_basic_info;
struct task_basic_info task_basic_info;
mach_msg_type_number_t info_count;
struct policy_state tmp_ps;
if (!ps)
ps = &tmp_ps;
if ((task & thread) || ((!task) && (!thread)))
test_error("get_sched_attr", "invalid arguments");
if (task) {
info_count = sizeof(struct task_basic_info);
MACH_CALL(task_info, (task,
TASK_BASIC_INFO,
(task_info_t)&task_basic_info,
&info_count));
ps->policy = task_basic_info.policy;
} else {
info_count = sizeof(struct thread_basic_info);
MACH_CALL(thread_info, (thread,
THREAD_BASIC_INFO,
(thread_info_t)&thread_basic_info,
&info_count));
ps->policy = thread_basic_info.policy;
}
switch(ps->policy) {
case POLICY_TIMESHARE: {
if (task) {
struct policy_timeshare_base time_share;
info_count = POLICY_TIMESHARE_BASE_COUNT;
MACH_CALL(task_info, (task,
TASK_SCHED_TIMESHARE_INFO,
(task_info_t)&time_share,
&info_count));
ps->base.tr_base.base_priority =
time_share.base_priority;
ps->limit.tr_limit.max_priority = -1;
} else {
struct policy_timeshare_info time_share;
info_count = POLICY_TIMESHARE_INFO_COUNT;
MACH_CALL(thread_info, (thread,
THREAD_SCHED_TIMESHARE_INFO,
(thread_info_t)&time_share,
&info_count));
ps->base.tr_base.base_priority =
time_share.base_priority;
ps->limit.tr_limit.max_priority =
time_share.max_priority;
}
break;
}
case POLICY_RR: {
if (task) {
struct policy_rr_base round_robin;
info_count = POLICY_RR_BASE_COUNT;
MACH_CALL(task_info, (task,
TASK_SCHED_RR_INFO,
(task_info_t)&round_robin,
&info_count));
ps->base.rr_base.base_priority =
round_robin.base_priority;
ps->base.rr_base.quantum = -1;
ps->limit.rr_limit.max_priority = -1;
} else {
struct policy_rr_info round_robin;
info_count = POLICY_RR_INFO_COUNT;
MACH_CALL(thread_info, (thread,
THREAD_SCHED_RR_INFO,
(thread_info_t)&round_robin,
&info_count));
ps->base.rr_base.base_priority =
round_robin.base_priority;
ps->base.rr_base.quantum = round_robin.quantum;
ps->limit.rr_limit.max_priority =
round_robin.max_priority;
}
break;
}
case POLICY_FIFO: {
if (task) {
struct policy_fifo_base fifo;
info_count = POLICY_FIFO_BASE_COUNT;
MACH_CALL(task_info, (task,
TASK_SCHED_FIFO_INFO,
(task_info_t)&fifo,
&info_count));
ps->base.ff_base.base_priority = fifo.base_priority;
ps->limit.ff_limit.max_priority = -1;
} else {
struct policy_fifo_info fifo;
info_count = POLICY_FIFO_INFO_COUNT;
MACH_CALL(thread_info, (thread,
THREAD_SCHED_FIFO_INFO,
(thread_info_t)&fifo,
&info_count));
ps->base.ff_base.base_priority = fifo.base_priority;
ps->limit.ff_limit.max_priority = fifo.max_priority;
}
break;
}
default:
printf("get_sched_attr: unknown policy 0x%x: ", ps->policy);
}
if (debug || print)
print_policy(ps);
return(KERN_SUCCESS);
}
void print_policy(struct osddb_policy *pol, int unroll)
{
int r = 1;
char buf[1024];
for ( r = 0 ; r < pol->rules.pol_ruleList_len ; r++ ) {
pol_rule rule = pol->rules.pol_ruleList_val[r];
int copies = POLPROP_NCOPIES(rule.properties);
int stripes = POLPROP_NSTRIPES(rule.properties);
int use_osd = POLPROP_OSD(rule.properties);
int use_local = POLPROP_LOCAL(rule.properties);
int use_dynamic = POLPROP_DYNAMIC(rule.properties);
int force = POLPROP_FORCE(rule.properties);
int log2size = POLPROP_SSTRIPES(rule.properties);
if ( !rule.used_policy ) {
if ( rule.condition.type != POLCOND_TRUE ) {
condtree_to_string(&rule.condition, buf, NULL,
predicate_printers[output_format],
operator_strings[output_format]);
printf(predicate_formats[output_format], buf);
}
else
printf("%s", empty_predicate[output_format]);
if ( output_format == POL_OUTPUT_TABULAR ) printf("[");
if ( use_osd || use_local || use_dynamic ) {
printf(location_format[output_format],
use_osd ? string_osd[output_format]
: use_local ? string_local[output_format]
: string_dynamic[output_format]);
if ( stripes || log2size || copies )
printf("%s", seperator[output_format]);
}
if ( output_format == POL_OUTPUT_TABULAR ) printf(",");
if ( stripes ) {
printf(stripes_format[output_format], stripes);
if ( log2size || copies ) printf("%s", seperator[output_format]);
}
if ( output_format == POL_OUTPUT_TABULAR ) printf(",");
if ( log2size ) {
printf(ssize_format[output_format], log2size);
if ( copies ) printf("%s", seperator[output_format]);
}
if ( output_format == POL_OUTPUT_TABULAR ) printf(",");
if ( copies )
printf(copies_format[output_format], copies);
if ( output_format == POL_OUTPUT_TABULAR ) printf("] ");
if ( force || output_format != POL_OUTPUT_LONG )
printf("%s", seperator[output_format]);
printf("%s", force ? stop_string[output_format]
: continue_string[output_format]);
printf("%s", ending[output_format]);
}
else
if ( unroll ) {
struct osddb_policy *inner_policy = get_pol(rule.used_policy);
if ( !inner_policy ) {
printf("\tpolicy(id=%d) not found!\n", rule.used_policy);
continue;
}
print_policy(inner_policy, 1);
}
else switch(output_format) {
case 0:
case 1:
printf("\tuse the rules from policy %d\n",rule.used_policy);
break;
default:
printf("\tuse(%d);\n", rule.used_policy);
break;
}
}
}
