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