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