bsd/dev/ppc/systemcalls.c

   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         /* Make sure there is a process associated with this task */
 103         if (proc == NULL) {
 104                 regs->save_r3 = (long long)EPERM;
 105                 /* set the "pc" to execute cerror routine */
 106                 regs->save_srr0 -= 4;
 107                 task_terminate_internal(current_task());
 108                 thread_exception_return();
 109                 /* NOTREACHED */
 110         }
 111
 112         /*
 113          * Delayed binding of thread credential to process credential, if we
 114          * are not running with an explicitly set thread credential.
 115          */
 116         if (uthread->uu_ucred != proc->p_ucred &&
 117             (uthread->uu_flag & UT_SETUID) == 0) {
 118                 kauth_cred_t old = uthread->uu_ucred;
 119                 proc_lock(proc);
 120                 uthread->uu_ucred = proc->p_ucred;
 121                 kauth_cred_ref(uthread->uu_ucred);
 122                 proc_unlock(proc);
 123                 if (old != NOCRED)
 124                         kauth_cred_rele(old);
 125         }
 126
 127         uthread->uu_ar0 = (int *)regs;
 128
 129         callp = (code >= nsysent) ? &sysent[63] : &sysent[code];
 130
 131         if (callp->sy_narg != 0) {
 132                 void            *regsp;
 133                 sy_munge_t      *mungerp;
 134
 135                 if (IS_64BIT_PROCESS(proc)) {
 136                         /* XXX Turn 64 bit unsafe calls into nosys() */
 137                         if (callp->sy_funnel & UNSAFE_64BIT) {
 138                                 callp = &sysent[63];
 139                                 goto unsafe;
 140                         }
 141                         mungerp = callp->sy_arg_munge64;
 142                 }
 143                 else {
 144                         mungerp = callp->sy_arg_munge32;
 145                 }
 146                 if ( !flavor) {
 147                         regsp = (void *) &regs->save_r3;
 148                 } else {
 149                         /* indirect system call consumes an argument so only 7 are supported */
 150                         if (callp->sy_narg > 7) {
 151                                 callp = &sysent[63];
 152                                 goto unsafe;
 153                         }
 154                         regsp = (void *) &regs->save_r4;
 155                 }
 156                 /* call syscall argument munger to copy in arguments (see xnu/bsd/dev/ppc/munge.s) */
 157                 (*mungerp)(regsp, (void *) &uthread->uu_arg[0]);
 158         }
 159
 160 unsafe:
 161         cancel_enable = callp->sy_cancel;
 162
 163         if (cancel_enable == _SYSCALL_CANCEL_NONE) {
 164                         uthread->uu_flag |= UT_NOTCANCELPT;
 165         } else {
 166                 if((uthread->uu_flag & (UT_CANCELDISABLE | UT_CANCEL | UT_CANCELED)) == UT_CANCEL) {
 167                         if (cancel_enable == _SYSCALL_CANCEL_PRE) {
 168                                         /* system call cancelled; return to handle cancellation */
 169                                         regs->save_r3 = (long long)EINTR;
 170                                         thread_exception_return();
 171                                         /* NOTREACHED */
 172                         } else {
 173                         thread_abort_safely(thread_act);
 174                         }
 175                 }
 176         }
 177
 178         funnel_type = (int)(callp->sy_funnel & FUNNEL_MASK);
 179         if (funnel_type == KERNEL_FUNNEL)
 180                  enter_funnel_section(kernel_flock);
 181
 182         uthread->uu_rval[0] = 0;
 183
 184         /*
 185          * r4 is volatile, if we set it to regs->save_r4 here the child
 186          * will have parents r4 after execve
 187          */
 188         uthread->uu_rval[1] = 0;
 189
 190         error = 0;
 191
 192         /*
 193          * PPC runtime calls cerror after every unix system call, so
 194          * assume no error and adjust the "pc" to skip this call.
 195          * It will be set back to the cerror call if an error is detected.
 196          */
 197         regs->save_srr0 += 4;
 198
 199         if (KTRPOINT(proc, KTR_SYSCALL))
 200                 ktrsyscall(proc, code, callp->sy_narg, uthread->uu_arg);
 201
 202 #ifdef JOE_DEBUG
 203         uthread->uu_iocount = 0;
 204         uthread->uu_vpindex = 0;
 205 #endif
 206         AUDIT_SYSCALL_ENTER(code, proc, uthread);
 207         error = (*(callp->sy_call))(proc, (void *)uthread->uu_arg, &(uthread->uu_rval[0]));
 208         AUDIT_SYSCALL_EXIT(error, proc, uthread);
 209
 210 #ifdef JOE_DEBUG
 211         if (uthread->uu_iocount)
 212                 joe_debug("system call returned with uu_iocount != 0");
 213 #endif
 214         regs = find_user_regs(thread_act);
 215
 216         if (error == ERESTART) {
 217                 regs->save_srr0 -= 8;
 218         } else if (error != EJUSTRETURN) {
 219                 if (error) {
 220                         regs->save_r3 = (long long)error;
 221                         /* set the "pc" to execute cerror routine */
 222                         regs->save_srr0 -= 4;
 223                 } else { /* (not error) */
 224                         switch (callp->sy_return_type) {
 225                         case _SYSCALL_RET_INT_T:
 226                                 regs->save_r3 = uthread->uu_rval[0];
 227                                 regs->save_r4 = uthread->uu_rval[1];
 228                                 break;
 229                         case _SYSCALL_RET_UINT_T:
 230                                 regs->save_r3 = ((u_int)uthread->uu_rval[0]);
 231                                 regs->save_r4 = ((u_int)uthread->uu_rval[1]);
 232                                 break;
 233                         case _SYSCALL_RET_OFF_T:
 234                                 /* off_t returns 64 bits split across two registers for 32 bit */
 235                                 /* process and in one register for 64 bit process */
 236                                 if (IS_64BIT_PROCESS(proc)) {
 237                                         u_int64_t       *retp = (u_int64_t *)&uthread->uu_rval[0];
 238                                         regs->save_r3 = *retp;
 239                                         regs->save_r4 = 0;
 240                                 }
 241                                 else {
 242                                         regs->save_r3 = uthread->uu_rval[0];
 243                                         regs->save_r4 = uthread->uu_rval[1];
 244                                 }
 245                                 break;
 246                         case _SYSCALL_RET_ADDR_T:
 247                         case _SYSCALL_RET_SIZE_T:
 248                         case _SYSCALL_RET_SSIZE_T:
 249                                 /* the variable length return types (user_addr_t, user_ssize_t,
 250                                  * and user_size_t) are always the largest possible size in the
 251                                  * kernel (we use uu_rval[0] and [1] as one 64 bit value).
 252                                  */
 253                                 {
 254                                         user_addr_t *retp = (user_addr_t *)&uthread->uu_rval[0];
 255                                         regs->save_r3 = *retp;
 256                                         regs->save_r4 = 0;
 257                                 }
 258                                 break;
 259                         case _SYSCALL_RET_NONE:
 260                                 break;
 261                         default:
 262                                 panic("unix_syscall: unknown return type");
 263                                 break;
 264                         }
 265                 }
 266         }
 267         /* else  (error == EJUSTRETURN) { nothing } */
 268
 269
 270         if (KTRPOINT(proc, KTR_SYSRET)) {
 271                 switch(callp->sy_return_type) {
 272                 case _SYSCALL_RET_ADDR_T:
 273                 case _SYSCALL_RET_SIZE_T:
 274                 case _SYSCALL_RET_SSIZE_T:
 275                         /*
 276                          * Trace the value of the least significant bits,
 277                          * until we can revise the ktrace API safely.
 278                          */
 279                         ktrsysret(proc, code, error, uthread->uu_rval[1]);
 280                         break;
 281                 default:
 282                         ktrsysret(proc, code, error, uthread->uu_rval[0]);
 283                         break;
 284                 }
 285         }
 286
 287         if (cancel_enable == _SYSCALL_CANCEL_NONE)
 288                 uthread->uu_flag &= ~UT_NOTCANCELPT;
 289
 290         exit_funnel_section();
 291
 292         if (uthread->uu_lowpri_delay) {
 293                 /*
 294                  * task is marked as a low priority I/O type
 295                  * and the I/O we issued while in this system call
 296                  * collided with normal I/O operations... we'll
 297                  * delay in order to mitigate the impact of this
 298                  * task on the normal operation of the system
 299                  */
 300                 IOSleep(uthread->uu_lowpri_delay);
 301                 uthread->uu_lowpri_delay = 0;
 302         }
 303         if (kdebug_enable && (code != 180)) {
 304
 305                 if (callp->sy_return_type == _SYSCALL_RET_SSIZE_T)
 306                         KERNEL_DEBUG_CONSTANT(BSDDBG_CODE(DBG_BSD_EXCP_SC, code) | DBG_FUNC_END,
 307                                               error, uthread->uu_rval[1], 0, 0, 0);
 308                 else
 309                         KERNEL_DEBUG_CONSTANT(BSDDBG_CODE(DBG_BSD_EXCP_SC, code) | DBG_FUNC_END,
 310                                               error, uthread->uu_rval[0], uthread->uu_rval[1], 0, 0);
 311         }
 312
 313         thread_exception_return();
 314         /* NOTREACHED */
 315 }
 316
 317 void
 318 unix_syscall_return(int error)
 319 {
 320         thread_t                                        thread_act;
 321         struct uthread                          *uthread;
 322         struct proc                                     *proc;
 323         struct savearea                         *regs;
 324         unsigned short                          code;
 325         struct sysent                           *callp;
 326         int funnel_type;
 327         unsigned int cancel_enable;
 328
 329         thread_act = current_thread();
 330         proc = current_proc();
 331         uthread = get_bsdthread_info(thread_act);
 332
 333         regs = find_user_regs(thread_act);
 334
 335         if (regs->save_r0 != 0)
 336                 code = regs->save_r0;
 337         else
 338                 code = regs->save_r3;
 339
 340         callp = (code >= nsysent) ? &sysent[63] : &sysent[code];
 341
 342         /*
 343          * Get index into sysent table
 344          */
 345         if (error == ERESTART) {
 346                 regs->save_srr0 -= 8;
 347         } else if (error != EJUSTRETURN) {
 348                 if (error) {
 349                         regs->save_r3 = (long long)error;
 350                         /* set the "pc" to execute cerror routine */
 351                         regs->save_srr0 -= 4;
 352                 } else { /* (not error) */
 353                         switch (callp->sy_return_type) {
 354                         case _SYSCALL_RET_INT_T:
 355                                 regs->save_r3 = uthread->uu_rval[0];
 356                                 regs->save_r4 = uthread->uu_rval[1];
 357                                 break;
 358                         case _SYSCALL_RET_UINT_T:
 359                                 regs->save_r3 = ((u_int)uthread->uu_rval[0]);
 360                                 regs->save_r4 = ((u_int)uthread->uu_rval[1]);
 361                                 break;
 362                         case _SYSCALL_RET_OFF_T:
 363                                 /* off_t returns 64 bits split across two registers for 32 bit */
 364                                 /* process and in one register for 64 bit process */
 365                                 if (IS_64BIT_PROCESS(proc)) {
 366                                         u_int64_t       *retp = (u_int64_t *)&uthread->uu_rval[0];
 367                                         regs->save_r3 = *retp;
 368                                 }
 369                                 else {
 370                                         regs->save_r3 = uthread->uu_rval[0];
 371                                         regs->save_r4 = uthread->uu_rval[1];
 372                                 }
 373                                 break;
 374                         case _SYSCALL_RET_ADDR_T:
 375                         case _SYSCALL_RET_SIZE_T:
 376                         case _SYSCALL_RET_SSIZE_T:
 377                                 /* the variable length return types (user_addr_t, user_ssize_t,
 378                                  * and user_size_t) are always the largest possible size in the
 379                                  * kernel (we use uu_rval[0] and [1] as one 64 bit value).
 380                                  */
 381                                 {
 382                                         u_int64_t       *retp = (u_int64_t *)&uthread->uu_rval[0];
 383                                         regs->save_r3 = *retp;
 384                                 }
 385                                 break;
 386                         case _SYSCALL_RET_NONE:
 387                                 break;
 388                         default:
 389                                 panic("unix_syscall: unknown return type");
 390                                 break;
 391                         }
 392                 }
 393         }
 394         /* else  (error == EJUSTRETURN) { nothing } */
 395
 396         if (KTRPOINT(proc, KTR_SYSRET)) {
 397                 switch(callp->sy_return_type) {
 398                 case _SYSCALL_RET_ADDR_T:
 399                 case _SYSCALL_RET_SIZE_T:
 400                 case _SYSCALL_RET_SSIZE_T:
 401                         /*
 402                          * Trace the value of the least significant bits,
 403                          * until we can revise the ktrace API safely.
 404                          */
 405                         ktrsysret(proc, code, error, uthread->uu_rval[1]);
 406                         break;
 407                 default:
 408                         ktrsysret(proc, code, error, uthread->uu_rval[0]);
 409                         break;
 410                 }
 411         }
 412
 413         cancel_enable = callp->sy_cancel;
 414
 415         if (cancel_enable == _SYSCALL_CANCEL_NONE)
 416                 uthread->uu_flag &= ~UT_NOTCANCELPT;
 417
 418         exit_funnel_section();
 419
 420         if (uthread->uu_lowpri_delay) {
 421                 /*
 422                  * task is marked as a low priority I/O type
 423                  * and the I/O we issued while in this system call
 424                  * collided with normal I/O operations... we'll
 425                  * delay in order to mitigate the impact of this
 426                  * task on the normal operation of the system
 427                  */
 428                 IOSleep(uthread->uu_lowpri_delay);
 429                 uthread->uu_lowpri_delay = 0;
 430         }
 431         if (kdebug_enable && (code != 180)) {
 432                 if (callp->sy_return_type == _SYSCALL_RET_SSIZE_T)
 433                         KERNEL_DEBUG_CONSTANT(BSDDBG_CODE(DBG_BSD_EXCP_SC, code) | DBG_FUNC_END,
 434                                               error, uthread->uu_rval[1], 0, 0, 0);
 435                 else
 436                         KERNEL_DEBUG_CONSTANT(BSDDBG_CODE(DBG_BSD_EXCP_SC, code) | DBG_FUNC_END,
 437                                               error, uthread->uu_rval[0], uthread->uu_rval[1], 0, 0);
 438         }
 439
 440         thread_exception_return();
 441         /* NOTREACHED */
 442 }
 443
 444 /*
 445  * Time of day and interval timer support.
 446  *
 447  * These routines provide the kernel entry points to get and set
 448  * the time-of-day and per-process interval timers.  Subroutines
 449  * here provide support for adding and subtracting timeval structures
 450  * and decrementing interval timers, optionally reloading the interval
 451  * timers when they expire.
 452  */
 453 /*  NOTE THIS implementation is for  ppc architectures only.
 454  *  It is infrequently called, since the commpage intercepts
 455  *  most calls in user mode.
 456  *
 457  * XXX Y2038 bug because of assumed return of 32 bit seconds value, and
 458  * XXX first parameter to clock_gettimeofday()
 459  */
 460 int
 461 ppc_gettimeofday(__unused struct proc *p,
 462                                  register struct ppc_gettimeofday_args *uap,
 463                                  register_t *retval)
 464 {
 465         int error = 0;
 466         extern lck_spin_t * tz_slock;
 467
 468         if (uap->tp)
 469                 clock_gettimeofday(&retval[0], &retval[1]);
 470
 471         if (uap->tzp) {
 472                 struct timezone ltz;
 473
 474                 lck_spin_lock(tz_slock);
 475                 ltz = tz;
 476                 lck_spin_unlock(tz_slock);
 477                 error = copyout((caddr_t)&ltz, uap->tzp, sizeof (tz));
 478         }
 479
 480         return (error);
 481 }
 482
 483 #ifdef JOE_DEBUG
 484 joe_debug(char *p) {
 485
 486         printf("%s\n", p);
 487 }
 488 #endif
 489
 490
 491 /*
 492  * WARNING - this is a temporary workaround for binary compatibility issues
 493  * with anti-piracy software that relies on patching ptrace (3928003).
 494  * This KPI will be removed in the system release after Tiger.
 495  */
 496 uintptr_t temp_patch_ptrace(uintptr_t new_ptrace)
 497 {
 498         struct sysent *         callp;
 499         sy_call_t *                     old_ptrace;
 500
 501         if (new_ptrace == 0)
 502                 return(0);
 503
 504         enter_funnel_section(kernel_flock);
 505         callp = &sysent[26];
 506         old_ptrace = callp->sy_call;
 507
 508         /* only allow one patcher of ptrace */
 509         if (old_ptrace == (sy_call_t *) ptrace) {
 510                 callp->sy_call = (sy_call_t *) new_ptrace;
 511         }
 512         else {
 513                 old_ptrace = NULL;
 514         }
 515         exit_funnel_section( );
 516
 517         return((uintptr_t)old_ptrace);
 518 }
 519
 520 void temp_unpatch_ptrace(void)
 521 {
 522         struct sysent *         callp;
 523
 524         enter_funnel_section(kernel_flock);
 525         callp = &sysent[26];
 526         callp->sy_call = (sy_call_t *) ptrace;
 527         exit_funnel_section( );
 528
 529         return;
 530 }