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