void add_trace(struct io *iop)
{
if (iop->t.action & BLK_TC_ACT(BLK_TC_NOTIFY)) {
if (iop->t.action == BLK_TN_PROCESS) {
if (iop->t.pid == 0)
process_alloc(0, "kernel");
else {
char *slash = strchr(iop->pdu, '/');
if (slash)
*slash = '\0';
process_alloc(iop->t.pid, iop->pdu);
}
} else if (iop->t.action == BLK_TN_MESSAGE)
trace_message(iop);
io_release(iop);
} else if (iop->t.action & BLK_TC_ACT(BLK_TC_PC)) {
io_release(iop);
} else {
if (time_bounded) {
if (BIT_TIME(iop->t.time) < t_astart) {
io_release(iop);
return;
} else if (BIT_TIME(iop->t.time) > t_aend) {
io_release(iop);
done = 1;
return;
}
}
__add_trace(iop);
}
}
static bool process_one_request(struct thread_arg *arg)
{
union tee_rpc_invoke request;
size_t num_params;
size_t num_meta;
struct tee_ioctl_param *params;
uint32_t func;
uint32_t ret;
DMSG("looping");
memset(&request, 0, sizeof(request));
request.recv.num_params = RPC_NUM_PARAMS;
/* Let it be known that we can deal with meta parameters */
params = (struct tee_ioctl_param *)(&request.send + 1);
params->attr = TEE_IOCTL_PARAM_ATTR_META;
num_waiters_inc(arg);
if (!read_request(arg->fd, &request))
return false;
if (!find_params(&request, &func, &num_params, ¶ms, &num_meta))
return false;
if (num_meta && !num_waiters_dec(arg) && !spawn_thread(arg))
return false;
switch (func) {
case OPTEE_MSG_RPC_CMD_LOAD_TA:
ret = load_ta(num_params, params);
break;
case OPTEE_MSG_RPC_CMD_FS:
ret = tee_supp_fs_process(num_params, params);
break;
case OPTEE_MSG_RPC_CMD_RPMB:
ret = process_rpmb(num_params, params);
break;
case OPTEE_MSG_RPC_CMD_SHM_ALLOC:
ret = process_alloc(arg, num_params, params);
break;
case OPTEE_MSG_RPC_CMD_SHM_FREE:
ret = process_free(num_params, params);
break;
case OPTEE_MSG_RPC_CMD_GPROF:
ret = gprof_process(num_params, params);
break;
case OPTEE_MSG_RPC_CMD_SOCKET:
ret = tee_socket_process(num_params, params);
break;
default:
EMSG("Cmd [0x%" PRIx32 "] not supported", func);
/* Not supported. */
ret = TEEC_ERROR_NOT_SUPPORTED;
break;
}
request.send.ret = ret;
return write_response(arg->fd, &request);
}
gfarm_error_t
gfm_server_process_alloc(struct peer *peer, int from_client, int skip)
{
gfarm_int32_t e;
struct user *user;
gfarm_int32_t keytype;
size_t keylen;
char sharedkey[GFM_PROTO_PROCESS_KEY_LEN_SHAREDSECRET];
struct process *process;
gfarm_pid_t pid;
e = gfm_server_get_request(peer, "process_alloc",
"ib", &keytype, sizeof(sharedkey), &keylen, sharedkey);
if (e != GFARM_ERR_NO_ERROR)
return (e);
if (skip)
return (GFARM_ERR_NO_ERROR);
giant_lock();
if (peer_get_process(peer) != NULL) {
e = GFARM_ERR_ALREADY_EXISTS;
} else if (!from_client || (user = peer_get_user(peer)) == NULL) {
e = GFARM_ERR_OPERATION_NOT_PERMITTED;
} else if ((e = process_alloc(user, keytype, keylen, sharedkey,
&process, &pid)) == GFARM_ERR_NO_ERROR) {
peer_set_process(peer, process);
}
giant_unlock();
return (gfm_server_put_reply(peer, "process_alloc", e, "l", pid));
}
/*
* This is the entry point for allocating memory for an process already loaded into omnius.
*/
int
omnius_alloc(blob_t *blob) {
int ret = EXIT_FAILURE;
/* find the proc based on pid */
secmem_process_t *proc = g_pid_lookup[blob->head.pid];
/* validate and process*/
if (proc && blob->head.size >= 0 && blob->head.size < proc->mem_size && blob->head.policy_id < proc->fsm_count) {
/* assuming success, the process routine will stuff the allocation address into blob */
ret = process_alloc(blob, proc);
}
return ret;
}
static void system_sysc_thread(PSW* m) {
Process* child = process_alloc();
memcpy(&child->cpu, m, sizeof (PSW));
m->AC = child->number;
m->DR[m->RI.i] = child->number;
++m->PC;
child->cpu.AC = 0;
child->cpu.DR[m->RI.i] = 0;
++child->cpu.PC;
child->state = PROC_STATE_READY;
}
static PSW systeme_init(void) {
DEBUG_PUTS(DEBUG_T_SYSTEM, "Booting");
process_init();
//Création du processus père
process_alloc()->state = PROC_STATE_READY;
process_next();
PSW cpu;
const int varIndex = 15;
/*** creation d'un programme ***/
make_inst(0, INST_SUB, 1, 1, 0); //R1 = 0
make_inst(1, INST_SUB, 2, 2, 0); //R2 = 0
make_inst(2, INST_STORE, 1, 1, varIndex); //mem[15] = 0
make_inst(3, INST_SYSC, 2, 2, SYSC_FORK); //R2 = fork()
make_inst(4, INST_IFGT, 0, 0, 10); //if(AC == 0) faire fils, sinon le père
//Code fils
make_inst(5, INST_ADD, 1, 0, 1); //R1 = 1
make_inst(6, INST_SYSC, 1, 0, SYSC_PUTI); //puti(1)
make_inst(7, INST_SYSC, 1, 0, SYSC_SLEEP);//sleep(1)
make_inst(8, INST_SYSC, 1, 0, SYSC_PUTI);//puti(1)
make_inst(9, INST_SYSC, 0, 0, SYSC_EXIT);//exit()
//Code Père
make_inst(10, INST_ADD, 1, 0, 1); //R1 = 4
make_inst(11, INST_SYSC, 1, 0, SYSC_SLEEP); //sleep(4)
make_inst(12, INST_JUMP, 0, 0, 3); //refait le fork
make_inst(13, INST_SYSC, 2, 0, SYSC_PUTI); //puti(R2)
make_inst(14, INST_JUMP, 0, 0, 11);
/*** valeur initiale du PSW ***/
memset(&cpu, 0, sizeof (PSW));
cpu.IN = INT_NONE;
cpu.PC = 0;
cpu.SB = 0;
cpu.SS = 20;
return cpu;
}
gfarm_error_t
gfm_server_process_alloc_child(struct peer *peer, int from_client, int skip)
{
gfarm_int32_t e;
struct user *user;
gfarm_int32_t parent_keytype, keytype;
size_t parent_keylen, keylen;
char parent_sharedkey[GFM_PROTO_PROCESS_KEY_LEN_SHAREDSECRET];
char sharedkey[GFM_PROTO_PROCESS_KEY_LEN_SHAREDSECRET];
struct process *parent_process, *process;
gfarm_pid_t parent_pid, pid;
e = gfm_server_get_request(peer, "process_alloc_child", "iblib",
&parent_keytype,
sizeof(parent_sharedkey), &parent_keylen, parent_sharedkey,
&parent_pid,
&keytype, sizeof(sharedkey), &keylen, sharedkey);
if (e != GFARM_ERR_NO_ERROR)
return (e);
if (skip)
return (GFARM_ERR_NO_ERROR);
giant_lock();
if (peer_get_process(peer) != NULL) {
e = GFARM_ERR_ALREADY_EXISTS;
} else if (!from_client || (user = peer_get_user(peer)) == NULL) {
e = GFARM_ERR_OPERATION_NOT_PERMITTED;
} else if (parent_keytype != GFM_PROTO_PROCESS_KEY_TYPE_SHAREDSECRET ||
parent_keylen != GFM_PROTO_PROCESS_KEY_LEN_SHAREDSECRET) {
e = GFARM_ERR_INVALID_ARGUMENT;
} else if ((e = process_does_match(parent_pid,
parent_keytype, parent_keylen, parent_sharedkey,
&parent_process)) != GFARM_ERR_NO_ERROR) {
/* error */
} else if ((e = process_alloc(user, keytype, keylen, sharedkey,
&process, &pid)) == GFARM_ERR_NO_ERROR) {
peer_set_process(peer, process);
process_add_child(parent_process, process);
}
giant_unlock();
return (gfm_server_put_reply(peer, "process_alloc_child", e, "l",
pid));
}
struct thread *init(struct multiboot *mboot, uint32_t mboot_magic) {
struct process *idle, *init;
struct module *module;
struct memory_map *mem_map;
size_t mem_map_count, i, addr;
uintptr_t boot_image_size;
void *boot_image;
struct elf32_ehdr *init_image;
struct elf32_ehdr *dl_image;
/* initialize debugging output */
debug_init();
debug_printf("Rhombus Operating System Kernel v0.8a\n");
/* check multiboot header */
if (mboot_magic != 0x2BADB002) {
debug_panic("bootloader is not multiboot compliant");
}
/* touch pages for the kernel heap */
for (i = KSPACE; i < KERNEL_HEAP_END; i += SEGSZ) {
page_touch(i);
}
/* identity map kernel boot frames */
for (i = KSPACE + KERNEL_BOOT; i < KSPACE + KERNEL_BOOT_END; i += PAGESZ) {
page_set(i, page_fmt(i - KSPACE, PF_PRES | PF_RW));
}
/* parse the multiboot memory map to find the size of memory */
mem_map = (void*) (mboot->mmap_addr + KSPACE);
mem_map_count = mboot->mmap_length / sizeof(struct memory_map);
for (i = 0; i < mem_map_count; i++) {
if (mem_map[i].type == 1 && mem_map[i].base_addr_low <= 0x100000) {
for (addr = 0; addr < mem_map[i].length_low; addr += PAGESZ) {
frame_add(mem_map[i].base_addr_low + addr);
}
}
}
/* bootstrap process 0 (idle) */
idle = process_alloc();
idle->space = cpu_get_cr3();
idle->user = 0;
/* fork process 1 (init) and switch */
init = process_clone(idle, NULL);
process_switch(init);
/* get multiboot module information */
if (mboot->mods_count < 3) {
if (mboot->mods_count < 2) {
if (mboot->mods_count < 1) {
debug_panic("no boot or init or dl modules found");
}
else {
debug_panic("no boot or dl modules found");
}
}
else {
debug_panic("no dl module found");
}
}
module = (void*) (mboot->mods_addr + KSPACE);
init_image = (void*) (module[0].mod_start + KSPACE);
boot_image = (void*) (module[1].mod_start + KSPACE);
dl_image = (void*) (module[2].mod_start + KSPACE);
boot_image_size = module[1].mod_end - module[1].mod_start;
/* move boot image to BOOT_IMAGE in userspace */
mem_alloc(BOOT_IMAGE, boot_image_size, PF_PRES | PF_USER | PF_RW);
memcpy((void*) BOOT_IMAGE, boot_image, boot_image_size);
/* bootstrap thread 0 in init */
thread_bind(init->thread[0], init);
init->thread[0]->useresp = init->thread[0]->stack + SEGSZ;
init->thread[0]->esp = (uintptr_t) &init->thread[0]->num;
init->thread[0]->ss = 0x23;
init->thread[0]->ds = 0x23;
init->thread[0]->cs = 0x1B;
init->thread[0]->eflags = cpu_get_eflags() | 0x3200; /* IF, IOPL = 3 */
/* bootstrap idle thread */
idle->thread[0] = &__idle_thread;
__idle_thread.proc = idle;
/* load dl */
if (elf_check_file(dl_image)) {
debug_panic("dl.so is not a valid ELF executable");
}
elf_load_file(dl_image);
/* execute init */
if (elf_check_file(init_image)) {
debug_panic("init is not a valid ELF executable");
}
elf_load_file(init_image);
init->thread[0]->eip = init_image->e_entry;
/* register system calls */
int_set_handler(SYSCALL_SEND, syscall_send);
int_set_handler(SYSCALL_DONE, syscall_done);
int_set_handler(SYSCALL_WHEN, syscall_when);
int_set_handler(SYSCALL_RIRQ, syscall_rirq);
int_set_handler(SYSCALL_ALSO, syscall_also);
int_set_handler(SYSCALL_STAT, syscall_stat);
int_set_handler(SYSCALL_PAGE, syscall_page);
int_set_handler(SYSCALL_PHYS, syscall_phys);
int_set_handler(SYSCALL_FORK, syscall_fork);
int_set_handler(SYSCALL_EXIT, syscall_exit);
int_set_handler(SYSCALL_STOP, syscall_stop);
int_set_handler(SYSCALL_WAKE, syscall_wake);
int_set_handler(SYSCALL_GPID, syscall_gpid);
int_set_handler(SYSCALL_TIME, syscall_time);
int_set_handler(SYSCALL_USER, syscall_user);
int_set_handler(SYSCALL_AUTH, syscall_auth);
int_set_handler(SYSCALL_PROC, syscall_proc);
int_set_handler(SYSCALL_KILL, syscall_kill);
int_set_handler(SYSCALL_VM86, syscall_vm86);
int_set_handler(SYSCALL_NAME, syscall_name);
int_set_handler(SYSCALL_REAP, syscall_reap);
/* register fault handlers */
int_set_handler(FAULT_DE, fault_float);
int_set_handler(FAULT_DB, fault_generic);
int_set_handler(FAULT_NI, fault_generic);
int_set_handler(FAULT_BP, fault_generic);
int_set_handler(FAULT_OF, fault_generic);
int_set_handler(FAULT_BR, fault_generic);
int_set_handler(FAULT_UD, fault_generic);
int_set_handler(FAULT_NM, fault_nomath);
int_set_handler(FAULT_DF, fault_double);
int_set_handler(FAULT_CO, fault_float);
int_set_handler(FAULT_TS, fault_generic);
int_set_handler(FAULT_NP, fault_generic);
int_set_handler(FAULT_SS, fault_generic);
int_set_handler(FAULT_GP, fault_gpf);
int_set_handler(FAULT_PF, fault_page);
int_set_handler(FAULT_MF, fault_float);
int_set_handler(FAULT_AC, fault_generic);
int_set_handler(FAULT_MC, fault_generic);
int_set_handler(FAULT_XM, fault_nomath);
/* start timer (for preemption) */
timer_set_freq(64);
/* initialize FPU/MMX/SSE */
cpu_init_fpu();
/* drop to usermode, scheduling the next thread */
debug_printf("dropping to usermode\n");
return thread_switch(NULL, schedule_next());
}
int main (int argc, char *argv[])
{
pid_t pid;
int status = 1;
struct tracer *tracer = NULL;
struct process *process = NULL;
if (argc < 2)
return 1;
pid = fork ();
if (pid < 0)
{
perror ("fork");
return 2;
}
if (pid == 0)
fork_and_trace_child (argv);
if (wait_for_stopped (pid, false, &status))
{
fprintf (stderr, "child process unexpectedly dead\n");
return 3;
}
/*
When delivering syscall traps, set bit 7 in the signal number
(i.e., deliver SIGTRAP | 0x80). This makes it easy for the tracer
to tell the difference between normal traps and those caused by a
syscall. (PTRACE_O_TRACESYSGOOD may not work on all architectures.)
*/
if (ptrace (PTRACE_SETOPTIONS, pid, 0, PTRACE_O_TRACESYSGOOD) == -1)
return 5;
status = 1;
if (!(tracer = tracer_alloc ()))
{
fprintf (stderr, "Can not allocate tracer\n");
goto end;
}
if (!(process = process_alloc (pid)))
{
fprintf (stderr, "Can not allocate process\n");
goto end;
}
if (tracer_add_process (tracer, process) == -1)
{
fprintf (stderr, "Cannot add process to tracer\n");
goto end;
}
/* process = NULL should be here (!) */
for (;;)
{
struct user_regs_struct state1;
struct user_regs_struct state2;
if (wait_for_break (pid, &state1, &status))
break;
if (wait_for_break (pid, &state2, &status))
break;
trace_syscall (process, &state1, &state2);
}
process = NULL;
status &= 0xff;
end:
if (process)
process_destroy (process);
if (tracer)
tracer_destroy (tracer);
return status;
}
