gh0s7/mckernel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

support builtin-x86 and builtin-mic

Browse Source
This commit is contained in:
shirasawa
2013-01-06 15:45:17 +09:00
parent 884bd5db82
commit 9818e199f6
17 changed files with 380 additions and 142 deletions
Download Patch File Download Diff File Expand all files Collapse all files

25
arch/x86/elfboot/Makefile
View File

@ -1,29 +1,36 @@
DEST=$(O)/elfboot
CFLAGS=-c -Wall -O
CFLAGS_TEST=-DTEST
all: elfboot
all: $(DEST) $(DEST)/elfboot
elfboot: elfboot.bin
$(DEST)/elfboot: $(DEST)/elfboot.bin
cp $^ $@
truncate -s $(shell expr '(' `stat -c '%s' $^` + 4095 ')' / 4096 '*' 4096) $@
elfboot.bin: elfboot.elf
$(DEST)/elfboot.bin: $(DEST)/elfboot.elf
$(OBJCOPY) -O binary $^ $@
elfboot.elf: head.o elfboot.raw.o raw.lds
$(DEST)/elfboot.elf: $(DEST)/head.o $(DEST)/elfboot.raw.o raw.lds
$(LD) $(LDFLAGS_RAW) -T raw.lds -o $@ $^
elfboot_test: elfboot.test.o test_main.o
$(DEST)/elfboot_test: $(DEST)/elfboot.test.o $(DEST)/test_main.o
$(CC) -o $@ $^
elfboot.raw.o: elfboot.c
$(DEST)/head.o: head.S
$(CC) $(CFLAGS) -o $@ $^
elfboot.test.o: elfboot.c
$(DEST)/elfboot.raw.o: elfboot.c
$(CC) $(CFLAGS) -o $@ $^
$(DEST)/elfboot.test.o: elfboot.c
$(CC) $(CFLAGS) $(CFLAGS_TEST) -o $@ $^
clean:
$(RM) elfboot *.bin *.elf elfboot_test *.o
$(RM) $(DEST)/elfboot *.bin $(DEST)/*.elf $(DEST)/elfboot_test *.o
disas:
$(OBJDUMP) -b binary -m i386:x86-64 -D elfboot.bin
$(OBJDUMP) -b binary -m i386:x86-64 -D $(DEST)/elfboot.bin
$(DEST):
@mkdir -p $(DEST)

70
executer/kernel/control.c
View File

@ -16,9 +16,9 @@
#define dprintk(...)
#endif
static DECLARE_WAIT_QUEUE_HEAD(wq_prepare);
extern struct mcctrl_channel *channels;
int mcctrl_ikc_set_recv_cpu(int cpu);
//static DECLARE_WAIT_QUEUE_HEAD(wq_prepare);
//extern struct mcctrl_channel *channels;
int mcctrl_ikc_set_recv_cpu(ihk_os_t os, int cpu);
static long mcexec_prepare_image(ihk_os_t os,
struct program_load_desc * __user udesc)
@ -27,6 +27,7 @@ static long mcexec_prepare_image(ihk_os_t os,
struct ikc_scd_packet isp;
void *args, *envs;
long ret = 0;
struct mcctrl_usrdata *usrdata = ihk_host_os_get_usrdata(os);
if (copy_from_user(&desc, udesc,
sizeof(struct program_load_desc))) {
@ -77,9 +78,9 @@ static long mcexec_prepare_image(ihk_os_t os,
printk("%p (%lx)\n", pdesc, isp.arg);
pdesc->status = 0;
mcctrl_ikc_send(pdesc->cpu, &isp);
mcctrl_ikc_send(os, pdesc->cpu, &isp);
wait_event_interruptible(wq_prepare, pdesc->status);
wait_event_interruptible(usrdata->wq_prepare, pdesc->status);
if (copy_to_user(udesc, pdesc, sizeof(struct program_load_desc) +
sizeof(struct program_image_section) * desc.num_sections)) {
@ -167,7 +168,7 @@ int mcexec_load_image(ihk_os_t os, struct program_transfer *__user upt)
#endif
}
extern unsigned long last_thread_exec;
//extern unsigned long last_thread_exec;
static long mcexec_start_image(ihk_os_t os,
struct program_load_desc * __user udesc)
@ -175,23 +176,24 @@ static long mcexec_start_image(ihk_os_t os,
struct program_load_desc desc;
struct ikc_scd_packet isp;
struct mcctrl_channel *c;
struct mcctrl_usrdata *usrdata = ihk_host_os_get_usrdata(os);
if (copy_from_user(&desc, udesc,
sizeof(struct program_load_desc))) {
return -EFAULT;
}
c = channels + desc.cpu;
c = usrdata->channels + desc.cpu;
mcctrl_ikc_set_recv_cpu(desc.cpu);
mcctrl_ikc_set_recv_cpu(os, desc.cpu);
last_thread_exec = desc.cpu;
usrdata->last_thread_exec = desc.cpu;
isp.msg = SCD_MSG_SCHEDULE_PROCESS;
isp.ref = desc.cpu;
isp.arg = desc.rprocess;
mcctrl_ikc_send(desc.cpu, &isp);
mcctrl_ikc_send(os, desc.cpu, &isp);
return 0;
}
@ -207,31 +209,37 @@ int mcexec_syscall(struct mcctrl_channel *c, unsigned long arg)
#ifndef DO_USER_MODE
int __do_in_kernel_syscall(ihk_os_t os, struct mcctrl_channel *c,
struct syscall_request *sc);
static int remaining_job, base_cpu, job_pos;
// static int remaining_job, base_cpu, job_pos;
#endif
extern int num_channels;
extern int mcctrl_dma_abort;
// extern int num_channels;
// extern int mcctrl_dma_abort;
int mcexec_wait_syscall(ihk_os_t os, struct syscall_wait_desc *__user req)
{
struct syscall_wait_desc swd;
struct mcctrl_channel *c;
struct mcctrl_usrdata *usrdata = ihk_host_os_get_usrdata(os);
#ifndef DO_USER_MODE
unsigned long s, w, d;
#endif
if (copy_from_user(&swd, req, sizeof(swd.cpu))) {
return -EFAULT;
}
c = channels + swd.cpu;
if(swd.cpu >= usrdata->num_channels)return -EINVAL;
c = usrdata->channels + swd.cpu;
#ifdef DO_USER_MODE
wait_event_interruptible(c->wq_syscall, c->req);
c->req = 0;
#else
while (1) {
c = channels + swd.cpu;
c = usrdata->channels + swd.cpu;
rdtscll(s);
if (!remaining_job) {
if (!usrdata->remaining_job) {
while (!(*c->param.doorbell_va)) {
mb();
cpu_relax();
@ -243,22 +251,22 @@ int mcexec_wait_syscall(ihk_os_t os, struct syscall_wait_desc *__user req)
d = (*c->param.doorbell_va) - 1;
*c->param.doorbell_va = 0;
if (d < 0 || d >= num_channels) {
if (d < 0 || d >= usrdata->num_channels) {
d = 0;
}
base_cpu = d;
job_pos = 0;
remaining_job = 1;
usrdata->base_cpu = d;
usrdata->job_pos = 0;
usrdata->remaining_job = 1;
} else {
job_pos++;
usrdata->job_pos++;
}
for (; job_pos < num_channels; job_pos++) {
for (; usrdata->job_pos < usrdata->num_channels; usrdata->job_pos++) {
if (base_cpu + job_pos >= num_channels) {
c = channels +
(base_cpu + job_pos - num_channels);
c = usrdata->channels +
(usrdata->base_cpu + usrdata->job_pos - usrdata->num_channels);
} else {
c = channels + base_cpu + job_pos;
c = usrdata->channels + usrdata->base_cpu + usrdata->job_pos;
}
if (!c) {
continue;
@ -278,12 +286,12 @@ int mcexec_wait_syscall(ihk_os_t os, struct syscall_wait_desc *__user req)
#ifndef DO_USER_MODE
return 0;
}
if (mcctrl_dma_abort) {
if (usrdata->mcctrl_dma_abort) {
return -2;
}
}
}
remaining_job = 0;
usrdata->remaining_job = 0;
}
#endif
return 0;
@ -404,6 +412,7 @@ long mcexec_ret_syscall(ihk_os_t os, struct syscall_ret_desc *__user arg)
{
struct syscall_ret_desc ret;
struct mcctrl_channel *mc;
struct mcctrl_usrdata *usrdata = ihk_host_os_get_usrdata(os);
#if 0
ihk_dma_channel_t channel;
struct ihk_dma_request request;
@ -417,7 +426,7 @@ long mcexec_ret_syscall(ihk_os_t os, struct syscall_ret_desc *__user arg)
if (copy_from_user(&ret, arg, sizeof(struct syscall_ret_desc))) {
return -EFAULT;
}
mc = channels + ret.cpu;
mc = usrdata->channels + ret.cpu;
if (!mc) {
return -EINVAL;
}
@ -501,12 +510,13 @@ long __mcctrl_control(ihk_os_t os, unsigned int req, unsigned long arg)
return -EINVAL;
}
void mcexec_prepare_ack(unsigned long arg)
void mcexec_prepare_ack(ihk_os_t os, unsigned long arg)
{
struct program_load_desc *desc = phys_to_virt(arg);
struct mcctrl_usrdata *usrdata = ihk_host_os_get_usrdata(os);
desc->status = 1;
wake_up_all(&wq_prepare);
wake_up_all(&usrdata->wq_prepare);
}

66
executer/kernel/driver.c
View File

@ -9,9 +9,14 @@
#include <linux/slab.h>
#include "mcctrl.h"
#define OS_MAX_MINOR 64
extern long __mcctrl_control(ihk_os_t, unsigned int, unsigned long);
extern int prepare_ikc_channels(ihk_os_t os);
extern void destroy_ikc_channels(ihk_os_t os);
#ifndef DO_USER_MODE
extern void mcctrl_syscall_init(void);
#endif
static long mcctrl_ioctl(ihk_os_t os, unsigned int request, void *priv,
unsigned long arg)
@ -30,33 +35,70 @@ static struct ihk_os_user_call_handler mcctrl_uchs[] = {
{ .request = MCEXEC_UP_FREE_DMA, .func = mcctrl_ioctl },
};
static struct ihk_os_user_call mcctrl_uc = {
static struct ihk_os_user_call mcctrl_uc_proto = {
.num_handlers = sizeof(mcctrl_uchs) / sizeof(mcctrl_uchs[0]),
.handlers = mcctrl_uchs,
};
static ihk_os_t os;
static struct ihk_os_user_call mcctrl_uc[OS_MAX_MINOR];
static ihk_os_t os[OS_MAX_MINOR];
static int __init mcctrl_init(void)
{
os = ihk_host_find_os(0, NULL);
if (!os) {
printk("OS #0 not found.\n");
return -ENOENT;
int i;
int rc;
rc = -ENOENT;
for(i = 0; i < OS_MAX_MINOR; i++){
os[i] = ihk_host_find_os(i, NULL);
if (os[i]) {
printk("OS #%d found.\n", i);
rc = 0;
}
if (prepare_ikc_channels(os) != 0) {
printk("Preparing syscall channels failed.\n");
return -EINVAL;
}
if(rc){
printk("OS not found.\n");
return rc;
}
return ihk_os_register_user_call_handlers(os, &mcctrl_uc);
for(i = 0; i < OS_MAX_MINOR; i++){
if (os[i]) {
if (prepare_ikc_channels(os[i]) != 0) {
printk("Preparing syscall channels failed.\n");
os[i] = NULL;
}
}
}
#ifndef DO_USER_MODE
mcctrl_syscall_init();
#endif
for(i = 0; i < OS_MAX_MINOR; i++){
if (os[i]) {
memcpy(mcctrl_uc + i, &mcctrl_uc_proto, sizeof mcctrl_uc_proto);
rc = ihk_os_register_user_call_handlers(os[i], mcctrl_uc + i);
if(rc < 0){
destroy_ikc_channels(os[i]);
os[i] = NULL;
}
}
}
return 0;
}
static void __exit mcctrl_exit(void)
{
int i;
printk("mcctrl: unregistered.\n");
ihk_os_unregister_user_call_handlers(os, &mcctrl_uc);
destroy_ikc_channels(os);
for(i = 0; i < OS_MAX_MINOR; i++){
if(os[i]){
ihk_os_unregister_user_call_handlers(os[i], mcctrl_uc + i);
destroy_ikc_channels(os[i]);
}
}
}
MODULE_LICENSE("GPL v2");

98
executer/kernel/ikc.c
View File

@ -3,18 +3,19 @@
#include <linux/fs.h>
#include <linux/miscdevice.h>
#include <linux/slab.h>
#include <linux/string.h>
#include "mcctrl.h"
#include <ihk/ikc.h>
#include <ikc/master.h>
#ifdef ATTACHED_MIC
#include <sysdeps/mic/mic/micconst.h>
#endif
#define REQUEST_SHIFT 16
int num_channels;
//int num_channels;
struct mcctrl_channel *channels;
//struct mcctrl_channel *channels;
void mcexec_prepare_ack(unsigned long arg);
void mcexec_prepare_ack(ihk_os_t os, unsigned long arg);
static void mcctrl_ikc_init(ihk_os_t os, int cpu, unsigned long rphys);
int mcexec_syscall(struct mcctrl_channel *c, unsigned long arg);
@ -22,6 +23,7 @@ static int syscall_packet_handler(struct ihk_ikc_channel_desc *c,
void *__packet, void *__os)
{
struct ikc_scd_packet *pisp = __packet;
struct mcctrl_usrdata *usrdata = ihk_host_os_get_usrdata(__os);
switch (pisp->msg) {
case SCD_MSG_INIT_CHANNEL:
@ -29,30 +31,33 @@ static int syscall_packet_handler(struct ihk_ikc_channel_desc *c,
break;
case SCD_MSG_PREPARE_PROCESS_ACKED:
mcexec_prepare_ack(pisp->arg);
mcexec_prepare_ack(__os, pisp->arg);
break;
case SCD_MSG_SYSCALL_ONESIDE:
mcexec_syscall(channels + pisp->ref, pisp->arg);
mcexec_syscall(usrdata->channels + pisp->ref, pisp->arg);
break;
}
return 0;
}
int mcctrl_ikc_send(int cpu, struct ikc_scd_packet *pisp)
int mcctrl_ikc_send(ihk_os_t os, int cpu, struct ikc_scd_packet *pisp)
{
if (cpu < 0 || cpu >= num_channels || !channels[cpu].c) {
struct mcctrl_usrdata *usrdata = ihk_host_os_get_usrdata(os);
if (cpu < 0 || cpu >= usrdata->num_channels || !usrdata->channels[cpu].c) {
return -EINVAL;
}
return ihk_ikc_send(channels[cpu].c, pisp, 0);
return ihk_ikc_send(usrdata->channels[cpu].c, pisp, 0);
}
int mcctrl_ikc_send_msg(int cpu, int msg, int ref, unsigned long arg)
int mcctrl_ikc_send_msg(ihk_os_t os, int cpu, int msg, int ref, unsigned long arg)
{
struct ikc_scd_packet packet;
struct mcctrl_usrdata *usrdata = ihk_host_os_get_usrdata(os);
if (cpu < 0 || cpu >= num_channels || !channels[cpu].c) {
if (cpu < 0 || cpu >= usrdata->num_channels || !usrdata->channels[cpu].c) {
return -EINVAL;
}
@ -60,34 +65,39 @@ int mcctrl_ikc_send_msg(int cpu, int msg, int ref, unsigned long arg)
packet.ref = ref;
packet.arg = arg;
return ihk_ikc_send(channels[cpu].c, &packet, 0);
return ihk_ikc_send(usrdata->channels[cpu].c, &packet, 0);
}
int mcctrl_ikc_set_recv_cpu(int cpu)
int mcctrl_ikc_set_recv_cpu(ihk_os_t os, int cpu)
{
ihk_ikc_channel_set_cpu(channels[cpu].c,
struct mcctrl_usrdata *usrdata = ihk_host_os_get_usrdata(os);
ihk_ikc_channel_set_cpu(usrdata->channels[cpu].c,
ihk_ikc_get_processor_id());
kprintf("Setting the target to %d\n",
ihk_ikc_get_processor_id());
return 0;
}
int mcctrl_ikc_is_valid_thread(int cpu)
int mcctrl_ikc_is_valid_thread(ihk_os_t os, int cpu)
{
if (cpu < 0 || cpu >= num_channels || !channels[cpu].c) {
struct mcctrl_usrdata *usrdata = ihk_host_os_get_usrdata(os);
if (cpu < 0 || cpu >= usrdata->num_channels || !usrdata->channels[cpu].c) {
return 0;
} else {
return 1;
}
}
unsigned long *mcctrl_doorbell_va;
unsigned long mcctrl_doorbell_pa;
//unsigned long *mcctrl_doorbell_va;
//unsigned long mcctrl_doorbell_pa;
static void mcctrl_ikc_init(ihk_os_t os, int cpu, unsigned long rphys)
{
struct mcctrl_usrdata *usrdata = ihk_host_os_get_usrdata(os);
struct ikc_scd_packet packet;
struct mcctrl_channel *pmc = channels + cpu;
struct mcctrl_channel *pmc = usrdata->channels + cpu;
unsigned long phys;
struct ikc_scd_init_param *rpm;
@ -111,8 +121,8 @@ static void mcctrl_ikc_init(ihk_os_t os, int cpu, unsigned long rphys)
(void *)__get_free_pages(GFP_KERNEL,
REQUEST_SHIFT - PAGE_SHIFT);
pmc->param.request_pa = virt_to_phys(pmc->param.request_va);
pmc->param.doorbell_va = mcctrl_doorbell_va;
pmc->param.doorbell_pa = mcctrl_doorbell_pa;
pmc->param.doorbell_va = usrdata->mcctrl_doorbell_va;
pmc->param.doorbell_pa = usrdata->mcctrl_doorbell_pa;
pmc->param.post_va = (void *)__get_free_page(GFP_KERNEL);
pmc->param.post_pa = virt_to_phys(pmc->param.post_va);
memset(pmc->param.doorbell_va, 0, PAGE_SIZE);
@ -168,18 +178,20 @@ static int connect_handler(struct ihk_ikc_channel_info *param)
{
struct ihk_ikc_channel_desc *c;
int cpu;
ihk_os_t os = param->channel->remote_os;
struct mcctrl_usrdata *usrdata = ihk_host_os_get_usrdata(os);
c = param->channel;
cpu = c->send.queue->read_cpu;
if (cpu < 0 || cpu >= num_channels) {
if (cpu < 0 || cpu >= usrdata->num_channels) {
kprintf("Invalid connect source processor: %d\n", cpu);
return 1;
}
param->packet_handler = syscall_packet_handler;
init_waitqueue_head(&channels[cpu].wq_syscall);
init_waitqueue_head(&usrdata->channels[cpu].wq_syscall);
channels[cpu].c = c;
usrdata->channels[cpu].c = c;
kprintf("syscall: MC CPU %d connected.\n", cpu);
return 0;
@ -196,9 +208,11 @@ static struct ihk_ikc_listen_param listen_param = {
int prepare_ikc_channels(ihk_os_t os)
{
struct ihk_cpu_info *info;
struct mcctrl_usrdata *usrdata;
mcctrl_doorbell_va = (void *)__get_free_page(GFP_KERNEL);
mcctrl_doorbell_pa = virt_to_phys(mcctrl_doorbell_va);
usrdata = kzalloc(sizeof(struct mcctrl_usrdata), GFP_KERNEL);
usrdata->mcctrl_doorbell_va = (void *)__get_free_page(GFP_KERNEL);
usrdata->mcctrl_doorbell_pa = virt_to_phys(usrdata->mcctrl_doorbell_va);
info = ihk_os_get_cpu_info(os);
if (!info) {
@ -210,15 +224,19 @@ int prepare_ikc_channels(ihk_os_t os)
return -EINVAL;
}
num_channels = info->n_cpus;
channels = kzalloc(sizeof(struct mcctrl_channel) * num_channels,
usrdata->num_channels = info->n_cpus;
usrdata->channels = kzalloc(sizeof(struct mcctrl_channel) * usrdata->num_channels,
GFP_KERNEL);
if (!channels) {
if (!usrdata->channels) {
printk("Error: cannot allocate channels.\n");
return -ENOMEM;
}
ihk_ikc_listen_port(os, &listen_param);
usrdata->os = os;
init_waitqueue_head(&usrdata->wq_prepare);
ihk_host_os_set_usrdata(os, usrdata);
memcpy(&usrdata->listen_param, &listen_param, sizeof listen_param);
ihk_ikc_listen_port(os, &usrdata->listen_param);
return 0;
}
@ -243,16 +261,20 @@ void __destroy_ikc_channel(ihk_os_t os, struct mcctrl_channel *pmc)
void destroy_ikc_channels(ihk_os_t os)
{
int i;
struct mcctrl_usrdata *usrdata = ihk_host_os_get_usrdata(os);
for (i = 0; i < num_channels; i++) {
if (channels[i].c) {
// ihk_ikc_disconnect(channels[i].c);
ihk_ikc_free_channel(channels[i].c);
__destroy_ikc_channel(os, channels + i);
ihk_host_os_set_usrdata(os, NULL);
for (i = 0; i < usrdata->num_channels; i++) {
if (usrdata->channels[i].c) {
// ihk_ikc_disconnect(usrdata->channels[i].c);
ihk_ikc_free_channel(usrdata->channels[i].c);
__destroy_ikc_channel(os, usrdata->channels + i);
printk("Channel #%d freed.\n", i);
}
}
free_page((unsigned long)mcctrl_doorbell_va);
free_page((unsigned long)usrdata->mcctrl_doorbell_va);
kfree(channels);
kfree(usrdata->channels);
kfree(usrdata);
}

23
executer/kernel/mcctrl.h
View File

@ -4,6 +4,8 @@
#include <ihk/ihk_host_driver.h>
#include <uprotocol.h>
#include <linux/wait.h>
#include <ihk/ikc.h>
#include <ikc/master.h>
#define SCD_MSG_PREPARE_PROCESS 0x1
#define SCD_MSG_PREPARE_PROCESS_ACKED 0x2
@ -62,7 +64,22 @@ struct mcctrl_channel {
wait_queue_head_t wq_syscall;
};
int mcctrl_ikc_send(int cpu, struct ikc_scd_packet *pisp);
int mcctrl_ikc_send_msg(int cpu, int msg, int ref, unsigned long arg);
int mcctrl_ikc_is_valid_thread(int cpu);
struct mcctrl_usrdata {
struct ihk_ikc_listen_param listen_param;
ihk_os_t os;
int num_channels;
struct mcctrl_channel *channels;
unsigned long *mcctrl_doorbell_va;
unsigned long mcctrl_doorbell_pa;
int remaining_job;
int base_cpu;
int job_pos;
int mcctrl_dma_abort;
unsigned long last_thread_exec;
wait_queue_head_t wq_prepare;
};
int mcctrl_ikc_send(ihk_os_t os, int cpu, struct ikc_scd_packet *pisp);
int mcctrl_ikc_send_msg(ihk_os_t os, int cpu, int msg, int ref, unsigned long arg);
int mcctrl_ikc_is_valid_thread(ihk_os_t os, int cpu);
#endif

64
executer/kernel/syscall.c
View File

@ -14,7 +14,7 @@
//#define SC_DEBUG
#ifdef SC_DEBUG
static struct ihk_dma_request last_request;
//static struct ihk_dma_request last_request;
static void print_dma_lastreq(void)
{
@ -26,9 +26,30 @@ static void print_dma_lastreq(void)
}
#endif
unsigned long last_thread_exec = 0;
//unsigned long last_thread_exec = 0;
#ifndef DO_USER_MODE
static struct {
long (*do_sys_open)(int, const char __user *, int, int);
long (*sys_lseek)(unsigned int, off_t, unsigned int);
long (*sys_read)(unsigned int, char __user *, size_t);
long (*sys_write)(unsigned int, const char __user *, size_t);
} syscalls;
void
mcctrl_syscall_init(void)
{
printk("mcctrl_syscall_init\n");
syscalls.do_sys_open = (void *)kallsyms_lookup_name("do_sys_open");
syscalls.sys_lseek = (void *)kallsyms_lookup_name("sys_lseek");
syscalls.sys_read = (void *)kallsyms_lookup_name("sys_read");
syscalls.sys_write = (void *)kallsyms_lookup_name("sys_write");
printk("syscalls.do_sys_open=%lx\n", (long)syscalls.do_sys_open);
printk("syscalls.sys_lseek=%lx\n", (long)syscalls.sys_lseek);
printk("syscalls.sys_read=%lx\n", (long)syscalls.sys_read);
printk("syscalls.sys_write=%lx\n", (long)syscalls.sys_write);
}
static int do_async_copy(ihk_os_t os, unsigned long dest, unsigned long src,
unsigned long size, unsigned int inbound)
{
@ -60,12 +81,13 @@ static int do_async_copy(ihk_os_t os, unsigned long dest, unsigned long src,
return 0;
}
int mcctrl_dma_abort;
//int mcctrl_dma_abort;
static void async_wait(unsigned char *p, int size)
static void async_wait(ihk_os_t os, unsigned char *p, int size)
{
int asize = ALIGN_WAIT_BUF(size);
unsigned long long s, w;
struct mcctrl_usrdata *usrdata = ihk_host_os_get_usrdata(os);
rdtscll(s);
while (!p[asize]) {
@ -75,12 +97,15 @@ static void async_wait(unsigned char *p, int size)
if (w > s + 1024UL * 1024 * 1024 * 10) {
printk("DMA Timed out : %p (%p + %d) => %d\n",
p + asize, p, size, p[asize]);
#ifdef SC_DEBUG
print_dma_lastreq();
mcctrl_dma_abort = 1;
#endif
usrdata->mcctrl_dma_abort = 1;
return;
}
}
}
static void clear_wait(unsigned char *p, int size)
{
//int asize = ALIGN_WAIT_BUF(size);
@ -117,7 +142,7 @@ static unsigned long translate_remote_va(struct mcctrl_channel *c,
return -EFAULT;
}
extern struct mcctrl_channel *channels;
//extern struct mcctrl_channel *channels;
int __do_in_kernel_syscall(ihk_os_t os, struct mcctrl_channel *c,
struct syscall_request *sc)
@ -125,6 +150,7 @@ int __do_in_kernel_syscall(ihk_os_t os, struct mcctrl_channel *c,
int ret;
mm_segment_t fs;
unsigned long pa;
struct mcctrl_usrdata *usrdata = ihk_host_os_get_usrdata(os);
switch (sc->number) {
case 0: /* read */
@ -140,13 +166,13 @@ int __do_in_kernel_syscall(ihk_os_t os, struct mcctrl_channel *c,
clear_wait(c->dma_buf, sc->args[2]);
fs = get_fs();
set_fs(KERNEL_DS);
ret = sys_read(sc->args[0], c->dma_buf, sc->args[2]);
ret = syscalls.sys_read(sc->args[0], c->dma_buf, sc->args[2]);
if (ret > 0) {
do_async_copy(os, sc->args[1], virt_to_phys(c->dma_buf),
sc->args[2], 0);
set_fs(fs);
async_wait(c->dma_buf, sc->args[2]);
async_wait(os, c->dma_buf, sc->args[2]);
}
__return_syscall(c, ret);
return 0;
@ -166,9 +192,9 @@ int __do_in_kernel_syscall(ihk_os_t os, struct mcctrl_channel *c,
sc->args[2], 1);
fs = get_fs();
set_fs(KERNEL_DS);
async_wait(c->dma_buf, sc->args[2]);
async_wait(os, c->dma_buf, sc->args[2]);
ret = sys_write(sc->args[0], c->dma_buf, sc->args[2]);
ret = syscalls.sys_write(sc->args[0], c->dma_buf, sc->args[2]);
set_fs(fs);
__return_syscall(c, ret);
@ -189,9 +215,9 @@ int __do_in_kernel_syscall(ihk_os_t os, struct mcctrl_channel *c,
256, 1);
fs = get_fs();
set_fs(KERNEL_DS);
async_wait(c->dma_buf, 256);
async_wait(os, c->dma_buf, 256);
ret = do_sys_open(AT_FDCWD, c->dma_buf, sc->args[1],
ret = syscalls.do_sys_open(AT_FDCWD, c->dma_buf, sc->args[1],
sc->args[2]);
set_fs(fs);
@ -204,21 +230,21 @@ int __do_in_kernel_syscall(ihk_os_t os, struct mcctrl_channel *c,
return 0;
case 8: /* lseek */
ret = sys_lseek(sc->args[0], sc->args[1], sc->args[2]);
ret = syscalls.sys_lseek(sc->args[0], sc->args[1], sc->args[2]);
__return_syscall(c, ret);
return 0;
case 56: /* Clone */
last_thread_exec++;
if (mcctrl_ikc_is_valid_thread(last_thread_exec)) {
usrdata->last_thread_exec++;
if (mcctrl_ikc_is_valid_thread(usrdata->last_thread_exec)) {
printk("Clone notification: %lx\n", sc->args[0]);
if (channels[last_thread_exec].param.post_va) {
memcpy(channels[last_thread_exec].param.post_va,
if (channels[usrdata->last_thread_exec].param.post_va) {
memcpy(usrdata->channels[usrdata->last_thread_exec].param.post_va,
c->param.post_va, PAGE_SIZE);
}
mcctrl_ikc_send_msg(last_thread_exec,
mcctrl_ikc_send_msg(usrdata->last_thread_exec,
SCD_MSG_SCHEDULE_PROCESS,
last_thread_exec, sc->args[0]);
usrdata->last_thread_exec, sc->args[0]);
}
__return_syscall(c, 0);

20
executer/user/mcexec.c
View File

@ -327,6 +327,9 @@ int main(int argc, char **argv)
struct program_load_desc *desc;
char *envs;
char *args;
char dev[64];
char **a;
char *p;
int i;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
@ -335,8 +338,19 @@ int main(int argc, char **argv)
__glob_argv = argv;
#endif
strcpy(dev, "/dev/mcos0");
if(argv[1]){
for(p = argv[1]; *p && *p >= '0' && *p <= '9'; p++);
if(!*p){
sprintf(dev, "/dev/mcos%s", argv[1]);
for(a = argv + 2; *a; a++)
a[-1] = a[0];
a[-1] = NULL;
argc--;
}
}
if (argc < 2) {
fprintf(stderr, "Usage: %s (program) [args...]\n",
fprintf(stderr, "Usage: %s [<mcos-id>] (program) [args...]\n",
argv[0]);
return 1;
}
@ -364,9 +378,9 @@ int main(int argc, char **argv)
desc->args = args;
//print_flat(args);
fd = open("/dev/mcos0", O_RDWR);
fd = open(dev, O_RDWR);
if (fd < 0) {
fprintf(stderr, "Error: Failed to open /dev/mcctrl.\n");
fprintf(stderr, "Error: Failed to open %s.\n", dev);
return 1;
}

2
kernel/Makefile
View File

@ -1,5 +1,5 @@
#BUILD_TARGET = builtin-mic attached-mic
BUILD_TARGET = attached-mic
BUILD_TARGET ?= attached-mic
SRC = $(CURDIR)
IHKBASE ?= $(SRC)/../../ihk/cokernel

3
kernel/Makefile.build
View File

@ -14,6 +14,9 @@ include $(IHKBASE)/Makefile.common
SUBCMD_OPTS = TARGET=$(TARGET) O=$(CURDIR)/ihk CC=$(CC) LD=$(LD) SRC=$(SRC)
OBJDUMP ?= objdump
OBJCOPY ?= objcopy
ld_kern_cmd_base = $(LD) $(LDFLAGS) -o $@.elf $^
mkimage_cmd_base = [ -f $(SRC)/script/mkimage.$(TARGET) ] && CC=$(CC) LD=$(LD) LDFLAGS="$(LDFLAGS_MKIMAGE)" OBJDUMP=$(OBJDUMP) OBJCOPY=$(OBJCOPY) sh $(SRC)/script/mkimage.$(TARGET) '$@.elf' '$@' '$(SRC)' || cp $@.elf $@

33
kernel/config/builtin-mic.lds Normal file
View File

@ -0,0 +1,33 @@
PHDRS
{
text PT_LOAD FLAGS(5);
data PT_LOAD FLAGS(7);
}
SECTIONS
{
. = 0xffffffff80001000;
_head = .;
.text : {
*(.text);
} : text
. = ALIGN(4096);
.data : {
*(.data)
*(.data.*)
} :data
.rodata : {
*(.rodata .rodata.*)
} :data
.bss : {
*(.bss .bss.*)
}
. = ALIGN(4096);
_end = .;
/DISCARD/ : {
*(.eh_frame)
*(.note.gnu.build-id)
}
}

8
kernel/config/config.builtin-mic Normal file
View File

@ -0,0 +1,8 @@
CC = /opt/knc/linux-k1om-4.7/bin/x86_64-k1om-linux-gcc
LD = /opt/knc/linux-k1om-4.7/bin/x86_64-k1om-linux-ld
OBJDUMP = /opt/knc/linux-k1om-4.7/bin/x86_64-k1om-linux-objdump
OBJCOPY = /opt/knc/linux-k1om-4.7/bin/x86_64-k1om-linux-objcopy
CFLAGS += -mno-sse -mno-mmx -mno-sse2 -mno-3dnow
LDFLAGS += -m elf_k1om -T $(SRC)/config/builtin-mic.lds
LDFLAGS_MKIMAGE = -m elf_k1om

2
kernel/include/process.h
View File

@ -20,7 +20,9 @@
#define PS_NORMAL (PS_INTERRUPTIBLE | PS_UNINTERRUPTIBLE)
#ifdef ATTACHED_MIC
#define USE_LARGE_PAGES
#endif
#include <waitq.h>
#include <futex.h>

10
kernel/mem.c
View File

@ -7,8 +7,10 @@
#include <ihk/mm.h>
#include <ihk/page_alloc.h>
#include <registers.h>
#ifdef ATTACHED_MIC
#include <sysdeps/mic/mic/micconst.h>
#include <sysdeps/mic/mic/micsboxdefine.h>
#endif
#include <cls.h>
//#define DEBUG_PRINT_MEM
@ -125,13 +127,15 @@ static void page_allocator_init(void)
pa_start &= PAGE_MASK;
pa_end = (pa_end + PAGE_SIZE - 1) & PAGE_MASK;
/*
#ifndef ATTACHED_MIC
page_map_pa = ihk_mc_get_memory_address(IHK_MC_GMA_HEAP_START, 0);
page_map = phys_to_virt(page_map_pa);
#else
/*
* Can't allocate in reserved area
* TODO: figure this out automatically!
*/
page_map_pa = 0x100000;
#endif
page_map = phys_to_virt(page_map_pa);
pa_allocator = __ihk_pagealloc_init(pa_start, pa_end - pa_start,
@ -209,6 +213,7 @@ void ihk_mc_unmap_virtual(void *va, int npages, int free_physical)
ihk_pagealloc_free(vmap_allocator, virt_to_phys(va), npages);
}
#ifdef ATTACHED_MIC
/* moved from ihk_knc/manycore/mic/setup.c */
/*static*/ void *sbox_base = (void *)SBOX_BASE;
void sbox_write(int offset, unsigned int value)
@ -258,6 +263,7 @@ void ihk_mc_clean_micpa(void){
free_bitmap_micpa = ((~((1ULL<<(NUM_SMPT_ENTRIES_IN_USE - NUM_SMPT_ENTRIES_MICPA))-1))&((1ULL << NUM_SMPT_ENTRIES_IN_USE) - 1));
kprintf("ihk_mc_clean_micpa\n");
}
#endif
void mem_init(void)
{

20
kernel/script/mkimage.builtin-mic Normal file
View File

@ -0,0 +1,20 @@
#!/bin/sh
set -e
O=`pwd`
make -C $3/../arch/x86/kboot O=$O clean
#make -C $3/../kboot O=$O KIMAGE="$O/$1" LOAD_PA=0x3a001000
make -C $3/../arch/x86/kboot O=$O KIMAGE="$O/$1" LOAD_PA=0x21001000
#make -C $3/../kboot O=$O KIMAGE="$O/$1" LOAD_PA=0x901001000
make -C $3/../arch/x86/elfboot O=$O clean
make -C $3/../arch/x86/elfboot O=$O
cat elfboot/elfboot kboot/kboot.elf > $2
make -C $3/../arch/x86/kboot O=$O clean
#make -C $3/../kboot O=$O KIMAGE="$O/$1" LOAD_PA=0x3a001000
make -C $3/../arch/x86/kboot O=$O KIMAGE="$O/$1" LOAD_PA=0x31001000
cat elfboot/elfboot kboot/kboot.elf > $2.768M

14
kernel/script/mkimage.builtin-x86
View File

@ -4,9 +4,17 @@ set -e
O=`pwd`
make -C $3/../kboot O=$O clean
make -C $3/../arch/x86/kboot O=$O clean
#make -C $3/../kboot O=$O KIMAGE="$O/$1" LOAD_PA=0x3a001000
make -C $3/../kboot O=$O KIMAGE="$O/$1" LOAD_PA=0x101001000
make -C $3/../arch/x86/kboot O=$O KIMAGE="$O/$1" LOAD_PA=0x101001000
#make -C $3/../kboot O=$O KIMAGE="$O/$1" LOAD_PA=0x901001000
cat $3/../elfboot/elfboot kboot/kboot.elf > $2
make -C $3/../arch/x86/elfboot O=$O clean
make -C $3/../arch/x86/elfboot O=$O
cat elfboot/elfboot kboot/kboot.elf > $2
make -C $3/../arch/x86/kboot O=$O clean
#make -C $3/../kboot O=$O KIMAGE="$O/$1" LOAD_PA=0x3a001000
make -C $3/../arch/x86/kboot O=$O KIMAGE="$O/$1" LOAD_PA=0x201001000
cat elfboot/elfboot kboot/kboot.elf > $2.8G

6
lib/include/ihk/perfctr.h
View File

@ -27,6 +27,12 @@ enum ihk_perfctr_type {
APT_TYPE_ITLB_MISS,
APT_TYPE_STALL,
APT_TYPE_CYCLE,
APT_TYPE_INSTRUCTIONS,
APT_TYPE_L1D_MISS,
APT_TYPE_L1I_MISS,
APT_TYPE_L2_MISS,
PERFCTR_MAX_TYPE,
};

32
make.sh
View File

@ -1,4 +1,6 @@
#!/bin/sh
MOPT=
OPT=
ihkdir=`pwd`/../ihk
installdir=
kerneldir=
@ -45,10 +47,24 @@ if [ "X$target" = X ]; then
target=attached-mic
fi
if [ "X$kerneldir" = X ]; then
if [ -f $ihkdir/kerneldir ]; then
kerneldir="`cat $ihkdir/kerneldir`"
fi
fi
if [ "X$kerneldir" != X ]; then
MOPT="KDIR=$kerneldir"
fi
if [ "X$target" = "Xbuiltin-mic" ]; then
MOPT="$MOPT ARCH=k1om"
OPT="CC=x86_64-k1om-linux-gcc"
fi
if [ "X$installdir" != X ]; then
mkdir -p "$installdir"
fi
(cd executer/kernel; make)
(cd executer/kernel; make $MOPT)
if [ -f executer/kernel/mcctrl.ko ]; then
if [ "X$installdir" != X ]; then
cp executer/kernel/mcctrl.ko "$installdir"
@ -58,14 +74,13 @@ else
exit 1
fi
for tgt in $target; do
case "$tgt" in
attached-mic)
(cd kernel; mkdir -p build; make O=`pwd`/build)
krn=kernel/build/$tgt/kernel.img
case "$target" in
attached-mic | builtin-x86 | builtin-mic)
(cd kernel; mkdir -p build; make O=`pwd`/build BUILD_TARGET=$target)
krn=kernel/build/$target/kernel.img
;;
*)
echo "unknown target $tgt" >&2
echo "unknown target $target" >&2
exit 1
;;
esac
@ -77,9 +92,8 @@ for tgt in $target; do
echo "$krn could not be built" >&2
exit 1
fi
done
(cd executer/user; make)
(cd executer/user; make $OPT)
if [ -f executer/user/mcexec ]; then
if [ "X$installdir" != X ]; then
cp executer/user/mcexec "$installdir"