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

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");

100
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;
}