int main() { usr_sem_t *wait0, *wait1, *read_write_lock; uint32_t prog0, prog1; int ret0, ret1; puts("Create the semaphores.\n"); wait0 = syscall_sem_open("wait0", 0); wait1 = syscall_sem_open("wait1", 0); read_write_lock = syscall_sem_open("rwlock", 1); read_write_lock = read_write_lock; puts("Run the children.\n"); prog0 = syscall_exec(VOLUME "sem_barrier_p0"); prog1 = syscall_exec(VOLUME "sem_barrier_p1"); puts("Wait for them to finish.\n"); ret0 = syscall_join(prog0); ret1 = syscall_join(prog1); printf("Children joined with return values %d and %d.\n", ret0, ret1); puts("Destroy the semaphores.\n"); syscall_sem_destroy(wait0); syscall_sem_destroy(wait1); syscall_halt(); return 0; }
int main(void) { uint32_t child; uint32_t child2; uint32_t child3; uint32_t child4; int ret; int ret2; int ret3; int ret4; int i; for(i = 0; i < 10;i++) { printf("Starting program %s\n", prog); child = syscall_exec(prog); child2 = syscall_exec(prog); child3 = syscall_exec(prog); child4 = syscall_exec(prog); printf("Now joining child %d\n", child); ret = (char)syscall_join(child); ret2 = (char)syscall_join(child2); ret3 = (char)syscall_join(child3); ret4 = (char)syscall_join(child4); printf("Child joined with status: %d\n", ret); printf("Child joined with status: %d\n", ret2); printf("Child joined with status: %d\n", ret3); printf("Child joined with status: %d\n", ret4); } syscall_halt(); return 0; }
int main(void) { int a,b,c,d,e; a = syscall_exec("[arkimedes]a", -1); b = syscall_exec("[arkimedes]b", 9000); c = syscall_exec("[arkimedes]c", 3000); d = syscall_exec("[arkimedes]d", 4000); e = syscall_exec("[arkimedes]e", 2000); syscall_join(a); syscall_join(b); syscall_join(c); syscall_join(d); syscall_join(e); return 0; }
int cmd_run(char* prog) { if (does_file_exist(prog)) { return syscall_join(syscall_exec(prog)); } else { printf("No such program: %s.\n", prog); return 1; } }
int main(void) { uint32_t child; printf("Beginning proc_test \n"); child = syscall_exec(prog); syscall_join(child); printf("Ending proc_test \n"); syscall_halt(); return 0; }
int main(void) { uint32_t child; int ret; printf("Starting program %s\n", prog); child = syscall_exec(prog); printf("Now joining child %d\n", child); ret = (char)syscall_join(child); printf("Child joined with status: %d\n", ret); printf("Starting program %s\n", prog2); child = syscall_exec(prog2); printf("Now joining child %d\n", child); ret = (char)syscall_join(child); printf("Child joined with status: %d\n", ret); syscall_halt(); return 0; }
int cmd_wait(int argc, char** argv) { argv=argv; if (argc != 1) { printf("Usage: wait\n"); } else if (background_proc == -1) { printf("No background process to wait for.\n"); } else { int retval = syscall_join(background_proc); background_proc = 1; return retval; } return 1; }
int main(void) { int child_p, retval; write("dette er en test\n"); child_p = syscall_exec("[test]testexit"); retval = syscall_join(child_p); syscall_halt(); return -1; }
/** * Handle system calls. Interrupts are enabled when this function is * called. * * @param user_context The userland context (CPU registers as they * where when system call instruction was called in userland) */ void syscall_handle(context_t *user_context) { /* When a syscall is executed in userland, register a0 contains * the number of the syscall. Registers a1, a2 and a3 contain the * arguments of the syscall. The userland code expects that after * returning from the syscall instruction the return value of the * syscall is found in register v0. Before entering this function * the userland context has been saved to user_context and after * returning from this function the userland context will be * restored from user_context. */ switch(user_context->cpu_regs[MIPS_REGISTER_A0]) { case SYSCALL_HALT: halt_kernel(); break; case SYSCALL_READ: user_context->cpu_regs[MIPS_REGISTER_V0] = syscall_read(user_context->cpu_regs[MIPS_REGISTER_A1], (void *)user_context->cpu_regs[MIPS_REGISTER_A2], user_context->cpu_regs[MIPS_REGISTER_A3]); break; case SYSCALL_WRITE: user_context->cpu_regs[MIPS_REGISTER_V0] = syscall_write(user_context->cpu_regs[MIPS_REGISTER_A1], (const void *)user_context->cpu_regs[MIPS_REGISTER_A2], user_context->cpu_regs[MIPS_REGISTER_A3]); break; case SYSCALL_EXEC: user_context->cpu_regs[MIPS_REGISTER_V0] = syscall_exec((const char *)user_context->cpu_regs[MIPS_REGISTER_A1]); break; case SYSCALL_EXIT: syscall_exit(user_context->cpu_regs[MIPS_REGISTER_A1]); break; case SYSCALL_JOIN: user_context->cpu_regs[MIPS_REGISTER_V0] = syscall_join(user_context->cpu_regs[MIPS_REGISTER_A1]); break; default: KERNEL_PANIC("Unhandled system call\n"); } /* Move to next instruction after system call */ user_context->pc += 4; }
/** * Handle system calls. Interrupts are enabled when this function is * called. * * @param user_context The userland context (CPU registers as they * where when system call instruction was called in userland) */ void syscall_handle(context_t *user_context) { /* When a syscall is executed in userland, register a0 contains * the number of the syscall. Registers a1, a2 and a3 contain the * arguments of the syscall. The userland code expects that after * returning from the syscall instruction the return value of the * syscall is found in register v0. Before entering this function * the userland context has been saved to user_context and after * returning from this function the userland context will be * restored from user_context. */ switch (A0) { case SYSCALL_HALT: halt_kernel(); break; case SYSCALL_READ: V0 = tty_read((int) A1, (void*) A2, (int) A3); break; case SYSCALL_WRITE: V0 = tty_write((int) A1, (void*) A2, (int) A3); break; case SYSCALL_EXEC: V0 = syscall_exec((char*) A1); break; case SYSCALL_EXIT: syscall_exit((int) A1); break; case SYSCALL_JOIN: V0 = syscall_join((process_id_t) A1); break; case SYSCALL_MEMLIMIT: V0 = (int)process_memlimit((void *) A1); break; default: KERNEL_PANIC("Unhandled system call\n"); } /* Move to next instruction after system call */ user_context->pc += 4; }
/** * Handle system calls. Interrupts are enabled when this function is * called. */ uintptr_t syscall_entry(uintptr_t syscall, uintptr_t arg0, uintptr_t arg1, uintptr_t arg2) { arg0 = arg0; arg1 = arg1; arg2 = arg2; /* When a syscall is executed in userland, register a0 contains * the number of the syscall. Registers a1, a2 and a3 contain the * arguments of the syscall. The userland code expects that after * returning from the syscall instruction the return value of the * syscall is found in register v0. Before entering this function * the userland context has been saved to user_context and after * returning from this function the userland context will be * restored from user_context. */ switch(syscall) { case SYSCALL_HALT: halt_kernel(); break; case SYSCALL_READ: return syscall_read((void*)arg0); break; case SYSCALL_WRITE: return syscall_write((const void*)arg0, (int)arg1); break; case SYSCALL_SPAWN: return syscall_spawn((char const*)arg0, (char const**)arg1); break; case SYSCALL_EXIT: syscall_exit((int)arg0); break; case SYSCALL_JOIN: return syscall_join((int)arg0); break; default: KERNEL_PANIC("Unhandled system call\n"); } return 0; }
/** * Handle system calls. Interrupts are enabled when this function is * called. * * @param user_context The userland context (CPU registers as they * where when system call instruction was called in userland) */ void syscall_handle(context_t *user_context) { /* When a syscall is executed in userland, register a0 contains * the number of the syscall. Registers a1, a2 and a3 contain the * arguments of the syscall. The userland code expects that after * returning from the syscall instruction the return value of the * syscall is found in register v0. Before entering this function * the userland context has been saved to user_context and after * returning from this function the userland context will be * restored from user_context. */ switch(user_context->cpu_regs[MIPS_REGISTER_A0]) { case SYSCALL_HALT: halt_kernel(); break; case SYSCALL_EXIT: syscall_exit(user_context->cpu_regs[MIPS_REGISTER_A1]); break; case SYSCALL_WRITE: user_context->cpu_regs[MIPS_REGISTER_V0] = syscall_write(user_context->cpu_regs[MIPS_REGISTER_A1], (char*)user_context->cpu_regs[MIPS_REGISTER_A2], (user_context->cpu_regs[MIPS_REGISTER_A3])); break; case SYSCALL_READ: user_context->cpu_regs[MIPS_REGISTER_V0] = syscall_read(user_context->cpu_regs[MIPS_REGISTER_A1], (char*)user_context->cpu_regs[MIPS_REGISTER_A2], (user_context->cpu_regs[MIPS_REGISTER_A3])); break; case SYSCALL_JOIN: user_context->cpu_regs[MIPS_REGISTER_V0] = syscall_join(user_context->cpu_regs[MIPS_REGISTER_A1]); break; case SYSCALL_EXEC: user_context->cpu_regs[MIPS_REGISTER_V0] = syscall_exec((char*)user_context->cpu_regs[MIPS_REGISTER_A1]); break; case SYSCALL_FORK: user_context->cpu_regs[MIPS_REGISTER_V0] = syscall_fork((void (*)(int))user_context->cpu_regs[MIPS_REGISTER_A1], user_context->cpu_regs[MIPS_REGISTER_A2]); break; case SYSCALL_LOCK_CREATE: user_context->cpu_regs[MIPS_REGISTER_V0] = syscall_lock_create((lock_t*) user_context->cpu_regs[MIPS_REGISTER_A1]); break; case SYSCALL_LOCK_ACQUIRE: syscall_lock_acquire((lock_t*) user_context->cpu_regs[MIPS_REGISTER_A1]); break; case SYSCALL_LOCK_RELEASE: syscall_lock_release((lock_t*) user_context->cpu_regs[MIPS_REGISTER_A1]); break; case SYSCALL_CONDITION_CREATE: user_context->cpu_regs[MIPS_REGISTER_V0] = syscall_condition_create((cond_t*) user_context->cpu_regs[MIPS_REGISTER_A1]); break; case SYSCALL_CONDITION_WAIT: syscall_condition_wait((cond_t*) user_context->cpu_regs[MIPS_REGISTER_A1], (lock_t*) user_context->cpu_regs[MIPS_REGISTER_A2]); break; case SYSCALL_CONDITION_SIGNAL: syscall_condition_signal((cond_t*) user_context->cpu_regs[MIPS_REGISTER_A1], (lock_t*) user_context->cpu_regs[MIPS_REGISTER_A2]); break; case SYSCALL_CONDITION_BROADCAST: syscall_condition_broadcast((cond_t*) user_context->cpu_regs[MIPS_REGISTER_A1], (lock_t*) user_context->cpu_regs[MIPS_REGISTER_A2]); break; default: KERNEL_PANIC("Unhandled system call\n"); } /* Move to next instruction after system call */ user_context->pc += 4; }
/** * Handle system calls. Interrupts are enabled when this function is * called. * * @param user_context The userland context (CPU registers as they * where when system call instruction was called in userland) */ void syscall_handle(context_t *user_context) { /* When a syscall is executed in userland, register a0 contains * the number of the syscall. Registers a1, a2 and a3 contain the * arguments of the syscall. The userland code expects that after * returning from the syscall instruction the return value of the * syscall is found in register v0. Before entering this function * the userland context has been saved to user_context and after * returning from this function the userland context will be * restored from user_context. */ switch (A0) { case SYSCALL_HALT: halt_kernel(); break; case SYSCALL_READ: { int filehandle = (int)A1; if (filehandle == FILEHANDLE_STDIN || filehandle == FILEHANDLE_STDOUT || filehandle == FILEHANDLE_STDERR) { V0 = io_read((int) A1, (void*) A2, (int) A3); } else { V0 = syscall_read((openfile_t)A1, (void *)A2, (int)A3); } } break; case SYSCALL_WRITE: { int filehandle = (int)A1; if (filehandle == FILEHANDLE_STDIN || filehandle == FILEHANDLE_STDOUT || filehandle == FILEHANDLE_STDERR) { V0 = io_write((int) A1, (void*) A2, (int) A3); } else { V0 = syscall_write((openfile_t)A1, (void *)A2, (int)A3); } } break; case SYSCALL_EXEC: V0 = syscall_exec((char*) A1); break; case SYSCALL_EXIT: syscall_exit((int) A1); break; case SYSCALL_JOIN: V0 = syscall_join((process_id_t) A1); break; case SYSCALL_OPEN: V0 = syscall_open((char *) A1); break; case SYSCALL_CLOSE: V0 = syscall_close((openfile_t) A1); break; case SYSCALL_SEEK: V0 = syscall_seek((openfile_t)A1, (int)A2); break; case SYSCALL_CREATE: V0 = syscall_create((const char *)A1, (int)A2); break; case SYSCALL_REMOVE: V0 = syscall_remove((const char *)A1); break; case SYSCALL_TELL: V0 = syscall_tell((openfile_t)A1); break; case SYSCALL_SEM_OPEN: V0 = (uint32_t) usr_sem_open((char*) A1, A2); break; case SYSCALL_SEM_PROCURE: V0 = usr_sem_p((usr_sem_t*) A1); break; case SYSCALL_SEM_VACATE: V0 = usr_sem_v((usr_sem_t*) A1); break; case SYSCALL_SEM_DESTROY: V0 = usr_sem_destroy((usr_sem_t*) A1); break; default: KERNEL_PANIC("Unhandled system call\n"); } /* Move to next instruction after system call */ user_context->pc += 4; }