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