The Design and Implementation of the FreeBSD Operating System, Second Edition
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  -  FREEBSD11  -  FREEBSD10  -  FREEBSD9  -  FREEBSD92  -  FREEBSD91  -  FREEBSD90  -  FREEBSD8  -  FREEBSD82  -  FREEBSD81  -  FREEBSD80  -  FREEBSD7  -  FREEBSD74  -  FREEBSD73  -  FREEBSD72  -  FREEBSD71  -  FREEBSD70  -  FREEBSD6  -  FREEBSD64  -  FREEBSD63  -  FREEBSD62  -  FREEBSD61  -  FREEBSD60  -  FREEBSD5  -  FREEBSD55  -  FREEBSD54  -  FREEBSD53  -  FREEBSD52  -  FREEBSD51  -  FREEBSD50  -  FREEBSD4  -  FREEBSD3  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
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 *) &regs->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 *) &regs->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)&ltz, 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 ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.