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