void check_preload_task0(scheduler_t *sched, table_t *tbl, table_preload_t preload) {
ophtask_t *task = scheduler_get(sched, 0);
assert(task->kind == preload_one);
ophload_t *load = task->data;
assert(load->tbl == tbl);
assert(load->preload == preload);
ophtask_free(task);
scheduler_done(sched, 0);
}
void check_unload_task(scheduler_t *sched, table_t *tbl) {
assert(sched->ntasks > 0);
ophtask_t *task = scheduler_get(sched, 0);
assert(task->kind == unload);
ophload_t *load = task->data;
assert(load->tbl == tbl);
ophtask_free(task);
scheduler_done(sched, 0);
}
void kernel_runloop() {
volatile TaskDescriptor* td;
int** sp_pointer;
idleTimeStart = 0;
totalIdleTime = 0;
lastReportTime = 0;
latestIdle = 999;
while (LIKELY((td = scheduler_get()) != (TaskDescriptor *)NULL && notQuit)) {
if (idleTid == td->id) idleTimeStart = GET_TIMER4();
sp_pointer = (int**)&(td->sp);
scheduler_set_running(td);
int is_interrupt = asm_switch_to_usermode(sp_pointer);
unsigned int current = GET_TIMER4();
if (idleTid == td->id) {
totalIdleTime += current - idleTimeStart;
}
if ((current - lastReportTime) > 200000) {
latestIdle = totalIdleTime*10000 / (current - lastReportTime);
lastReportTime = current;
totalIdleTime = 0;
}
if (is_interrupt) {
scheduler_move2ready();
kernel_handle_interrupt();
} else {
int *arg0 = *sp_pointer;
int request = *arg0 & MASK_LOWER;
ASSERT(request >= 0 && request < LAST_SYSCALL, "System call not in range.");
(*syscall_handler[request])(*sp_pointer,
(*sp_pointer)[1],
(*sp_pointer)[2],
(*sp_pointer)[3]);
if (request <= SYSCALL_REPLY) {
scheduler_move2ready();
}
}
} // End kernel loop;
kernel_close();
}
void test_ophcrack_preload_all4() {
table_t *tables[] = {
// xp free fast (lmalphanum5k)
table_alloc(0x0fa2031c, ".", 0),
table_alloc(0x0fa2031c, ".", 1),
table_alloc(0x0fa2031c, ".", 2),
table_alloc(0x0fa2031c, ".", 3)
};
int ntables = sizeof(tables) / sizeof(table_t*);
ophcrack_t *crack = create_crack_4test(tables, ntables);
// Assume a specific amount of RAM is availble
uint64_t preload_size =
table_preload_size(tables[0], preload_full) +
table_preload_size(tables[1], preload_full) +
table_preload_size(tables[2], preload_full) +
table_preload_size(tables[3], preload_full);
crack->freeram = preload_size;
for (int s=0; s<2; ++s) {
// Perform preload
if (s == 0) {
assert(crack->enabled->size == ntables);
preload_4test(crack, tables, ntables);
assert(crack->active->size == ntables);
assert(crack->remaining->size == 0);
}
else {
for (int i=0; i<ntables; ++i)
tables[i]->enabled = 0;
list_clear(crack->enabled);
assert(crack->enabled->size == 0);
preload_4test(crack, tables, 0);
assert(crack->active->size == 0);
assert(crack->remaining->size == 0);
}
assert(crack->remaining->size == crack->enabled->size - crack->active->size);
// Check the tasks
if (s == 0) {
assert(crack->sched->ntasks == 1 + 4*4 + 1);
while (crack->sched->ntasks > 0) {
ophtask_t *task = scheduler_get(crack->sched, 0);
ophtask_free(task);
scheduler_done(crack->sched, 0);
}
}
else {
assert(crack->sched->ntasks == 1);
check_preload_task(crack->sched, NULL, preload_none);
}
assert(crack->sched->ntasks == 0);
// Check the messages
if (s == 0)
check_preload_message(NULL, ntables, 0, preload_size);
else
check_preload_message(NULL, 0, 0, 0);
message_t *msg = message_tryget();
assert(msg == NULL);
}
// Free memory
free_crack_4test(crack);
}
