int __fs_open(struct _reent *r, void *fileStruct, const char *path, int flags, int mode)
{
int creat = 0;
struct __FILE * f = (struct __FILE *)fileStruct;
memset(f, 0, sizeof(struct __FILE));
int accmode = (flags & O_ACCMODE) + 1;
f->filename = __path_to_native(path);
f->append = (flags & O_APPEND);
printf("Append Mode: %X\r\n", flags & O_APPEND);
if (f->filename == NULL) {
r->_errno = ENOMEM;
return -1;
}
f->fd = sys_open(f->filename, accmode);
if (f->fd >= 0) {
if (flags & O_EXCL) {
sys_close(f->fd);
f->fd = -99;
} else if ((flags & O_TRUNC) &&
(accmode & 0x2)) {
sys_close(f->fd);
sys_delete(f->filename);
sys_create(f->filename, 1);
f->fd = sys_open(f->filename, accmode);
}
} else if (f->fd == -1 && (flags & O_CREAT)) {
sys_create(f->filename, 1);
f->fd = sys_open(f->filename, accmode);
if (f->fd == -1)
f->fd = -98;
printf("open with O_CREAT fd = %d\r\n", f->fd);
}
if (f->fd < 0) {
switch(f->fd) {
case -1:
r->_errno = ENOENT;
break;
case -2:
r->_errno = ENXIO;
break;
case -33:
r->_errno = ENODEV;
break;
case -98:
r->_errno = EISDIR;
break;
case -99:
r->_errno = EEXIST;
break;
default:
printf("open unknown error code %d\r\n", f->fd);
r->_errno = EINVAL;
}
free(f->filename);
f->fd = -1;
} else {
f->size = sys_get_filesize(f->fd);
}
return f->fd;
}
/*
* Register application in ctx. As the matter of fact it is normal
* to register it in app->ctx, but that depends on what you want.
*/
int
register_app(struct ctx_t *ctx, struct app_t *app)
{
struct str_t *app_name;
log(ctx, 0, "register app: %s\n", app->name);
/* Main application */
app_name = sys_get(ctx, "app");
if(NULL == app_name)
{
app_name = sys_create(ctx, "app", T_STR);
if(NULL == app_name)
return E_NOMEM;
}
else
log(ctx,1,"already got app [%s]!\n", app_name);
app_name->str = app->name;
app_name->len = strlen(app->name);
if(!add_app(ctx, app))
return E_SYS;
return E_NONE;
}
void *
parser_sys_init(struct ctx_t *dst)
{
struct store_t *sys;
if(NULL == SYS(dst))
return NULL;
log(dst, 4, "parser sys init\n");
sys = sys_get(dst, "parser");
if(NULL == sys)
{
log(dst, 4, "create parser sys\n");
sys = sys_create(dst, "parser", T_STORE);
if(NULL == sys)
return NULL;
store_set(sys, 2, sizeof(struct store_t), parserbscmp);
}
return sys;
}
/*
* Boot.
* Squat app/module is using it
*/
struct ctx_t *
app_boot(struct ctx_t *cur, void *a, void *args)
{
app_getopt *opts = args;
struct app_t *app = a;
struct cfg_t *cfg;
if(NULL == cur)
{
if(app->ctx)
log(app->ctx, 1, "Alredy got app->ctx!\n");
app->ctx = ctx_new(CTX_STDERR|CTX_BOOT);
if (NULL == app->ctx)
return NULL;
}
else
app->ctx = cur;
cfg = app->ctx->cfg;
set_early_log(app->ctx);
/* Ok we really really need this very early */
if(NULL == sys_create(app->ctx, "api", T_HASH))
return NULL;
/*if(NULL == sys_create(app->ctx, "parser", T_STORE))
return NULL;*/
log(app->ctx, 0, "app boot: %s\n", app->name);
/*
* Default handler is sig_run
* sig_run is responsible of traversing ctx/scope
* and run all handlers that are registered
*/
/*signal(SIGINT, sig_run);
signal(SIGHUP, sig_run);
signal(SIGTERM, sig_run);
signal(SIGSEGV, sig_run);
signal(SIGBUS, sig_run);*/
/* reset to default boot options */
if(GET_BIT(app->type, APP_DAEMON))
cfg->basic->daemon = 1;
if(GET_BIT(app->type, APP_LOG))
cfg->basic->prio = 1;
/* cfg */
cfg->basic->argc = opts->argc;
cfg->basic->argv = opts->argv;
optind = 1;
return app->ctx;
}
int main(int argc, char *argv[])
{
vir_machine_init();
bootstrap();
os_init();
char order[800];
int i;
while (1) {
echo_mip4();
mips_want_get_string(order, 799);
switch(order[0]) {
case 'e':
sys_exec(order + 2);
break;
case 'f':
format_disk();
write_stdout("successfully formats the disk!\n", F_WHITE, B_BLACK);
break;
case 'c':
sys_create(order + 2);
write_stdout("successfully create file\n", F_WHITE, B_BLACK);
break;
case 'w': // copy the file to disk!
{
char *name = order + 2; // only one spaces !
sys_create(name);
int fid = sys_open(name);
int obj_id = open(name, O_RDONLY);
while (1) {
int buf;
if (read(obj_id, &buf, 1) == 0)
break;
char char_buf = (char)buf;
sys_write(fid, &char_buf, 1);
}
sys_close(fid);
write_stdout("successfully write file\n", F_WHITE, B_BLACK);
break;
}
}
}
return 0;
}
int main() {
unsigned int tid;
boot();
sys_create(15, NameServer, &tid);
sys_create(15, ClockServer, &tid);
sys_create(12, InputServer, &tid);
sys_create(12, OutputServer, &tid);
sys_create(13, TimerTask, &tid);
sys_create(1, go, &tid);
sys_create(10, SensorServer, &tid);
sys_create(10, TrainController, &tid);
kernel_main();
shutdown();
return 0;
}
/*
* Add app to context
* Creates system called app->name and put app in it
*/
int
add_app(struct ctx_t *ctx, struct app_t *app)
{
struct app_t *sys;
sys = sys_get(ctx, app->name);
if(NULL == sys)
{
sys = sys_create(ctx, app->name, T_APP);
if(NULL == sys)
return E_NOMEM;
}
else
log(ctx,1,"warn: already got [%s] system!\n", app->name);
memcpy(sys, app, sizeof(struct app_t));
return E_NONE;
}
int __fs_mkdir(struct _reent *r, const char *path, int mode)
{
char *filename = __path_to_native(path);
if (filename == NULL) {
r->_errno = ENOMEM;
return -1;
}
int result = sys_create(filename, 5);
free(filename);
if (result < 0) {
switch(result) {
case -33:
r->_errno = ENODEV;
break;
default:
r->_errno = EIO;
}
return -1;
}
return 0;
}
void *
parser_scope_init(struct ctx_t *scope)
{
struct store_t *sys;
if(NULL == SYS(scope))
return NULL;
sys = sys_get(scope, "parser");
if(NULL == sys)
{
sys = sys_create(scope, "parser", T_STORE);
if(NULL == sys)
return NULL;
store_set(sys, 2, sizeof(struct store_t), pbscmp);
}
return sys;
}
static void
syscall_handler (struct intr_frame *f)
{
int syscall_number;
ASSERT( sizeof(syscall_number) == 4 ); // assuming x86
// The system call number is in the 32-bit word at the caller's stack pointer.
memread_user(f->esp, &syscall_number, sizeof(syscall_number));
_DEBUG_PRINTF ("[DEBUG] system call, number = %d!\n", syscall_number);
// Store the esp, which is needed in the page fault handler.
// refer to exception.c:page_fault() (see manual 4.3.3)
thread_current()->current_esp = f->esp;
// Dispatch w.r.t system call number
// SYS_*** constants are defined in syscall-nr.h
switch (syscall_number) {
case SYS_HALT: // 0
{
sys_halt();
NOT_REACHED();
break;
}
case SYS_EXIT: // 1
{
int exitcode;
memread_user(f->esp + 4, &exitcode, sizeof(exitcode));
sys_exit(exitcode);
NOT_REACHED();
break;
}
case SYS_EXEC: // 2
{
void* cmdline;
memread_user(f->esp + 4, &cmdline, sizeof(cmdline));
int return_code = sys_exec((const char*) cmdline);
f->eax = (uint32_t) return_code;
break;
}
case SYS_WAIT: // 3
{
pid_t pid;
memread_user(f->esp + 4, &pid, sizeof(pid_t));
int ret = sys_wait(pid);
f->eax = (uint32_t) ret;
break;
}
case SYS_CREATE: // 4
{
const char* filename;
unsigned initial_size;
bool return_code;
memread_user(f->esp + 4, &filename, sizeof(filename));
memread_user(f->esp + 8, &initial_size, sizeof(initial_size));
return_code = sys_create(filename, initial_size);
f->eax = return_code;
break;
}
case SYS_REMOVE: // 5
{
const char* filename;
bool return_code;
memread_user(f->esp + 4, &filename, sizeof(filename));
return_code = sys_remove(filename);
f->eax = return_code;
break;
}
case SYS_OPEN: // 6
{
const char* filename;
int return_code;
memread_user(f->esp + 4, &filename, sizeof(filename));
return_code = sys_open(filename);
f->eax = return_code;
break;
}
case SYS_FILESIZE: // 7
{
int fd, return_code;
memread_user(f->esp + 4, &fd, sizeof(fd));
return_code = sys_filesize(fd);
f->eax = return_code;
break;
}
case SYS_READ: // 8
{
int fd, return_code;
void *buffer;
unsigned size;
memread_user(f->esp + 4, &fd, sizeof(fd));
memread_user(f->esp + 8, &buffer, sizeof(buffer));
memread_user(f->esp + 12, &size, sizeof(size));
return_code = sys_read(fd, buffer, size);
f->eax = (uint32_t) return_code;
break;
}
case SYS_WRITE: // 9
{
int fd, return_code;
const void *buffer;
unsigned size;
memread_user(f->esp + 4, &fd, sizeof(fd));
memread_user(f->esp + 8, &buffer, sizeof(buffer));
memread_user(f->esp + 12, &size, sizeof(size));
return_code = sys_write(fd, buffer, size);
f->eax = (uint32_t) return_code;
break;
}
case SYS_SEEK: // 10
{
int fd;
unsigned position;
memread_user(f->esp + 4, &fd, sizeof(fd));
memread_user(f->esp + 8, &position, sizeof(position));
sys_seek(fd, position);
break;
}
case SYS_TELL: // 11
{
int fd;
unsigned return_code;
memread_user(f->esp + 4, &fd, sizeof(fd));
return_code = sys_tell(fd);
f->eax = (uint32_t) return_code;
break;
}
case SYS_CLOSE: // 12
{
int fd;
memread_user(f->esp + 4, &fd, sizeof(fd));
sys_close(fd);
break;
}
#ifdef VM
case SYS_MMAP: // 13
{
int fd;
void *addr;
memread_user(f->esp + 4, &fd, sizeof(fd));
memread_user(f->esp + 8, &addr, sizeof(addr));
mmapid_t ret = sys_mmap (fd, addr);
f->eax = ret;
break;
}
case SYS_MUNMAP: // 14
{
mmapid_t mid;
memread_user(f->esp + 4, &mid, sizeof(mid));
sys_munmap(mid);
break;
}
#endif
#ifdef FILESYS
case SYS_CHDIR: // 15
{
const char* filename;
int return_code;
memread_user(f->esp + 4, &filename, sizeof(filename));
return_code = sys_chdir(filename);
f->eax = return_code;
break;
}
case SYS_MKDIR: // 16
{
const char* filename;
int return_code;
memread_user(f->esp + 4, &filename, sizeof(filename));
return_code = sys_mkdir(filename);
f->eax = return_code;
break;
}
case SYS_READDIR: // 17
{
int fd;
char *name;
int return_code;
memread_user(f->esp + 4, &fd, sizeof(fd));
memread_user(f->esp + 8, &name, sizeof(name));
return_code = sys_readdir(fd, name);
f->eax = return_code;
break;
}
case SYS_ISDIR: // 18
{
int fd;
int return_code;
memread_user(f->esp + 4, &fd, sizeof(fd));
return_code = sys_isdir(fd);
f->eax = return_code;
break;
}
case SYS_INUMBER: // 19
{
int fd;
int return_code;
memread_user(f->esp + 4, &fd, sizeof(fd));
return_code = sys_inumber(fd);
f->eax = return_code;
break;
}
#endif
/* unhandled case */
default:
printf("[ERROR] system call %d is unimplemented!\n", syscall_number);
// ensure that waiting (parent) process should wake up and terminate.
sys_exit(-1);
break;
}
}
static void
syscall_handler (struct intr_frame *f)
{
if(f)
{
stack_address_check(f->esp);
// get sys call number off the stack
int sys_call_no = get_nth_arg_int(f->esp, 0);
DPRINTF("system call! %d\n", sys_call_no);
switch(sys_call_no)
{
case SYS_HALT:
power_off();
break;
case SYS_EXIT:
{
int status = get_nth_arg_int(f->esp, 1);
thread_current()->exit_status = status;
process_terminate();
return;
}
break;
case SYS_EXEC:
{
char* file_name = (char*)get_nth_arg_ptr(f->esp, 1);
user_string_add_range_check_and_terminate(file_name);
int tid = sys_exec(file_name);
DPRINTF("exec %s, tid = %d\n", file_name, tid);
f->eax = tid;
}
return;
case SYS_WAIT:
{
int pid = get_nth_arg_int(f->esp, 1);
int ret = process_wait(pid);
DPRINTF("wait for pid %d by %d return %d\n", pid, thread_current()->tid ,ret);
f->eax = ret;
}
return;
case SYS_CREATE:
{
char* file_name = (char*)get_nth_arg_ptr(f->esp, 1);
user_string_add_range_check_and_terminate(file_name);
int size = get_nth_arg_int(f->esp, 2);
DPRINTF("sys_create(%s,%d)\n", file_name, size);
f->eax = sys_create(file_name, size);
}
return;
case SYS_REMOVE:
{
char* file_name = (char*)get_nth_arg_ptr(f->esp, 1);
user_string_add_range_check_and_terminate(file_name);
DPRINTF("sys_remove(%s)\n", file_name);
f->eax = sys_remove(file_name);
}
return;
case SYS_OPEN:
{
char* file_name = (char*)get_nth_arg_ptr(f->esp, 1);
user_string_add_range_check_and_terminate(file_name);
DPRINTF("sys_open(%s)\n", file_name);
f->eax = sys_open(file_name);
}
return;
case SYS_FILESIZE:
{
int fd = get_nth_arg_int(f->esp, 1);
DPRINTF("sys_filesize(%d)\n", fd);
f->eax = sys_filesize(fd);
}
return;
case SYS_READ:
{
int fd = get_nth_arg_int(f->esp, 1);
char* buf = (char*)get_nth_arg_ptr(f->esp, 2);
int size = get_nth_arg_int(f->esp, 3);
user_add_range_check_and_terminate(buf, size);
DPRINTF("sys_read(%d,%s,%d)\n", fd, buf, size);
f->eax = sys_read(fd, buf, size);
}
return;
case SYS_WRITE:
{
int fd = get_nth_arg_int(f->esp, 1);
char* buf = (char*)get_nth_arg_ptr(f->esp, 2);
int size = get_nth_arg_int(f->esp, 3);
user_add_range_check_and_terminate(buf, size);
DPRINTF("sys_write(%d,%s,%d)\n", fd, buf, size);
f->eax = sys_write(fd, buf, size);
}
return;
case SYS_SEEK:
{
int fd = get_nth_arg_int(f->esp, 1);
unsigned pos = get_nth_arg_int(f->esp, 2);
DPRINTF("sys_seek(%d,%d)\n", fd, pos);
sys_seek(fd, pos);
}
return;
case SYS_TELL:
{
int fd = get_nth_arg_int(f->esp, 1);
DPRINTF("sys_tell(%d)\n", fd);
f->eax = sys_tell(fd);
}
return;
case SYS_CLOSE:
{
int fd = get_nth_arg_int(f->esp, 1);
DPRINTF("sys_close(%d)\n", fd);
sys_close(fd);
}
return;
/*
case SYS_MMAP:
case SYS_MUNMAP:
case SYS_CHDIR:
case SYS_MKDIR:
case SYS_READDIR:
case SYS_ISDIR:
case SYS_INUMBER:
*/
default:
thread_exit();
break;
}
}
else
thread_exit();
}
static void
syscall_handler (struct intr_frame *f)
{
int sys_vector;
sys_vector=*(int *)(f->esp);
switch(sys_vector)
{
case SYS_HALT:
esp_under_phys_base(f, 0);
sys_halt ();
break;
case SYS_EXIT:
if ((void *)((int *)f->esp + 1) >= PHYS_BASE)
sys_exit (-1);
else
sys_exit (*((int *)f->esp + 1));
break;
case SYS_EXEC:
esp_under_phys_base(f, 1);
under_phys_base (*((int **)f->esp + 1));
sys_exec (*((int **)f->esp + 1), f);
break;
case SYS_WAIT:
esp_under_phys_base(f, 1);
sys_wait (*((int *)f->esp + 1), f);
break;
case SYS_CREATE:
if ((void*)*((int **)f->esp + 1) == NULL)
sys_exit(-1);
esp_under_phys_base(f, 2);
under_phys_base (*((int **)f->esp + 1));
sys_create (*((int **)f->esp + 1), *((int *)f->esp + 2), f);
break;
case SYS_REMOVE:
esp_under_phys_base(f, 1);
under_phys_base (*((int **)f->esp + 1));
sys_remove (*((int **)f->esp + 1), f);
break;
case SYS_OPEN:
if ((void*)*((int **)f->esp + 1) == NULL)
sys_exit(-1);
esp_under_phys_base(f, 1);
under_phys_base (*((int **)f->esp + 1));
sys_open (*((int **)f->esp + 1), f);
break;
case SYS_FILESIZE:
esp_under_phys_base(f, 1);
check_fd(*((int *)f->esp + 1), -1, f);
sys_filesize (*((int *)f->esp + 1), f);
break;
case SYS_READ:
esp_under_phys_base(f, 3);
under_phys_base (*((int **)f->esp + 2));
check_fd(*((int *)f->esp + 1), -1, f)
sys_read (*((int *)f->esp + 1), *((int **)f->esp + 2), *((int *)f->esp + 3), f);
break;
case SYS_WRITE:
esp_under_phys_base(f, 3);
under_phys_base (*((int **)f->esp + 2));
check_fd(*((int *)f->esp + 1), -1, f)
sys_write (*((int *)f->esp + 1), *((int **)f->esp + 2), *((int *)f->esp + 3), f);
break;
case SYS_SEEK:
esp_under_phys_base(f, 2);
check_fd(*((int *)f->esp + 1), 0, f)
sys_seek (*((int *)f->esp + 1), *((int *)f->esp + 2), f);
break;
case SYS_TELL:
esp_under_phys_base(f, 1);
check_fd(*((int *)f->esp + 1), 0, f)
sys_tell (*((int *)f->esp + 1), f);
break;
case SYS_CLOSE:
esp_under_phys_base(f, 1);
check_fd(*((int *)f->esp + 1), 0, f)
sys_close (*((int *)f->esp + 1), f);
break;
}
}
/* Syscall handler calls the appropriate function. */
static void
syscall_handler (struct intr_frame *f)
{
int ret = 0;
int *syscall_nr = (int *) f->esp;
void *arg1 = (int *) f->esp + 1;
void *arg2 = (int *) f->esp + 2;
void *arg3 = (int *) f->esp + 3;
/* Check validate pointer. */
if (!is_user_vaddr (syscall_nr) || !is_user_vaddr (arg1) ||
!is_user_vaddr (arg2) || !is_user_vaddr (arg3))
sys_exit (-1);
switch (*syscall_nr)
{
case SYS_HALT:
sys_halt ();
break;
case SYS_EXIT:
sys_exit (*(int *) arg1);
break;
case SYS_EXEC:
ret = sys_exec (*(char **) arg1);
break;
case SYS_WAIT:
ret = sys_wait (*(pid_t *) arg1);
break;
case SYS_CREATE:
ret = sys_create (*(char **) arg1, *(unsigned *) arg2);
break;
case SYS_REMOVE:
ret = sys_remove (*(char **) arg1);
break;
case SYS_OPEN:
ret = sys_open (*(char **) arg1);
break;
case SYS_FILESIZE:
ret = sys_filesize (*(int *) arg1);
break;
case SYS_READ:
ret = sys_read (*(int *) arg1, *(void **) arg2, *(unsigned *) arg3);
break;
case SYS_WRITE:
ret = sys_write (*(int *) arg1, *(void **) arg2, *(unsigned *) arg3);
break;
case SYS_SEEK:
sys_seek (*(int *) arg1, *(unsigned *) arg2);
break;
case SYS_TELL:
ret = sys_tell (*(int *) arg1);
break;
case SYS_CLOSE:
sys_close (*(int *) arg1);
break;
default:
printf (" (%s) system call! (%d)\n", thread_name (), *syscall_nr);
sys_exit (-1);
break;
}
f->eax = ret;
}
static void
syscall_handler (struct intr_frame *f)
{
/* Check to see that we can read supplied user memory pointer, using the
check_mem_ptr helper() function, in get_word_from_stack(). If the
check fails, the process is terminated. */
int syscall_number = (int)get_word_on_stack(f, 0);
switch(syscall_number) {
case SYS_HALT:
{
sys_halt();
break;
}
case SYS_EXIT:
{
int status = (int)get_word_on_stack(f, 1);
sys_exit(status);
/* Returns exit status to the kernel. */
f->eax = status;
break;
}
case SYS_EXEC:
{
const char *cmd_line = (const char *)get_word_on_stack(f, 1);
pid_t pid = sys_exec(cmd_line);
/* Returns new processes pid. */
f->eax = pid;
break;
}
case SYS_WAIT:
{
pid_t pid = (pid_t)get_word_on_stack(f, 1);
/* Returns child's exit status (pid argument is pid of this child). */
f->eax = sys_wait(pid);
break;
}
case SYS_CREATE:
{
const char *filename = (const char *)get_word_on_stack(f, 1);
unsigned initial_size = (unsigned)get_word_on_stack(f, 2);
/* Returns true to the kernel if creation is successful. */
f->eax = (int)sys_create(filename, initial_size);
break;
}
case SYS_REMOVE:
{
const char *filename = (const char *)get_word_on_stack(f, 1);
/* Returns true if successful, and false otherwise. */
f->eax = sys_remove(filename);
break;
}
case SYS_OPEN:
{
const char *filename = (const char *)get_word_on_stack(f, 1);
/* Returns file descriptor of opened file, or -1 if it could not
be opened. */
f->eax = sys_open(filename);
break;
}
case SYS_FILESIZE:
{
int fd = (int)get_word_on_stack(f, 1);
/* Returns size of file in bytes. */
f->eax = sys_filesize(fd);
break;
}
case SYS_READ:
{
int fd = (int)get_word_on_stack(f, 1);
void *buffer = (void *)get_word_on_stack(f, 2);
unsigned size = (unsigned)get_word_on_stack(f, 3);
/* Returns number of bytes actually read, or -1 if it could not
be read. */
f->eax = sys_read(fd, buffer, size, f);
break;
}
case SYS_WRITE:
{
int fd = (int)get_word_on_stack(f, 1);
void *buffer = (void *)get_word_on_stack(f, 2);
unsigned size = (unsigned)get_word_on_stack(f, 3);
/* Returns number of bytes written. */
f->eax = sys_write(fd, buffer, size);
break;
}
case SYS_SEEK:
{
int fd = (int)get_word_on_stack(f, 1);
unsigned position = (int)get_word_on_stack(f, 2);
sys_seek(fd, position);
break;
}
case SYS_TELL:
{
int fd = (int)get_word_on_stack(f, 1);
/* Returns the position of the next byte to be read or written in open
file 'fd' (in bytes, from start of file). */
f->eax = sys_tell(fd);
break;
}
case SYS_CLOSE:
{
int fd = (int)get_word_on_stack(f, 1);
sys_close(fd);
break;
}
case SYS_MMAP:
{
int fd = (int)get_word_on_stack(f, 1);
void *addr = (void *)get_word_on_stack(f, 2);
f->eax = sys_mmap(fd, addr);
break;
}
case SYS_MUNMAP:
{
mapid_t mapping = (mapid_t)get_word_on_stack(f, 1);
sys_munmap(mapping);
break;
}
default:
{
NOT_REACHED();
}
}
}
static void
syscall_handler (struct intr_frame *f)
{
int *sys_call;
int *status;
int *fd;
const char **buf;
int *size;
const char **file;
tid_t *pid;
const char **cmd_line;
unsigned *initial_size;
unsigned *position;
void **buffer;
sys_call = (int*) f->esp;
check_ptr(sys_call);
switch(*sys_call) {
case SYS_HALT:
sys_halt ();
break;
case SYS_EXIT:
status = (int *) get_arg_ptr (f->esp, 1);
sys_exit(*status);
NOT_REACHED();
break;
case SYS_EXEC:
cmd_line = (const char **) get_arg_ptr (f->esp, 1);
f->eax = sys_exec (*cmd_line);
break;
case SYS_WAIT:
pid = (tid_t *) get_arg_ptr (f->esp, 1);
f->eax = sys_wait (*pid);
break;
case SYS_CREATE:
file = (const char **) get_arg_ptr (f->esp, 1);
initial_size = (unsigned *) get_arg_ptr (f->esp, 2);
f->eax = sys_create (*file, *initial_size);
break;
case SYS_REMOVE:
file = (const char **) get_arg_ptr (f->esp, 1);
f->eax = sys_remove (*file);
break;
case SYS_OPEN:
file = (const char **) get_arg_ptr(f->esp, 1);
f->eax = sys_open (*file);
break;
case SYS_FILESIZE:
fd = (int *) get_arg_ptr (f->esp, 1);
f->eax = sys_filesize (*fd);
break;
case SYS_READ:
fd = (int *) get_arg_ptr (f->esp, 1);
buffer = (void **) get_arg_ptr (f->esp, 2);
size = (int *) get_arg_ptr (f->esp, 3);
f->eax = sys_read (*fd, *buffer, *size);
break;
case SYS_WRITE:
fd = (int *) get_arg_ptr (f->esp, 1);
buf = (const void **) get_arg_ptr (f->esp, 2);
size = (int *) get_arg_ptr (f->esp, 3);
f->eax = sys_write (*fd, *buf, *size);
break;
case SYS_SEEK:
fd = (int *) get_arg_ptr (f->esp, 1);
position = (unsigned *) get_arg_ptr (f->esp, 2);
sys_seek (*fd, *position);
break;
case SYS_TELL:
fd = (int *) get_arg_ptr (f->esp, 1);
f->eax = sys_tell (*fd);
break;
case SYS_CLOSE:
fd = (int *) get_arg_ptr (f->esp, 1);
sys_close (*fd);
break;
default:
printf ("Unrecognized system call!\n");
thread_exit ();
}
}
