void manager_jenkins()
{
#ifdef CONFIG_KERNEL_TESTING
printk("<-- BEGIN_KERNEL_TESTS -->\n");
run_registered_ktest_suites();
printk("<-- END_KERNEL_TESTS -->\n");
#endif
// Run userspace tests (from config specified path).
#ifdef CONFIG_USERSPACE_TESTING
if (strlen(CONFIG_USERSPACE_TESTING_SCRIPT) != 0) {
char exec[] = "/bin/ash";
char *p_argv[] = {exec, CONFIG_USERSPACE_TESTING_SCRIPT, 0};
struct file *program = do_file_open(exec, 0, 0);
struct proc *p = proc_create(program, p_argv, NULL);
proc_wakeup(p);
proc_decref(p); /* let go of the reference created in proc_create() */
kref_put(&program->f_kref);
run_scheduler();
// Need a way to wait for p to finish
} else {
printk("No user-space launcher file specified.\n");
}
#endif
smp_idle();
assert(0);
}
void manager_waterman()
{
static bool first = true;
if (first)
mon_bb(0, 0, 0);
smp_idle();
assert(0);
}
void
smp_init(void)
{
static spinlock_t report_in_lock = SPINLOCK_INITIALIZER;
smp_percpu_init();
spin_lock(&report_in_lock);
num_cpus++;
spin_unlock(&report_in_lock);
printd("Good morning, Vietnam! (core id = %d)\n",core_id());
smp_idle();
}
/* Helper for running a proc (if we should). Lots of repetition with
* proc_restartcore */
static void try_run_proc(void)
{
struct per_cpu_info *pcpui = &per_cpu_info[core_id()];
/* There was a process running here, and we should return to it. */
if (pcpui->owning_proc) {
assert(!pcpui->cur_kthread->sysc);
assert(pcpui->cur_ctx);
__proc_startcore(pcpui->owning_proc, pcpui->cur_ctx);
assert(0);
} else {
/* Make sure we have abandoned core. It's possible to have an
* owner without a current (smp_idle, __startcore, __death).
*
* If we had a current process, we might trigger __proc_free,
* which could send us a KMSG. Since we're called after PRKM,
* let's just restart the idle loop. */
if (abandon_core())
smp_idle();
}
}
/*
* Panic is called on unresolvable fatal errors.
* It prints "panic: mesg", and then enters the kernel monitor.
*/
void _panic(const char *file, int line, const char *fmt,...)
{
va_list ap;
struct per_cpu_info *pcpui;
/* We're panicing, possibly in a place that can't handle the lock checker */
pcpui = &per_cpu_info[core_id_early()];
pcpui->__lock_checking_enabled--;
va_start(ap, fmt);
printk("kernel panic at %s:%d, from core %d: ", file, line,
core_id_early());
vcprintf(fmt, ap);
cprintf("\n");
va_end(ap);
dead:
monitor(NULL);
/* We could consider turning the lock checker back on here, but things are
* probably a mess anyways, and with it on we would probably lock up right
* away when we idle. */
//pcpui->__lock_checking_enabled++;
smp_idle();
}
void manager_brho(void)
{
static bool first = TRUE;
struct per_cpu_info *pcpui = &per_cpu_info[core_id()];
if (first) {
printk("*** IRQs must be enabled for input emergency codes ***\n");
#ifdef CONFIG_X86
printk("*** Hit ctrl-g to enter the monitor. ***\n");
printk("*** Hit ctrl-q to force-enter the monitor. ***\n");
printk("*** Hit ctrl-b for a backtrace of core 0 ***\n");
#else
printk("*** Hit ctrl-g to enter the monitor. ***\n");
#warning "***** ctrl-g untested on riscv, check k/a/r/trap.c *****"
#endif
first = FALSE;
}
/* just idle, and deal with things via interrupts. or via face. */
smp_idle();
/* whatever we do in the manager, keep in mind that we need to not do
* anything too soon (like make processes), since we'll drop in here during
* boot if the boot sequence required any I/O (like EXT2), and we need to
* PRKM() */
assert(0);
#if 0 /* ancient tests below: (keeping around til we ditch the manager) */
// for testing taking cores, check in case 1 for usage
uint32_t corelist[MAX_NUM_CORES];
uint32_t num = 3;
struct file *temp_f;
static struct proc *p;
static uint8_t RACY progress = 0; /* this will wrap around. */
switch (progress++) {
case 0:
printk("Top of the manager to ya!\n");
/* 124 is half of the available boxboro colors (with the kernel
* getting 8) */
//quick_proc_color_run("msr_dumb_while", p, 124, temp_f);
quick_proc_run("/bin/hello", p, temp_f);
#if 0
// this is how you can transition to a parallel process manually
// make sure you don't proc run first
__proc_set_state(p, PROC_RUNNING_S);
__proc_set_state(p, PROC_RUNNABLE_M);
p->resources[RES_CORES].amt_wanted = 5;
spin_unlock(&p->proc_lock);
core_request(p);
panic("This is okay");
#endif
break;
case 1:
#if 0
udelay(10000000);
// this is a ghetto way to test restarting an _M
printk("\nattempting to ghetto preempt...\n");
spin_lock(&p->proc_lock);
proc_take_allcores(p, __death);
__proc_set_state(p, PROC_RUNNABLE_M);
spin_unlock(&p->proc_lock);
udelay(5000000);
printk("\nattempting to restart...\n");
core_request(p); // proc still wants the cores
panic("This is okay");
// this tests taking some cores, and later killing an _M
printk("taking 3 cores from p\n");
for (int i = 0; i < num; i++)
corelist[i] = 7-i; // 7, 6, and 5
spin_lock(&p->proc_lock);
proc_take_cores(p, corelist, &num, __death);
spin_unlock(&p->proc_lock);
udelay(5000000);
printk("Killing p\n");
enable_irq();
proc_destroy(p);
printk("Killed p\n");
panic("This is okay");
envs[0] = kfs_proc_create(kfs_lookup_path("roslib_hello"));
__proc_set_state(envs[0], PROC_RUNNABLE_S);
proc_run(envs[0]);
warn("DEPRECATED");
break;
#endif
case 2:
/*
test_smp_call_functions();
test_checklists();
test_barrier();
test_print_info();
test_lapic_status_bit();
test_ipi_sending();
test_pit();
*/
default:
printd("Manager Progress: %d\n", progress);
// delay if you want to test rescheduling an MCP that yielded
//udelay(15000000);
run_scheduler();
}
panic("If you see me, then you probably screwed up");
monitor(0);
/*
printk("Servicing syscalls from Core 0:\n\n");
while (1) {
process_generic_syscalls(&envs[0], 1);
cpu_relax();
}
*/
return;
#endif
}
