Return to syscall_emulation.c CVS log

Up to [Apple XNU] / XNU / osfmk / kern

Annotation of XNU/osfmk/kern/syscall_emulation.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:  * @OSF_COPYRIGHT@
        !            24:  */
        !            25: /* 
        !            26:  * Mach Operating System
        !            27:  * Copyright (c) 1991,1990,1989,1988,1987 Carnegie Mellon University
        !            28:  * All Rights Reserved.
        !            29:  * 
        !            30:  * Permission to use, copy, modify and ditribute this software and its
        !            31:  * documentation is hereby granted, provided that both the copyright
        !            32:  * notice and this permission notice appear in all copies of the
        !            33:  * software, derivative works or modified versions, and any portions
        !            34:  * thereof, and that both notices appear in supporting documentation.
        !            35:  * 
        !            36:  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
        !            37:  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
        !            38:  * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
        !            39:  * 
        !            40:  * Carnegie Mellon requests users of this software to return to
        !            41:  * 
        !            42:  *  Software Distribution Coordinator  or  [email protected]
        !            43:  *  School of Computer Science
        !            44:  *  Carnegie Mellon University
        !            45:  *  Pittsburgh PA 15213-3890
        !            46:  * 
        !            47:  * any improvements or extensions that they make and grant Carnegie Mellon
        !            48:  * the rights to redistribute these changes.
        !            49:  */
        !            50: /*
        !            51:  */
        !            52: 
        !            53: #include <mach/error.h>
        !            54: #include <mach/vm_param.h>
        !            55: #include <mach/boolean.h>
        !            56: #include <kern/misc_protos.h>
        !            57: #include <kern/syscall_emulation.h>
        !            58: #include <kern/task.h>
        !            59: #include <kern/kalloc.h>
        !            60: #include <vm/vm_kern.h>
        !            61: #include <machine/thread.h>    /* for syscall_emulation_sync */
        !            62: 
        !            63: /*
        !            64:  * Exported interface
        !            65:  */
        !            66: 
        !            67: /*
        !            68:  * WARNING:
        !            69:  * This code knows that kalloc() allocates memory most efficiently
        !            70:  * in sizes that are powers of 2, and asks for those sizes.
        !            71:  */
        !            72: 
        !            73: /*
        !            74:  * Go from number of entries to size of struct eml_dispatch and back.
        !            75:  */
        !            76: #define        base_size       (sizeof(struct eml_dispatch) - sizeof(eml_routine_t))
        !            77: #define        count_to_size(count) \
        !            78:        (base_size + sizeof(vm_offset_t) * (count))
        !            79: 
        !            80: #define        size_to_count(size) \
        !            81:        ( ((size) - base_size) / sizeof(vm_offset_t) )
        !            82: 
        !            83: /* Forwards */
        !            84: kern_return_t
        !            85: task_set_emulation_vector_internal(
        !            86:        task_t                  task,
        !            87:        int                     vector_start,
        !            88:        emulation_vector_t      emulation_vector,
        !            89:        mach_msg_type_number_t  emulation_vector_count);
        !            90: 
        !            91: /*
        !            92:  *  eml_init:  initialize user space emulation code
        !            93:  */
        !            94: void
        !            95: eml_init(void)
        !            96: {
        !            97: }
        !            98: 
        !            99: /*
        !           100:  * eml_task_reference() [Exported]
        !           101:  *
        !           102:  *     Bumps the reference count on the common emulation
        !           103:  *     vector.
        !           104:  */
        !           105: 
        !           106: void
        !           107: eml_task_reference(
        !           108:        task_t  task,
        !           109:        task_t  parent)
        !           110: {
        !           111:        register eml_dispatch_t eml;
        !           112: 
        !           113:        if (parent == TASK_NULL)
        !           114:            eml = EML_DISPATCH_NULL;
        !           115:        else
        !           116:            eml = parent->eml_dispatch;
        !           117: 
        !           118:        if (eml != EML_DISPATCH_NULL) {
        !           119:            mutex_lock(&eml->lock);
        !           120:            eml->ref_count++;
        !           121:            mutex_unlock(&eml->lock);
        !           122:        }
        !           123:        task->eml_dispatch = eml;
        !           124: }
        !           125: 
        !           126: 
        !           127: /*
        !           128:  * eml_task_deallocate() [Exported]
        !           129:  *
        !           130:  *     Cleans up after the emulation code when a process exits.
        !           131:  */
        !           132:  
        !           133: void
        !           134: eml_task_deallocate(
        !           135:        task_t task)
        !           136: {
        !           137:        register eml_dispatch_t eml;
        !           138: 
        !           139:        eml = task->eml_dispatch;
        !           140:        if (eml != EML_DISPATCH_NULL) {
        !           141:            int count;
        !           142: 
        !           143:            mutex_lock(&eml->lock);
        !           144:            count = --eml->ref_count;
        !           145:            mutex_unlock(&eml->lock);
        !           146: 
        !           147:            if (count == 0)
        !           148:                kfree((vm_offset_t)eml, count_to_size(eml->disp_count));
        !           149: 
        !           150:            task->eml_dispatch = EML_DISPATCH_NULL;
        !           151:        }
        !           152: }
        !           153: 
        !           154: /*
        !           155:  *   task_set_emulation_vector:  [Server Entry]
        !           156:  *   set a list of emulated system calls for this task.
        !           157:  */
        !           158: kern_return_t
        !           159: task_set_emulation_vector_internal(
        !           160:        task_t                  task,
        !           161:        int                     vector_start,
        !           162:        emulation_vector_t      emulation_vector,
        !           163:        mach_msg_type_number_t  emulation_vector_count)
        !           164: {
        !           165:        eml_dispatch_t  cur_eml, new_eml, old_eml;
        !           166:        vm_size_t       new_size;
        !           167:        int             cur_start, cur_end;
        !           168:        int             new_start, new_end;
        !           169:        int             vector_end;
        !           170: 
        !           171:        if (task == TASK_NULL)
        !           172:                return EML_BAD_TASK;
        !           173: 
        !           174:        vector_end = vector_start + (int) emulation_vector_count;
        !           175: 
        !           176:        /*
        !           177:         * We try to re-use the existing emulation vetor
        !           178:         * if possible.  We can reuse the vector if it
        !           179:         * is not shared with another task and if it is
        !           180:         * large enough to contain the entries we are
        !           181:         * supplying.
        !           182:         *
        !           183:         * We must grab the lock on the task to check whether
        !           184:         * there is an emulation vector.
        !           185:         * If the vector is shared or not large enough, we
        !           186:         * need to drop the lock and allocate a new emulation
        !           187:         * vector.
        !           188:         *
        !           189:         * While the lock is dropped, the emulation vector
        !           190:         * may be released by all other tasks (giving us
        !           191:         * exclusive use), or may be enlarged by another
        !           192:         * task_set_emulation_vector call.  Therefore,
        !           193:         * after allocating the new emulation vector, we
        !           194:         * must grab the lock again to check whether we
        !           195:         * really need the new vector we just allocated.
        !           196:         *
        !           197:         * Since an emulation vector cannot be altered
        !           198:         * if it is in use by more than one task, the
        !           199:         * task lock is sufficient to protect the vector`s
        !           200:         * start, count, and contents.  The lock in the
        !           201:         * vector protects only the reference count.
        !           202:         */
        !           203: 
        !           204:        old_eml = EML_DISPATCH_NULL;    /* vector to discard */
        !           205:        new_eml = EML_DISPATCH_NULL;    /* new vector */
        !           206: 
        !           207:        for (;;) {
        !           208:            /*
        !           209:             * Find the current emulation vector.
        !           210:             * See whether we can overwrite it.
        !           211:             */
        !           212:            task_lock(task);
        !           213:            cur_eml = task->eml_dispatch;
        !           214:            if (cur_eml != EML_DISPATCH_NULL) {
        !           215:                cur_start = cur_eml->disp_min;
        !           216:                cur_end   = cur_eml->disp_count + cur_start;
        !           217: 
        !           218:                mutex_lock(&cur_eml->lock);
        !           219:                if (cur_eml->ref_count == 1 &&
        !           220:                    cur_start <= vector_start &&
        !           221:                    cur_end >= vector_end)
        !           222:                {
        !           223:                    /*
        !           224:                     * Can use the existing emulation vector.
        !           225:                     * Discard any new one we allocated.
        !           226:                     */
        !           227:                    mutex_unlock(&cur_eml->lock);
        !           228:                    old_eml = new_eml;
        !           229:                    break;
        !           230:                }
        !           231: 
        !           232:                if (new_eml != EML_DISPATCH_NULL &&
        !           233:                    new_start <= cur_start &&
        !           234:                    new_end >= cur_end)
        !           235:                {
        !           236:                    /*
        !           237:                     * A new vector was allocated, and it is large enough
        !           238:                     * to hold all the entries from the current vector.
        !           239:                     * Copy the entries to the new emulation vector,
        !           240:                     * deallocate the current one, and use the new one.
        !           241:                     */
        !           242:                    
        !           243:                    bcopy((char *)&cur_eml->disp_vector[0],
        !           244:                          (char *)&new_eml->disp_vector[cur_start-new_start],
        !           245:                          cur_eml->disp_count * sizeof(vm_offset_t));
        !           246: 
        !           247: 
        !           248:                    if (--cur_eml->ref_count == 0)
        !           249:                        old_eml = cur_eml;      /* discard old vector */
        !           250:                    mutex_unlock(&cur_eml->lock);
        !           251: 
        !           252:                    task->eml_dispatch = new_eml;
        !           253:                    syscall_emulation_sync(task);
        !           254:                    cur_eml = new_eml;
        !           255:                    break;
        !           256:                }
        !           257:                mutex_unlock(&cur_eml->lock);
        !           258: 
        !           259:                /*
        !           260:                 * Need a new emulation vector.
        !           261:                 * Ensure it will hold all the entries from
        !           262:                 * both the old and new emulation vectors.
        !           263:                 */
        !           264:                new_start = vector_start;
        !           265:                if (new_start > cur_start)
        !           266:                    new_start = cur_start;
        !           267:                new_end = vector_end;
        !           268:                if (new_end < cur_end)
        !           269:                    new_end = cur_end;
        !           270:            }
        !           271:            else {
        !           272:                /*
        !           273:                 * There is no curren emulation vector.
        !           274:                 * If a new one was allocated, use it.
        !           275:                 */
        !           276:                if (new_eml != EML_DISPATCH_NULL) {
        !           277:                    task->eml_dispatch = new_eml;
        !           278:                    cur_eml = new_eml;
        !           279:                    break;
        !           280:                }
        !           281: 
        !           282:                /*
        !           283:                 * Compute the size needed for the new vector.
        !           284:                 */
        !           285:                new_start = vector_start;
        !           286:                new_end = vector_end;
        !           287:            }
        !           288: 
        !           289:            /*
        !           290:             * Have no vector (or one that is no longer large enough).
        !           291:             * Drop all the locks and allocate a new vector.
        !           292:             * Repeat the loop to check whether the old vector was
        !           293:             * changed while we didn`t hold the locks.
        !           294:             */
        !           295: 
        !           296:            task_unlock(task);
        !           297: 
        !           298:            if (new_eml != EML_DISPATCH_NULL)
        !           299:                kfree((vm_offset_t)new_eml, count_to_size(new_eml->disp_count));
        !           300: 
        !           301:            new_size = count_to_size(new_end - new_start);
        !           302:            new_eml = (eml_dispatch_t) kalloc(new_size);
        !           303: 
        !           304:            bzero((char *)new_eml, new_size);
        !           305:            mutex_init(&new_eml->lock, ETAP_MISC_EMULATE);
        !           306:            new_eml->ref_count = 1;
        !           307:            new_eml->disp_min   = new_start;
        !           308:            new_eml->disp_count = new_end - new_start;
        !           309: 
        !           310:            continue;
        !           311:        }
        !           312: 
        !           313:        /*
        !           314:         * We have the emulation vector.
        !           315:         * Install the new emulation entries.
        !           316:         */
        !           317:        bcopy((char *)&emulation_vector[0],
        !           318:              (char *)&cur_eml->disp_vector[vector_start - cur_eml->disp_min],
        !           319:              emulation_vector_count * sizeof(vm_offset_t));
        !           320: 
        !           321:        task_unlock(task);
        !           322: 
        !           323:        /*
        !           324:         * Discard any old emulation vector we don`t need.
        !           325:         */
        !           326:        if (old_eml)
        !           327:            kfree((vm_offset_t) old_eml, count_to_size(old_eml->disp_count));
        !           328: 
        !           329:        return KERN_SUCCESS;
        !           330: }
        !           331: 
        !           332: /*
        !           333:  *     task_set_emulation_vector:  [Server Entry]
        !           334:  *
        !           335:  *     Set the list of emulated system calls for this task.
        !           336:  *     The list is out-of-line.
        !           337:  */
        !           338: kern_return_t
        !           339: task_set_emulation_vector(
        !           340:        task_t                  task,
        !           341:        int                     vector_start,
        !           342:        emulation_vector_t      emulation_vector,
        !           343:        mach_msg_type_number_t  emulation_vector_count)
        !           344: {
        !           345:        kern_return_t           kr;
        !           346:        vm_offset_t             emul_vector_addr;
        !           347: 
        !           348:        if (task == TASK_NULL)
        !           349:            return EML_BAD_TASK;        /* XXX sb KERN_INVALID_ARGUMENT */
        !           350: 
        !           351:        /*
        !           352:         * XXX - [email protected].
        !           353:         * If emulation_vector_count is NULL, discard the emulation
        !           354:         * vectors.
        !           355:         * We need a way to do that for emulator-less servers started
        !           356:         * from a classic server. There seems to be no way to get rid
        !           357:         * of or to avoid inheriting the emulation vector !?
        !           358:         */
        !           359:        if (emulation_vector_count == 0) {
        !           360:                eml_task_deallocate(task);
        !           361:                return KERN_SUCCESS;
        !           362:        }
        !           363: 
        !           364: 
        !           365:        /*
        !           366:         *      The emulation vector is really a vm_map_copy_t.
        !           367:         */
        !           368:        kr = vm_map_copyout(ipc_kernel_map, &emul_vector_addr,
        !           369:                        (vm_map_copy_t) emulation_vector);
        !           370:        if (kr != KERN_SUCCESS)
        !           371:            return kr;
        !           372: 
        !           373:        /*
        !           374:         *      Can't fault while we hold locks.
        !           375:         */
        !           376:        kr = vm_map_wire(ipc_kernel_map,
        !           377:                             trunc_page(emul_vector_addr),
        !           378:                             round_page(emul_vector_addr +
        !           379:                                        emulation_vector_count *
        !           380:                                        sizeof(eml_dispatch_t)),
        !           381:                             VM_PROT_READ|VM_PROT_WRITE, FALSE);
        !           382:        assert(kr == KERN_SUCCESS);
        !           383: 
        !           384:        /*
        !           385:         *      Do the work.
        !           386:         */
        !           387:        kr = task_set_emulation_vector_internal(
        !           388:                        task,
        !           389:                        vector_start,
        !           390:                        (emulation_vector_t) emul_vector_addr,
        !           391:                        emulation_vector_count);
        !           392:        assert(kr == KERN_SUCCESS);
        !           393: 
        !           394:        /*
        !           395:         *      Discard the memory
        !           396:         */
        !           397:        (void) kmem_free(ipc_kernel_map,
        !           398:                         emul_vector_addr,
        !           399:                         emulation_vector_count * sizeof(eml_dispatch_t));
        !           400: 
        !           401:        return KERN_SUCCESS;
        !           402: }
        !           403: 
        !           404: /*
        !           405:  *     task_get_emulation_vector: [Server Entry]
        !           406:  *
        !           407:  *     Get the list of emulated system calls for this task.
        !           408:  *     List is returned out-of-line.
        !           409:  */
        !           410: kern_return_t
        !           411: task_get_emulation_vector(
        !           412:        task_t                  task,
        !           413:        int                     *vector_start,                  /* out */
        !           414:        emulation_vector_t      *emulation_vector,              /* out */
        !           415:        mach_msg_type_number_t  *emulation_vector_count)        /* out */
        !           416: {
        !           417:        eml_dispatch_t          eml;
        !           418:        vm_size_t               vector_size, size;
        !           419:        vm_offset_t             addr;
        !           420: 
        !           421:        if (task == TASK_NULL)
        !           422:            return EML_BAD_TASK;
        !           423: 
        !           424:        addr = 0;
        !           425:        size = 0;
        !           426: 
        !           427:        for(;;) {
        !           428:            vm_size_t   size_needed;
        !           429: 
        !           430:            task_lock(task);
        !           431:            eml = task->eml_dispatch;
        !           432:            if (eml == EML_DISPATCH_NULL) {
        !           433:                task_unlock(task);
        !           434:                if (addr)
        !           435:                    (void) kmem_free(ipc_kernel_map, addr, size);
        !           436:                *vector_start = 0;
        !           437:                *emulation_vector = 0;
        !           438:                *emulation_vector_count = 0;
        !           439:                return KERN_SUCCESS;
        !           440:            }
        !           441: 
        !           442:            /*
        !           443:             * Do we have the memory we need?
        !           444:             */
        !           445:            vector_size = eml->disp_count * sizeof(vm_offset_t);
        !           446: 
        !           447:            size_needed = round_page(vector_size);
        !           448:            if (size_needed <= size)
        !           449:                break;
        !           450: 
        !           451:            /*
        !           452:             * If not, unlock the task and allocate more memory.
        !           453:             */
        !           454:            task_unlock(task);
        !           455: 
        !           456:            if (size != 0)
        !           457:                kmem_free(ipc_kernel_map, addr, size);
        !           458: 
        !           459:            size = size_needed;
        !           460:            if (kmem_alloc(ipc_kernel_map, &addr, size) != KERN_SUCCESS)
        !           461:                return KERN_RESOURCE_SHORTAGE;
        !           462:        }
        !           463: 
        !           464:        /*
        !           465:         * Copy out the dispatch addresses
        !           466:         */
        !           467:        *vector_start = eml->disp_min;
        !           468:        *emulation_vector_count = eml->disp_count;
        !           469:        bcopy((char *)eml->disp_vector,
        !           470:              (char *)addr,
        !           471:              vector_size);
        !           472: 
        !           473:        /*
        !           474:         * Unlock the task and free any memory we did not need
        !           475:         */
        !           476:        task_unlock(task);
        !           477:     {
        !           478:        vm_size_t       size_used, size_left;
        !           479:        vm_map_copy_t   memory;
        !           480: 
        !           481:        /*
        !           482:         * Free any unused memory beyond the end of the last page used
        !           483:         */
        !           484:        size_used = round_page(vector_size);
        !           485:        if (size_used != size)
        !           486:            (void) kmem_free(ipc_kernel_map,
        !           487:                             addr + size_used,
        !           488:                             size - size_used);
        !           489: 
        !           490:        /*
        !           491:         * Zero the remainder of the page being returned.
        !           492:         */
        !           493:        size_left = size_used - vector_size;
        !           494:        if (size_left > 0)
        !           495:            bzero((char *)addr + vector_size, size_left);
        !           496: 
        !           497:        /*
        !           498:         * Unwire and make memory into copyin form.
        !           499:         */
        !           500:        (void) vm_map_unwire(ipc_kernel_map, addr, addr + size_used, FALSE);
        !           501:        (void) vm_map_copyin(ipc_kernel_map, addr, vector_size,
        !           502:                             TRUE, &memory);
        !           503: 
        !           504:        *emulation_vector = (emulation_vector_t) memory;
        !           505:     }
        !           506: 
        !           507:        return KERN_SUCCESS;
        !           508: }
        !           509: 
        !           510: /*
        !           511:  *   task_set_emulation:  [Server Entry]
        !           512:  *   set up for user space emulation of syscalls within this task.
        !           513:  */
        !           514: kern_return_t
        !           515: task_set_emulation(
        !           516:        task_t          task,
        !           517:        vm_offset_t     routine_entry_pt,
        !           518:        int             routine_number)
        !           519: {
        !           520:        return task_set_emulation_vector_internal(task, routine_number,
        !           521:                                         &routine_entry_pt, 1);
        !           522: }
        !           523: 
        !           524: 
        !           525: 
        !           526: 

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