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 (); } }