int main(void) { heap_init(); char buffer[64]; char startString[] = "Please write 10 characters: \n"; char endString[] = "\nTest complete.\n"; void *pointer = malloc(sizeof(buffer)); syscall_write(FILEHANDLE_STDIN, startString, 30); syscall_read(FILEHANDLE_STDIN, buffer, 10); syscall_write(FILEHANDLE_STDIN, buffer, 10); syscall_write(FILEHANDLE_STDIN, endString, 16); syscall_halt(); return 0; }
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) { syscall_usr_sem_open("lol", 0); syscall_halt(); return 0; }
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) { char c; while(1){ syscall_read(stdin,&c,1); syscall_write(stdout,&c,1); if (c == 'q') syscall_halt(); // press 'q' to quit } return 0; }
int main(void) { char cmdline[BUFFER_SIZE]; int ret = 0; help(); while (1) { print_prompt(ret); (void) readline(cmdline, BUFFER_SIZE); run_command(cmdline); } 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); syscall_halt(); return 0; }
int main() { const char test[] = "test\0"; usr_sem_t* dummy = syscall_usr_sem_open(test, 0); printf("Thread 1 is waiting for thread 2 to vacate\n"); syscall_spawn("[disk]sem_w.mips32", NULL); syscall_usr_sem_procure(dummy); printf("Thread 1 is alive and going to destroy semaphore\n"); syscall_usr_sem_destroy(dummy); syscall_halt(); return 0; }
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; }
int main(void) { char cmdline[BUFFER_SIZE]; int count; int ret = 0; help(); while (1) { print_prompt(ret); count = readline_with_completion(cmdline, BUFFER_SIZE); run_command(cmdline); } syscall_halt(); return 0; }
int main(void) { char buffer[100]; int len; puts("====================\n"); puts("==syscall_write OK==\n"); puts("====================\n"); puts("Enter between 1 and 100 characters:\n"); len = readline(buffer, 100); printf("You entered %d chars: %s\n",len,buffer); printf("Shutting down\n"); syscall_halt(); return 0; }
int main(void) { heap_init(); char *foo = malloc(10 * sizeof(char)); foo = "Foo\n"; printf(foo); free(foo); printf("freeeee!\n"); syscall_halt(); return 0; }
int main() { usr_sem_t* sem = syscall_usr_sem_open("S1", 0); syscall_spawn("[disk]prog2.mips32", NULL); printf("Test (1) %d\n", 101); syscall_usr_sem_procure(sem); printf("Bjon (3)%d\n", 101); syscall_halt(); return 0; }
/* * get system call */ static void syscall_handler (struct intr_frame *f) { int *esp = (int *)syscall_user_to_kernel_vaddr(f->esp); switch(*esp) { case SYS_WRITE: syscall_write(f); break; case SYS_EXIT: syscall_exit(f); break; case SYS_HALT: syscall_halt(f); break; case SYS_EXEC: syscall_exec(f); break; case SYS_CREATE: syscall_create(f); break; case SYS_REMOVE: syscall_remove(f); break; case SYS_OPEN: syscall_open(f); break; case SYS_FILESIZE: syscall_filesize(f); break; case SYS_READ: syscall_read(f); break; case SYS_SEEK: syscall_seek(f); break; case SYS_TELL: syscall_tell(f); break; case SYS_CLOSE: syscall_close(f); break; case SYS_WAIT: syscall_wait(f); break; } }
int main(void) { char buffer[64]; char *ptr = buffer; char intro[20] = "Press a button!"; char *introptr = intro; int a = syscall_write(1, introptr, 15); int b = syscall_read(0, ptr, 10); int c = syscall_write(1, ptr, 10); a = a; b = b; c = c; syscall_halt(); return 0; }
int main(void) { char buffer[64]; write("Hello, World!\n"); write("Type q or quit to get out.\n"); while(1) { prompt("echo> ", buffer, 63); if(strcmp(buffer, "q\n") || strcmp(buffer, "quit\n")) { break; } else { write(buffer); } } syscall_halt(); return 0; }
int main() { char buff[20]; syscall_delete(file1); if (syscall_create(file1, 100) < 0) fail("Couldn't create file :(\n"); int fd = syscall_open(file1); if (fd < 0) fail("Couldn't open file :(\n"); printf("Wrote %d bytes\n", syscall_write(fd, "Teststring!\n", 11)); if (syscall_seek(fd, 0) < 0) fail("Couldn't seek :(\n"); printf("Read %d bytes\n", syscall_read(fd, buff, 20)); printf(buff); syscall_halt(); return 0; }
int main() { /* setup needed variables */ int fhin = FILEHANDLE_STDIN; char* wbuff = "Oh hello there!! \nwhat is your name?\n"; char rbuff[64]; int c; /* test the calls */ syscall_write(fhin,wbuff,37); c = syscall_read(fhin,rbuff,63); wbuff = "Hello"; syscall_write(fhin,wbuff,5); syscall_write(fhin,rbuff,c); wbuff = ", how are you doing today?\n"; syscall_write(fhin,wbuff,27); c = syscall_read(fhin,rbuff,63); wbuff = "Oh you're doing "; syscall_write(fhin,wbuff,16); syscall_write(fhin,rbuff,c); wbuff = "!!!\n"; syscall_write(fhin,wbuff, 4); wbuff = "Go on have a good day now!!"; syscall_write(fhin,wbuff, 28); /* ensure proper system shut down */ syscall_halt(); return 0; }
int main(void) { char buffer[64]; //syscall_exec("[arkimedes]useless"); puts("Hello, World!\n"); puts("Type q or quit to get out.\n"); while(1) { prompt("echo> ", buffer, 63); if(strcmp(buffer, "q") == 0 || strcmp(buffer, "quit") == 0) { break; } else { puts(buffer); puts("\n"); } } syscall_halt(); return 0; }
int main() { heap_init(); char* buf; char** tokenized; buf = readline(PROMPT); tokenized = tokenize(buf); int i; for(i = 0; tokenized[i] != NULL; i++) { puts(tokenized[i]); puts("\n"); } tokenized = tokenized; commands[0] = commands[0]; syscall_halt(); return 0; }
static void syscall_handler (struct intr_frame *f) { // XXX : EDIT WITH 'syscall.h' 'lib/user/syscall.c' 'lib/syscall-nr.h //printf ("system call!\n"); void *now = f->esp; // XXX : Check PTR Range, and bash to syscall_exit(-1); if(!is_valid_ptr(now)) syscall_exit(-1); int syscall_number = *(int *)(f->esp); int argc_size_table[22] = { // CHECK syscall-nr.h 0, // SYS_HALT (*) :0 1, // SYS_EXIT (*) :1 1, // SYS_EXEC (*) :2 1, // SYS_WAIT (*) :3 2, // SYS_CREATE :4 1, // SYS_REMOVE :5 1, // SYS_OPEN :6 1, // SYS_FILESIZE :7 3, // SYS_READ (*) :8 3, // SYS_WRITE (*):9 2, // SYS_SEEK :10 1, // SYS_TELL :11 1, // SYS_CLOSE :12 (proj 2-2) 2, // SYS_MMAP 1, // SYS_MUNMAP 1, // SYS_CHDIR 1, // SYS_MKDIR 2, // SYS_READDIR 1, // SYS_ISDIR 1, // SYS_INUMBER 1, // SYS_PIBONACCI 4 // SYS_SUM_OF_FOUR_INTEGERS }; int argc_size = argc_size_table[syscall_number]; //printf("SYSCALL %d SIZE %d\n", syscall_number, argc_size); void *argc[4] = {NULL,}; { int i; for(i = 0; i < argc_size; i++){ now += 4; // sizeof(void *); // IT WILL USE 4 Bytes. (ref:man38). argc[i] = now; // XXX : Check argument's ptr; if(!is_valid_ptr(argc[i])) syscall_exit(-1); // printf("%x\n", now); } } switch(syscall_number){ default: case -1: break; case 0: // SYS_HALT syscall_halt(); break; case 1: // SYS_EXIT syscall_exit(*(int *)argc[0]); break; case 2: // SYS_EXEC f->eax = syscall_exec(*(const char **)argc[0]); break; case 3: // SYS_WAIT //printf("CALLED SYS_WAIT!\n"); f->eax = syscall_wait(*(pid_t *)argc[0]); break; case 4: // SYS_CREATE f->eax = syscall_create(*(const char **)argc[0], *(unsigned *)argc[1]); break; case 5: // SYS_REMOVE f->eax = syscall_remove(*(const char **)argc[0]); break; case 6: // SYS_OPEN f->eax = syscall_open(*(const char **)argc[0]); break; case 7: // SYS_FILESIZE f->eax = syscall_filesize(*(int *)argc[0]); break; case 8: // SYS_READ f->eax = syscall_read( *(int *)argc[0], *(void **)argc[1], *(unsigned *)argc[2] ); break; case 9: // SYS_WRITE //printf("CALLED WRITE! %d %x %u\n", *(int *)argc[0], argc[1], *(unsigned *)argc[2]); f->eax = syscall_write( *(int *)argc[0], *(const void **)argc[1], *(unsigned *)argc[2] ); break; case 10: // SYS_SEEK syscall_seek(*(int *)argc[0], *(unsigned *)argc[1] ); break; case 11: // SYS_TELL f->eax = syscall_tell(*(int *)argc[0]); break; case 12: // SYS_CLOSE syscall_close(*(int *)argc[0]); break; case 20: // SYS_PIBONACCI f->eax = syscall_pibonacci(*(int *)argc[0]); break; case 21: // SYS_SUM_OF_FOUR_INTEGERS f->eax = syscall_sum_of_four_integers( *(int *)argc[0], *(int *)argc[1], *(int *)argc[2], *(int *)argc[3] ); break; // case *: } // printf("SYSCALL_RETURN: %d\n", f->eax); // thread_exit (); // XXX }
static void syscall_handler (struct intr_frame *f) { /* Validate the first addr of the stack frame */ void *esp = utok_addr (f->esp, NULL); if (esp == NULL) { syscall_exit (-1); return; } enum SYSCALL_NUMBER call_number = *(enum SYSCALL_NUMBER *) esp; if (call_number < syscall_first_call || call_number > syscall_last_call) { syscall_exit (-1); return; } /* Buffer the arguments for validation */ int argc = syscall_argc[call_number]; uint32_t argbuf[3]; int i = 0; for (; i < argc; i++) { /* Validate each argument */ void *vaddr = uptr_valid((uint32_t *) f->esp + 1 + i, f->esp); if (vaddr == NULL) { syscall_exit (-1); return; } /* Translate the argument to kernel virtual (== physical) memory */ argbuf[i] = *(uint32_t *) vaddr; } int retval = 0; /* Switch based on call_number to delegate to corresponding syscall. Have not implemented several syscalls as of this project. Use validation methods to check user-provided arguments. */ switch (call_number) { case SYS_HALT: syscall_halt (); break; case SYS_EXIT: syscall_exit ((int) argbuf[0]); break; case SYS_EXEC: if (str_valid ((void *) argbuf[0], f->esp) == NULL) { syscall_exit (-1); return; } retval = syscall_exec ((char *) argbuf[0]); break; case SYS_WAIT: retval = syscall_wait ((int) argbuf[0]); break; case SYS_CREATE: if (str_valid ((char *) argbuf[0], f->esp) == NULL) { syscall_exit (-1); return; } retval = (int) syscall_create ((char *) argbuf[0], (unsigned) argbuf[1]); break; case SYS_REMOVE: if (!uptr_valid ((char *) argbuf[0], f->esp)) { syscall_exit (-1); return; } retval = (int) syscall_remove ((char *) argbuf[0]); break; case SYS_OPEN: if (str_valid ((char *) argbuf[0], f->esp) == NULL) { syscall_exit (-1); return; } retval = (int) syscall_open ((char *) argbuf[0]); break; case SYS_FILESIZE: retval = syscall_filesize ((int) argbuf[0]); break; case SYS_READ: if (buffer_valid ((void *) argbuf[1], f->esp, (unsigned) argbuf[2]) == NULL) { syscall_exit (-1); return; } retval = syscall_read ((int) argbuf[0], (void *) argbuf[1], (unsigned) argbuf[2]); break; case SYS_WRITE: if (buffer_valid ((void *) argbuf[1], f->esp, (unsigned) argbuf[2]) == NULL) { syscall_exit (-1); return; } retval = syscall_write ((int) argbuf[0], (void *) argbuf[1], (unsigned) argbuf[2]); break; case SYS_SEEK: syscall_seek ((int) argbuf[0], (unsigned) argbuf[1]); break; case SYS_TELL: retval = (int) syscall_tell ((int) argbuf[0]); break; case SYS_CLOSE: syscall_close ((int) argbuf[0]); break; #ifdef VM case SYS_MMAP: // addr will be checked internally inside mmap retval = (int) syscall_mmap ((int) argbuf[0], (void *) argbuf[1]); break; case SYS_MUNMAP: syscall_munmap ((int) argbuf[0]); break; #endif default: printf("unhandled system call!\n"); thread_exit(); } f->eax = retval; }
static void syscall_handler (struct intr_frame *f) { int syscall_num; VALIDATE_AND_GET_ARG (f->esp, syscall_num, f); void *cur_sp = f->esp + sizeof (void *); /* store user program stack pointer to the thread's user_esp before changing to kernel mode */ struct thread *t = thread_current (); t->user_esp = f->esp; switch (syscall_num) { case SYS_HALT: syscall_halt (f, cur_sp); break; case SYS_EXIT: syscall_exit (f, cur_sp); break; case SYS_EXEC: syscall_exec (f, cur_sp); break; case SYS_WAIT: syscall_wait (f, cur_sp); break; case SYS_CREATE: syscall_create (f, cur_sp); break; case SYS_REMOVE: syscall_remove (f, cur_sp); break; case SYS_OPEN: syscall_open (f, cur_sp); break; case SYS_FILESIZE: syscall_filesize (f, cur_sp); break; case SYS_READ: syscall_read (f, cur_sp); break; case SYS_WRITE: syscall_write (f, cur_sp); break; case SYS_SEEK: syscall_seek (f, cur_sp); break; case SYS_TELL: syscall_tell (f, cur_sp); break; case SYS_CLOSE: syscall_close (f, cur_sp); break; case SYS_MMAP: syscall_mmap (f, cur_sp); break; case SYS_MUNMAP: syscall_unmmap (f, cur_sp); break; default : printf ("Invalid system call! #%d\n", syscall_num); syscall_thread_exit (f, -1); break; } }
int main(void) { syscall_halt(); return 0; }