Return to stubs.c CVS log

Up to [Apple XNU] / XNU / bsd / dev / i386

Annotation of XNU/bsd/dev/i386/stubs.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 2000 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:  * Copyright (c) 1997 by Apple Computer, Inc., all rights reserved
        !            24:  * Copyright (c) 1993 NeXT Computer, Inc.
        !            25:  *
        !            26:  */
        !            27: 
        !            28: #include <sys/param.h>
        !            29: #include <sys/systm.h>
        !            30: #include <sys/buf.h>
        !            31: #include <sys/ioctl.h>
        !            32: #include <sys/tty.h>
        !            33: #include <sys/conf.h>
        !            34: #include <sys/proc.h>
        !            35: #include <sys/user.h>
        !            36: #include <kern/task.h>
        !            37: #include <kern/thread.h>
        !            38: #include <kern/thread_act.h>
        !            39: #include <vm/vm_map.h>
        !            40: 
        !            41: 
        !            42: /* 
        !            43:  * copy a null terminated string from the kernel address space into
        !            44:  * the user address space.
        !            45:  *   - if the user is denied write access, return EFAULT.
        !            46:  *   - if the end of string isn't found before
        !            47:  *     maxlen bytes are copied,  return ENAMETOOLONG,
        !            48:  *     indicating an incomplete copy.
        !            49:  *   - otherwise, return 0, indicating success.
        !            50:  * the number of bytes copied is always returned in lencopied.
        !            51:  */
        !            52: int
        !            53: copyoutstr(from, to, maxlen, lencopied)
        !            54:     void * from, * to;
        !            55:     size_t maxlen, *lencopied;
        !            56: {
        !            57:        int slen,len,error=0;
        !            58: 
        !            59:        slen = strlen(from) + 1;
        !            60: 
        !            61:        len = min(maxlen,slen);
        !            62:        if (copyout(from, to, len))
        !            63:                error = EIO;
        !            64:        *lencopied = len;
        !            65: 
        !            66:        return error;
        !            67: }
        !            68: 
        !            69: 
        !            70: /* 
        !            71:  * copy a null terminated string from one point to another in 
        !            72:  * the kernel address space.
        !            73:  *   - no access checks are performed.
        !            74:  *   - if the end of string isn't found before
        !            75:  *     maxlen bytes are copied,  return ENAMETOOLONG,
        !            76:  *     indicating an incomplete copy.
        !            77:  *   - otherwise, return 0, indicating success.
        !            78:  * the number of bytes copied is always returned in lencopied.
        !            79:  */
        !            80: /* from ppc/fault_copy.c -Titan1T4 VERSION  */
        !            81: int
        !            82: copystr(vfrom, vto, maxlen, lencopied)
        !            83:     register void * vfrom, *vto;
        !            84:     size_t maxlen, *lencopied;
        !            85: {
        !            86:     register unsigned l;
        !            87:     int error;
        !            88: caddr_t from, to;
        !            89: 
        !            90:        from = vfrom;
        !            91:        to = vto;
        !            92:     for (l = 0; l < maxlen; l++)
        !            93:         if ((*to++ = *from++) == '\0') {
        !            94:             if (lencopied)
        !            95:                 *lencopied = l + 1;
        !            96:             return 0;
        !            97:         }
        !            98:     if (lencopied)
        !            99:        *lencopied = maxlen;
        !           100:     return ENAMETOOLONG;
        !           101: }
        !           102: 
        !           103: int copywithin(src, dst, count)
        !           104: void  * src, *dst;
        !           105: size_t count;
        !           106: {
        !           107:        bcopy(src,dst,count);
        !           108:        return 0;
        !           109: }
        !           110: 
        !           111: cpu_number() {return(0);}
        !           112: 
        !           113: set_bsduthreadargs(thread_t th, void * pcb, void *ignored_arg)
        !           114: {
        !           115: struct uthread * ut;
        !           116: 
        !           117:        ut = get_bsdthread_info(th);
        !           118:        ut->uu_ar0 = (int *)pcb;
        !           119: 
        !           120:        return(1);
        !           121: }
        !           122: 
        !           123: void *
        !           124: get_bsduthreadarg(thread_t th)
        !           125: {
        !           126: struct uthread *ut;
        !           127:        ut = get_bsdthread_info(th);
        !           128:        return((void *)(ut->uu_arg));
        !           129: }
        !           130: 
        !           131: int *
        !           132: get_bsduthreadrval(thread_act_t th)
        !           133: {
        !           134: struct uthread *ut;
        !           135:        ut = get_bsdthread_info(th);
        !           136:        return(&ut->uu_rval[0]);
        !           137: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.