Beispiel #1
0
void schedule_init(void)
{
	spin_lock(&sched_lock);
	/* init provisioning stuff */
	all_pcores = kmalloc(sizeof(struct sched_pcore) * num_cores, 0);
	memset(all_pcores, 0, sizeof(struct sched_pcore) * num_cores);
	assert(!core_id());		/* want the alarm on core0 for now */
	init_awaiter(&ksched_waiter, __ksched_tick);
	set_ksched_alarm();
	/* init the idlecore list.  if they turned off hyperthreading, give them the
	 * odds from 1..max-1.  otherwise, give them everything by 0 (default mgmt
	 * core).  TODO: (CG/LL) better LL/CG mgmt */
#ifndef CONFIG_DISABLE_SMT
	for (int i = 1; i < num_cores; i++)
		TAILQ_INSERT_TAIL(&idlecores, pcoreid2spc(i), alloc_next);
#else
	assert(!(num_cores % 2));
	for (int i = 1; i < num_cores; i += 2)
		TAILQ_INSERT_TAIL(&idlecores, pcoreid2spc(i), alloc_next);
#endif /* CONFIG_DISABLE_SMT */
	spin_unlock(&sched_lock);

#ifdef CONFIG_ARSC_SERVER
	int arsc_coreid = get_any_idle_core();
	assert(arsc_coreid >= 0);
	send_kernel_message(arsc_coreid, arsc_server, 0, 0, 0, KMSG_ROUTINE);
	printk("Using core %d for the ARSC server\n", arsc_coreid);
#endif /* CONFIG_ARSC_SERVER */
}
Beispiel #2
0
void schedule_init(void)
{
	spin_lock(&sched_lock);
	/* init provisioning stuff */
	all_pcores = kmalloc(sizeof(struct sched_pcore) * num_cpus, 0);
	memset(all_pcores, 0, sizeof(struct sched_pcore) * num_cpus);
	assert(!core_id());		/* want the alarm on core0 for now */
	init_awaiter(&ksched_waiter, __kalarm);
	set_ksched_alarm();
	/* init the idlecore list.  if they turned off hyperthreading, give them the
	 * odds from 1..max-1.  otherwise, give them everything by 0 (default mgmt
	 * core).  TODO: (CG/LL) better LL/CG mgmt */
#ifndef CONFIG_DISABLE_SMT
	for (int i = 1; i < num_cpus; i++)
		TAILQ_INSERT_TAIL(&idlecores, pcoreid2spc(i), alloc_next);
#else
	assert(!(num_cpus % 2));
	for (int i = 1; i < num_cpus; i += 2)
		TAILQ_INSERT_TAIL(&idlecores, pcoreid2spc(i), alloc_next);
#endif /* CONFIG_DISABLE_SMT */
#ifdef CONFIG_ARSC_SERVER
	struct sched_pcore *a_core = TAILQ_FIRST(&idlecores);
	assert(a_core);
	TAILQ_REMOVE(&idlecores, a_core, alloc_next);
	send_kernel_message(spc2pcoreid(a_core), arsc_server, 0, 0, 0,
	                    KMSG_ROUTINE);
	warn("Using core %d for the ARSCs - there are probably issues with this.",
	     spc2pcoreid(a_core));
#endif /* CONFIG_ARSC_SERVER */
	spin_unlock(&sched_lock);
	return;
}
Beispiel #3
0
static void handle_keypress(char c)
{
	amr_t handler = c == 'G' ? __run_mon : __cons_add_char;
	send_kernel_message(core_id(), handler, (long)&cons_buf, (long)c, 0,
	                    KMSG_ROUTINE);
	cons_init();
}
Beispiel #4
0
static void handle_keypress(char c)
{
    /* brho: not sure if this will work on riscv or not... */
#define capchar2ctl(x) ((x) - '@')
    amr_t handler = c == capchar2ctl('G') ? __run_mon : __cons_add_char;
    send_kernel_message(core_id(), handler, (long)&cons_buf, (long)c, 0,
                        KMSG_ROUTINE);
    cons_init();
}
Beispiel #5
0
void appserver_die(uintptr_t code)
{
	int i;
	for(i = 0; i < num_cpus; i++)
		if(i != core_id())
			while(send_kernel_message(i, (amr_t)&__diediedie, code, 0, 0,
			                          KMSG_IMMEDIATE));

	// just in case.
	__diediedie(0, code, 0, 0);
}
Beispiel #6
0
Datei: en_tx.c Projekt: 8l/akaros
void mlx4_en_tx_irq(struct mlx4_cq *mcq)
{
	struct mlx4_en_cq *cq = container_of(mcq, struct mlx4_en_cq, mcq);
	struct mlx4_en_priv *priv = netdev_priv(cq->dev);

	if (likely(priv->port_up))
#if 0 // AKAROS_PORT
		napi_schedule_irqoff(&cq->napi);
#else
		send_kernel_message(core_id(), mlx4_en_poll_tx_cq, (long)cq,
				    0, 0, KMSG_ROUTINE);
#endif
	else
Beispiel #7
0
int smp_call_function_all(isr_t handler, void* data,
                          handler_wrapper_t** wait_wrapper)
{
	int8_t state = 0;
	int i;
	handler_wrapper_t* wrapper = 0;
	if(wait_wrapper)
	{
		wrapper = *wait_wrapper = smp_make_wrapper();
		if(!wrapper)
			return -ENOMEM;

		for(i = 0; i < num_cores(); i++)
			wrapper->wait_list[i] = 1;
	}

	enable_irqsave(&state);

	// send to others
	for(i = 0; i < num_cores(); i++)
	{
		if(i == core_id())
			continue;

		send_kernel_message(i,(amr_t)smp_call_wrapper,
	        	                  handler, wrapper, data, KMSG_IMMEDIATE);
	}

	// send to me
	send_kernel_message(core_id(),(amr_t)smp_call_wrapper,
	                          handler,wrapper,data, KMSG_IMMEDIATE);

	cpu_relax(); // wait to get the interrupt

	disable_irqsave(&state);

	return 0;
}
Beispiel #8
0
void smp_do_in_cores(const struct core_set *cset, void (*func)(void *),
					 void *opaque)
{
	int cpu = core_id();
	struct all_cpu_work acw;

	memset(&acw, 0, sizeof(acw));
	completion_init(&acw.comp, core_set_remote_count(cset));
	acw.func = func;
	acw.opaque = opaque;

	for (int i = 0; i < num_cores; i++) {
		if (core_set_getcpu(cset, i)) {
			if (i == cpu)
				func(opaque);
			else
				send_kernel_message(i, smp_do_core_work, (long) &acw, 0, 0,
									KMSG_ROUTINE);
		}
	}
	completion_wait(&acw.comp);
}
Beispiel #9
0
int smp_call_function_single(uint32_t dest, isr_t handler, void* data,
                             handler_wrapper_t** wait_wrapper)
{
	int8_t state = 0;
	handler_wrapper_t* wrapper = 0;
	if(wait_wrapper)
	{
		wrapper = *wait_wrapper = smp_make_wrapper();
		if(!wrapper)
			return -ENOMEM;
		wrapper->wait_list[dest] = 1;
	}

	enable_irqsave(&state);

	send_kernel_message(dest,(amr_t)smp_call_wrapper,
	                          handler,wrapper,data, KMSG_IMMEDIATE);

	cpu_relax(); // wait to get the interrupt, if it's to this core

	disable_irqsave(&state);

	return 0;
}
Beispiel #10
0
/* Interrupt/alarm handler: tells our core to run the scheduler (out of
 * interrupt context). */
static void __kalarm(struct alarm_waiter *waiter)
{
	/* Not necessary when alarms are running in RKM context (check
	 * timer_interrupt()) */
	send_kernel_message(core_id(), __ksched_tick, 0, 0, 0, KMSG_ROUTINE);
}
Beispiel #11
0
/* Interrupt/alarm handler: tells our core to run the scheduler (out of
 * interrupt context). */
static void __kalarm(struct alarm_waiter *waiter)
{
	send_kernel_message(core_id(), __ksched_tick, 0, 0, 0, KMSG_ROUTINE);
}