Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
FreeBSD/Linux Kernel Cross Reference
sys/bsd/dev/ppc/systemcalls.c
Version:
- FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
SearchContext: - none - 3 - 10
1 /* 2 * Copyright (c) 2000-2004 Apple Computer, Inc. All rights reserved. 3 * 4 * @APPLE_LICENSE_HEADER_START@ 5 * 6 * The contents of this file constitute Original Code as defined in and 7 * are subject to the Apple Public Source License Version 1.1 (the 8 * "License"). You may not use this file except in compliance with the 9 * License. Please obtain a copy of the License at 10 * http://www.apple.com/publicsource and read it before using this file. 11 * 12 * This Original Code and all software distributed under the License are 13 * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER 14 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, 15 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, 16 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the 17 * License for the specific language governing rights and limitations 18 * under the License. 19 * 20 * @APPLE_LICENSE_HEADER_END@ 21 */ 22 23 #include <kern/task.h> 24 #include <kern/thread.h> 25 #include <kern/assert.h> 26 #include <kern/clock.h> 27 #include <kern/locks.h> 28 #include <kern/sched_prim.h> 29 #include <mach/machine/thread_status.h> 30 #include <ppc/savearea.h> 31 32 #include <sys/kernel.h> 33 #include <sys/vm.h> 34 #include <sys/proc_internal.h> 35 #include <sys/syscall.h> 36 #include <sys/systm.h> 37 #include <sys/user.h> 38 #include <sys/errno.h> 39 #include <sys/ktrace.h> 40 #include <sys/kdebug.h> 41 #include <sys/sysent.h> 42 #include <sys/sysproto.h> 43 #include <sys/kauth.h> 44 45 #include <bsm/audit_kernel.h> 46 47 extern void 48 unix_syscall(struct savearea *regs); 49 void 50 unix_syscall_return(int error); 51 52 extern struct savearea * 53 find_user_regs( 54 thread_t act); 55 56 extern void enter_funnel_section(funnel_t *funnel_lock); 57 extern void exit_funnel_section(void); 58 59 /* 60 * Function: unix_syscall 61 * 62 * Inputs: regs - pointer to Process Control Block 63 * 64 * Outputs: none 65 */ 66 void 67 unix_syscall(struct savearea *regs) 68 { 69 thread_t thread_act; 70 struct uthread *uthread; 71 struct proc *proc; 72 struct sysent *callp; 73 int error; 74 unsigned short code; 75 boolean_t flavor; 76 int funnel_type; 77 unsigned int cancel_enable; 78 79 flavor = (((unsigned int)regs->save_r0) == 0)? 1: 0; 80 81 if (flavor) 82 code = regs->save_r3; 83 else 84 code = regs->save_r0; 85 86 if (kdebug_enable && (code != 180)) { 87 if (flavor) 88 KERNEL_DEBUG_CONSTANT(BSDDBG_CODE(DBG_BSD_EXCP_SC, code) | DBG_FUNC_START, 89 regs->save_r4, regs->save_r5, regs->save_r6, regs->save_r7, 0); 90 else 91 KERNEL_DEBUG_CONSTANT(BSDDBG_CODE(DBG_BSD_EXCP_SC, code) | DBG_FUNC_START, 92 regs->save_r3, regs->save_r4, regs->save_r5, regs->save_r6, 0); 93 } 94 thread_act = current_thread(); 95 uthread = get_bsdthread_info(thread_act); 96 97 if (!(uthread->uu_flag & UT_VFORK)) 98 proc = (struct proc *)get_bsdtask_info(current_task()); 99 else 100 proc = current_proc(); 101 102 /* 103 * Delayed binding of thread credential to process credential, if we 104 * are not running with an explicitly set thread credential. 105 */ 106 if (uthread->uu_ucred != proc->p_ucred && 107 (uthread->uu_flag & UT_SETUID) == 0) { 108 kauth_cred_t old = uthread->uu_ucred; 109 proc_lock(proc); 110 uthread->uu_ucred = proc->p_ucred; 111 kauth_cred_ref(uthread->uu_ucred); 112 proc_unlock(proc); 113 if (old != NOCRED) 114 kauth_cred_rele(old); 115 } 116 117 uthread->uu_ar0 = (int *)regs; 118 119 callp = (code >= nsysent) ? &sysent[63] : &sysent[code]; 120 121 if (callp->sy_narg != 0) { 122 void *regsp; 123 sy_munge_t *mungerp; 124 125 if (IS_64BIT_PROCESS(proc)) { 126 /* XXX Turn 64 bit unsafe calls into nosys() */ 127 if (callp->sy_funnel & UNSAFE_64BIT) { 128 callp = &sysent[63]; 129 goto unsafe; 130 } 131 mungerp = callp->sy_arg_munge64; 132 } 133 else { 134 mungerp = callp->sy_arg_munge32; 135 } 136 if ( !flavor) { 137 regsp = (void *) ®s->save_r3; 138 } else { 139 /* indirect system call consumes an argument so only 7 are supported */ 140 if (callp->sy_narg > 7) { 141 callp = &sysent[63]; 142 goto unsafe; 143 } 144 regsp = (void *) ®s->save_r4; 145 } 146 /* call syscall argument munger to copy in arguments (see xnu/bsd/dev/ppc/munge.s) */ 147 (*mungerp)(regsp, (void *) &uthread->uu_arg[0]); 148 } 149 150 unsafe: 151 cancel_enable = callp->sy_cancel; 152 153 if (cancel_enable == _SYSCALL_CANCEL_NONE) { 154 uthread->uu_flag |= UT_NOTCANCELPT; 155 } else { 156 if((uthread->uu_flag & (UT_CANCELDISABLE | UT_CANCEL | UT_CANCELED)) == UT_CANCEL) { 157 if (cancel_enable == _SYSCALL_CANCEL_PRE) { 158 /* system call cancelled; return to handle cancellation */ 159 regs->save_r3 = (long long)EINTR; 160 thread_exception_return(); 161 /* NOTREACHED */ 162 } else { 163 thread_abort_safely(thread_act); 164 } 165 } 166 } 167 168 funnel_type = (int)(callp->sy_funnel & FUNNEL_MASK); 169 if (funnel_type == KERNEL_FUNNEL) 170 enter_funnel_section(kernel_flock); 171 172 uthread->uu_rval[0] = 0; 173 174 /* 175 * r4 is volatile, if we set it to regs->save_r4 here the child 176 * will have parents r4 after execve 177 */ 178 uthread->uu_rval[1] = 0; 179 180 error = 0; 181 182 /* 183 * PPC runtime calls cerror after every unix system call, so 184 * assume no error and adjust the "pc" to skip this call. 185 * It will be set back to the cerror call if an error is detected. 186 */ 187 regs->save_srr0 += 4; 188 189 if (KTRPOINT(proc, KTR_SYSCALL)) 190 ktrsyscall(proc, code, callp->sy_narg, uthread->uu_arg); 191 192 #ifdef JOE_DEBUG 193 uthread->uu_iocount = 0; 194 uthread->uu_vpindex = 0; 195 #endif 196 AUDIT_SYSCALL_ENTER(code, proc, uthread); 197 error = (*(callp->sy_call))(proc, (void *)uthread->uu_arg, &(uthread->uu_rval[0])); 198 AUDIT_SYSCALL_EXIT(error, proc, uthread); 199 200 #ifdef JOE_DEBUG 201 if (uthread->uu_iocount) 202 joe_debug("system call returned with uu_iocount != 0"); 203 #endif 204 regs = find_user_regs(thread_act); 205 206 if (error == ERESTART) { 207 regs->save_srr0 -= 8; 208 } else if (error != EJUSTRETURN) { 209 if (error) { 210 regs->save_r3 = (long long)error; 211 /* set the "pc" to execute cerror routine */ 212 regs->save_srr0 -= 4; 213 } else { /* (not error) */ 214 switch (callp->sy_return_type) { 215 case _SYSCALL_RET_INT_T: 216 regs->save_r3 = uthread->uu_rval[0]; 217 regs->save_r4 = uthread->uu_rval[1]; 218 break; 219 case _SYSCALL_RET_UINT_T: 220 regs->save_r3 = ((u_int)uthread->uu_rval[0]); 221 regs->save_r4 = ((u_int)uthread->uu_rval[1]); 222 break; 223 case _SYSCALL_RET_OFF_T: 224 /* off_t returns 64 bits split across two registers for 32 bit */ 225 /* process and in one register for 64 bit process */ 226 if (IS_64BIT_PROCESS(proc)) { 227 u_int64_t *retp = (u_int64_t *)&uthread->uu_rval[0]; 228 regs->save_r3 = *retp; 229 regs->save_r4 = 0; 230 } 231 else { 232 regs->save_r3 = uthread->uu_rval[0]; 233 regs->save_r4 = uthread->uu_rval[1]; 234 } 235 break; 236 case _SYSCALL_RET_ADDR_T: 237 case _SYSCALL_RET_SIZE_T: 238 case _SYSCALL_RET_SSIZE_T: 239 /* the variable length return types (user_addr_t, user_ssize_t, 240 * and user_size_t) are always the largest possible size in the 241 * kernel (we use uu_rval[0] and [1] as one 64 bit value). 242 */ 243 { 244 user_addr_t *retp = (user_addr_t *)&uthread->uu_rval[0]; 245 regs->save_r3 = *retp; 246 regs->save_r4 = 0; 247 } 248 break; 249 case _SYSCALL_RET_NONE: 250 break; 251 default: 252 panic("unix_syscall: unknown return type"); 253 break; 254 } 255 } 256 } 257 /* else (error == EJUSTRETURN) { nothing } */ 258 259 260 if (KTRPOINT(proc, KTR_SYSRET)) { 261 switch(callp->sy_return_type) { 262 case _SYSCALL_RET_ADDR_T: 263 case _SYSCALL_RET_SIZE_T: 264 case _SYSCALL_RET_SSIZE_T: 265 /* 266 * Trace the value of the least significant bits, 267 * until we can revise the ktrace API safely. 268 */ 269 ktrsysret(proc, code, error, uthread->uu_rval[1]); 270 break; 271 default: 272 ktrsysret(proc, code, error, uthread->uu_rval[0]); 273 break; 274 } 275 } 276 277 if (cancel_enable == _SYSCALL_CANCEL_NONE) 278 uthread->uu_flag &= ~UT_NOTCANCELPT; 279 280 exit_funnel_section(); 281 282 if (uthread->uu_lowpri_delay) { 283 /* 284 * task is marked as a low priority I/O type 285 * and the I/O we issued while in this system call 286 * collided with normal I/O operations... we'll 287 * delay in order to mitigate the impact of this 288 * task on the normal operation of the system 289 */ 290 IOSleep(uthread->uu_lowpri_delay); 291 uthread->uu_lowpri_delay = 0; 292 } 293 if (kdebug_enable && (code != 180)) { 294 295 if (callp->sy_return_type == _SYSCALL_RET_SSIZE_T) 296 KERNEL_DEBUG_CONSTANT(BSDDBG_CODE(DBG_BSD_EXCP_SC, code) | DBG_FUNC_END, 297 error, uthread->uu_rval[1], 0, 0, 0); 298 else 299 KERNEL_DEBUG_CONSTANT(BSDDBG_CODE(DBG_BSD_EXCP_SC, code) | DBG_FUNC_END, 300 error, uthread->uu_rval[0], uthread->uu_rval[1], 0, 0); 301 } 302 303 thread_exception_return(); 304 /* NOTREACHED */ 305 } 306 307 void 308 unix_syscall_return(int error) 309 { 310 thread_t thread_act; 311 struct uthread *uthread; 312 struct proc *proc; 313 struct savearea *regs; 314 unsigned short code; 315 struct sysent *callp; 316 int funnel_type; 317 unsigned int cancel_enable; 318 319 thread_act = current_thread(); 320 proc = current_proc(); 321 uthread = get_bsdthread_info(thread_act); 322 323 regs = find_user_regs(thread_act); 324 325 if (regs->save_r0 != 0) 326 code = regs->save_r0; 327 else 328 code = regs->save_r3; 329 330 callp = (code >= nsysent) ? &sysent[63] : &sysent[code]; 331 332 /* 333 * Get index into sysent table 334 */ 335 if (error == ERESTART) { 336 regs->save_srr0 -= 8; 337 } else if (error != EJUSTRETURN) { 338 if (error) { 339 regs->save_r3 = (long long)error; 340 /* set the "pc" to execute cerror routine */ 341 regs->save_srr0 -= 4; 342 } else { /* (not error) */ 343 switch (callp->sy_return_type) { 344 case _SYSCALL_RET_INT_T: 345 regs->save_r3 = uthread->uu_rval[0]; 346 regs->save_r4 = uthread->uu_rval[1]; 347 break; 348 case _SYSCALL_RET_UINT_T: 349 regs->save_r3 = ((u_int)uthread->uu_rval[0]); 350 regs->save_r4 = ((u_int)uthread->uu_rval[1]); 351 break; 352 case _SYSCALL_RET_OFF_T: 353 /* off_t returns 64 bits split across two registers for 32 bit */ 354 /* process and in one register for 64 bit process */ 355 if (IS_64BIT_PROCESS(proc)) { 356 u_int64_t *retp = (u_int64_t *)&uthread->uu_rval[0]; 357 regs->save_r3 = *retp; 358 } 359 else { 360 regs->save_r3 = uthread->uu_rval[0]; 361 regs->save_r4 = uthread->uu_rval[1]; 362 } 363 break; 364 case _SYSCALL_RET_ADDR_T: 365 case _SYSCALL_RET_SIZE_T: 366 case _SYSCALL_RET_SSIZE_T: 367 /* the variable length return types (user_addr_t, user_ssize_t, 368 * and user_size_t) are always the largest possible size in the 369 * kernel (we use uu_rval[0] and [1] as one 64 bit value). 370 */ 371 { 372 u_int64_t *retp = (u_int64_t *)&uthread->uu_rval[0]; 373 regs->save_r3 = *retp; 374 } 375 break; 376 case _SYSCALL_RET_NONE: 377 break; 378 default: 379 panic("unix_syscall: unknown return type"); 380 break; 381 } 382 } 383 } 384 /* else (error == EJUSTRETURN) { nothing } */ 385 386 if (KTRPOINT(proc, KTR_SYSRET)) { 387 switch(callp->sy_return_type) { 388 case _SYSCALL_RET_ADDR_T: 389 case _SYSCALL_RET_SIZE_T: 390 case _SYSCALL_RET_SSIZE_T: 391 /* 392 * Trace the value of the least significant bits, 393 * until we can revise the ktrace API safely. 394 */ 395 ktrsysret(proc, code, error, uthread->uu_rval[1]); 396 break; 397 default: 398 ktrsysret(proc, code, error, uthread->uu_rval[0]); 399 break; 400 } 401 } 402 403 cancel_enable = callp->sy_cancel; 404 405 if (cancel_enable == _SYSCALL_CANCEL_NONE) 406 uthread->uu_flag &= ~UT_NOTCANCELPT; 407 408 exit_funnel_section(); 409 410 if (uthread->uu_lowpri_delay) { 411 /* 412 * task is marked as a low priority I/O type 413 * and the I/O we issued while in this system call 414 * collided with normal I/O operations... we'll 415 * delay in order to mitigate the impact of this 416 * task on the normal operation of the system 417 */ 418 IOSleep(uthread->uu_lowpri_delay); 419 uthread->uu_lowpri_delay = 0; 420 } 421 if (kdebug_enable && (code != 180)) { 422 if (callp->sy_return_type == _SYSCALL_RET_SSIZE_T) 423 KERNEL_DEBUG_CONSTANT(BSDDBG_CODE(DBG_BSD_EXCP_SC, code) | DBG_FUNC_END, 424 error, uthread->uu_rval[1], 0, 0, 0); 425 else 426 KERNEL_DEBUG_CONSTANT(BSDDBG_CODE(DBG_BSD_EXCP_SC, code) | DBG_FUNC_END, 427 error, uthread->uu_rval[0], uthread->uu_rval[1], 0, 0); 428 } 429 430 thread_exception_return(); 431 /* NOTREACHED */ 432 } 433 434 /* 435 * Time of day and interval timer support. 436 * 437 * These routines provide the kernel entry points to get and set 438 * the time-of-day and per-process interval timers. Subroutines 439 * here provide support for adding and subtracting timeval structures 440 * and decrementing interval timers, optionally reloading the interval 441 * timers when they expire. 442 */ 443 /* NOTE THIS implementation is for ppc architectures only. 444 * It is infrequently called, since the commpage intercepts 445 * most calls in user mode. 446 * 447 * XXX Y2038 bug because of assumed return of 32 bit seconds value, and 448 * XXX first parameter to clock_gettimeofday() 449 */ 450 int 451 ppc_gettimeofday(__unused struct proc *p, 452 register struct ppc_gettimeofday_args *uap, 453 register_t *retval) 454 { 455 int error = 0; 456 extern lck_spin_t * tz_slock; 457 458 if (uap->tp) 459 clock_gettimeofday(&retval[0], &retval[1]); 460 461 if (uap->tzp) { 462 struct timezone ltz; 463 464 lck_spin_lock(tz_slock); 465 ltz = tz; 466 lck_spin_unlock(tz_slock); 467 error = copyout((caddr_t)<z, uap->tzp, sizeof (tz)); 468 } 469 470 return (error); 471 } 472 473 #ifdef JOE_DEBUG 474 joe_debug(char *p) { 475 476 printf("%s\n", p); 477 } 478 #endif 479 480 481 /* 482 * WARNING - this is a temporary workaround for binary compatibility issues 483 * with anti-piracy software that relies on patching ptrace (3928003). 484 * This KPI will be removed in the system release after Tiger. 485 */ 486 uintptr_t temp_patch_ptrace(uintptr_t new_ptrace) 487 { 488 struct sysent * callp; 489 sy_call_t * old_ptrace; 490 491 if (new_ptrace == 0) 492 return(0); 493 494 enter_funnel_section(kernel_flock); 495 callp = &sysent[26]; 496 old_ptrace = callp->sy_call; 497 498 /* only allow one patcher of ptrace */ 499 if (old_ptrace == (sy_call_t *) ptrace) { 500 callp->sy_call = (sy_call_t *) new_ptrace; 501 } 502 else { 503 old_ptrace = NULL; 504 } 505 exit_funnel_section( ); 506 507 return((uintptr_t)old_ptrace); 508 } 509 510 void temp_unpatch_ptrace(void) 511 { 512 struct sysent * callp; 513 514 enter_funnel_section(kernel_flock); 515 callp = &sysent[26]; 516 callp->sy_call = (sy_call_t *) ptrace; 517 exit_funnel_section( ); 518 519 return; 520 }
Cache object: 72183ad0d75cbd0d4a07f2d3f5ed7b03
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]