Mercurial > hg > Members > menikon > CbC_xv6
annotate src/syscall.cbc @ 92:bc5bcfd2f6d6
rename CbCFile to CbCSysFile
| author | anatofuz <anatofuz@cr.ie.u-ryukyu.ac.jp> |
|---|---|
| date | Sat, 19 Oct 2019 16:44:24 +0900 |
| parents | b5ddf6fb0a6d |
| children | 94ee7046d190 |
| rev | line source |
|---|---|
| 0 | 1 #include "types.h" |
| 2 #include "defs.h" | |
| 3 #include "param.h" | |
| 4 #include "memlayout.h" | |
| 5 #include "mmu.h" | |
| 6 #include "proc.h" | |
| 7 #include "arm.h" | |
| 8 #include "syscall.h" | |
| 9 | |
| 52 | 10 #define __ncode __code |
| 11 # | |
| 0 | 12 // User code makes a system call with INT T_SYSCALL. System call number |
| 13 // in r0. Arguments on the stack, from the user call to the C library | |
| 14 // system call function. The saved user sp points to the first argument. | |
| 15 | |
| 16 // Fetch the int at addr from the current process. | |
| 17 int fetchint(uint addr, int *ip) | |
| 18 { | |
| 19 if(addr >= proc->sz || addr+4 > proc->sz) { | |
| 20 return -1; | |
| 21 } | |
| 22 | |
| 23 *ip = *(int*)(addr); | |
| 24 return 0; | |
| 25 } | |
| 26 | |
| 27 // Fetch the nul-terminated string at addr from the current process. | |
| 28 // Doesn't actually copy the string - just sets *pp to point at it. | |
| 29 // Returns length of string, not including nul. | |
| 30 int fetchstr(uint addr, char **pp) | |
| 31 { | |
| 32 char *s, *ep; | |
| 33 | |
| 34 if(addr >= proc->sz) { | |
| 35 return -1; | |
| 36 } | |
| 37 | |
| 38 *pp = (char*)addr; | |
| 39 ep = (char*)proc->sz; | |
| 40 | |
| 41 for(s = *pp; s < ep; s++) { | |
| 42 if(*s == 0) { | |
| 43 return s - *pp; | |
| 44 } | |
| 45 } | |
| 46 | |
| 47 return -1; | |
| 48 } | |
| 49 | |
| 50 // Fetch the nth (starting from 0) 32-bit system call argument. | |
| 51 // In our ABI, r0 contains system call index, r1-r4 contain parameters. | |
| 52 // now we support system calls with at most 4 parameters. | |
| 53 int argint(int n, int *ip) | |
| 54 { | |
| 55 if (n > 3) { | |
| 56 panic ("too many system call parameters\n"); | |
| 57 } | |
| 58 | |
| 59 *ip = *(&proc->tf->r1 + n); | |
| 60 | |
| 61 return 0; | |
| 62 } | |
| 63 | |
| 64 // Fetch the nth word-sized system call argument as a pointer | |
| 65 // to a block of memory of size n bytes. Check that the pointer | |
| 66 // lies within the process address space. | |
| 67 int argptr(int n, char **pp, int size) | |
| 68 { | |
| 69 int i; | |
| 70 | |
| 71 if(argint(n, &i) < 0) { | |
| 72 return -1; | |
| 73 } | |
| 74 | |
| 75 if((uint)i >= proc->sz || (uint)i+size > proc->sz) { | |
| 76 return -1; | |
| 77 } | |
| 78 | |
| 79 *pp = (char*)i; | |
| 80 return 0; | |
| 81 } | |
| 82 | |
| 83 // Fetch the nth word-sized system call argument as a string pointer. | |
| 84 // Check that the pointer is valid and the string is nul-terminated. | |
| 85 // (There is no shared writable memory, so the string can't change | |
| 86 // between this check and being used by the kernel.) | |
| 87 int argstr(int n, char **pp) | |
| 88 { | |
| 89 int addr; | |
| 90 | |
| 91 if(argint(n, &addr) < 0) { | |
| 92 return -1; | |
| 93 } | |
| 94 | |
| 95 return fetchstr(addr, pp); | |
| 96 } | |
| 97 | |
| 98 extern int sys_chdir(void); | |
| 99 extern int sys_close(void); | |
| 100 extern int sys_dup(void); | |
| 101 extern int sys_exec(void); | |
| 102 extern int sys_exit(void); | |
| 103 extern int sys_fork(void); | |
| 104 extern int sys_fstat(void); | |
| 105 extern int sys_getpid(void); | |
| 106 extern int sys_kill(void); | |
| 107 extern int sys_link(void); | |
| 108 extern int sys_mkdir(void); | |
| 109 extern int sys_mknod(void); | |
| 110 extern int sys_open(void); | |
| 111 extern int sys_pipe(void); | |
| 112 extern int sys_read(void); | |
| 113 extern int sys_sbrk(void); | |
| 114 extern int sys_sleep(void); | |
| 115 extern int sys_unlink(void); | |
| 116 extern int sys_wait(void); | |
| 117 extern int sys_write(void); | |
| 118 extern int sys_uptime(void); | |
| 119 | |
| 29 | 120 extern __code cbc_read(__code(*)(int)); |
| 121 | |
| 0 | 122 static int (*syscalls[])(void) = { |
| 22 | 123 [SYS_fork] =sys_fork, |
| 124 [SYS_exit] =sys_exit, | |
| 125 [SYS_wait] =sys_wait, | |
| 126 [SYS_pipe] =sys_pipe, | |
| 127 [SYS_read] =sys_read, | |
| 128 [SYS_kill] =sys_kill, | |
| 129 [SYS_exec] =sys_exec, | |
| 130 [SYS_fstat] =sys_fstat, | |
| 131 [SYS_chdir] =sys_chdir, | |
| 132 [SYS_dup] =sys_dup, | |
| 133 [SYS_getpid] =sys_getpid, | |
| 134 [SYS_sbrk] =sys_sbrk, | |
| 135 [SYS_sleep] =sys_sleep, | |
| 136 [SYS_uptime] =sys_uptime, | |
| 137 [SYS_open] =sys_open, | |
| 138 [SYS_write] =sys_write, | |
| 139 [SYS_mknod] =sys_mknod, | |
| 140 [SYS_unlink] =sys_unlink, | |
| 141 [SYS_link] =sys_link, | |
| 142 [SYS_mkdir] =sys_mkdir, | |
| 143 [SYS_close] =sys_close, | |
| 0 | 144 }; |
| 145 | |
|
91
b5ddf6fb0a6d
use CbCFile instead of File struct Interface
anatofuz <anatofuz@cr.ie.u-ryukyu.ac.jp>
parents:
52
diff
changeset
|
146 static enum Code cbccodes[] = { |
|
92
bc5bcfd2f6d6
rename CbCFile to CbCSysFile
anatofuz <anatofuz@cr.ie.u-ryukyu.ac.jp>
parents:
91
diff
changeset
|
147 [SYS_cbc_read] = C_start_code, |
| 24 | 148 }; |
| 149 | |
| 52 | 150 __ncode cbc_trap_return(){ |
| 31 | 151 return; |
| 30 | 152 } |
| 153 | |
| 52 | 154 __ncode cbc_ret(int ret){ |
| 32 | 155 int num = proc->cbc_arg.cbc_console_arg.num; |
| 156 if (num != SYS_exec) { | |
| 157 proc->tf->r0 = ret; | |
| 158 } | |
| 24 | 159 goto cbc_trap_return(); |
| 160 } | |
| 161 | |
| 0 | 162 void syscall(void) |
| 163 { | |
| 164 int num; | |
| 165 int ret; | |
|
91
b5ddf6fb0a6d
use CbCFile instead of File struct Interface
anatofuz <anatofuz@cr.ie.u-ryukyu.ac.jp>
parents:
52
diff
changeset
|
166 struct Context* cbc_context; |
| 0 | 167 |
| 168 num = proc->tf->r0; | |
| 169 | |
| 31 | 170 if (num == 5) |
|
91
b5ddf6fb0a6d
use CbCFile instead of File struct Interface
anatofuz <anatofuz@cr.ie.u-ryukyu.ac.jp>
parents:
52
diff
changeset
|
171 num = 22; |
| 0 | 172 //cprintf ("syscall(%d) from %s(%d)\n", num, proc->name, proc->pid); |
| 173 | |
| 31 | 174 if((num >= NELEM(syscalls)) && (num <= NELEM(cbccodes)) && cbccodes[num]) { |
| 32 | 175 proc->cbc_arg.cbc_console_arg.num = num; |
|
91
b5ddf6fb0a6d
use CbCFile instead of File struct Interface
anatofuz <anatofuz@cr.ie.u-ryukyu.ac.jp>
parents:
52
diff
changeset
|
176 goto meta(cbc_context, cbccodes[num]); |
| 24 | 177 } |
| 178 | |
| 179 | |
| 34 | 180 if((num > 0) && (num < NELEM(syscalls)) && syscalls[num]) { |
| 0 | 181 ret = syscalls[num](); |
| 182 | |
| 183 // in ARM, parameters to main (argc, argv) are passed in r0 and r1 | |
| 184 // do not set the return value if it is SYS_exec (the user program | |
| 185 // anyway does not expect us to return anything). | |
| 186 if (num != SYS_exec) { | |
| 187 proc->tf->r0 = ret; | |
| 188 } | |
| 189 } else { | |
| 190 cprintf("%d %s: unknown sys call %d\n", proc->pid, proc->name, num); | |
| 191 proc->tf->r0 = -1; | |
| 192 } | |
| 193 } |