Navigation
- Accueil
- Présentation :
- FAQ
- Bugs et errata
- Contributions de lecteurs
- Téléchargements
- LXR (référencement des sources)
- Mailing-list
- Liens et Projets reliés
Site hébergé par :
Site hébergé par :
|
[ source navigation ] [ diff markup ] [ identifier search ] [ general search ] |
|||
|
||||
001 /* Copyright (C) 2005 David Decotigny 001 /* Copyright (C) 2005 David Decotigny 002 002 003 This program is free software; you can redi 003 This program is free software; you can redistribute it and/or 004 modify it under the terms of the GNU Genera 004 modify it under the terms of the GNU General Public License 005 as published by the Free Software Foundatio 005 as published by the Free Software Foundation; either version 2 006 of the License, or (at your option) any lat 006 of the License, or (at your option) any later version. 007 007 008 This program is distributed in the hope tha 008 This program is distributed in the hope that it will be useful, 009 but WITHOUT ANY WARRANTY; without even the 009 but WITHOUT ANY WARRANTY; without even the implied warranty of 010 MERCHANTABILITY or FITNESS FOR A PARTICULAR 010 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 011 GNU General Public License for more details 011 GNU General Public License for more details. 012 012 013 You should have received a copy of the GNU 013 You should have received a copy of the GNU General Public License 014 along with this program; if not, write to t 014 along with this program; if not, write to the Free Software 015 Foundation, Inc., 59 Temple Place - Suite 3 015 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 016 USA. 016 USA. 017 */ 017 */ 018 #include <sos/thread.h> 018 #include <sos/thread.h> 019 #include <sos/kmalloc.h> 019 #include <sos/kmalloc.h> 020 #include <sos/klibc.h> 020 #include <sos/klibc.h> 021 #include <drivers/bochs.h> 021 #include <drivers/bochs.h> 022 #include <hwcore/paging.h> 022 #include <hwcore/paging.h> 023 #include <sos/physmem.h> 023 #include <sos/physmem.h> 024 #include <sos/umem_vmm.h> 024 #include <sos/umem_vmm.h> 025 #include <drivers/zero.h> 025 #include <drivers/zero.h> 026 #include <drivers/mem.h> 026 #include <drivers/mem.h> 027 #include <sos/binfmt_elf32.h> 027 #include <sos/binfmt_elf32.h> 028 028 029 #include <hwcore/cpu_context.h> 029 #include <hwcore/cpu_context.h> 030 #include <sos/uaccess.h> 030 #include <sos/uaccess.h> 031 #include "syscall.h" 031 #include "syscall.h" 032 032 033 033 034 /** 034 /** 035 * THE syscall entry point 035 * THE syscall entry point 036 */ 036 */ 037 sos_ret_t sos_do_syscall(int syscall_id, 037 sos_ret_t sos_do_syscall(int syscall_id, 038 const struct sos_cpu_ 038 const struct sos_cpu_state *user_ctxt) 039 { 039 { 040 sos_ret_t retval; 040 sos_ret_t retval; 041 041 042 switch(syscall_id) 042 switch(syscall_id) 043 { 043 { 044 case SOS_SYSCALL_ID_EXIT: 044 case SOS_SYSCALL_ID_EXIT: 045 { 045 { 046 unsigned int status; 046 unsigned int status; 047 << 048 retval = sos_syscall_get1arg(user_ctxt 047 retval = sos_syscall_get1arg(user_ctxt, & status); 049 if (SOS_OK != retval) 048 if (SOS_OK != retval) 050 break; 049 break; 051 sos_thread_exit(); 050 sos_thread_exit(); 052 retval = -SOS_EFATAL; /* Not reached * 051 retval = -SOS_EFATAL; /* Not reached */ 053 } 052 } 054 break; 053 break; 055 054 056 case SOS_SYSCALL_ID_FORK: 055 case SOS_SYSCALL_ID_FORK: 057 { 056 { 058 struct sos_thread *cur_thr, *new_thr; 057 struct sos_thread *cur_thr, *new_thr; 059 struct sos_process *new_proc; 058 struct sos_process *new_proc; 060 059 061 cur_thr = sos_thread_get_current(); 060 cur_thr = sos_thread_get_current(); 062 061 063 /* Duplicate the current process (and 062 /* Duplicate the current process (and its address space) */ 064 new_proc = sos_process_create(NULL, TR 063 new_proc = sos_process_create(NULL, TRUE); 065 if (! new_proc) 064 if (! new_proc) 066 { 065 { 067 retval = -SOS_ENOMEM; 066 retval = -SOS_ENOMEM; 068 break; 067 break; 069 } 068 } 070 069 071 /* Create *the* thread in this new pro 070 /* Create *the* thread in this new processs, copy of the 072 current user thread (same registers 071 current user thread (same registers, EXCEPT eax which is 073 set to 0) */ 072 set to 0) */ 074 new_thr = 073 new_thr = 075 sos_duplicate_user_thread(NULL, new_ 074 sos_duplicate_user_thread(NULL, new_proc, 076 cur_thr, 075 cur_thr, 077 user_ctxt, 076 user_ctxt, 078 0); 077 0); 079 if (! new_thr) 078 if (! new_thr) 080 { 079 { 081 sos_process_unref(new_proc); 080 sos_process_unref(new_proc); 082 retval = -SOS_ENOMEM; 081 retval = -SOS_ENOMEM; 083 break; 082 break; 084 } 083 } 085 084 086 sos_process_unref(new_proc); 085 sos_process_unref(new_proc); 087 086 088 /* Return to the "parent" thread with 087 /* Return to the "parent" thread with a value different from 089 0. Unix says it should be the "PID" 088 0. Unix says it should be the "PID" of the child. We don't 090 have such a "PID" notion for now */ 089 have such a "PID" notion for now */ 091 retval = (sos_ui32_t)new_proc; 090 retval = (sos_ui32_t)new_proc; 092 } 091 } 093 break; 092 break; 094 093 095 case SOS_SYSCALL_ID_EXEC: 094 case SOS_SYSCALL_ID_EXEC: 096 { 095 { 097 struct sos_thread *cur_thr, *new_thr; 096 struct sos_thread *cur_thr, *new_thr; 098 struct sos_process * proc; << 099 struct sos_umem_vmm_as *new_as; 097 struct sos_umem_vmm_as *new_as; 100 sos_uaddr_t user_str, ustack, start_ua 098 sos_uaddr_t user_str, ustack, start_uaddr; 101 sos_size_t len; 099 sos_size_t len; 102 char * str; 100 char * str; 103 101 104 cur_thr = sos_thread_get_current(); 102 cur_thr = sos_thread_get_current(); 105 proc = cur_thr->process; << 106 103 107 /* Make sure the process has exactly 1 104 /* Make sure the process has exactly 1 thread in it */ 108 if (sos_process_get_nb_threads(proc) ! !! 105 if (sos_process_get_nb_threads(cur_thr->process) != 1) 109 { 106 { 110 retval = -SOS_EBUSY; 107 retval = -SOS_EBUSY; 111 break; 108 break; 112 } 109 } 113 110 114 /* Get the user arguments */ 111 /* Get the user arguments */ 115 retval = sos_syscall_get2args(user_ctx 112 retval = sos_syscall_get2args(user_ctxt, & user_str, & len); 116 if (SOS_OK != retval) 113 if (SOS_OK != retval) 117 break; 114 break; 118 115 119 /* Copy the program name into kernel s 116 /* Copy the program name into kernel sppace */ 120 retval = sos_strndup_from_user(& str, !! 117 str = (char*)sos_kmalloc(len + 1, 0); 121 if (SOS_OK != retval) !! 118 if (! str) 122 { 119 { >> 120 retval = -SOS_ENOMEM; >> 121 break; >> 122 } >> 123 retval = sos_strzcpy_from_user(str, user_str, len + 1); >> 124 if (retval < SOS_OK) >> 125 { >> 126 sos_kfree((sos_vaddr_t)str); 123 break; 127 break; 124 } 128 } 125 129 126 /* Create a new empty address space to 130 /* Create a new empty address space to map the program */ 127 new_as = sos_umem_vmm_create_empty_as( !! 131 new_as = sos_umem_vmm_create_empty_as(cur_thr->process); 128 if (! new_as) 132 if (! new_as) 129 { 133 { 130 sos_kfree((sos_vaddr_t)str); 134 sos_kfree((sos_vaddr_t)str); 131 retval = -SOS_ENOMEM; 135 retval = -SOS_ENOMEM; 132 break; 136 break; 133 } 137 } 134 138 135 /* Map the program in it */ 139 /* Map the program in it */ 136 start_uaddr = sos_binfmt_elf32_map(new 140 start_uaddr = sos_binfmt_elf32_map(new_as, str); 137 if (start_uaddr == (sos_uaddr_t)NULL) 141 if (start_uaddr == (sos_uaddr_t)NULL) 138 { 142 { 139 sos_umem_vmm_delete_as(new_as); 143 sos_umem_vmm_delete_as(new_as); 140 sos_kfree((sos_vaddr_t)str); 144 sos_kfree((sos_vaddr_t)str); 141 retval = -SOS_ENOENT; 145 retval = -SOS_ENOENT; 142 break; 146 break; 143 } 147 } 144 148 145 /* Allocate space for the user stack ( 149 /* Allocate space for the user stack (8MB) */ 146 #define SOS_DEFAULT_USER_STACK_SIZE (8 << 20) 150 #define SOS_DEFAULT_USER_STACK_SIZE (8 << 20) 147 ustack = (SOS_PAGING_TOP_USER_ADDRESS 151 ustack = (SOS_PAGING_TOP_USER_ADDRESS - SOS_DEFAULT_USER_STACK_SIZE) 148 + 1; 152 + 1; 149 retval = sos_dev_zero_map(new_as, &ust 153 retval = sos_dev_zero_map(new_as, &ustack, SOS_DEFAULT_USER_STACK_SIZE, 150 SOS_VM_MAP_P 154 SOS_VM_MAP_PROT_READ | SOS_VM_MAP_PROT_WRITE, 151 /* PRIVATE * 155 /* PRIVATE */ 0); 152 if (SOS_OK != retval) 156 if (SOS_OK != retval) 153 { 157 { 154 sos_umem_vmm_delete_as(new_as); 158 sos_umem_vmm_delete_as(new_as); 155 sos_kfree((sos_vaddr_t)str); 159 sos_kfree((sos_vaddr_t)str); 156 break; 160 break; 157 } 161 } 158 162 159 /* Now create the user thread */ 163 /* Now create the user thread */ 160 new_thr = sos_create_user_thread(NULL, 164 new_thr = sos_create_user_thread(NULL, 161 proc, !! 165 cur_thr->process, 162 start 166 start_uaddr, 163 0, 0, 167 0, 0, 164 ustac 168 ustack + SOS_DEFAULT_USER_STACK_SIZE 165 - 4 169 - 4, 166 SOS_S 170 SOS_SCHED_PRIO_TS_LOWEST); 167 if (! new_thr) 171 if (! new_thr) 168 { 172 { 169 sos_umem_vmm_delete_as(new_as); 173 sos_umem_vmm_delete_as(new_as); 170 sos_kfree((sos_vaddr_t)str); 174 sos_kfree((sos_vaddr_t)str); 171 retval = -SOS_ENOMEM; 175 retval = -SOS_ENOMEM; 172 break; 176 break; 173 } 177 } 174 178 175 sos_process_set_name(proc, str); !! 179 sos_process_set_name(cur_thr->process, str); 176 180 177 /* Switch to this address space */ 181 /* Switch to this address space */ 178 retval = sos_process_set_address_space !! 182 retval = sos_process_set_address_space(cur_thr->process, 179 183 new_as); 180 if (SOS_OK != retval) 184 if (SOS_OK != retval) 181 { 185 { 182 sos_umem_vmm_delete_as(new_as); 186 sos_umem_vmm_delete_as(new_as); 183 sos_kfree((sos_vaddr_t)str); 187 sos_kfree((sos_vaddr_t)str); 184 break; 188 break; 185 } 189 } 186 190 187 /* The current thread must exit now */ 191 /* The current thread must exit now */ 188 sos_kfree((sos_vaddr_t)str); 192 sos_kfree((sos_vaddr_t)str); 189 sos_thread_exit(); 193 sos_thread_exit(); 190 retval = -SOS_EFATAL; 194 retval = -SOS_EFATAL; 191 } 195 } 192 break; 196 break; 193 197 194 case SOS_SYSCALL_ID_FAKEMMAP: !! 198 case SOS_SYSCALL_ID_MMAP: 195 { 199 { 196 sos_uaddr_t ptr_hint_uaddr; 200 sos_uaddr_t ptr_hint_uaddr; 197 sos_uaddr_t hint_uaddr; 201 sos_uaddr_t hint_uaddr; 198 sos_size_t length; 202 sos_size_t length; 199 sos_ui32_t prot; 203 sos_ui32_t prot; 200 sos_ui32_t flags; 204 sos_ui32_t flags; 201 sos_uaddr_t name_user; 205 sos_uaddr_t name_user; 202 sos_ui32_t offs64_hi; 206 sos_ui32_t offs64_hi; 203 sos_ui32_t offs64_lo; 207 sos_ui32_t offs64_lo; 204 sos_luoffset_t offset_in_resource; 208 sos_luoffset_t offset_in_resource; 205 char name[256]; 209 char name[256]; 206 struct sos_umem_vmm_as * my_as; 210 struct sos_umem_vmm_as * my_as; 207 211 208 retval = sos_syscall_get7args(user_ctx 212 retval = sos_syscall_get7args(user_ctxt, 209 (unsigne 213 (unsigned int*)& ptr_hint_uaddr, 210 (unsigne 214 (unsigned int*)& length, 211 (unsigne 215 (unsigned int*)& prot, 212 (unsigne 216 (unsigned int*)& flags, 213 (unsigne 217 (unsigned int*)& name_user, 214 (unsigne 218 (unsigned int*)& offs64_hi, 215 (unsigne 219 (unsigned int*)& offs64_lo); 216 if (SOS_OK != retval) 220 if (SOS_OK != retval) 217 break; 221 break; 218 222 219 /* Compute 64 bits offset value */ 223 /* Compute 64 bits offset value */ 220 offset_in_resource = offs64_hi; 224 offset_in_resource = offs64_hi; 221 offset_in_resource <<= 32; 225 offset_in_resource <<= 32; 222 offset_in_resource |= offs64_lo; 226 offset_in_resource |= offs64_lo; 223 227 224 retval = sos_memcpy_from_user((sos_vad 228 retval = sos_memcpy_from_user((sos_vaddr_t)& hint_uaddr, 225 ptr_hint 229 ptr_hint_uaddr, 226 sizeof(h 230 sizeof(hint_uaddr)); 227 if (sizeof(hint_uaddr) != retval) 231 if (sizeof(hint_uaddr) != retval) 228 { 232 { 229 retval = -SOS_EFAULT; 233 retval = -SOS_EFAULT; 230 break; 234 break; 231 } 235 } 232 236 233 retval = sos_strzcpy_from_user(name, n 237 retval = sos_strzcpy_from_user(name, name_user, sizeof(name)); 234 if (SOS_OK != retval) 238 if (SOS_OK != retval) 235 break; 239 break; 236 240 237 my_as 241 my_as 238 = sos_process_get_address_space(sos_ 242 = sos_process_get_address_space(sos_thread_get_current()->process); 239 if ( (0 == strncmp(name, "/dev/zero", 243 if ( (0 == strncmp(name, "/dev/zero", sizeof(name))) 240 || (0 == strncmp(name, "/dev/null 244 || (0 == strncmp(name, "/dev/null", sizeof(name))) ) 241 retval = sos_dev_zero_map(my_as, & h 245 retval = sos_dev_zero_map(my_as, & hint_uaddr, length, prot, flags); 242 else if (0 == strncmp(name, "/dev/mem" 246 else if (0 == strncmp(name, "/dev/mem", sizeof(name))) 243 retval = sos_dev_physmem_map(my_as, 247 retval = sos_dev_physmem_map(my_as, & hint_uaddr, length, 244 offset_ 248 offset_in_resource, prot, flags); 245 else if (0 == strncmp(name, "/dev/kmem 249 else if (0 == strncmp(name, "/dev/kmem", sizeof(name))) 246 retval = sos_dev_kmem_map(my_as, & h 250 retval = sos_dev_kmem_map(my_as, & hint_uaddr, length, 247 offset_in_ 251 offset_in_resource, prot, flags); 248 else 252 else 249 retval = -SOS_ENOENT; 253 retval = -SOS_ENOENT; 250 254 251 if (SOS_OK == retval) 255 if (SOS_OK == retval) 252 { 256 { 253 if (sizeof(hint_uaddr) 257 if (sizeof(hint_uaddr) 254 != sos_memcpy_to_user(ptr_hint 258 != sos_memcpy_to_user(ptr_hint_uaddr, 255 (sos_vad 259 (sos_vaddr_t)& hint_uaddr, 256 sizeof(h 260 sizeof(hint_uaddr))) 257 { 261 { 258 sos_umem_vmm_unmap(my_as, hint 262 sos_umem_vmm_unmap(my_as, hint_uaddr, length); 259 retval = -SOS_EFAULT; 263 retval = -SOS_EFAULT; 260 } 264 } 261 } 265 } 262 266 263 } 267 } 264 break; 268 break; 265 269 266 case SOS_SYSCALL_ID_MUNMAP: 270 case SOS_SYSCALL_ID_MUNMAP: 267 { 271 { 268 sos_uaddr_t start_uaddr; 272 sos_uaddr_t start_uaddr; 269 sos_size_t size; 273 sos_size_t size; 270 struct sos_umem_vmm_as * my_as; 274 struct sos_umem_vmm_as * my_as; 271 275 272 my_as 276 my_as 273 = sos_process_get_address_space(sos_ 277 = sos_process_get_address_space(sos_thread_get_current()->process); 274 278 275 retval = sos_syscall_get2args(user_ctx 279 retval = sos_syscall_get2args(user_ctxt, 276 (unsigne 280 (unsigned int*)& start_uaddr, 277 (unsigne 281 (unsigned int*)& size); 278 if (SOS_OK != retval) 282 if (SOS_OK != retval) 279 break; 283 break; 280 284 281 retval = sos_umem_vmm_unmap(my_as, sta 285 retval = sos_umem_vmm_unmap(my_as, start_uaddr, size); 282 } 286 } 283 break; 287 break; 284 288 285 case SOS_SYSCALL_ID_MPROTECT: 289 case SOS_SYSCALL_ID_MPROTECT: 286 { 290 { 287 sos_uaddr_t start_uaddr; 291 sos_uaddr_t start_uaddr; 288 sos_size_t size; 292 sos_size_t size; 289 sos_ui32_t new_access_rights; 293 sos_ui32_t new_access_rights; 290 struct sos_umem_vmm_as * my_as; 294 struct sos_umem_vmm_as * my_as; 291 295 292 my_as 296 my_as 293 = sos_process_get_address_space(sos_ 297 = sos_process_get_address_space(sos_thread_get_current()->process); 294 298 295 retval = sos_syscall_get3args(user_ctx 299 retval = sos_syscall_get3args(user_ctxt, 296 (unsigne 300 (unsigned int*)& start_uaddr, 297 (unsigne 301 (unsigned int*)& size, 298 (unsigne 302 (unsigned int*)& new_access_rights); 299 if (SOS_OK != retval) 303 if (SOS_OK != retval) 300 break; 304 break; 301 305 302 retval = sos_thread_prepare_user_space 306 retval = sos_thread_prepare_user_space_access(NULL, (sos_vaddr_t)NULL); 303 if (SOS_OK != retval) 307 if (SOS_OK != retval) 304 break; 308 break; 305 309 306 retval = sos_umem_vmm_chprot(my_as, st 310 retval = sos_umem_vmm_chprot(my_as, start_uaddr, size, 307 new_acces 311 new_access_rights); 308 312 309 sos_thread_end_user_space_access(); 313 sos_thread_end_user_space_access(); 310 } 314 } 311 break; 315 break; 312 316 313 case SOS_SYSCALL_ID_MRESIZE: 317 case SOS_SYSCALL_ID_MRESIZE: 314 { 318 { 315 sos_uaddr_t old_uaddr; 319 sos_uaddr_t old_uaddr; 316 sos_size_t old_size; 320 sos_size_t old_size; 317 sos_uaddr_t *uptr_new_uaddr; 321 sos_uaddr_t *uptr_new_uaddr; 318 sos_uaddr_t new_uaddr; 322 sos_uaddr_t new_uaddr; 319 sos_size_t new_size; 323 sos_size_t new_size; 320 sos_ui32_t flags; 324 sos_ui32_t flags; 321 struct sos_umem_vmm_as * my_as; 325 struct sos_umem_vmm_as * my_as; 322 326 323 my_as 327 my_as 324 = sos_process_get_address_space(sos_ 328 = sos_process_get_address_space(sos_thread_get_current()->process); 325 329 326 retval = sos_syscall_get5args(user_ctx 330 retval = sos_syscall_get5args(user_ctxt, 327 (unsigne 331 (unsigned int*)& old_uaddr, 328 (unsigne 332 (unsigned int*)& old_size, 329 (unsigne 333 (unsigned int*)& uptr_new_uaddr, 330 (unsigne 334 (unsigned int*)& new_size, 331 (unsigne 335 (unsigned int*)& flags); 332 if (SOS_OK != retval) 336 if (SOS_OK != retval) 333 break; 337 break; 334 338 335 if (sizeof(new_uaddr) != sos_memcpy_fr 339 if (sizeof(new_uaddr) != sos_memcpy_from_user((sos_vaddr_t)& new_uaddr, 336 340 (sos_uaddr_t) 337 341 uptr_new_uaddr, 338 342 sizeof(new_uaddr))) 339 { 343 { 340 retval = -SOS_EFAULT; 344 retval = -SOS_EFAULT; 341 break; 345 break; 342 } 346 } 343 347 344 retval = sos_thread_prepare_user_space 348 retval = sos_thread_prepare_user_space_access(NULL, (sos_vaddr_t)NULL); 345 if (SOS_OK != retval) 349 if (SOS_OK != retval) 346 break; 350 break; 347 351 348 retval = sos_umem_vmm_resize(my_as, ol 352 retval = sos_umem_vmm_resize(my_as, old_uaddr, old_size, 349 & new_uad 353 & new_uaddr, new_size, flags); 350 sos_thread_end_user_space_access(); 354 sos_thread_end_user_space_access(); 351 if (SOS_OK != retval) 355 if (SOS_OK != retval) 352 break; 356 break; 353 357 354 if (sizeof(new_uaddr) 358 if (sizeof(new_uaddr) 355 == sos_memcpy_to_user((sos_uaddr_t 359 == sos_memcpy_to_user((sos_uaddr_t)uptr_new_uaddr, 356 (sos_vaddr_t 360 (sos_vaddr_t)&new_uaddr, 357 sizeof(new_u 361 sizeof(new_uaddr))) 358 { 362 { 359 retval = -SOS_EFAULT; 363 retval = -SOS_EFAULT; 360 break; 364 break; 361 } 365 } 362 } 366 } 363 break; 367 break; 364 368 365 case SOS_SYSCALL_ID_NEW_THREAD: 369 case SOS_SYSCALL_ID_NEW_THREAD: 366 { 370 { 367 sos_uaddr_t start_func; 371 sos_uaddr_t start_func; 368 sos_ui32_t start_arg1, start_arg2; 372 sos_ui32_t start_arg1, start_arg2; 369 sos_size_t stack_size; 373 sos_size_t stack_size; 370 sos_uaddr_t stack_uaddr; 374 sos_uaddr_t stack_uaddr; 371 375 372 struct sos_thread * new_thr; 376 struct sos_thread * new_thr; 373 struct sos_umem_vmm_as * my_as; 377 struct sos_umem_vmm_as * my_as; 374 378 375 my_as 379 my_as 376 = sos_process_get_address_space(sos_ 380 = sos_process_get_address_space(sos_thread_get_current()->process); 377 381 378 retval = sos_syscall_get4args(user_ctx 382 retval = sos_syscall_get4args(user_ctxt, 379 (unsigne 383 (unsigned int*)& start_func, 380 (unsigne 384 (unsigned int*)& start_arg1, 381 (unsigne 385 (unsigned int*)& start_arg2, 382 (unsigne 386 (unsigned int*)& stack_size); 383 if (SOS_OK != retval) 387 if (SOS_OK != retval) 384 break; 388 break; 385 389 386 if (stack_size <= 0) 390 if (stack_size <= 0) 387 { 391 { 388 retval = -SOS_EINVAL; 392 retval = -SOS_EINVAL; 389 break; 393 break; 390 } 394 } 391 395 392 /* Allocate the stack */ 396 /* Allocate the stack */ 393 stack_uaddr = 0; 397 stack_uaddr = 0; 394 stack_size = SOS_PAGE_ALIGN_SUP(stack_ 398 stack_size = SOS_PAGE_ALIGN_SUP(stack_size); 395 retval = sos_dev_zero_map(my_as, & sta 399 retval = sos_dev_zero_map(my_as, & stack_uaddr, stack_size, 396 SOS_VM_MAP_P 400 SOS_VM_MAP_PROT_READ | SOS_VM_MAP_PROT_WRITE, 397 /* PRIVATE * 401 /* PRIVATE */ 0); 398 if (SOS_OK != retval) 402 if (SOS_OK != retval) 399 break; 403 break; 400 404 401 /* Now create the user thread */ 405 /* Now create the user thread */ 402 new_thr = sos_create_user_thread(NULL, 406 new_thr = sos_create_user_thread(NULL, 403 sos_t 407 sos_thread_get_current()->process, 404 start 408 start_func, 405 start 409 start_arg1, 406 start 410 start_arg2, 407 stack 411 stack_uaddr + stack_size - 4, 408 SOS_S 412 SOS_SCHED_PRIO_TS_LOWEST); 409 413 410 if (! new_thr) 414 if (! new_thr) 411 { 415 { 412 sos_umem_vmm_unmap(my_as, stack_ua 416 sos_umem_vmm_unmap(my_as, stack_uaddr, stack_size); 413 retval = -SOS_ENOMEM; 417 retval = -SOS_ENOMEM; 414 break; 418 break; 415 } 419 } 416 << 417 } 420 } 418 break; 421 break; 419 422 420 case SOS_SYSCALL_ID_NANOSLEEP: 423 case SOS_SYSCALL_ID_NANOSLEEP: 421 { 424 { 422 struct sos_time delay; 425 struct sos_time delay; 423 426 424 retval = sos_syscall_get2args(user_ctx 427 retval = sos_syscall_get2args(user_ctxt, 425 (unsigne 428 (unsigned int*)& delay.sec, 426 (unsigne 429 (unsigned int*)& delay.nanosec); 427 if (SOS_OK != retval) 430 if (SOS_OK != retval) 428 break; 431 break; 429 432 430 retval = sos_thread_sleep(& delay); 433 retval = sos_thread_sleep(& delay); 431 } 434 } 432 break; 435 break; 433 436 434 case SOS_SYSCALL_ID_BRK: 437 case SOS_SYSCALL_ID_BRK: 435 { 438 { 436 sos_uaddr_t new_top_heap; 439 sos_uaddr_t new_top_heap; 437 struct sos_umem_vmm_as * my_as; 440 struct sos_umem_vmm_as * my_as; 438 441 439 my_as 442 my_as 440 = sos_process_get_address_space(sos_ 443 = sos_process_get_address_space(sos_thread_get_current()->process); 441 444 442 retval = sos_syscall_get1arg(user_ctxt 445 retval = sos_syscall_get1arg(user_ctxt, 443 (unsigned 446 (unsigned int*)& new_top_heap); 444 if (SOS_OK != retval) 447 if (SOS_OK != retval) 445 break; 448 break; 446 449 447 retval = sos_thread_prepare_user_space 450 retval = sos_thread_prepare_user_space_access(NULL, (sos_vaddr_t)NULL); 448 if (SOS_OK != retval) 451 if (SOS_OK != retval) 449 break; 452 break; 450 453 451 retval = sos_umem_vmm_brk(my_as, new_t 454 retval = sos_umem_vmm_brk(my_as, new_top_heap); 452 sos_thread_end_user_space_access(); 455 sos_thread_end_user_space_access(); 453 } 456 } 454 break; 457 break; 455 458 456 << 457 /** << 458 * File system interface << 459 */ << 460 case SOS_SYSCALL_ID_MOUNT: << 461 { << 462 sos_uaddr_t user_src; << 463 sos_size_t srclen; << 464 const char * kernel_src = NULL; << 465 sos_uaddr_t user_dst; << 466 sos_size_t dstlen; << 467 const char * kernel_dst; << 468 sos_ui32_t mountflags; << 469 sos_uaddr_t user_fstype; << 470 char * kernel_fstype; << 471 sos_uaddr_t user_args; << 472 char * kernel_args = NULL; << 473 struct sos_process * proc; << 474 << 475 proc = sos_thread_get_current()->proce << 476 retval = sos_syscall_get7args(user_ctx << 477 (unsigne << 478 (unsigne << 479 (unsigne << 480 (unsigne << 481 (unsigne << 482 (unsigne << 483 (unsigne << 484 if (SOS_OK != retval) << 485 break; << 486 << 487 if (user_src != (sos_uaddr_t)NULL) << 488 { << 489 retval = sos_memdup_from_user((sos << 490 if (SOS_OK != retval) << 491 break; << 492 } << 493 << 494 retval = sos_memdup_from_user((sos_vad << 495 if (SOS_OK != retval) << 496 { << 497 if (kernel_src) << 498 sos_kfree((sos_vaddr_t)kernel_sr << 499 break; << 500 } << 501 << 502 retval = sos_strndup_from_user(& kerne << 503 if (SOS_OK != retval) << 504 { << 505 if (kernel_src) << 506 sos_kfree((sos_vaddr_t)kernel_sr << 507 sos_kfree((sos_vaddr_t)kernel_dst) << 508 break; << 509 } << 510 << 511 if (user_args != (sos_uaddr_t)NULL) << 512 { << 513 retval = sos_strndup_from_user(& k << 514 if (SOS_OK != retval) << 515 { << 516 if (kernel_src) << 517 sos_kfree((sos_vaddr_t)kerne << 518 sos_kfree((sos_vaddr_t)kernel_ << 519 sos_kfree((sos_vaddr_t)kernel_ << 520 break; << 521 } << 522 } << 523 << 524 retval = sos_fs_mount(proc, kernel_src << 525 kernel_dst, dstl << 526 kernel_fstype, << 527 mountflags, << 528 kernel_args, << 529 NULL); << 530 if (kernel_src) << 531 sos_kfree((sos_vaddr_t)kernel_src); << 532 sos_kfree((sos_vaddr_t)kernel_dst); << 533 sos_kfree((sos_vaddr_t)kernel_fstype); << 534 if (kernel_args) << 535 sos_kfree((sos_vaddr_t)kernel_args); << 536 } << 537 break; << 538 << 539 case SOS_SYSCALL_ID_UMOUNT: << 540 { << 541 sos_uaddr_t user_str; << 542 sos_size_t len; << 543 char * path; << 544 struct sos_process * proc; << 545 << 546 proc = sos_thread_get_current()->proce << 547 retval = sos_syscall_get2args(user_ctx << 548 (unsigne << 549 (unsigne << 550 if (SOS_OK != retval) << 551 break; << 552 << 553 retval = sos_memdup_from_user((sos_vad << 554 if (SOS_OK != retval) << 555 break; << 556 << 557 retval = sos_fs_umount(proc, << 558 path, len); << 559 sos_kfree((sos_vaddr_t)path); << 560 } << 561 break; << 562 << 563 case SOS_SYSCALL_ID_SYNC: << 564 { << 565 sos_fs_sync_all_fs(); << 566 retval = SOS_OK; << 567 } << 568 break; << 569 << 570 case SOS_SYSCALL_ID_VFSTAT64: << 571 { << 572 sos_uaddr_t user_str; << 573 sos_size_t len; << 574 sos_uaddr_t user_vfstat_struct; << 575 struct sos_fs_statfs kernel_vfstat_str << 576 char * path; << 577 struct sos_process * proc; << 578 << 579 proc = sos_thread_get_current()->proce << 580 retval = sos_syscall_get3args(user_ctx << 581 (unsigne << 582 (unsigne << 583 (unsigne << 584 if (SOS_OK != retval) << 585 break; << 586 << 587 retval = sos_memdup_from_user((sos_vad << 588 if (SOS_OK != retval) << 589 break; << 590 << 591 retval = sos_fs_vfstat(proc, path, len << 592 sos_kfree((sos_vaddr_t)path); << 593 if (SOS_OK != retval) << 594 break; << 595 << 596 if (sizeof(kernel_vfstat_struct) << 597 != sos_memcpy_to_user(user_vfstat_ << 598 (sos_vaddr_t << 599 sizeof(kerne << 600 retval = -SOS_EFAULT; << 601 } << 602 break; << 603 << 604 case SOS_SYSCALL_ID_OPEN: << 605 { << 606 sos_uaddr_t user_str; << 607 sos_size_t len; << 608 sos_ui32_t open_flags; << 609 sos_ui32_t access_rights; << 610 char * path; << 611 struct sos_fs_opened_file * of; << 612 struct sos_process * proc; << 613 << 614 proc = sos_thread_get_current()->proce << 615 retval = sos_syscall_get4args(user_ctx << 616 (unsigne << 617 (unsigne << 618 (unsigne << 619 (unsigne << 620 if (SOS_OK != retval) << 621 break; << 622 << 623 retval = sos_memdup_from_user((sos_vad << 624 if (SOS_OK != retval) << 625 break; << 626 << 627 retval = sos_fs_open(proc, << 628 path, len, << 629 open_flags, << 630 access_rights, << 631 & of); << 632 sos_kfree((sos_vaddr_t)path); << 633 if (SOS_OK != retval) << 634 break; << 635 << 636 retval = sos_process_register_opened_f << 637 if (retval < 0) << 638 { << 639 sos_fs_close(of); << 640 break; << 641 } << 642 } << 643 break; << 644 << 645 case SOS_SYSCALL_ID_CLOSE: << 646 { << 647 struct sos_fs_opened_file * of; << 648 struct sos_process * proc; << 649 int fd; << 650 << 651 proc = sos_thread_get_current()->proce << 652 retval = sos_syscall_get1arg(user_ctxt << 653 (unsigned << 654 if (SOS_OK != retval) << 655 break; << 656 << 657 of = sos_process_get_opened_file(proc, << 658 if (NULL == of) << 659 { << 660 retval = -SOS_EBADF; << 661 break; << 662 } << 663 << 664 retval = sos_process_unregister_opened << 665 if (SOS_OK != retval) << 666 break; << 667 << 668 retval = sos_fs_close(of); << 669 } << 670 break; << 671 << 672 case SOS_SYSCALL_ID_READ: << 673 { << 674 struct sos_fs_opened_file * of; << 675 struct sos_process * proc; << 676 sos_uaddr_t uaddr_buf; << 677 sos_uaddr_t uaddr_buflen; << 678 sos_size_t kernel_buflen; << 679 int fd; << 680 << 681 proc = sos_thread_get_current()->proce << 682 retval = sos_syscall_get3args(user_ctx << 683 (unsigne << 684 (unsigne << 685 (unsigne << 686 if (SOS_OK != retval) << 687 break; << 688 << 689 /* Retrieve the value for "buflen" */ << 690 retval = sos_memcpy_from_user((sos_vad << 691 uaddr_bu << 692 sizeof(k << 693 if (sizeof(kernel_buflen) != retval) << 694 { << 695 retval = -SOS_EFAULT; << 696 break; << 697 } << 698 << 699 of = sos_process_get_opened_file(proc, << 700 if (NULL == of) << 701 { << 702 retval = -SOS_EBADF; << 703 break; << 704 } << 705 << 706 /* Do the actual reading */ << 707 retval = sos_fs_read(of, uaddr_buf, & << 708 << 709 /* Send successful number of bytes rea << 710 sos_memcpy_to_user(uaddr_buflen, << 711 (sos_vaddr_t)& kern << 712 sizeof(kernel_bufle << 713 } << 714 break; << 715 << 716 case SOS_SYSCALL_ID_READDIR: << 717 { << 718 struct sos_fs_opened_file * of; << 719 struct sos_process * proc; << 720 sos_uaddr_t uaddr_direntry; << 721 struct sos_fs_dirent direntry; << 722 int fd; << 723 << 724 proc = sos_thread_get_current()->proce << 725 retval = sos_syscall_get2args(user_ctx << 726 (unsigne << 727 (unsigne << 728 if (SOS_OK != retval) << 729 break; << 730 << 731 of = sos_process_get_opened_file(proc, << 732 if (NULL == of) << 733 { << 734 retval = -SOS_EBADF; << 735 break; << 736 } << 737 << 738 /* Do the actual readdir */ << 739 retval = sos_fs_readdir(of, & direntry << 740 if (SOS_OK != retval) << 741 break; << 742 << 743 /* Send direntry structure to user */ << 744 if (sizeof(direntry) != sos_memcpy_to_ << 745 << 746 << 747 retval = -SOS_EFAULT; << 748 } << 749 break; << 750 << 751 case SOS_SYSCALL_ID_WRITE: << 752 { << 753 struct sos_fs_opened_file * of; << 754 struct sos_process * proc; << 755 sos_uaddr_t uaddr_buf; << 756 sos_uaddr_t uaddr_buflen; << 757 sos_size_t kernel_buflen; << 758 int fd; << 759 << 760 proc = sos_thread_get_current()->proce << 761 retval = sos_syscall_get3args(user_ctx << 762 (unsigne << 763 (unsigne << 764 (unsigne << 765 if (SOS_OK != retval) << 766 break; << 767 << 768 /* Retrieve the value for "buflen" */ << 769 retval = sos_memcpy_from_user((sos_vad << 770 uaddr_bu << 771 sizeof(k << 772 if (sizeof(kernel_buflen) != retval) << 773 { << 774 retval = -SOS_EFAULT; << 775 break; << 776 } << 777 << 778 of = sos_process_get_opened_file(proc, << 779 if (NULL == of) << 780 { << 781 retval = -SOS_EBADF; << 782 break; << 783 } << 784 << 785 /* Do the actual writing */ << 786 retval = sos_fs_write(of, uaddr_buf, & << 787 << 788 /* Send successful number of bytes wri << 789 sos_memcpy_to_user(uaddr_buflen, << 790 (sos_vaddr_t)& kern << 791 sizeof(kernel_bufle << 792 } << 793 break; << 794 << 795 case SOS_SYSCALL_ID_SEEK64: << 796 { << 797 struct sos_fs_opened_file * of; << 798 struct sos_process * proc; << 799 sos_uaddr_t uaddr_offset; << 800 sos_seek_whence_t whence; << 801 sos_lsoffset_t kernel_offset, result_p << 802 int fd; << 803 << 804 proc = sos_thread_get_current()->proce << 805 retval = sos_syscall_get3args(user_ctx << 806 (unsigne << 807 (unsigne << 808 (unsigne << 809 if (SOS_OK != retval) << 810 break; << 811 << 812 /* Retrieve the value for "buflen" */ << 813 retval = sos_memcpy_from_user((sos_vad << 814 uaddr_of << 815 sizeof(k << 816 if (sizeof(kernel_offset) != retval) << 817 { << 818 retval = -SOS_EFAULT; << 819 break; << 820 } << 821 << 822 of = sos_process_get_opened_file(proc, << 823 if (NULL == of) << 824 { << 825 retval = -SOS_EBADF; << 826 break; << 827 } << 828 << 829 /* Do the actual seek */ << 830 retval = sos_fs_seek(of, kernel_offset << 831 << 832 /* Send successful number of bytes wri << 833 sos_memcpy_to_user(uaddr_offset, << 834 (sos_vaddr_t)& resu << 835 sizeof(kernel_offse << 836 } << 837 break; << 838 << 839 case SOS_SYSCALL_ID_FTRUNCATE64: << 840 { << 841 struct sos_fs_opened_file * of; << 842 struct sos_process * proc; << 843 sos_lsoffset_t length; << 844 int fd; << 845 << 846 proc = sos_thread_get_current()->proce << 847 retval = sos_syscall_get2args(user_ctx << 848 (unsigne << 849 (unsigne << 850 if (SOS_OK != retval) << 851 break; << 852 << 853 of = sos_process_get_opened_file(proc, << 854 if (NULL == of) << 855 { << 856 retval = -SOS_EBADF; << 857 break; << 858 } << 859 << 860 /* Do the actual trunc */ << 861 retval = sos_fs_ftruncate(of, length); << 862 } << 863 break; << 864 << 865 case SOS_SYSCALL_ID_FSMMAP: << 866 { << 867 sos_uaddr_t ptr_hint_uaddr; << 868 sos_uaddr_t hint_uaddr; << 869 sos_size_t length; << 870 sos_ui32_t prot; << 871 sos_ui32_t flags; << 872 int fd; << 873 sos_ui32_t offs64_hi; << 874 sos_ui32_t offs64_lo; << 875 sos_luoffset_t offset_in_resource; << 876 struct sos_fs_opened_file * of; << 877 struct sos_process * proc; << 878 << 879 proc = sos_thread_get_current()->proce << 880 retval = sos_syscall_get7args(user_ctx << 881 (unsigne << 882 (unsigne << 883 (unsigne << 884 (unsigne << 885 (unsigne << 886 (unsigne << 887 (unsigne << 888 if (SOS_OK != retval) << 889 break; << 890 << 891 of = sos_process_get_opened_file(proc, << 892 if (NULL == of) << 893 { << 894 retval = -SOS_EBADF; << 895 break; << 896 } << 897 << 898 /* Compute 64 bits offset value */ << 899 offset_in_resource = offs64_hi; << 900 offset_in_resource <<= 32; << 901 offset_in_resource |= offs64_lo; << 902 << 903 retval = sos_memcpy_from_user((sos_vad << 904 ptr_hint << 905 sizeof(h << 906 if (sizeof(hint_uaddr) != retval) << 907 { << 908 retval = -SOS_EFAULT; << 909 break; << 910 } << 911 << 912 retval = sos_fs_mmap(of, & hint_uaddr, << 913 offset_in_resourc << 914 if (SOS_OK == retval) << 915 { << 916 if (sizeof(hint_uaddr) << 917 != sos_memcpy_to_user(ptr_hint << 918 (sos_vad << 919 sizeof(h << 920 { << 921 sos_umem_vmm_unmap(sos_process << 922 hint_uaddr, << 923 retval = -SOS_EFAULT; << 924 } << 925 } << 926 << 927 } << 928 break; << 929 << 930 case SOS_SYSCALL_ID_FSYNC: << 931 { << 932 struct sos_fs_opened_file * of; << 933 struct sos_process * proc; << 934 int fd; << 935 << 936 proc = sos_thread_get_current()->proce << 937 retval = sos_syscall_get1arg(user_ctxt << 938 (unsigned << 939 if (SOS_OK != retval) << 940 break; << 941 << 942 of = sos_process_get_opened_file(proc, << 943 if (NULL == of) << 944 { << 945 retval = -SOS_EBADF; << 946 break; << 947 } << 948 << 949 /* Do the actual sync */ << 950 retval = sos_fs_fsync(of); << 951 } << 952 break; << 953 << 954 case SOS_SYSCALL_ID_FCNTL: << 955 { << 956 struct sos_fs_opened_file * of; << 957 struct sos_process * proc; << 958 sos_ui32_t cmd, arg; << 959 int fd; << 960 << 961 proc = sos_thread_get_current()->proce << 962 retval = sos_syscall_get3args(user_ctx << 963 (unsigne << 964 (unsigne << 965 (unsigne << 966 if (SOS_OK != retval) << 967 break; << 968 << 969 of = sos_process_get_opened_file(proc, << 970 if (NULL == of) << 971 { << 972 retval = -SOS_EBADF; << 973 break; << 974 } << 975 << 976 /* Do the actual fcntl */ << 977 retval = sos_fs_fcntl(of, cmd, arg); << 978 } << 979 break; << 980 << 981 case SOS_SYSCALL_ID_CREAT: << 982 { << 983 sos_uaddr_t user_str; << 984 sos_size_t len; << 985 sos_ui32_t access_rights; << 986 char * path; << 987 struct sos_process * proc; << 988 << 989 proc = sos_thread_get_current()->proce << 990 retval = sos_syscall_get3args(user_ctx << 991 (unsigne << 992 (unsigne << 993 (unsigne << 994 if (SOS_OK != retval) << 995 break; << 996 << 997 retval = sos_memdup_from_user((sos_vad << 998 if (SOS_OK != retval) << 999 break; << 1000 << 1001 retval = sos_fs_creat(proc, << 1002 path, len, << 1003 access_rights); << 1004 sos_kfree((sos_vaddr_t)path); << 1005 } << 1006 break; << 1007 << 1008 case SOS_SYSCALL_ID_LINK: << 1009 case SOS_SYSCALL_ID_RENAME: << 1010 { << 1011 sos_uaddr_t user_oldpath, user_newpat << 1012 sos_size_t oldpathlen, newpathlen; << 1013 char * kernel_oldpath, * kernel_newpa << 1014 struct sos_process * proc; << 1015 << 1016 proc = sos_thread_get_current()->proc << 1017 retval = sos_syscall_get4args(user_ct << 1018 (unsign << 1019 (unsign << 1020 (unsign << 1021 (unsign << 1022 if (SOS_OK != retval) << 1023 break; << 1024 << 1025 retval = sos_memdup_from_user((sos_va << 1026 user_ol << 1027 oldpath << 1028 if (SOS_OK != retval) << 1029 break; << 1030 << 1031 retval = sos_memdup_from_user((sos_va << 1032 user_ne << 1033 newpath << 1034 if (SOS_OK != retval) << 1035 { << 1036 sos_kfree((sos_vaddr_t) kernel_ol << 1037 break; << 1038 } << 1039 << 1040 if (syscall_id == SOS_SYSCALL_ID_LINK << 1041 retval = sos_fs_link(proc, << 1042 kernel_oldpath << 1043 kernel_newpath << 1044 else << 1045 retval = sos_fs_rename(proc, << 1046 kernel_oldpa << 1047 kernel_newpa << 1048 sos_kfree((sos_vaddr_t)kernel_oldpath << 1049 sos_kfree((sos_vaddr_t)kernel_newpath << 1050 } << 1051 break; << 1052 << 1053 case SOS_SYSCALL_ID_UNLINK: << 1054 { << 1055 sos_uaddr_t user_str; << 1056 sos_size_t len; << 1057 char * path; << 1058 struct sos_process * proc; << 1059 << 1060 proc = sos_thread_get_current()->proc << 1061 retval = sos_syscall_get2args(user_ct << 1062 (unsign << 1063 (unsign << 1064 if (SOS_OK != retval) << 1065 break; << 1066 << 1067 retval = sos_memdup_from_user((sos_va << 1068 if (SOS_OK != retval) << 1069 break; << 1070 << 1071 retval = sos_fs_unlink(proc, << 1072 path, len); << 1073 sos_kfree((sos_vaddr_t)path); << 1074 } << 1075 break; << 1076 << 1077 case SOS_SYSCALL_ID_SYMLINK: << 1078 { << 1079 sos_uaddr_t user_path, user_targetpat << 1080 sos_size_t pathlen, targetpathlen; << 1081 char * kernel_path; << 1082 struct sos_process * proc; << 1083 << 1084 proc = sos_thread_get_current()->proc << 1085 retval = sos_syscall_get4args(user_ct << 1086 (unsign << 1087 (unsign << 1088 (unsign << 1089 (unsign << 1090 if (SOS_OK != retval) << 1091 break; << 1092 << 1093 retval = sos_memdup_from_user((sos_va << 1094 user_pa << 1095 pathlen << 1096 if (SOS_OK != retval) << 1097 break; << 1098 << 1099 retval = sos_fs_symlink(proc, << 1100 kernel_path, << 1101 user_targetpa << 1102 sos_kfree((sos_vaddr_t)kernel_path); << 1103 } << 1104 break; << 1105 << 1106 case SOS_SYSCALL_ID_MKDIR: << 1107 { << 1108 sos_uaddr_t user_str; << 1109 sos_size_t len; << 1110 sos_ui32_t access_rights; << 1111 char * path; << 1112 struct sos_process * proc; << 1113 << 1114 proc = sos_thread_get_current()->proc << 1115 retval = sos_syscall_get3args(user_ct << 1116 (unsign << 1117 (unsign << 1118 (unsign << 1119 if (SOS_OK != retval) << 1120 break; << 1121 << 1122 retval = sos_memdup_from_user((sos_va << 1123 if (SOS_OK != retval) << 1124 break; << 1125 << 1126 retval = sos_fs_mkdir(proc, << 1127 path, len, acce << 1128 sos_kfree((sos_vaddr_t)path); << 1129 } << 1130 break; << 1131 << 1132 case SOS_SYSCALL_ID_RMDIR: << 1133 { << 1134 sos_uaddr_t user_str; << 1135 sos_size_t len; << 1136 char * path; << 1137 struct sos_process * proc; << 1138 << 1139 proc = sos_thread_get_current()->proc << 1140 retval = sos_syscall_get2args(user_ct << 1141 (unsign << 1142 (unsign << 1143 if (SOS_OK != retval) << 1144 break; << 1145 << 1146 retval = sos_memdup_from_user((sos_va << 1147 if (SOS_OK != retval) << 1148 break; << 1149 << 1150 retval = sos_fs_rmdir(proc, path, len << 1151 sos_kfree((sos_vaddr_t)path); << 1152 } << 1153 break; << 1154 << 1155 case SOS_SYSCALL_ID_CHMOD: << 1156 { << 1157 sos_uaddr_t user_str; << 1158 sos_size_t len; << 1159 sos_ui32_t access_rights; << 1160 char * path; << 1161 struct sos_process * proc; << 1162 << 1163 proc = sos_thread_get_current()->proc << 1164 retval = sos_syscall_get3args(user_ct << 1165 (unsign << 1166 (unsign << 1167 (unsign << 1168 if (SOS_OK != retval) << 1169 break; << 1170 << 1171 retval = sos_memdup_from_user((sos_va << 1172 if (SOS_OK != retval) << 1173 break; << 1174 << 1175 retval = sos_fs_chmod(proc, path, len << 1176 sos_kfree((sos_vaddr_t)path); << 1177 } << 1178 break; << 1179 << 1180 case SOS_SYSCALL_ID_STAT64: << 1181 { << 1182 sos_uaddr_t user_str; << 1183 sos_size_t len; << 1184 sos_uaddr_t user_stat_struct; << 1185 struct sos_fs_stat kernel_stat_struct << 1186 int nofollow; << 1187 char * path; << 1188 struct sos_process * proc; << 1189 << 1190 proc = sos_thread_get_current()->proc << 1191 retval = sos_syscall_get4args(user_ct << 1192 (unsign << 1193 (unsign << 1194 (unsign << 1195 (unsign << 1196 if (SOS_OK != retval) << 1197 break; << 1198 << 1199 retval = sos_memdup_from_user((sos_va << 1200 if (SOS_OK != retval) << 1201 break; << 1202 << 1203 retval = sos_fs_stat(proc, path, len, << 1204 sos_kfree((sos_vaddr_t)path); << 1205 if (SOS_OK != retval) << 1206 break; << 1207 << 1208 if (sizeof(kernel_stat_struct) << 1209 != sos_memcpy_to_user(user_stat_s << 1210 (sos_vaddr_ << 1211 sizeof(kern << 1212 retval = -SOS_EFAULT; << 1213 } << 1214 break; << 1215 << 1216 case SOS_SYSCALL_ID_CHROOT: << 1217 case SOS_SYSCALL_ID_CHDIR: << 1218 { << 1219 sos_uaddr_t user_str; << 1220 sos_size_t len; << 1221 char * path; << 1222 struct sos_fs_opened_file * of, * old << 1223 struct sos_process * proc; << 1224 << 1225 proc = sos_thread_get_current()->proc << 1226 retval = sos_syscall_get2args(user_ct << 1227 (unsign << 1228 (unsign << 1229 if (SOS_OK != retval) << 1230 break; << 1231 << 1232 retval = sos_memdup_from_user((sos_va << 1233 if (SOS_OK != retval) << 1234 break; << 1235 << 1236 retval = sos_fs_open(proc, << 1237 path, len, << 1238 SOS_FS_OPEN_DIRE << 1239 SOS_FS_OPEN_READ << 1240 & of); << 1241 sos_kfree((sos_vaddr_t)path); << 1242 if (SOS_OK != retval) << 1243 break; << 1244 << 1245 if (syscall_id == SOS_SYSCALL_ID_CHRO << 1246 retval = sos_process_chroot(proc, o << 1247 else << 1248 retval = sos_process_chdir(proc, of << 1249 << 1250 if (retval < 0) << 1251 { << 1252 sos_fs_close(of); << 1253 break; << 1254 } << 1255 << 1256 sos_fs_close(old_of); << 1257 } << 1258 break; << 1259 << 1260 case SOS_SYSCALL_ID_FCHDIR: << 1261 { << 1262 struct sos_fs_opened_file * of, * new << 1263 struct sos_process * proc; << 1264 int fd; << 1265 << 1266 proc = sos_thread_get_current()->proc << 1267 retval = sos_syscall_get1arg(user_ctx << 1268 (unsigne << 1269 if (SOS_OK != retval) << 1270 break; << 1271 << 1272 of = sos_process_get_opened_file(proc << 1273 if (NULL == of) << 1274 { << 1275 retval = -SOS_EBADF; << 1276 break; << 1277 } << 1278 << 1279 /* Duplicate this FD */ << 1280 retval = sos_fs_duplicate_opened_file << 1281 if (SOS_OK != retval) << 1282 break; << 1283 << 1284 /* Do the actual chdir */ << 1285 retval = sos_process_chdir(proc, new_ << 1286 if (retval < 0) << 1287 { << 1288 sos_fs_close(new_of); << 1289 break; << 1290 } << 1291 << 1292 sos_fs_close(old_of); << 1293 } << 1294 break; << 1295 << 1296 case SOS_SYSCALL_ID_BOCHS_WRITE: 459 case SOS_SYSCALL_ID_BOCHS_WRITE: 1297 { 460 { 1298 sos_uaddr_t user_str; 461 sos_uaddr_t user_str; 1299 sos_size_t len; 462 sos_size_t len; 1300 char * str; 463 char * str; 1301 retval = sos_syscall_get2args(user_ct 464 retval = sos_syscall_get2args(user_ctxt, & user_str, & len); 1302 if (SOS_OK != retval) 465 if (SOS_OK != retval) 1303 break; 466 break; 1304 467 1305 retval = sos_strndup_from_user(& str, !! 468 str = (char*)sos_kmalloc(len + 1, 0); 1306 if (SOS_OK == retval) !! 469 if (str) 1307 { 470 { 1308 sos_bochs_printf("THR 0x%x: ", !! 471 retval = sos_strzcpy_from_user(str, user_str, len+1); 1309 (unsigned)sos_th !! 472 str[len] = '\0'; 1310 retval = sos_bochs_putstring(str) !! 473 if (SOS_OK == retval) 1311 retval = len; !! 474 { >> 475 sos_bochs_printf("THR 0x%x: ", >> 476 (unsigned)sos_thread_get_current()); >> 477 retval = sos_bochs_putstring(str); >> 478 retval = len; >> 479 } 1312 sos_kfree((sos_vaddr_t)str); 480 sos_kfree((sos_vaddr_t)str); 1313 } 481 } >> 482 else >> 483 retval = -SOS_ENOMEM; 1314 } 484 } 1315 break; 485 break; 1316 486 1317 487 1318 /* ************************************ 488 /* *********************************************** 1319 * Debug syscalls (will be removed in t 489 * Debug syscalls (will be removed in the future) 1320 */ 490 */ 1321 491 1322 492 1323 /** 493 /** 1324 * Syscall 4012: hexdump of a user-spac 494 * Syscall 4012: hexdump of a user-space memory region 1325 * args: addr_start size, retval=ignore 495 * args: addr_start size, retval=ignored 1326 */ 496 */ 1327 case 4012: 497 case 4012: 1328 { 498 { 1329 sos_uaddr_t user_str; 499 sos_uaddr_t user_str; 1330 unsigned int len; 500 unsigned int len; 1331 unsigned char * str; 501 unsigned char * str; 1332 502 1333 retval = sos_syscall_get2args(user_ct 503 retval = sos_syscall_get2args(user_ctxt, & user_str, & len); 1334 if (SOS_OK != retval) 504 if (SOS_OK != retval) 1335 break; 505 break; 1336 506 1337 str = (char*)sos_kmalloc(len, 0); !! 507 str = (char*)sos_kmalloc(len + 1, 0); 1338 if (str) 508 if (str) 1339 { 509 { 1340 int i; 510 int i; 1341 sos_bochs_printf("Hexdump(0x%x, % 511 sos_bochs_printf("Hexdump(0x%x, %d):\n", user_str, len); 1342 retval = sos_memcpy_from_user((so 512 retval = sos_memcpy_from_user((sos_vaddr_t) str, user_str, len); 1343 sos_bochs_printf(" (Successfully 513 sos_bochs_printf(" (Successfully copied %d out of %d)\n", 1344 retval, len); 514 retval, len); 1345 515 1346 for (i = 0 ; i < retval ; i++) 516 for (i = 0 ; i < retval ; i++) 1347 { 517 { 1348 if ((i % 32) == 0) 518 if ((i % 32) == 0) 1349 sos_bochs_printf("%x:", i); 519 sos_bochs_printf("%x:", i); 1350 sos_bochs_printf(" %x", str[i 520 sos_bochs_printf(" %x", str[i]); 1351 if (((i+1) % 32) == 0) 521 if (((i+1) % 32) == 0) 1352 sos_bochs_printf("\n"); 522 sos_bochs_printf("\n"); 1353 } 523 } 1354 if (i % 32) 524 if (i % 32) 1355 sos_bochs_printf("\n"); 525 sos_bochs_printf("\n"); 1356 526 1357 sos_kfree((sos_vaddr_t)str); 527 sos_kfree((sos_vaddr_t)str); 1358 } 528 } 1359 else 529 else 1360 retval = -SOS_ENOMEM; 530 retval = -SOS_ENOMEM; 1361 } 531 } 1362 break; 532 break; 1363 533 1364 534 1365 /** 535 /** 1366 * Syscall 4004: lists the VR of the cu 536 * Syscall 4004: lists the VR of the current thread's address space 1367 * args: debug_string, retval=ignored 537 * args: debug_string, retval=ignored 1368 */ 538 */ 1369 case 4004: 539 case 4004: 1370 { 540 { 1371 sos_uaddr_t ustr; 541 sos_uaddr_t ustr; 1372 char * kstr; 542 char * kstr; 1373 struct sos_umem_vmm_as * my_as; 543 struct sos_umem_vmm_as * my_as; 1374 544 1375 retval = sos_syscall_get1arg(user_ctx 545 retval = sos_syscall_get1arg(user_ctxt, & ustr); 1376 if (SOS_OK != retval) 546 if (SOS_OK != retval) 1377 break; 547 break; 1378 548 1379 retval = sos_strndup_from_user(& kstr 549 retval = sos_strndup_from_user(& kstr, ustr, 256, 0); 1380 if (SOS_OK != retval) 550 if (SOS_OK != retval) 1381 break; 551 break; 1382 552 1383 extern void sos_dump_as(const struct 553 extern void sos_dump_as(const struct sos_umem_vmm_as *, const char *); 1384 my_as 554 my_as 1385 = sos_process_get_address_space(sos 555 = sos_process_get_address_space(sos_thread_get_current()->process); 1386 sos_dump_as(my_as, kstr); 556 sos_dump_as(my_as, kstr); 1387 sos_kfree((sos_vaddr_t)kstr); 557 sos_kfree((sos_vaddr_t)kstr); 1388 } 558 } 1389 break; 559 break; 1390 560 1391 561 1392 /** 562 /** 1393 * Syscall 4008: dump the list of proce 563 * Syscall 4008: dump the list of processes in the system 1394 * args: none, retval=ignored 564 * args: none, retval=ignored 1395 */ 565 */ 1396 case 4008: 566 case 4008: 1397 { 567 { 1398 extern void sos_process_dumplist(void 568 extern void sos_process_dumplist(void); 1399 sos_process_dumplist(); 569 sos_process_dumplist(); 1400 retval = SOS_OK; 570 retval = SOS_OK; 1401 } 571 } 1402 break; 572 break; 1403 573 1404 default: 574 default: 1405 sos_bochs_printf("Syscall: UNKNOWN[%d]\ 575 sos_bochs_printf("Syscall: UNKNOWN[%d]\n", syscall_id); 1406 retval = -SOS_ENOSUP; 576 retval = -SOS_ENOSUP; 1407 } 577 } 1408 578 1409 return retval; 579 return retval; 1410 } 580 }
| [ source navigation ] | [ diff markup ] | [ identifier search ] | [ general search ] |