Return to mach_port.c CVS log

Up to [GnuMach] / Gnu-Mach / ipc

Annotation of Gnu-Mach/ipc/mach_port.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Mach Operating System
        !             3:  * Copyright (c) 1991,1990,1989 Carnegie Mellon University.
        !             4:  * Copyright (c) 1993,1994 The University of Utah and
        !             5:  * the Computer Systems Laboratory (CSL).
        !             6:  * All rights reserved.
        !             7:  *
        !             8:  * Permission to use, copy, modify and distribute this software and its
        !             9:  * documentation is hereby granted, provided that both the copyright
        !            10:  * notice and this permission notice appear in all copies of the
        !            11:  * software, derivative works or modified versions, and any portions
        !            12:  * thereof, and that both notices appear in supporting documentation.
        !            13:  *
        !            14:  * CARNEGIE MELLON, THE UNIVERSITY OF UTAH AND CSL ALLOW FREE USE OF
        !            15:  * THIS SOFTWARE IN ITS "AS IS" CONDITION, AND DISCLAIM ANY LIABILITY
        !            16:  * OF ANY KIND FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF
        !            17:  * THIS SOFTWARE.
        !            18:  *
        !            19:  * Carnegie Mellon requests users of this software to return to
        !            20:  *
        !            21:  *  Software Distribution Coordinator  or  [email protected]
        !            22:  *  School of Computer Science
        !            23:  *  Carnegie Mellon University
        !            24:  *  Pittsburgh PA 15213-3890
        !            25:  *
        !            26:  * any improvements or extensions that they make and grant Carnegie Mellon
        !            27:  * the rights to redistribute these changes.
        !            28:  */
        !            29: /*
        !            30:  */
        !            31: /*
        !            32:  *     File:   ipc/mach_port.c
        !            33:  *     Author: Rich Draves
        !            34:  *     Date:   1989
        !            35:  *
        !            36:  *     Exported kernel calls.  See mach/mach_port.defs.
        !            37:  */
        !            38: 
        !            39: #include <mach_ipc_compat.h>
        !            40: 
        !            41: #include <mach/port.h>
        !            42: #include <mach/kern_return.h>
        !            43: #include <mach/notify.h>
        !            44: #include <mach/mach_param.h>
        !            45: #include <mach/vm_param.h>
        !            46: #include <mach/vm_prot.h>
        !            47: #ifdef MIGRATING_THREADS
        !            48: #include <mach/rpc.h>
        !            49: #include <kern/task.h>
        !            50: #include <kern/act.h>
        !            51: #endif /* MIGRATING_THREADS */
        !            52: #include <vm/vm_map.h>
        !            53: #include <vm/vm_kern.h>
        !            54: #include <vm/vm_user.h>
        !            55: #include <ipc/ipc_entry.h>
        !            56: #include <ipc/ipc_space.h>
        !            57: #include <ipc/ipc_object.h>
        !            58: #include <ipc/ipc_notify.h>
        !            59: #include <ipc/ipc_port.h>
        !            60: #include <ipc/ipc_pset.h>
        !            61: #include <ipc/ipc_right.h>
        !            62: 
        !            63: 
        !            64: 
        !            65: /*
        !            66:  *     Routine:        mach_port_names_helper
        !            67:  *     Purpose:
        !            68:  *             A helper function for mach_port_names.
        !            69:  */
        !            70: 
        !            71: void
        !            72: mach_port_names_helper(
        !            73:        ipc_port_timestamp_t    timestamp,
        !            74:        ipc_entry_t             entry,
        !            75:        mach_port_t             name,
        !            76:        mach_port_t             *names,
        !            77:        mach_port_type_t        *types,
        !            78:        ipc_entry_num_t         *actualp)
        !            79: {
        !            80:        ipc_entry_bits_t bits = entry->ie_bits;
        !            81:        ipc_port_request_index_t request = entry->ie_request;
        !            82:        mach_port_type_t type;
        !            83:        ipc_entry_num_t actual;
        !            84: 
        !            85:        if (bits & MACH_PORT_TYPE_SEND_RIGHTS) {
        !            86:                ipc_port_t port;
        !            87:                boolean_t died;
        !            88: 
        !            89:                port = (ipc_port_t) entry->ie_object;
        !            90:                assert(port != IP_NULL);
        !            91: 
        !            92:                /*
        !            93:                 *      The timestamp serializes mach_port_names
        !            94:                 *      with ipc_port_destroy.  If the port died,
        !            95:                 *      but after mach_port_names started, pretend
        !            96:                 *      that it isn't dead.
        !            97:                 */
        !            98: 
        !            99:                ip_lock(port);
        !           100:                died = (!ip_active(port) &&
        !           101:                        IP_TIMESTAMP_ORDER(port->ip_timestamp, timestamp));
        !           102:                ip_unlock(port);
        !           103: 
        !           104:                if (died) {
        !           105: #if    MACH_IPC_COMPAT
        !           106:                        if (bits & IE_BITS_COMPAT)
        !           107:                                return;
        !           108: #endif MACH_IPC_COMPAT
        !           109: 
        !           110:                        /* pretend this is a dead-name entry */
        !           111: 
        !           112:                        bits &= ~(IE_BITS_TYPE_MASK|IE_BITS_MAREQUEST);
        !           113:                        bits |= MACH_PORT_TYPE_DEAD_NAME;
        !           114:                        if (request != 0)
        !           115:                                bits++;
        !           116:                        request = 0;
        !           117:                }
        !           118:        }
        !           119: 
        !           120:        type = IE_BITS_TYPE(bits);
        !           121: #if    MACH_IPC_COMPAT
        !           122:        if (bits & IE_BITS_COMPAT)
        !           123:                type |= MACH_PORT_TYPE_COMPAT;
        !           124:        else
        !           125: #endif MACH_IPC_COMPAT
        !           126:        if (request != 0)
        !           127:                type |= MACH_PORT_TYPE_DNREQUEST;
        !           128:        if (bits & IE_BITS_MAREQUEST)
        !           129:                type |= MACH_PORT_TYPE_MAREQUEST;
        !           130: 
        !           131:        actual = *actualp;
        !           132:        names[actual] = name;
        !           133:        types[actual] = type;
        !           134:        *actualp = actual+1;
        !           135: }
        !           136: 
        !           137: /*
        !           138:  *     Routine:        mach_port_names [kernel call]
        !           139:  *     Purpose:
        !           140:  *             Retrieves a list of the rights present in the space,
        !           141:  *             along with type information.  (Same as returned
        !           142:  *             by mach_port_type.)  The names are returned in
        !           143:  *             no particular order, but they (and the type info)
        !           144:  *             are an accurate snapshot of the space.
        !           145:  *     Conditions:
        !           146:  *             Nothing locked.
        !           147:  *     Returns:
        !           148:  *             KERN_SUCCESS            Arrays of names and types returned.
        !           149:  *             KERN_INVALID_TASK       The space is null.
        !           150:  *             KERN_INVALID_TASK       The space is dead.
        !           151:  *             KERN_RESOURCE_SHORTAGE  Couldn't allocate memory.
        !           152:  */
        !           153: 
        !           154: kern_return_t
        !           155: mach_port_names(
        !           156:        ipc_space_t             space,
        !           157:        mach_port_t             **namesp,
        !           158:        mach_msg_type_number_t  *namesCnt,
        !           159:        mach_port_type_t        **typesp,
        !           160:        mach_msg_type_number_t  *typesCnt)
        !           161: {
        !           162:        ipc_tree_entry_t tentry;
        !           163:        ipc_entry_t table;
        !           164:        ipc_entry_num_t tsize;
        !           165:        mach_port_index_t index;
        !           166:        ipc_entry_num_t actual; /* this many names */
        !           167:        ipc_port_timestamp_t timestamp; /* logical time of this operation */
        !           168:        mach_port_t *names;
        !           169:        mach_port_type_t *types;
        !           170:        kern_return_t kr;
        !           171: 
        !           172:        vm_size_t size;         /* size of allocated memory */
        !           173:        vm_offset_t addr1;      /* allocated memory, for names */
        !           174:        vm_offset_t addr2;      /* allocated memory, for types */
        !           175:        vm_map_copy_t memory1;  /* copied-in memory, for names */
        !           176:        vm_map_copy_t memory2;  /* copied-in memory, for types */
        !           177: 
        !           178:        /* safe simplifying assumption */
        !           179:        assert_static(sizeof(mach_port_t) == sizeof(mach_port_type_t));
        !           180: 
        !           181:        if (space == IS_NULL)
        !           182:                return KERN_INVALID_TASK;
        !           183: 
        !           184:        size = 0;
        !           185: 
        !           186:        for (;;) {
        !           187:                ipc_entry_num_t bound;
        !           188:                vm_size_t size_needed;
        !           189: 
        !           190:                is_read_lock(space);
        !           191:                if (!space->is_active) {
        !           192:                        is_read_unlock(space);
        !           193:                        if (size != 0) {
        !           194:                                kmem_free(ipc_kernel_map, addr1, size);
        !           195:                                kmem_free(ipc_kernel_map, addr2, size);
        !           196:                        }
        !           197:                        return KERN_INVALID_TASK;
        !           198:                }
        !           199: 
        !           200:                /* upper bound on number of names in the space */
        !           201: 
        !           202:                bound = space->is_table_size + space->is_tree_total;
        !           203:                size_needed = round_page(bound * sizeof(mach_port_t));
        !           204: 
        !           205:                if (size_needed <= size)
        !           206:                        break;
        !           207: 
        !           208:                is_read_unlock(space);
        !           209: 
        !           210:                if (size != 0) {
        !           211:                        kmem_free(ipc_kernel_map, addr1, size);
        !           212:                        kmem_free(ipc_kernel_map, addr2, size);
        !           213:                }
        !           214:                size = size_needed;
        !           215: 
        !           216:                kr = vm_allocate(ipc_kernel_map, &addr1, size, TRUE);
        !           217:                if (kr != KERN_SUCCESS)
        !           218:                        return KERN_RESOURCE_SHORTAGE;
        !           219: 
        !           220:                kr = vm_allocate(ipc_kernel_map, &addr2, size, TRUE);
        !           221:                if (kr != KERN_SUCCESS) {
        !           222:                        kmem_free(ipc_kernel_map, addr1, size);
        !           223:                        return KERN_RESOURCE_SHORTAGE;
        !           224:                }
        !           225: 
        !           226:                /* can't fault while we hold locks */
        !           227: 
        !           228:                kr = vm_map_pageable(ipc_kernel_map, addr1, addr1 + size,
        !           229:                                     VM_PROT_READ|VM_PROT_WRITE);
        !           230:                assert(kr == KERN_SUCCESS);
        !           231: 
        !           232:                kr = vm_map_pageable(ipc_kernel_map, addr2, addr2 + size,
        !           233:                                     VM_PROT_READ|VM_PROT_WRITE);
        !           234:                assert(kr == KERN_SUCCESS);
        !           235:        }
        !           236:        /* space is read-locked and active */
        !           237: 
        !           238:        names = (mach_port_t *) addr1;
        !           239:        types = (mach_port_type_t *) addr2;
        !           240:        actual = 0;
        !           241: 
        !           242:        timestamp = ipc_port_timestamp();
        !           243: 
        !           244:        table = space->is_table;
        !           245:        tsize = space->is_table_size;
        !           246: 
        !           247:        for (index = 0; index < tsize; index++) {
        !           248:                ipc_entry_t entry = &table[index];
        !           249:                ipc_entry_bits_t bits = entry->ie_bits;
        !           250: 
        !           251:                if (IE_BITS_TYPE(bits) != MACH_PORT_TYPE_NONE) {
        !           252:                        mach_port_t name = MACH_PORT_MAKEB(index, bits);
        !           253: 
        !           254:                        mach_port_names_helper(timestamp, entry, name,
        !           255:                                               names, types, &actual);
        !           256:                }
        !           257:        }
        !           258: 
        !           259:        for (tentry = ipc_splay_traverse_start(&space->is_tree);
        !           260:             tentry != ITE_NULL;
        !           261:             tentry = ipc_splay_traverse_next(&space->is_tree, FALSE)) {
        !           262:                ipc_entry_t entry = &tentry->ite_entry;
        !           263:                mach_port_t name = tentry->ite_name;
        !           264: 
        !           265:                assert(IE_BITS_TYPE(tentry->ite_bits) != MACH_PORT_TYPE_NONE);
        !           266: 
        !           267:                mach_port_names_helper(timestamp, entry, name,
        !           268:                                       names, types, &actual);
        !           269:        }
        !           270:        ipc_splay_traverse_finish(&space->is_tree);
        !           271:        is_read_unlock(space);
        !           272: 
        !           273:        if (actual == 0) {
        !           274:                memory1 = VM_MAP_COPY_NULL;
        !           275:                memory2 = VM_MAP_COPY_NULL;
        !           276: 
        !           277:                if (size != 0) {
        !           278:                        kmem_free(ipc_kernel_map, addr1, size);
        !           279:                        kmem_free(ipc_kernel_map, addr2, size);
        !           280:                }
        !           281:        } else {
        !           282:                vm_size_t size_used;
        !           283: 
        !           284:                size_used = round_page(actual * sizeof(mach_port_t));
        !           285: 
        !           286:                /*
        !           287:                 *      Make used memory pageable and get it into
        !           288:                 *      copied-in form.  Free any unused memory.
        !           289:                 */
        !           290: 
        !           291:                kr = vm_map_pageable(ipc_kernel_map,
        !           292:                                     addr1, addr1 + size_used,
        !           293:                                     VM_PROT_NONE);
        !           294:                assert(kr == KERN_SUCCESS);
        !           295: 
        !           296:                kr = vm_map_pageable(ipc_kernel_map,
        !           297:                                     addr2, addr2 + size_used,
        !           298:                                     VM_PROT_NONE);
        !           299:                assert(kr == KERN_SUCCESS);
        !           300: 
        !           301:                kr = vm_map_copyin(ipc_kernel_map, addr1, size_used,
        !           302:                                   TRUE, &memory1);
        !           303:                assert(kr == KERN_SUCCESS);
        !           304: 
        !           305:                kr = vm_map_copyin(ipc_kernel_map, addr2, size_used,
        !           306:                                   TRUE, &memory2);
        !           307:                assert(kr == KERN_SUCCESS);
        !           308: 
        !           309:                if (size_used != size) {
        !           310:                        kmem_free(ipc_kernel_map,
        !           311:                                  addr1 + size_used, size - size_used);
        !           312:                        kmem_free(ipc_kernel_map,
        !           313:                                  addr2 + size_used, size - size_used);
        !           314:                }
        !           315:        }
        !           316: 
        !           317:        *namesp = (mach_port_t *) memory1;
        !           318:        *namesCnt = actual;
        !           319:        *typesp = (mach_port_type_t *) memory2;
        !           320:        *typesCnt = actual;
        !           321:        return KERN_SUCCESS;
        !           322: }
        !           323: 
        !           324: /*
        !           325:  *     Routine:        mach_port_type [kernel call]
        !           326:  *     Purpose:
        !           327:  *             Retrieves the type of a right in the space.
        !           328:  *             The type is a bitwise combination of one or more
        !           329:  *             of the following type bits:
        !           330:  *                     MACH_PORT_TYPE_SEND
        !           331:  *                     MACH_PORT_TYPE_RECEIVE
        !           332:  *                     MACH_PORT_TYPE_SEND_ONCE
        !           333:  *                     MACH_PORT_TYPE_PORT_SET
        !           334:  *                     MACH_PORT_TYPE_DEAD_NAME
        !           335:  *             In addition, the following pseudo-type bits may be present:
        !           336:  *                     MACH_PORT_TYPE_DNREQUEST
        !           337:  *                             A dead-name notification is requested.
        !           338:  *                     MACH_PORT_TYPE_MAREQUEST
        !           339:  *                             The send/receive right is blocked;
        !           340:  *                             a msg-accepted notification is outstanding.
        !           341:  *                     MACH_PORT_TYPE_COMPAT
        !           342:  *                             This is a compatibility-mode right;
        !           343:  *                             when the port dies, it will disappear
        !           344:  *                             instead of turning into a dead-name.
        !           345:  *     Conditions:
        !           346:  *             Nothing locked.
        !           347:  *     Returns:
        !           348:  *             KERN_SUCCESS            Type is returned.
        !           349:  *             KERN_INVALID_TASK       The space is null.
        !           350:  *             KERN_INVALID_TASK       The space is dead.
        !           351:  *             KERN_INVALID_NAME       The name doesn't denote a right.
        !           352:  */
        !           353: 
        !           354: kern_return_t
        !           355: mach_port_type(
        !           356:        ipc_space_t             space,
        !           357:        mach_port_t             name,
        !           358:        mach_port_type_t        *typep)
        !           359: {
        !           360:        mach_port_urefs_t urefs;
        !           361:        ipc_entry_t entry;
        !           362:        kern_return_t kr;
        !           363: 
        !           364:        if (space == IS_NULL)
        !           365:                return KERN_INVALID_TASK;
        !           366: 
        !           367:        kr = ipc_right_lookup_write(space, name, &entry);
        !           368:        if (kr != KERN_SUCCESS)
        !           369:                return kr;
        !           370:        /* space is write-locked and active */
        !           371: 
        !           372:        kr = ipc_right_info(space, name, entry, typep, &urefs);
        !           373:        if (kr == KERN_SUCCESS)
        !           374:                is_write_unlock(space);
        !           375:        /* space is unlocked */
        !           376:        return kr;
        !           377: }
        !           378: 
        !           379: /*
        !           380:  *     Routine:        mach_port_rename [kernel call]
        !           381:  *     Purpose:
        !           382:  *             Changes the name denoting a right,
        !           383:  *             from oname to nname.
        !           384:  *     Conditions:
        !           385:  *             Nothing locked.
        !           386:  *     Returns:
        !           387:  *             KERN_SUCCESS            The right is renamed.
        !           388:  *             KERN_INVALID_TASK       The space is null.
        !           389:  *             KERN_INVALID_TASK       The space is dead.
        !           390:  *             KERN_INVALID_NAME       The oname doesn't denote a right.
        !           391:  *             KERN_INVALID_VALUE      The nname isn't a legal name.
        !           392:  *             KERN_NAME_EXISTS        The nname already denotes a right.
        !           393:  *             KERN_RESOURCE_SHORTAGE  Couldn't allocate memory.
        !           394:  */
        !           395: 
        !           396: kern_return_t
        !           397: mach_port_rename(
        !           398:        ipc_space_t     space,
        !           399:        mach_port_t     oname,
        !           400:        mach_port_t     nname)
        !           401: {
        !           402:        if (space == IS_NULL)
        !           403:                return KERN_INVALID_TASK;
        !           404: 
        !           405:        if (!MACH_PORT_VALID(nname))
        !           406:                return KERN_INVALID_VALUE;
        !           407: 
        !           408:        return ipc_object_rename(space, oname, nname);
        !           409: }
        !           410: 
        !           411: /*
        !           412:  *     Routine:        mach_port_allocate_name [kernel call]
        !           413:  *     Purpose:
        !           414:  *             Allocates a right in a space, using a specific name
        !           415:  *             for the new right.  Possible rights:
        !           416:  *                     MACH_PORT_RIGHT_RECEIVE
        !           417:  *                     MACH_PORT_RIGHT_PORT_SET
        !           418:  *                     MACH_PORT_RIGHT_DEAD_NAME
        !           419:  *
        !           420:  *             A new port (allocated with MACH_PORT_RIGHT_RECEIVE)
        !           421:  *             has no extant send or send-once rights and no queued
        !           422:  *             messages.  Its queue limit is MACH_PORT_QLIMIT_DEFAULT
        !           423:  *             and its make-send count is 0.  It is not a member of
        !           424:  *             a port set.  It has no registered no-senders or
        !           425:  *             port-destroyed notification requests.
        !           426:  *
        !           427:  *             A new port set has no members.
        !           428:  *
        !           429:  *             A new dead name has one user reference.
        !           430:  *     Conditions:
        !           431:  *             Nothing locked.
        !           432:  *     Returns:
        !           433:  *             KERN_SUCCESS            The right is allocated.
        !           434:  *             KERN_INVALID_TASK       The space is null.
        !           435:  *             KERN_INVALID_TASK       The space is dead.
        !           436:  *             KERN_INVALID_VALUE      The name isn't a legal name.
        !           437:  *             KERN_INVALID_VALUE      "right" isn't a legal kind of right.
        !           438:  *             KERN_NAME_EXISTS        The name already denotes a right.
        !           439:  *             KERN_RESOURCE_SHORTAGE  Couldn't allocate memory.
        !           440:  */
        !           441: 
        !           442: kern_return_t
        !           443: mach_port_allocate_name(space, right, name)
        !           444:        ipc_space_t space;
        !           445:        mach_port_right_t right;
        !           446:        mach_port_t name;
        !           447: {
        !           448:        kern_return_t kr;
        !           449: 
        !           450:        if (space == IS_NULL)
        !           451:                return KERN_INVALID_TASK;
        !           452: 
        !           453:        if (!MACH_PORT_VALID(name))
        !           454:                return KERN_INVALID_VALUE;
        !           455: 
        !           456:        switch (right) {
        !           457:            case MACH_PORT_RIGHT_RECEIVE: {
        !           458:                ipc_port_t port;
        !           459: 
        !           460:                kr = ipc_port_alloc_name(space, name, &port);
        !           461:                if (kr == KERN_SUCCESS)
        !           462:                        ip_unlock(port);
        !           463:                break;
        !           464:            }
        !           465: 
        !           466:            case MACH_PORT_RIGHT_PORT_SET: {
        !           467:                ipc_pset_t pset;
        !           468: 
        !           469:                kr = ipc_pset_alloc_name(space, name, &pset);
        !           470:                if (kr == KERN_SUCCESS)
        !           471:                        ips_unlock(pset);
        !           472:                break;
        !           473:            }
        !           474: 
        !           475:            case MACH_PORT_RIGHT_DEAD_NAME:
        !           476:                kr = ipc_object_alloc_dead_name(space, name);
        !           477:                break;
        !           478: 
        !           479:            default:
        !           480:                kr = KERN_INVALID_VALUE;
        !           481:                break;
        !           482:        }
        !           483: 
        !           484:        return kr;
        !           485: }
        !           486: 
        !           487: /*
        !           488:  *     Routine:        mach_port_allocate [kernel call]
        !           489:  *     Purpose:
        !           490:  *             Allocates a right in a space.  Like mach_port_allocate_name,
        !           491:  *             except that the implementation picks a name for the right.
        !           492:  *             The name may be any legal name in the space that doesn't
        !           493:  *             currently denote a right.
        !           494:  *     Conditions:
        !           495:  *             Nothing locked.
        !           496:  *     Returns:
        !           497:  *             KERN_SUCCESS            The right is allocated.
        !           498:  *             KERN_INVALID_TASK       The space is null.
        !           499:  *             KERN_INVALID_TASK       The space is dead.
        !           500:  *             KERN_INVALID_VALUE      "right" isn't a legal kind of right.
        !           501:  *             KERN_RESOURCE_SHORTAGE  Couldn't allocate memory.
        !           502:  *             KERN_NO_SPACE           No room in space for another right.
        !           503:  */
        !           504: 
        !           505: kern_return_t
        !           506: mach_port_allocate(space, right, namep)
        !           507:        ipc_space_t space;
        !           508:        mach_port_right_t right;
        !           509:        mach_port_t *namep;
        !           510: {
        !           511:        kern_return_t kr;
        !           512: 
        !           513:        if (space == IS_NULL)
        !           514:                return KERN_INVALID_TASK;
        !           515: 
        !           516:        switch (right) {
        !           517:            case MACH_PORT_RIGHT_RECEIVE: {
        !           518:                ipc_port_t port;
        !           519: 
        !           520:                kr = ipc_port_alloc(space, namep, &port);
        !           521:                if (kr == KERN_SUCCESS)
        !           522:                        ip_unlock(port);
        !           523:                break;
        !           524:            }
        !           525: 
        !           526:            case MACH_PORT_RIGHT_PORT_SET: {
        !           527:                ipc_pset_t pset;
        !           528: 
        !           529:                kr = ipc_pset_alloc(space, namep, &pset);
        !           530:                if (kr == KERN_SUCCESS)
        !           531:                        ips_unlock(pset);
        !           532:                break;
        !           533:            }
        !           534: 
        !           535:            case MACH_PORT_RIGHT_DEAD_NAME:
        !           536:                kr = ipc_object_alloc_dead(space, namep);
        !           537:                break;
        !           538: 
        !           539:            default:
        !           540:                kr = KERN_INVALID_VALUE;
        !           541:                break;
        !           542:        }
        !           543: 
        !           544:        return (kr);
        !           545: }
        !           546: 
        !           547: /*
        !           548:  *     Routine:        mach_port_destroy [kernel call]
        !           549:  *     Purpose:
        !           550:  *             Cleans up and destroys all rights denoted by a name
        !           551:  *             in a space.  The destruction of a receive right
        !           552:  *             destroys the port, unless a port-destroyed request
        !           553:  *             has been made for it; the destruction of a port-set right
        !           554:  *             destroys the port set.
        !           555:  *     Conditions:
        !           556:  *             Nothing locked.
        !           557:  *     Returns:
        !           558:  *             KERN_SUCCESS            The name is destroyed.
        !           559:  *             KERN_INVALID_TASK       The space is null.
        !           560:  *             KERN_INVALID_TASK       The space is dead.
        !           561:  *             KERN_INVALID_NAME       The name doesn't denote a right.
        !           562:  */
        !           563: 
        !           564: kern_return_t
        !           565: mach_port_destroy(
        !           566:        ipc_space_t     space,
        !           567:        mach_port_t     name)
        !           568: {
        !           569:        ipc_entry_t entry;
        !           570:        kern_return_t kr;
        !           571: 
        !           572:        if (space == IS_NULL)
        !           573:                return KERN_INVALID_TASK;
        !           574: 
        !           575:        kr = ipc_right_lookup_write(space, name, &entry);
        !           576:        if (kr != KERN_SUCCESS)
        !           577:                return kr;
        !           578:        /* space is write-locked and active */
        !           579: 
        !           580:        kr = ipc_right_destroy(space, name, entry); /* unlocks space */
        !           581:        return kr;
        !           582: }
        !           583: 
        !           584: /*
        !           585:  *     Routine:        mach_port_deallocate [kernel call]
        !           586:  *     Purpose:
        !           587:  *             Deallocates a user reference from a send right,
        !           588:  *             send-once right, or a dead-name right.  May
        !           589:  *             deallocate the right, if this is the last uref,
        !           590:  *             and destroy the name, if it doesn't denote
        !           591:  *             other rights.
        !           592:  *     Conditions:
        !           593:  *             Nothing locked.
        !           594:  *     Returns:
        !           595:  *             KERN_SUCCESS            The uref is deallocated.
        !           596:  *             KERN_INVALID_TASK       The space is null.
        !           597:  *             KERN_INVALID_TASK       The space is dead.
        !           598:  *             KERN_INVALID_NAME       The name doesn't denote a right.
        !           599:  *             KERN_INVALID_RIGHT      The right isn't correct.
        !           600:  */
        !           601: 
        !           602: kern_return_t
        !           603: mach_port_deallocate(
        !           604:        ipc_space_t     space,
        !           605:        mach_port_t     name)
        !           606: {
        !           607:        ipc_entry_t entry;
        !           608:        kern_return_t kr;
        !           609: 
        !           610:        if (space == IS_NULL)
        !           611:                return KERN_INVALID_TASK;
        !           612: 
        !           613:        kr = ipc_right_lookup_write(space, name, &entry);
        !           614:        if (kr != KERN_SUCCESS)
        !           615:                return kr;
        !           616:        /* space is write-locked */
        !           617: 
        !           618:        kr = ipc_right_dealloc(space, name, entry); /* unlocks space */
        !           619:        return kr;
        !           620: }
        !           621: 
        !           622: /*
        !           623:  *     Routine:        mach_port_get_refs [kernel call]
        !           624:  *     Purpose:
        !           625:  *             Retrieves the number of user references held by a right.
        !           626:  *             Receive rights, port-set rights, and send-once rights
        !           627:  *             always have one user reference.  Returns zero if the
        !           628:  *             name denotes a right, but not the queried right.
        !           629:  *     Conditions:
        !           630:  *             Nothing locked.
        !           631:  *     Returns:
        !           632:  *             KERN_SUCCESS            Number of urefs returned.
        !           633:  *             KERN_INVALID_TASK       The space is null.
        !           634:  *             KERN_INVALID_TASK       The space is dead.
        !           635:  *             KERN_INVALID_VALUE      "right" isn't a legal value.
        !           636:  *             KERN_INVALID_NAME       The name doesn't denote a right.
        !           637:  */
        !           638: 
        !           639: kern_return_t
        !           640: mach_port_get_refs(
        !           641:        ipc_space_t             space,
        !           642:        mach_port_t             name,
        !           643:        mach_port_right_t       right,
        !           644:        mach_port_urefs_t       *urefsp)
        !           645: {
        !           646:        mach_port_type_t type;
        !           647:        mach_port_urefs_t urefs;
        !           648:        ipc_entry_t entry;
        !           649:        kern_return_t kr;
        !           650: 
        !           651:        if (space == IS_NULL)
        !           652:                return KERN_INVALID_TASK;
        !           653: 
        !           654:        if (right >= MACH_PORT_RIGHT_NUMBER)
        !           655:                return KERN_INVALID_VALUE;
        !           656: 
        !           657:        kr = ipc_right_lookup_write(space, name, &entry);
        !           658:        if (kr != KERN_SUCCESS)
        !           659:                return kr;
        !           660:        /* space is write-locked and active */
        !           661: 
        !           662:        kr = ipc_right_info(space, name, entry, &type, &urefs); /* unlocks */
        !           663:        if (kr != KERN_SUCCESS)
        !           664:                return kr;      /* space is unlocked */
        !           665:        is_write_unlock(space);
        !           666: 
        !           667:        if (type & MACH_PORT_TYPE(right))
        !           668:                switch (right) {
        !           669:                    case MACH_PORT_RIGHT_SEND_ONCE:
        !           670:                        assert(urefs == 1);
        !           671:                        /* fall-through */
        !           672: 
        !           673:                    case MACH_PORT_RIGHT_PORT_SET:
        !           674:                    case MACH_PORT_RIGHT_RECEIVE:
        !           675:                        *urefsp = 1;
        !           676:                        break;
        !           677: 
        !           678:                    case MACH_PORT_RIGHT_DEAD_NAME:
        !           679:                    case MACH_PORT_RIGHT_SEND:
        !           680:                        assert(urefs > 0);
        !           681:                        *urefsp = urefs;
        !           682:                        break;
        !           683: 
        !           684:                    default:
        !           685:                        panic("mach_port_get_refs: strange rights");
        !           686:                }
        !           687:        else
        !           688:                *urefsp = 0;
        !           689: 
        !           690:        return kr;
        !           691: }
        !           692: 
        !           693: /*
        !           694:  *     Routine:        mach_port_mod_refs
        !           695:  *     Purpose:
        !           696:  *             Modifies the number of user references held by a right.
        !           697:  *             The resulting number of user references must be non-negative.
        !           698:  *             If it is zero, the right is deallocated.  If the name
        !           699:  *             doesn't denote other rights, it is destroyed.
        !           700:  *     Conditions:
        !           701:  *             Nothing locked.
        !           702:  *     Returns:
        !           703:  *             KERN_SUCCESS            Modified number of urefs.
        !           704:  *             KERN_INVALID_TASK       The space is null.
        !           705:  *             KERN_INVALID_TASK       The space is dead.
        !           706:  *             KERN_INVALID_VALUE      "right" isn't a legal value.
        !           707:  *             KERN_INVALID_NAME       The name doesn't denote a right.
        !           708:  *             KERN_INVALID_RIGHT      Name doesn't denote specified right.
        !           709:  *             KERN_INVALID_VALUE      Impossible modification to urefs.
        !           710:  *             KERN_UREFS_OVERFLOW     Urefs would overflow.
        !           711:  */
        !           712: 
        !           713: kern_return_t
        !           714: mach_port_mod_refs(
        !           715:        ipc_space_t             space,
        !           716:        mach_port_t             name,
        !           717:        mach_port_right_t       right,
        !           718:        mach_port_delta_t       delta)
        !           719: {
        !           720:        ipc_entry_t entry;
        !           721:        kern_return_t kr;
        !           722: 
        !           723:        if (space == IS_NULL)
        !           724:                return KERN_INVALID_TASK;
        !           725: 
        !           726:        if (right >= MACH_PORT_RIGHT_NUMBER)
        !           727:                return KERN_INVALID_VALUE;
        !           728: 
        !           729:        kr = ipc_right_lookup_write(space, name, &entry);
        !           730:        if (kr != KERN_SUCCESS)
        !           731:                return kr;
        !           732:        /* space is write-locked and active */
        !           733: 
        !           734:        kr = ipc_right_delta(space, name, entry, right, delta); /* unlocks */
        !           735:        return kr;
        !           736: }
        !           737: 
        !           738: /*
        !           739:  *     Routine:        old_mach_port_get_receive_status [kernel call]
        !           740:  *     Purpose:
        !           741:  *             Compatibility for code written before sequence numbers.
        !           742:  *             Retrieves mucho info about a receive right.
        !           743:  *     Conditions:
        !           744:  *             Nothing locked.
        !           745:  *     Returns:
        !           746:  *             KERN_SUCCESS            Retrieved status.
        !           747:  *             KERN_INVALID_TASK       The space is null.
        !           748:  *             KERN_INVALID_TASK       The space is dead.
        !           749:  *             KERN_INVALID_NAME       The name doesn't denote a right.
        !           750:  *             KERN_INVALID_RIGHT      Name doesn't denote receive rights.
        !           751:  */
        !           752: 
        !           753: kern_return_t
        !           754: old_mach_port_get_receive_status(space, name, statusp)
        !           755:        ipc_space_t space;
        !           756:        mach_port_t name;
        !           757:        old_mach_port_status_t *statusp;
        !           758: {
        !           759:        mach_port_status_t status;
        !           760:        kern_return_t kr;
        !           761: 
        !           762:        kr = mach_port_get_receive_status(space, name, &status);
        !           763:        if (kr != KERN_SUCCESS)
        !           764:                return kr;
        !           765: 
        !           766:        statusp->mps_pset = status.mps_pset;
        !           767:        statusp->mps_mscount = status.mps_mscount;
        !           768:        statusp->mps_qlimit = status.mps_qlimit;
        !           769:        statusp->mps_msgcount = status.mps_msgcount;
        !           770:        statusp->mps_sorights = status.mps_sorights;
        !           771:        statusp->mps_srights = status.mps_srights;
        !           772:        statusp->mps_pdrequest = status.mps_pdrequest;
        !           773:        statusp->mps_nsrequest = status.mps_nsrequest;
        !           774: 
        !           775:        return KERN_SUCCESS;
        !           776: }
        !           777: 
        !           778: /*
        !           779:  *     Routine:        mach_port_set_qlimit [kernel call]
        !           780:  *     Purpose:
        !           781:  *             Changes a receive right's queue limit.
        !           782:  *             The new queue limit must be between 0 and
        !           783:  *             MACH_PORT_QLIMIT_MAX, inclusive.
        !           784:  *     Conditions:
        !           785:  *             Nothing locked.
        !           786:  *     Returns:
        !           787:  *             KERN_SUCCESS            Set queue limit.
        !           788:  *             KERN_INVALID_TASK       The space is null.
        !           789:  *             KERN_INVALID_TASK       The space is dead.
        !           790:  *             KERN_INVALID_NAME       The name doesn't denote a right.
        !           791:  *             KERN_INVALID_RIGHT      Name doesn't denote receive rights.
        !           792:  *             KERN_INVALID_VALUE      Illegal queue limit.
        !           793:  */
        !           794: 
        !           795: kern_return_t
        !           796: mach_port_set_qlimit(space, name, qlimit)
        !           797:        ipc_space_t space;
        !           798:        mach_port_t name;
        !           799:        mach_port_msgcount_t qlimit;
        !           800: {
        !           801:        ipc_port_t port;
        !           802:        kern_return_t kr;
        !           803: 
        !           804:        if (space == IS_NULL)
        !           805:                return KERN_INVALID_TASK;
        !           806: 
        !           807:        if (qlimit > MACH_PORT_QLIMIT_MAX)
        !           808:                return KERN_INVALID_VALUE;
        !           809: 
        !           810:        kr = ipc_port_translate_receive(space, name, &port);
        !           811:        if (kr != KERN_SUCCESS)
        !           812:                return kr;
        !           813:        /* port is locked and active */
        !           814: 
        !           815:        ipc_port_set_qlimit(port, qlimit);
        !           816: 
        !           817:        ip_unlock(port);
        !           818:        return KERN_SUCCESS;
        !           819: }
        !           820: 
        !           821: /*
        !           822:  *     Routine:        mach_port_set_mscount [kernel call]
        !           823:  *     Purpose:
        !           824:  *             Changes a receive right's make-send count.
        !           825:  *     Conditions:
        !           826:  *             Nothing locked.
        !           827:  *     Returns:
        !           828:  *             KERN_SUCCESS            Set make-send count.
        !           829:  *             KERN_INVALID_TASK       The space is null.
        !           830:  *             KERN_INVALID_TASK       The space is dead.
        !           831:  *             KERN_INVALID_NAME       The name doesn't denote a right.
        !           832:  *             KERN_INVALID_RIGHT      Name doesn't denote receive rights.
        !           833:  */
        !           834: 
        !           835: kern_return_t
        !           836: mach_port_set_mscount(
        !           837:        ipc_space_t             space,
        !           838:        mach_port_t             name,
        !           839:        mach_port_mscount_t     mscount)
        !           840: {
        !           841:        ipc_port_t port;
        !           842:        kern_return_t kr;
        !           843: 
        !           844:        if (space == IS_NULL)
        !           845:                return KERN_INVALID_TASK;
        !           846: 
        !           847:        kr = ipc_port_translate_receive(space, name, &port);
        !           848:        if (kr != KERN_SUCCESS)
        !           849:                return kr;
        !           850:        /* port is locked and active */
        !           851: 
        !           852:        ipc_port_set_mscount(port, mscount);
        !           853: 
        !           854:        ip_unlock(port);
        !           855:        return KERN_SUCCESS;
        !           856: }
        !           857: 
        !           858: /*
        !           859:  *     Routine:        mach_port_set_seqno [kernel call]
        !           860:  *     Purpose:
        !           861:  *             Changes a receive right's sequence number.
        !           862:  *     Conditions:
        !           863:  *             Nothing locked.
        !           864:  *     Returns:
        !           865:  *             KERN_SUCCESS            Set sequence number.
        !           866:  *             KERN_INVALID_TASK       The space is null.
        !           867:  *             KERN_INVALID_TASK       The space is dead.
        !           868:  *             KERN_INVALID_NAME       The name doesn't denote a right.
        !           869:  *             KERN_INVALID_RIGHT      Name doesn't denote receive rights.
        !           870:  */
        !           871: 
        !           872: kern_return_t
        !           873: mach_port_set_seqno(
        !           874:        ipc_space_t             space,
        !           875:        mach_port_t             name,
        !           876:        mach_port_seqno_t       seqno)
        !           877: {
        !           878:        ipc_port_t port;
        !           879:        kern_return_t kr;
        !           880: 
        !           881:        if (space == IS_NULL)
        !           882:                return KERN_INVALID_TASK;
        !           883: 
        !           884:        kr = ipc_port_translate_receive(space, name, &port);
        !           885:        if (kr != KERN_SUCCESS)
        !           886:                return kr;
        !           887:        /* port is locked and active */
        !           888: 
        !           889:        ipc_port_set_seqno(port, seqno);
        !           890: 
        !           891:        ip_unlock(port);
        !           892:        return KERN_SUCCESS;
        !           893: }
        !           894: 
        !           895: /*
        !           896:  *     Routine:        mach_port_gst_helper
        !           897:  *     Purpose:
        !           898:  *             A helper function for mach_port_get_set_status.
        !           899:  */
        !           900: 
        !           901: void
        !           902: mach_port_gst_helper(
        !           903:        ipc_pset_t              pset,
        !           904:        ipc_port_t              port,
        !           905:        ipc_entry_num_t         maxnames,
        !           906:        mach_port_t             *names,
        !           907:        ipc_entry_num_t         *actualp)
        !           908: {
        !           909:        ipc_pset_t ip_pset;
        !           910:        mach_port_t name;
        !           911: 
        !           912:        assert(port != IP_NULL);
        !           913: 
        !           914:        ip_lock(port);
        !           915:        assert(ip_active(port));
        !           916: 
        !           917:        name = port->ip_receiver_name;
        !           918:        assert(name != MACH_PORT_NULL);
        !           919:        ip_pset = port->ip_pset;
        !           920: 
        !           921:        ip_unlock(port);
        !           922: 
        !           923:        if (pset == ip_pset) {
        !           924:                ipc_entry_num_t actual = *actualp;
        !           925: 
        !           926:                if (actual < maxnames)
        !           927:                        names[actual] = name;
        !           928: 
        !           929:                *actualp = actual+1;
        !           930:        }
        !           931: }
        !           932: 
        !           933: /*
        !           934:  *     Routine:        mach_port_get_set_status [kernel call]
        !           935:  *     Purpose:
        !           936:  *             Retrieves a list of members in a port set.
        !           937:  *             Returns the space's name for each receive right member.
        !           938:  *     Conditions:
        !           939:  *             Nothing locked.
        !           940:  *     Returns:
        !           941:  *             KERN_SUCCESS            Retrieved list of members.
        !           942:  *             KERN_INVALID_TASK       The space is null.
        !           943:  *             KERN_INVALID_TASK       The space is dead.
        !           944:  *             KERN_INVALID_NAME       The name doesn't denote a right.
        !           945:  *             KERN_INVALID_RIGHT      Name doesn't denote a port set.
        !           946:  *             KERN_RESOURCE_SHORTAGE  Couldn't allocate memory.
        !           947:  */
        !           948: 
        !           949: kern_return_t
        !           950: mach_port_get_set_status(
        !           951:        ipc_space_t                     space,
        !           952:        mach_port_t                     name,
        !           953:        mach_port_t                     **members,
        !           954:        mach_msg_type_number_t          *membersCnt)
        !           955: {
        !           956:        ipc_entry_num_t actual;         /* this many members */
        !           957:        ipc_entry_num_t maxnames;       /* space for this many members */
        !           958:        kern_return_t kr;
        !           959: 
        !           960:        vm_size_t size;         /* size of allocated memory */
        !           961:        vm_offset_t addr;       /* allocated memory */
        !           962:        vm_map_copy_t memory;   /* copied-in memory */
        !           963: 
        !           964:        if (space == IS_NULL)
        !           965:                return KERN_INVALID_TASK;
        !           966: 
        !           967:        size = PAGE_SIZE;       /* initial guess */
        !           968: 
        !           969:        for (;;) {
        !           970:                ipc_tree_entry_t tentry;
        !           971:                ipc_entry_t entry, table;
        !           972:                ipc_entry_num_t tsize;
        !           973:                mach_port_index_t index;
        !           974:                mach_port_t *names;
        !           975:                ipc_pset_t pset;
        !           976: 
        !           977:                kr = vm_allocate(ipc_kernel_map, &addr, size, TRUE);
        !           978:                if (kr != KERN_SUCCESS)
        !           979:                        return KERN_RESOURCE_SHORTAGE;
        !           980: 
        !           981:                /* can't fault while we hold locks */
        !           982: 
        !           983:                kr = vm_map_pageable(ipc_kernel_map, addr, addr + size,
        !           984:                                     VM_PROT_READ|VM_PROT_WRITE);
        !           985:                assert(kr == KERN_SUCCESS);
        !           986: 
        !           987:                kr = ipc_right_lookup_read(space, name, &entry);
        !           988:                if (kr != KERN_SUCCESS) {
        !           989:                        kmem_free(ipc_kernel_map, addr, size);
        !           990:                        return kr;
        !           991:                }
        !           992:                /* space is read-locked and active */
        !           993: 
        !           994:                if (IE_BITS_TYPE(entry->ie_bits) != MACH_PORT_TYPE_PORT_SET) {
        !           995:                        is_read_unlock(space);
        !           996:                        kmem_free(ipc_kernel_map, addr, size);
        !           997:                        return KERN_INVALID_RIGHT;
        !           998:                }
        !           999: 
        !          1000:                pset = (ipc_pset_t) entry->ie_object;
        !          1001:                assert(pset != IPS_NULL);
        !          1002:                /* the port set must be active */
        !          1003: 
        !          1004:                names = (mach_port_t *) addr;
        !          1005:                maxnames = size / sizeof(mach_port_t);
        !          1006:                actual = 0;
        !          1007: 
        !          1008:                table = space->is_table;
        !          1009:                tsize = space->is_table_size;
        !          1010: 
        !          1011:                for (index = 0; index < tsize; index++) {
        !          1012:                        ipc_entry_t ientry = &table[index];
        !          1013:                        ipc_entry_bits_t bits = ientry->ie_bits;
        !          1014: 
        !          1015:                        if (bits & MACH_PORT_TYPE_RECEIVE) {
        !          1016:                                ipc_port_t port =
        !          1017:                                        (ipc_port_t) ientry->ie_object;
        !          1018: 
        !          1019:                                mach_port_gst_helper(pset, port, maxnames,
        !          1020:                                                     names, &actual);
        !          1021:                        }
        !          1022:                }
        !          1023: 
        !          1024:                for (tentry = ipc_splay_traverse_start(&space->is_tree);
        !          1025:                     tentry != ITE_NULL;
        !          1026:                     tentry = ipc_splay_traverse_next(&space->is_tree,FALSE)) {
        !          1027:                        ipc_entry_bits_t bits = tentry->ite_bits;
        !          1028: 
        !          1029:                        assert(IE_BITS_TYPE(bits) != MACH_PORT_TYPE_NONE);
        !          1030: 
        !          1031:                        if (bits & MACH_PORT_TYPE_RECEIVE) {
        !          1032:                                ipc_port_t port =
        !          1033:                                        (ipc_port_t) tentry->ite_object;
        !          1034: 
        !          1035:                                mach_port_gst_helper(pset, port, maxnames,
        !          1036:                                                     names, &actual);
        !          1037:                        }
        !          1038:                }
        !          1039:                ipc_splay_traverse_finish(&space->is_tree);
        !          1040:                is_read_unlock(space);
        !          1041: 
        !          1042:                if (actual <= maxnames)
        !          1043:                        break;
        !          1044: 
        !          1045:                /* didn't have enough memory; allocate more */
        !          1046: 
        !          1047:                kmem_free(ipc_kernel_map, addr, size);
        !          1048:                size = round_page(actual * sizeof(mach_port_t)) + PAGE_SIZE;
        !          1049:        }
        !          1050: 
        !          1051:        if (actual == 0) {
        !          1052:                memory = VM_MAP_COPY_NULL;
        !          1053: 
        !          1054:                kmem_free(ipc_kernel_map, addr, size);
        !          1055:        } else {
        !          1056:                vm_size_t size_used;
        !          1057: 
        !          1058:                size_used = round_page(actual * sizeof(mach_port_t));
        !          1059: 
        !          1060:                /*
        !          1061:                 *      Make used memory pageable and get it into
        !          1062:                 *      copied-in form.  Free any unused memory.
        !          1063:                 */
        !          1064: 
        !          1065:                kr = vm_map_pageable(ipc_kernel_map,
        !          1066:                                     addr, addr + size_used,
        !          1067:                                     VM_PROT_NONE);
        !          1068:                assert(kr == KERN_SUCCESS);
        !          1069: 
        !          1070:                kr = vm_map_copyin(ipc_kernel_map, addr, size_used,
        !          1071:                                   TRUE, &memory);
        !          1072:                assert(kr == KERN_SUCCESS);
        !          1073: 
        !          1074:                if (size_used != size)
        !          1075:                        kmem_free(ipc_kernel_map,
        !          1076:                                  addr + size_used, size - size_used);
        !          1077:        }
        !          1078: 
        !          1079:        *members = (mach_port_t *) memory;
        !          1080:        *membersCnt = actual;
        !          1081:        return KERN_SUCCESS;
        !          1082: }
        !          1083: 
        !          1084: /*
        !          1085:  *     Routine:        mach_port_move_member [kernel call]
        !          1086:  *     Purpose:
        !          1087:  *             If after is MACH_PORT_NULL, removes member
        !          1088:  *             from the port set it is in.  Otherwise, adds
        !          1089:  *             member to after, removing it from any set
        !          1090:  *             it might already be in.
        !          1091:  *     Conditions:
        !          1092:  *             Nothing locked.
        !          1093:  *     Returns:
        !          1094:  *             KERN_SUCCESS            Moved the port.
        !          1095:  *             KERN_INVALID_TASK       The space is null.
        !          1096:  *             KERN_INVALID_TASK       The space is dead.
        !          1097:  *             KERN_INVALID_NAME       Member didn't denote a right.
        !          1098:  *             KERN_INVALID_RIGHT      Member didn't denote a receive right.
        !          1099:  *             KERN_INVALID_NAME       After didn't denote a right.
        !          1100:  *             KERN_INVALID_RIGHT      After didn't denote a port set right.
        !          1101:  *             KERN_NOT_IN_SET
        !          1102:  *                     After is MACH_PORT_NULL and Member isn't in a port set.
        !          1103:  */
        !          1104: 
        !          1105: kern_return_t
        !          1106: mach_port_move_member(
        !          1107:        ipc_space_t     space,
        !          1108:        mach_port_t     member,
        !          1109:        mach_port_t     after)
        !          1110: {
        !          1111:        ipc_entry_t entry;
        !          1112:        ipc_port_t port;
        !          1113:        ipc_pset_t nset;
        !          1114:        kern_return_t kr;
        !          1115: 
        !          1116:        if (space == IS_NULL)
        !          1117:                return KERN_INVALID_TASK;
        !          1118: 
        !          1119:        kr = ipc_right_lookup_read(space, member, &entry);
        !          1120:        if (kr != KERN_SUCCESS)
        !          1121:                return kr;
        !          1122:        /* space is read-locked and active */
        !          1123: 
        !          1124:        if ((entry->ie_bits & MACH_PORT_TYPE_RECEIVE) == 0) {
        !          1125:                is_read_unlock(space);
        !          1126:                return KERN_INVALID_RIGHT;
        !          1127:        }
        !          1128: 
        !          1129:        port = (ipc_port_t) entry->ie_object;
        !          1130:        assert(port != IP_NULL);
        !          1131: 
        !          1132:        if (after == MACH_PORT_NULL)
        !          1133:                nset = IPS_NULL;
        !          1134:        else {
        !          1135:                entry = ipc_entry_lookup(space, after);
        !          1136:                if (entry == IE_NULL) {
        !          1137:                        is_read_unlock(space);
        !          1138:                        return KERN_INVALID_NAME;
        !          1139:                }
        !          1140: 
        !          1141:                if ((entry->ie_bits & MACH_PORT_TYPE_PORT_SET) == 0) {
        !          1142:                        is_read_unlock(space);
        !          1143:                        return KERN_INVALID_RIGHT;
        !          1144:                }
        !          1145: 
        !          1146:                nset = (ipc_pset_t) entry->ie_object;
        !          1147:                assert(nset != IPS_NULL);
        !          1148:        }
        !          1149: 
        !          1150:        kr = ipc_pset_move(space, port, nset);
        !          1151:        /* space is unlocked */
        !          1152:        return kr;
        !          1153: }
        !          1154: 
        !          1155: /*
        !          1156:  *     Routine:        mach_port_request_notification [kernel call]
        !          1157:  *     Purpose:
        !          1158:  *             Requests a notification.  The caller supplies
        !          1159:  *             a send-once right for the notification to use,
        !          1160:  *             and the call returns the previously registered
        !          1161:  *             send-once right, if any.  Possible types:
        !          1162:  *
        !          1163:  *             MACH_NOTIFY_PORT_DESTROYED
        !          1164:  *                     Requests a port-destroyed notification
        !          1165:  *                     for a receive right.  Sync should be zero.
        !          1166:  *             MACH_NOTIFY_NO_SENDERS
        !          1167:  *                     Requests a no-senders notification for a
        !          1168:  *                     receive right.  If there are currently no
        !          1169:  *                     senders, sync is less than or equal to the
        !          1170:  *                     current make-send count, and a send-once right
        !          1171:  *                     is supplied, then an immediate no-senders
        !          1172:  *                     notification is generated.
        !          1173:  *             MACH_NOTIFY_DEAD_NAME
        !          1174:  *                     Requests a dead-name notification for a send
        !          1175:  *                     or receive right.  If the name is already a
        !          1176:  *                     dead name, sync is non-zero, and a send-once
        !          1177:  *                     right is supplied, then an immediate dead-name
        !          1178:  *                     notification is generated.
        !          1179:  *     Conditions:
        !          1180:  *             Nothing locked.
        !          1181:  *     Returns:
        !          1182:  *             KERN_SUCCESS            Requested a notification.
        !          1183:  *             KERN_INVALID_TASK       The space is null.
        !          1184:  *             KERN_INVALID_TASK       The space is dead.
        !          1185:  *             KERN_INVALID_VALUE      Bad id value.
        !          1186:  *             KERN_INVALID_NAME       Name doesn't denote a right.
        !          1187:  *             KERN_INVALID_RIGHT      Name doesn't denote appropriate right.
        !          1188:  *             KERN_INVALID_CAPABILITY The notify port is dead.
        !          1189:  *     MACH_NOTIFY_PORT_DESTROYED:
        !          1190:  *             KERN_INVALID_VALUE      Sync isn't zero.
        !          1191:  *     MACH_NOTIFY_DEAD_NAME:
        !          1192:  *             KERN_RESOURCE_SHORTAGE  Couldn't allocate memory.
        !          1193:  *             KERN_INVALID_ARGUMENT   Name denotes dead name, but
        !          1194:  *                     sync is zero or notify is IP_NULL.
        !          1195:  *             KERN_UREFS_OVERFLOW     Name denotes dead name, but
        !          1196:  *                     generating immediate notif. would overflow urefs.
        !          1197:  */
        !          1198: 
        !          1199: kern_return_t
        !          1200: mach_port_request_notification(
        !          1201:        ipc_space_t             space,
        !          1202:        mach_port_t             name,
        !          1203:        mach_msg_id_t           id,
        !          1204:        mach_port_mscount_t     sync,
        !          1205:        ipc_port_t              notify,
        !          1206:        ipc_port_t              *previousp)
        !          1207: {
        !          1208:        kern_return_t kr;
        !          1209: 
        !          1210:        if (space == IS_NULL)
        !          1211:                return KERN_INVALID_TASK;
        !          1212: 
        !          1213:        if (notify == IP_DEAD)
        !          1214:                return KERN_INVALID_CAPABILITY;
        !          1215: 
        !          1216:        switch (id) {
        !          1217:            case MACH_NOTIFY_PORT_DESTROYED: {
        !          1218:                ipc_port_t port, previous;
        !          1219: 
        !          1220:                if (sync != 0)
        !          1221:                        return KERN_INVALID_VALUE;
        !          1222: 
        !          1223:                kr = ipc_port_translate_receive(space, name, &port);
        !          1224:                if (kr != KERN_SUCCESS)
        !          1225:                        return kr;
        !          1226:                /* port is locked and active */
        !          1227: 
        !          1228:                ipc_port_pdrequest(port, notify, &previous);
        !          1229:                /* port is unlocked */
        !          1230: 
        !          1231: #if    MACH_IPC_COMPAT
        !          1232:                /*
        !          1233:                 *      If previous was a send right instead of a send-once
        !          1234:                 *      right, we can't return it in the reply message.
        !          1235:                 *      So destroy it instead.
        !          1236:                 */
        !          1237: 
        !          1238:                if ((previous != IP_NULL) && ip_pdsendp(previous)) {
        !          1239:                        ipc_port_release_send(ip_pdsend(previous));
        !          1240:                        previous = IP_NULL;
        !          1241:                }
        !          1242: #endif MACH_IPC_COMPAT
        !          1243: 
        !          1244:                *previousp = previous;
        !          1245:                break;
        !          1246:            }
        !          1247: 
        !          1248:            case MACH_NOTIFY_NO_SENDERS: {
        !          1249:                ipc_port_t port;
        !          1250: 
        !          1251:                kr = ipc_port_translate_receive(space, name, &port);
        !          1252:                if (kr != KERN_SUCCESS)
        !          1253:                        return kr;
        !          1254:                /* port is locked and active */
        !          1255: 
        !          1256:                ipc_port_nsrequest(port, sync, notify, previousp);
        !          1257:                /* port is unlocked */
        !          1258:                break;
        !          1259:            }
        !          1260: 
        !          1261:            case MACH_NOTIFY_DEAD_NAME:
        !          1262:                kr = ipc_right_dnrequest(space, name, sync != 0,
        !          1263:                                         notify, previousp);
        !          1264:                if (kr != KERN_SUCCESS)
        !          1265:                        return kr;
        !          1266:                break;
        !          1267: 
        !          1268:            default:
        !          1269:                return KERN_INVALID_VALUE;
        !          1270:        }
        !          1271: 
        !          1272:        return KERN_SUCCESS;
        !          1273: }
        !          1274: 
        !          1275: /*
        !          1276:  *     Routine:        mach_port_insert_right [kernel call]
        !          1277:  *     Purpose:
        !          1278:  *             Inserts a right into a space, as if the space
        !          1279:  *             voluntarily received the right in a message,
        !          1280:  *             except that the right gets the specified name.
        !          1281:  *     Conditions:
        !          1282:  *             Nothing locked.
        !          1283:  *     Returns:
        !          1284:  *             KERN_SUCCESS            Inserted the right.
        !          1285:  *             KERN_INVALID_TASK       The space is null.
        !          1286:  *             KERN_INVALID_TASK       The space is dead.
        !          1287:  *             KERN_INVALID_VALUE      The name isn't a legal name.
        !          1288:  *             KERN_NAME_EXISTS        The name already denotes a right.
        !          1289:  *             KERN_INVALID_VALUE      Message doesn't carry a port right.
        !          1290:  *             KERN_INVALID_CAPABILITY Port is null or dead.
        !          1291:  *             KERN_UREFS_OVERFLOW     Urefs limit would be exceeded.
        !          1292:  *             KERN_RIGHT_EXISTS       Space has rights under another name.
        !          1293:  *             KERN_RESOURCE_SHORTAGE  Couldn't allocate memory.
        !          1294:  */
        !          1295: 
        !          1296: kern_return_t
        !          1297: mach_port_insert_right(
        !          1298:        ipc_space_t             space,
        !          1299:        mach_port_t             name,
        !          1300:        ipc_port_t              poly,
        !          1301:        mach_msg_type_name_t    polyPoly)
        !          1302: {
        !          1303:        if (space == IS_NULL)
        !          1304:                return KERN_INVALID_TASK;
        !          1305: 
        !          1306:        if (!MACH_PORT_VALID(name) ||
        !          1307:            !MACH_MSG_TYPE_PORT_ANY_RIGHT(polyPoly))
        !          1308:                return KERN_INVALID_VALUE;
        !          1309: 
        !          1310:        if (!IO_VALID(poly))
        !          1311:                return KERN_INVALID_CAPABILITY;
        !          1312: 
        !          1313:        return ipc_object_copyout_name(space, poly, polyPoly, FALSE, name);
        !          1314: }
        !          1315: 
        !          1316: /*
        !          1317:  *     Routine:        mach_port_extract_right [kernel call]
        !          1318:  *     Purpose:
        !          1319:  *             Extracts a right from a space, as if the space
        !          1320:  *             voluntarily sent the right to the caller.
        !          1321:  *     Conditions:
        !          1322:  *             Nothing locked.
        !          1323:  *     Returns:
        !          1324:  *             KERN_SUCCESS            Extracted the right.
        !          1325:  *             KERN_INVALID_TASK       The space is null.
        !          1326:  *             KERN_INVALID_TASK       The space is dead.
        !          1327:  *             KERN_INVALID_VALUE      Requested type isn't a port right.
        !          1328:  *             KERN_INVALID_NAME       Name doesn't denote a right.
        !          1329:  *             KERN_INVALID_RIGHT      Name doesn't denote appropriate right.
        !          1330:  */
        !          1331: 
        !          1332: kern_return_t
        !          1333: mach_port_extract_right(
        !          1334:        ipc_space_t             space,
        !          1335:        mach_port_t             name,
        !          1336:        mach_msg_type_name_t    msgt_name,
        !          1337:        ipc_port_t              *poly,
        !          1338:        mach_msg_type_name_t    *polyPoly)
        !          1339: {
        !          1340:        kern_return_t kr;
        !          1341: 
        !          1342:        if (space == IS_NULL)
        !          1343:                return KERN_INVALID_TASK;
        !          1344: 
        !          1345:        if (!MACH_MSG_TYPE_PORT_ANY(msgt_name))
        !          1346:                return KERN_INVALID_VALUE;
        !          1347: 
        !          1348:        kr = ipc_object_copyin(space, name, msgt_name, (ipc_object_t *) poly);
        !          1349: 
        !          1350:        if (kr == KERN_SUCCESS)
        !          1351:                *polyPoly = ipc_object_copyin_type(msgt_name);
        !          1352:        return kr;
        !          1353: }
        !          1354: 
        !          1355: /*
        !          1356:  *     Routine:        mach_port_get_receive_status [kernel call]
        !          1357:  *     Purpose:
        !          1358:  *             Retrieves mucho info about a receive right.
        !          1359:  *     Conditions:
        !          1360:  *             Nothing locked.
        !          1361:  *     Returns:
        !          1362:  *             KERN_SUCCESS            Retrieved status.
        !          1363:  *             KERN_INVALID_TASK       The space is null.
        !          1364:  *             KERN_INVALID_TASK       The space is dead.
        !          1365:  *             KERN_INVALID_NAME       The name doesn't denote a right.
        !          1366:  *             KERN_INVALID_RIGHT      Name doesn't denote receive rights.
        !          1367:  */
        !          1368: 
        !          1369: kern_return_t
        !          1370: mach_port_get_receive_status(space, name, statusp)
        !          1371:        ipc_space_t space;
        !          1372:        mach_port_t name;
        !          1373:        mach_port_status_t *statusp;
        !          1374: {
        !          1375:        ipc_port_t port;
        !          1376:        kern_return_t kr;
        !          1377: 
        !          1378:        if (space == IS_NULL)
        !          1379:                return KERN_INVALID_TASK;
        !          1380: 
        !          1381:        kr = ipc_port_translate_receive(space, name, &port);
        !          1382:        if (kr != KERN_SUCCESS)
        !          1383:                return kr;
        !          1384:        /* port is locked and active */
        !          1385: 
        !          1386:        if (port->ip_pset != IPS_NULL) {
        !          1387:                ipc_pset_t pset = port->ip_pset;
        !          1388: 
        !          1389:                ips_lock(pset);
        !          1390:                if (!ips_active(pset)) {
        !          1391:                        ipc_pset_remove(pset, port);
        !          1392:                        ips_check_unlock(pset);
        !          1393:                        goto no_port_set;
        !          1394:                } else {
        !          1395:                        statusp->mps_pset = pset->ips_local_name;
        !          1396:                        imq_lock(&pset->ips_messages);
        !          1397:                        statusp->mps_seqno = port->ip_seqno;
        !          1398:                        imq_unlock(&pset->ips_messages);
        !          1399:                        ips_unlock(pset);
        !          1400:                        assert(MACH_PORT_VALID(statusp->mps_pset));
        !          1401:                }
        !          1402:        } else {
        !          1403:            no_port_set:
        !          1404:                statusp->mps_pset = MACH_PORT_NULL;
        !          1405:                imq_lock(&port->ip_messages);
        !          1406:                statusp->mps_seqno = port->ip_seqno;
        !          1407:                imq_unlock(&port->ip_messages);
        !          1408:        }
        !          1409: 
        !          1410:        statusp->mps_mscount = port->ip_mscount;
        !          1411:        statusp->mps_qlimit = port->ip_qlimit;
        !          1412:        statusp->mps_msgcount = port->ip_msgcount;
        !          1413:        statusp->mps_sorights = port->ip_sorights;
        !          1414:        statusp->mps_srights = port->ip_srights > 0;
        !          1415:        statusp->mps_pdrequest = port->ip_pdrequest != IP_NULL;
        !          1416:        statusp->mps_nsrequest = port->ip_nsrequest != IP_NULL;
        !          1417:        ip_unlock(port);
        !          1418: 
        !          1419:        return KERN_SUCCESS;
        !          1420: }
        !          1421: 
        !          1422: #ifdef MIGRATING_THREADS
        !          1423: kern_return_t
        !          1424: mach_port_set_rpcinfo(space, name, rpc_info, rpc_info_count)
        !          1425:        ipc_space_t space;
        !          1426:        mach_port_t name;
        !          1427:        void *rpc_info;
        !          1428:        unsigned int rpc_info_count;
        !          1429: {
        !          1430:        ipc_target_t target;
        !          1431:        ipc_object_t object;
        !          1432:        kern_return_t kr;
        !          1433: 
        !          1434:        if (space == IS_NULL)
        !          1435:                return KERN_INVALID_TASK;
        !          1436: 
        !          1437:        kr = ipc_object_translate(space, name,
        !          1438:                                  MACH_PORT_RIGHT_PORT_SET, &object);
        !          1439:        if (kr == KERN_SUCCESS)
        !          1440:                target = &((ipc_pset_t)object)->ips_target;
        !          1441:        else {
        !          1442:                kr = ipc_object_translate(space, name,
        !          1443:                                          MACH_PORT_RIGHT_RECEIVE, &object);
        !          1444:                if (kr != KERN_SUCCESS)
        !          1445:                        return kr;
        !          1446:                target = &((ipc_port_t)object)->ip_target;
        !          1447:        }
        !          1448: 
        !          1449:        /* port/pset is locked and active */
        !          1450: 
        !          1451:        kr = port_machine_set_rpcinfo(target, rpc_info, rpc_info_count);
        !          1452: 
        !          1453:        io_unlock(object);
        !          1454: 
        !          1455:        return kr;
        !          1456: }
        !          1457: 
        !          1458: #if 1
        !          1459: int sacts, maxsacts;
        !          1460: #endif
        !          1461: 
        !          1462: sact_count()
        !          1463: {
        !          1464:        printf("%d server activations in use, %d max\n", sacts, maxsacts);
        !          1465: }
        !          1466: 
        !          1467: kern_return_t
        !          1468: mach_port_create_act(task, name, user_stack, user_rbuf, user_rbuf_size, out_act)
        !          1469:        task_t task;
        !          1470:        mach_port_t name;
        !          1471:        vm_offset_t user_stack;
        !          1472:        vm_offset_t user_rbuf;
        !          1473:        vm_size_t user_rbuf_size;
        !          1474:        Act **out_act;
        !          1475: {
        !          1476:        ipc_target_t target;
        !          1477:        ipc_space_t space;
        !          1478:        ipc_object_t object;
        !          1479:        kern_return_t kr;
        !          1480:        Act *act;
        !          1481: 
        !          1482:        if (task == 0)
        !          1483:                return KERN_INVALID_TASK;
        !          1484: 
        !          1485:        /* First create the new activation.  */
        !          1486:        kr = act_create(task, user_stack, user_rbuf, user_rbuf_size, &act);
        !          1487:        if (kr != KERN_SUCCESS)
        !          1488:                return kr;
        !          1489: 
        !          1490:        space = task->itk_space;
        !          1491: 
        !          1492:        kr = ipc_object_translate(space, name,
        !          1493:                                  MACH_PORT_RIGHT_PORT_SET, &object);
        !          1494:        if (kr == KERN_SUCCESS)
        !          1495:                target = &((ipc_pset_t)object)->ips_target;
        !          1496:        else {
        !          1497:                kr = ipc_object_translate(space, name,
        !          1498:                                          MACH_PORT_RIGHT_RECEIVE, &object);
        !          1499:                if (kr != KERN_SUCCESS) {
        !          1500:                        act_terminate(act);
        !          1501:                        act_deallocate(act);
        !          1502:                        return kr;
        !          1503:                }
        !          1504:                target = &((ipc_port_t)object)->ip_target;
        !          1505:        }
        !          1506: 
        !          1507:        /* port/pset is locked and active */
        !          1508: #if 0
        !          1509:        printf("act port/pset %08x ipc_target %08x stack %08x act %08x\n",
        !          1510:               object, target, user_stack, act);
        !          1511: #endif
        !          1512: 
        !          1513:        /* Assign the activation to the port's actpool.  */
        !          1514:        kr = act_set_target(act, target);
        !          1515:        if (kr != KERN_SUCCESS) {
        !          1516:                io_unlock(object);
        !          1517:                act_terminate(act);
        !          1518:                act_deallocate(act);
        !          1519:                return kr;
        !          1520:        }
        !          1521: #if 0
        !          1522:        printf(" actpool %08x act %08x\n", target->ip_actpool, act);
        !          1523: #endif
        !          1524: 
        !          1525:        io_unlock(object);
        !          1526: 
        !          1527:        /* Pass our reference to the activation back to the user.  */
        !          1528:        *out_act = act;
        !          1529: 
        !          1530: #if 1
        !          1531:        sacts++;
        !          1532:        if (sacts > maxsacts)
        !          1533:                maxsacts = sacts;
        !          1534:        act->mact.pcb->ss.mpsfu_high = 0x69;
        !          1535: #endif
        !          1536:        return KERN_SUCCESS;
        !          1537: }
        !          1538: 
        !          1539: #ifdef RPCKERNELSIG
        !          1540: kern_return_t
        !          1541: mach_port_set_syscall_right(task, name)
        !          1542:        task_t task;
        !          1543:        mach_port_t name;
        !          1544: {
        !          1545:        ipc_entry_t entry;
        !          1546:        ipc_port_t port;
        !          1547:        kern_return_t kr;
        !          1548: 
        !          1549:        if (task == IS_NULL)
        !          1550:                return KERN_INVALID_TASK;
        !          1551: 
        !          1552:        kr = ipc_right_lookup_write(task, name, &entry);
        !          1553:        if (kr != KERN_SUCCESS) {
        !          1554:                return kr;
        !          1555:        }
        !          1556: 
        !          1557:        if (!(entry->ie_bits & MACH_PORT_TYPE(MACH_PORT_RIGHT_SEND))) {
        !          1558:                is_write_unlock(space);
        !          1559:                return KERN_INVALID_RIGHT;
        !          1560:        }
        !          1561: 
        !          1562:        task->syscall_ipc_entry = *entry;
        !          1563: 
        !          1564:        is_write_unlock(space);
        !          1565: 
        !          1566:        return KERN_SUCCESS;
        !          1567: }
        !          1568: #endif
        !          1569: #endif /* MIGRATING_THREADS */
        !          1570: 
        !          1571: #if    MACH_IPC_COMPAT
        !          1572: 
        !          1573: /*
        !          1574:  *     Routine:        port_translate_compat
        !          1575:  *     Purpose:
        !          1576:  *             Converts a name to a receive right.
        !          1577:  *     Conditions:
        !          1578:  *             Nothing locked.  If successful, the port
        !          1579:  *             is returned locked and active.
        !          1580:  *     Returns:
        !          1581:  *             KERN_SUCCESS            Port is returned.
        !          1582:  *             KERN_INVALID_ARGUMENT   The space is dead.
        !          1583:  *             KERN_INVALID_ARGUMENT   Name doesn't denote port rights.
        !          1584:  *             KERN_NOT_RECEIVER       Name denotes send, not receive, rights.
        !          1585:  *             KERN_NOT_RECEIVER       Name denotes a send-once right.
        !          1586:  *             KERN_NOT_RECEIVER       Name denotes a dead name.
        !          1587:  */
        !          1588: 
        !          1589: kern_return_t
        !          1590: port_translate_compat(space, name, portp)
        !          1591:        ipc_space_t space;
        !          1592:        mach_port_t name;
        !          1593:        ipc_port_t *portp;
        !          1594: {
        !          1595:        ipc_entry_t entry;
        !          1596:        mach_port_type_t type;
        !          1597:        mach_port_urefs_t urefs;
        !          1598:        ipc_port_t port;
        !          1599:        kern_return_t kr;
        !          1600: 
        !          1601:        kr = ipc_right_lookup_write(space, name, &entry);
        !          1602:        if (kr != KERN_SUCCESS)
        !          1603:                return KERN_INVALID_ARGUMENT;
        !          1604:        /* space is write-locked and active */
        !          1605: 
        !          1606:        kr = ipc_right_info(space, name, entry, &type, &urefs);
        !          1607:        if (kr != KERN_SUCCESS)
        !          1608:                return KERN_INVALID_ARGUMENT; /* space is unlocked */
        !          1609: 
        !          1610:        if ((type & (MACH_PORT_TYPE_RECEIVE)) == 0) {
        !          1611:                is_write_unlock(space);
        !          1612:                if (type & MACH_PORT_TYPE_PORT_OR_DEAD)
        !          1613:                        return KERN_NOT_RECEIVER;
        !          1614:                else
        !          1615:                        return KERN_INVALID_ARGUMENT;
        !          1616:        }
        !          1617: 
        !          1618:        port = (ipc_port_t) entry->ie_object;
        !          1619:        assert(port != IP_NULL);
        !          1620: 
        !          1621:        ip_lock(port);
        !          1622:        is_write_unlock(space);
        !          1623:        assert(ip_active(port));
        !          1624: 
        !          1625:        *portp = port;
        !          1626:        return KERN_SUCCESS;
        !          1627: }
        !          1628: 
        !          1629: /*
        !          1630:  *     Routine:        convert_port_type
        !          1631:  *     Purpose:
        !          1632:  *             Convert a new mach_port_type_t to an old value.
        !          1633:  *             Note send-once rights and dead names get
        !          1634:  *             represented as send rights.  The extra info
        !          1635:  *             bits get dropped.
        !          1636:  */
        !          1637: 
        !          1638: mach_port_type_t
        !          1639: convert_port_type(type)
        !          1640:        mach_port_type_t type;
        !          1641: {
        !          1642:        switch (type & MACH_PORT_TYPE_ALL_RIGHTS) {
        !          1643:            case MACH_PORT_TYPE_SEND:
        !          1644:            case MACH_PORT_TYPE_SEND_ONCE:
        !          1645:            case MACH_PORT_TYPE_DEAD_NAME:
        !          1646:                return PORT_TYPE_SEND;
        !          1647: 
        !          1648:            case MACH_PORT_TYPE_RECEIVE:
        !          1649:            case MACH_PORT_TYPE_SEND_RECEIVE:
        !          1650:                return PORT_TYPE_RECEIVE_OWN;
        !          1651: 
        !          1652:            case MACH_PORT_TYPE_PORT_SET:
        !          1653:                return PORT_TYPE_SET;
        !          1654: 
        !          1655:            default:
        !          1656: #if MACH_ASSERT
        !          1657:                assert(!"convert_port_type: strange port type");
        !          1658: #else
        !          1659:                panic("convert_port_type: strange port type");
        !          1660: #endif
        !          1661:        }
        !          1662: }
        !          1663: 
        !          1664: /*
        !          1665:  *     Routine:        port_names [kernel call]
        !          1666:  *     Purpose:
        !          1667:  *             Retrieve all the names in the task's port name space.
        !          1668:  *             As a (major) convenience, return port type information.
        !          1669:  *             The port name space includes port sets.
        !          1670:  *     Conditions:
        !          1671:  *             Nothing locked.
        !          1672:  *     Returns:
        !          1673:  *             KERN_SUCCESS            Retrieved names.
        !          1674:  *             KERN_INVALID_ARGUMENT   Task is null.
        !          1675:  *             KERN_INVALID_ARGUMENT   Task is not active.
        !          1676:  *     Additions:
        !          1677:  *             KERN_RESOURCE_SHORTAGE  Couldn't allocate memory.
        !          1678:  */
        !          1679: 
        !          1680: kern_return_t
        !          1681: port_names(space, namesp, namesCnt, typesp, typesCnt)
        !          1682:        ipc_space_t space;
        !          1683:        mach_port_t **namesp;
        !          1684:        mach_msg_type_number_t *namesCnt;
        !          1685:        mach_port_type_t **typesp;
        !          1686:        mach_msg_type_number_t *typesCnt;
        !          1687: {
        !          1688:        kern_return_t kr;
        !          1689: 
        !          1690:        kr = mach_port_names(space, namesp, namesCnt, typesp, typesCnt);
        !          1691:        if (kr == KERN_SUCCESS) {
        !          1692:                ipc_entry_num_t actual = (ipc_entry_num_t) *typesCnt;
        !          1693:                mach_port_type_t *types;
        !          1694:                ipc_entry_num_t i;
        !          1695: 
        !          1696:                vm_map_copy_t copy = (vm_map_copy_t) *typesp;
        !          1697:                vm_offset_t addr;
        !          1698:                vm_size_t size = round_page(actual * sizeof(mach_port_type_t));
        !          1699: 
        !          1700:                /* convert copy object back to something we can use */
        !          1701: 
        !          1702:                kr = vm_map_copyout(ipc_kernel_map, &addr, copy);
        !          1703:                if (kr != KERN_SUCCESS) {
        !          1704:                        vm_map_copy_discard((vm_map_copy_t) *typesp);
        !          1705:                        vm_map_copy_discard((vm_map_copy_t) *namesp);
        !          1706:                        return KERN_RESOURCE_SHORTAGE;
        !          1707:                }
        !          1708: 
        !          1709:                types = (mach_port_type_t *) addr;
        !          1710: 
        !          1711:                for (i = 0; i < actual; i++)
        !          1712:                        types[i] = convert_port_type(types[i]);
        !          1713: 
        !          1714:                /* convert memory back into a copy object */
        !          1715: 
        !          1716:                kr = vm_map_copyin(ipc_kernel_map, addr, size,
        !          1717:                                   TRUE, &copy);
        !          1718:                assert(kr == KERN_SUCCESS);
        !          1719: 
        !          1720:                *typesp = (mach_port_type_t *) copy;
        !          1721:        } else if (kr != KERN_RESOURCE_SHORTAGE)
        !          1722:                kr = KERN_INVALID_ARGUMENT;
        !          1723: 
        !          1724:        return kr;
        !          1725: }
        !          1726: 
        !          1727: /*
        !          1728:  *     Routine:        port_type [kernel call]
        !          1729:  *     Purpose:
        !          1730:  *             Return type of the capability named.
        !          1731:  *     Conditions:
        !          1732:  *             Nothing locked.
        !          1733:  *     Returns:
        !          1734:  *             KERN_SUCCESS            Retrieved type.
        !          1735:  *             KERN_INVALID_ARGUMENT   Task is null.
        !          1736:  *             KERN_INVALID_ARGUMENT   Task is not active.
        !          1737:  *             KERN_INVALID_ARGUMENT   The name doesn't denote a right.
        !          1738:  */
        !          1739: 
        !          1740: kern_return_t
        !          1741: port_type(space, name, typep)
        !          1742:        ipc_space_t space;
        !          1743:        mach_port_t name;
        !          1744:        mach_port_type_t *typep;
        !          1745: {
        !          1746:        mach_port_type_t type;
        !          1747:        kern_return_t kr;
        !          1748: 
        !          1749:        kr = mach_port_type(space, name, &type);
        !          1750:        if (kr != KERN_SUCCESS)
        !          1751:                return KERN_INVALID_ARGUMENT;
        !          1752: 
        !          1753:        *typep = convert_port_type(type);
        !          1754:        return KERN_SUCCESS;
        !          1755: }
        !          1756: 
        !          1757: /*
        !          1758:  *     Routine:        port_rename [kernel call]
        !          1759:  *     Purpose:
        !          1760:  *             Change the name of a capability.
        !          1761:  *             The new name can't be in use.
        !          1762:  *     Conditions:
        !          1763:  *             Nothing locked.
        !          1764:  *     Returns:
        !          1765:  *             KERN_SUCCESS            Retrieved type.
        !          1766:  *             KERN_INVALID_ARGUMENT   Task is null.
        !          1767:  *             KERN_INVALID_ARGUMENT   Task is not active.
        !          1768:  *             KERN_INVALID_ARGUMENT   The new name is reserved.
        !          1769:  *             KERN_NAME_EXISTS        The new name already denotes a right.
        !          1770:  *             KERN_INVALID_ARGUMENT   The old name doesn't denote a right.
        !          1771:  */
        !          1772: 
        !          1773: kern_return_t
        !          1774: port_rename(space, old_name, new_name)
        !          1775:        ipc_space_t space;
        !          1776:        mach_port_t old_name;
        !          1777:        mach_port_t new_name;
        !          1778: {
        !          1779:        kern_return_t kr;
        !          1780: 
        !          1781:        kr = mach_port_rename(space, old_name, new_name);
        !          1782:        if ((kr != KERN_SUCCESS) && (kr != KERN_NAME_EXISTS))
        !          1783:                kr = KERN_INVALID_ARGUMENT;
        !          1784: 
        !          1785:        return kr;
        !          1786: }
        !          1787: 
        !          1788: /*
        !          1789:  *     Routine:        port_allocate [kernel call]
        !          1790:  *     Purpose:
        !          1791:  *             Allocate a new port, giving all rights to "task".
        !          1792:  *
        !          1793:  *             Returns in "port_name" the task's local name for the port.
        !          1794:  *             Doesn't return a reference to the port.
        !          1795:  *     Conditions:
        !          1796:  *             Nothing locked.
        !          1797:  *     Returns:
        !          1798:  *             KERN_SUCCESS            Allocated a port.
        !          1799:  *             KERN_INVALID_ARGUMENT   Task is null.
        !          1800:  *             KERN_INVALID_ARGUMENT   Task is not active.
        !          1801:  *             KERN_RESOURCE_SHORTAGE  Couldn't allocate memory.
        !          1802:  */
        !          1803: 
        !          1804: kern_return_t
        !          1805: port_allocate(space, namep)
        !          1806:        ipc_space_t space;
        !          1807:        mach_port_t *namep;
        !          1808: {
        !          1809:        ipc_port_t port;
        !          1810:        kern_return_t kr;
        !          1811: 
        !          1812:        if (space == IS_NULL)
        !          1813:                return KERN_INVALID_ARGUMENT;
        !          1814: 
        !          1815:        kr = ipc_port_alloc_compat(space, namep, &port);
        !          1816:        if (kr == KERN_SUCCESS)
        !          1817:                ip_unlock(port);
        !          1818:        else if (kr != KERN_RESOURCE_SHORTAGE)
        !          1819:                kr = KERN_INVALID_ARGUMENT;
        !          1820: 
        !          1821:        return kr;
        !          1822: }
        !          1823: 
        !          1824: /*
        !          1825:  *     Routine:        port_deallocate [kernel call]
        !          1826:  *     Purpose:
        !          1827:  *             Delete port rights (send and receive) from a task.
        !          1828:  *     Conditions:
        !          1829:  *             Nothing locked.
        !          1830:  *     Returns:
        !          1831:  *             KERN_SUCCESS            Deallocated the port right.
        !          1832:  *             KERN_INVALID_ARGUMENT   Task is null.
        !          1833:  *             KERN_INVALID_ARGUMENT   Task is not active.
        !          1834:  *             KERN_INVALID_ARGUMENT   Name doesn't denote a port right.
        !          1835:  *     Additions:
        !          1836:  *             KERN_SUCCESS            Deallocated a send-once right.
        !          1837:  *             KERN_SUCCESS            Destroyed a dead name.
        !          1838:  */
        !          1839: 
        !          1840: kern_return_t
        !          1841: port_deallocate(space, name)
        !          1842:        ipc_space_t space;
        !          1843:        mach_port_t name;
        !          1844: {
        !          1845:        ipc_entry_t entry;
        !          1846:        mach_port_type_t type;
        !          1847:        mach_port_urefs_t urefs;
        !          1848:        kern_return_t kr;
        !          1849: 
        !          1850:        if (space == IS_NULL)
        !          1851:                return KERN_INVALID_ARGUMENT;
        !          1852: 
        !          1853:        kr = ipc_right_lookup_write(space, name, &entry);
        !          1854:        if (kr != KERN_SUCCESS)
        !          1855:                return KERN_INVALID_ARGUMENT;
        !          1856:        /* space is write-locked and active */
        !          1857: 
        !          1858:        /*
        !          1859:         *      We serialize with port destruction with the
        !          1860:         *      ipc_right_info call, not ipc_right_destroy.
        !          1861:         *      After ipc_right_info, we pretend that the
        !          1862:         *      port doesn't get destroyed.
        !          1863:         */
        !          1864: 
        !          1865:        kr = ipc_right_info(space, name, entry, &type, &urefs);
        !          1866:        if (kr != KERN_SUCCESS)
        !          1867:                return KERN_INVALID_ARGUMENT; /* space is unlocked */
        !          1868: 
        !          1869:        if ((type & (MACH_PORT_TYPE_PORT_OR_DEAD)) == 0) {
        !          1870:                is_write_unlock(space);
        !          1871:                return KERN_INVALID_ARGUMENT;
        !          1872:        }
        !          1873: 
        !          1874:        (void) ipc_right_destroy(space, name, entry);
        !          1875:        /* space is unlocked */
        !          1876: 
        !          1877:        return KERN_SUCCESS;
        !          1878: }
        !          1879: 
        !          1880: /*
        !          1881:  *     Routine:        port_set_backlog [kernel call]
        !          1882:  *     Purpose:
        !          1883:  *             Change the queueing backlog on "port_name" to "backlog";
        !          1884:  *             the specified "task" must be the current receiver.
        !          1885:  *
        !          1886:  *             Valid backlog values are 0 < backlog <= PORT_BACKLOG_MAX.
        !          1887:  *     Conditions:
        !          1888:  *             Nothing locked.
        !          1889:  *     Returns:
        !          1890:  *             KERN_SUCCESS            Set the backlog.
        !          1891:  *             KERN_INVALID_ARGUMENT   Task is null.
        !          1892:  *             KERN_INVALID_ARGUMENT   Task is not active.
        !          1893:  *             KERN_INVALID_ARGUMENT   Name doesn't denote a port right.
        !          1894:  *             KERN_NOT_RECEIVER       Name denotes send rights, not receive.
        !          1895:  *             KERN_INVALID_ARGUMENT   Backlog value is invalid.
        !          1896:  *     Additions:
        !          1897:  *             KERN_NOT_RECEIVER       Name denotes a send-once right.
        !          1898:  *             KERN_NOT_RECEIVER       Name denotes a dead name.
        !          1899:  */
        !          1900: 
        !          1901: kern_return_t
        !          1902: port_set_backlog(space, name, backlog)
        !          1903:        ipc_space_t space;
        !          1904:        mach_port_t name;
        !          1905:        int backlog;
        !          1906: {
        !          1907:        ipc_port_t port;
        !          1908:        kern_return_t kr;
        !          1909: 
        !          1910:        if ((space == IS_NULL) ||
        !          1911:            (backlog <= 0) ||
        !          1912:            (backlog > PORT_BACKLOG_MAX))
        !          1913:                return KERN_INVALID_ARGUMENT;
        !          1914: 
        !          1915:        kr = port_translate_compat(space, name, &port);
        !          1916:        if (kr != KERN_SUCCESS)
        !          1917:                return kr;
        !          1918:        /* port is locked and active */
        !          1919: 
        !          1920:        ipc_port_set_qlimit(port, (mach_port_msgcount_t) backlog);
        !          1921: 
        !          1922:        ip_unlock(port);
        !          1923:        return KERN_SUCCESS;
        !          1924: }
        !          1925: 
        !          1926: /*
        !          1927:  *     Routine:        port_set_backup [kernel call]
        !          1928:  *     Purpose:
        !          1929:  *             Changes the backup port for the the named port.
        !          1930:  *             The specified "task" must be the current receiver.
        !          1931:  *             Returns the old backup port, if any.
        !          1932:  *     Conditions:
        !          1933:  *             Nothing locked.
        !          1934:  *     Returns:
        !          1935:  *             KERN_SUCCESS            Set the backup.
        !          1936:  *             KERN_INVALID_ARGUMENT   Task is null.
        !          1937:  *             KERN_INVALID_ARGUMENT   Task is not active.
        !          1938:  *             KERN_INVALID_ARGUMENT   Name doesn't denote a port right.
        !          1939:  *             KERN_NOT_RECEIVER       Name denotes send rights, not receive.
        !          1940:  *     Additions:
        !          1941:  *             KERN_NOT_RECEIVER       Name denotes a send-once right.
        !          1942:  *             KERN_NOT_RECEIVER       Name denotes a dead name.
        !          1943:  */
        !          1944: 
        !          1945: kern_return_t
        !          1946: port_set_backup(space, name, backup, previousp)
        !          1947:        ipc_space_t space;
        !          1948:        mach_port_t name;
        !          1949:        ipc_port_t backup;
        !          1950:        ipc_port_t *previousp;
        !          1951: {
        !          1952:        ipc_port_t port, previous;
        !          1953:        kern_return_t kr;
        !          1954: 
        !          1955:        if (space == IS_NULL)
        !          1956:                return KERN_INVALID_ARGUMENT;
        !          1957: 
        !          1958:        if (backup == IP_DEAD)
        !          1959:                backup = IP_NULL;
        !          1960:        else if (backup != IP_NULL)
        !          1961:                backup = ip_pdsendm(backup);
        !          1962: 
        !          1963:        kr = port_translate_compat(space, name, &port);
        !          1964:        if (kr != KERN_SUCCESS)
        !          1965:                return kr;
        !          1966:        /* port is locked and active */
        !          1967: 
        !          1968:        ipc_port_pdrequest(port, backup, &previous);
        !          1969:        /* port is unlocked */
        !          1970: 
        !          1971:        /*
        !          1972:         *      If previous was a send-once right instead of a send
        !          1973:         *      right, we can't return it in the reply message.
        !          1974:         *      So get rid of it in a notification instead.
        !          1975:         */
        !          1976: 
        !          1977:        if (previous != IP_NULL) {
        !          1978:                if (ip_pdsendp(previous))
        !          1979:                        previous = ip_pdsend(previous);
        !          1980:                else {
        !          1981:                        ipc_notify_send_once(previous);
        !          1982:                        previous = IP_NULL;
        !          1983:                }
        !          1984:        }
        !          1985: 
        !          1986:        *previousp = previous;
        !          1987:        return KERN_SUCCESS;
        !          1988: }
        !          1989: 
        !          1990: /*
        !          1991:  *     Routine:        port_status [kernel call]
        !          1992:  *     Purpose:
        !          1993:  *             Returns statistics related to "port_name", as seen by "task".
        !          1994:  *             Only the receiver for a given port will see true message
        !          1995:  *             counts.
        !          1996:  *     Conditions:
        !          1997:  *             Nothing locked.
        !          1998:  *     Returns:
        !          1999:  *             KERN_SUCCESS            Retrieved status.
        !          2000:  *             KERN_INVALID_ARGUMENT   Task is null.
        !          2001:  *             KERN_INVALID_ARGUMENT   Task is not active.
        !          2002:  *             KERN_INVALID_ARGUMENT   Name doesn't denote a port right.
        !          2003:  *     Additions:
        !          2004:  *             KERN_SUCCESS            Send-once right.
        !          2005:  *             KERN_SUCCESS            Dead name.
        !          2006:  */
        !          2007: 
        !          2008: kern_return_t
        !          2009: port_status(space, name, enabledp, num_msgs, backlog,
        !          2010:            ownership, receive_rights)
        !          2011:        ipc_space_t space;
        !          2012:        mach_port_t name;
        !          2013:        mach_port_t *enabledp;
        !          2014:        int *num_msgs;
        !          2015:        int *backlog;
        !          2016:        boolean_t *ownership;
        !          2017:        boolean_t *receive_rights;
        !          2018: {
        !          2019:        ipc_entry_t entry;
        !          2020:        mach_port_type_t type;
        !          2021:        mach_port_urefs_t urefs;
        !          2022:        kern_return_t kr;
        !          2023: 
        !          2024:        if (space == IS_NULL)
        !          2025:                return KERN_INVALID_ARGUMENT;
        !          2026: 
        !          2027:        kr = ipc_right_lookup_write(space, name, &entry);
        !          2028:        if (kr != KERN_SUCCESS)
        !          2029:                return KERN_INVALID_ARGUMENT;
        !          2030:        /* space is write-locked and active */
        !          2031: 
        !          2032:        kr = ipc_right_info(space, name, entry, &type, &urefs);
        !          2033:        if (kr != KERN_SUCCESS)
        !          2034:                return KERN_INVALID_ARGUMENT; /* space is unlocked */
        !          2035: 
        !          2036:        if ((type & MACH_PORT_TYPE_PORT_OR_DEAD) == 0) {
        !          2037:                is_write_unlock(space);
        !          2038:                return KERN_INVALID_ARGUMENT;
        !          2039:        }
        !          2040: 
        !          2041:        if (type & MACH_PORT_TYPE_RECEIVE) {
        !          2042:                mach_port_t enabled;
        !          2043:                mach_port_msgcount_t qlimit;
        !          2044:                mach_port_msgcount_t msgcount;
        !          2045:                ipc_port_t port;
        !          2046: 
        !          2047:                port = (ipc_port_t) entry->ie_object;
        !          2048:                assert(port != IP_NULL);
        !          2049: 
        !          2050:                ip_lock(port);
        !          2051:                is_write_unlock(space);
        !          2052:                assert(ip_active(port));
        !          2053: 
        !          2054:                if (port->ip_pset != IPS_NULL) {
        !          2055:                        ipc_pset_t pset = port->ip_pset;
        !          2056: 
        !          2057:                        ips_lock(pset);
        !          2058:                        if (!ips_active(pset)) {
        !          2059:                                ipc_pset_remove(pset, port);
        !          2060:                                ips_check_unlock(pset);
        !          2061:                                enabled = MACH_PORT_NULL;
        !          2062:                        } else {
        !          2063:                                enabled = pset->ips_local_name;
        !          2064:                                ips_unlock(pset);
        !          2065:                                assert(MACH_PORT_VALID(enabled));
        !          2066:                        }
        !          2067:                } else
        !          2068:                        enabled = MACH_PORT_NULL;
        !          2069: 
        !          2070:                qlimit = port->ip_qlimit;
        !          2071:                msgcount = port->ip_msgcount;
        !          2072:                ip_unlock(port);
        !          2073: 
        !          2074:                *ownership = TRUE;
        !          2075:                *receive_rights = TRUE;
        !          2076:                *enabledp = enabled;
        !          2077:                *num_msgs = (int) msgcount;
        !          2078:                *backlog = (int) qlimit;
        !          2079:        } else {
        !          2080:                is_write_unlock(space);
        !          2081: 
        !          2082:                *ownership = FALSE;
        !          2083:                *receive_rights = FALSE;
        !          2084:                *enabledp = MACH_PORT_NULL;
        !          2085:                *num_msgs = -1;
        !          2086:                *backlog = 0;
        !          2087:        }
        !          2088: 
        !          2089:        return KERN_SUCCESS;
        !          2090: }
        !          2091: 
        !          2092: /*
        !          2093:  *     Routine:        port_set_allocate [kernel call]
        !          2094:  *     Purpose:
        !          2095:  *             Create a new port set, give rights to task, and
        !          2096:  *             return task's local name for the set.
        !          2097:  *     Conditions:
        !          2098:  *             Nothing locked.
        !          2099:  *     Returns:
        !          2100:  *             KERN_SUCCESS            Allocated a port set.
        !          2101:  *             KERN_INVALID_ARGUMENT   Task is null.
        !          2102:  *             KERN_INVALID_ARGUMENT   Task is not active.
        !          2103:  *             KERN_RESOURCE_SHORTAGE  Couldn't allocate memory.
        !          2104:  */
        !          2105: 
        !          2106: kern_return_t
        !          2107: port_set_allocate(space, namep)
        !          2108:        ipc_space_t space;
        !          2109:        mach_port_t *namep;
        !          2110: {
        !          2111:        ipc_pset_t pset;
        !          2112:        kern_return_t kr;
        !          2113: 
        !          2114:        if (space == IS_NULL)
        !          2115:                return KERN_INVALID_ARGUMENT;
        !          2116: 
        !          2117:        kr = ipc_pset_alloc(space, namep, &pset);
        !          2118:        if (kr == KERN_SUCCESS)
        !          2119:                ips_unlock(pset);
        !          2120:        else if (kr != KERN_RESOURCE_SHORTAGE)
        !          2121:                kr = KERN_INVALID_ARGUMENT;
        !          2122: 
        !          2123:        return kr;
        !          2124: }
        !          2125: 
        !          2126: /*
        !          2127:  *     Routine:        port_set_deallocate [kernel call]
        !          2128:  *     Purpose:
        !          2129:  *             Destroys the task's port set.  If there are any
        !          2130:  *             receive rights in the set, they are removed.
        !          2131:  *     Conditions:
        !          2132:  *             Nothing locked.
        !          2133:  *     Returns:
        !          2134:  *             KERN_SUCCESS            Deallocated the port set.
        !          2135:  *             KERN_INVALID_ARGUMENT   Task is null.
        !          2136:  *             KERN_INVALID_ARGUMENT   Task is not active.
        !          2137:  *             KERN_INVALID_ARGUMENT   Name doesn't denote a port set.
        !          2138:  */
        !          2139: 
        !          2140: kern_return_t
        !          2141: port_set_deallocate(space, name)
        !          2142:        ipc_space_t space;
        !          2143:        mach_port_t name;
        !          2144: {
        !          2145:        ipc_entry_t entry;
        !          2146:        kern_return_t kr;
        !          2147: 
        !          2148:        if (space == IS_NULL)
        !          2149:                return KERN_INVALID_ARGUMENT;
        !          2150: 
        !          2151:        kr = ipc_right_lookup_write(space, name, &entry);
        !          2152:        if (kr != KERN_SUCCESS)
        !          2153:                return kr;
        !          2154:        /* space is write-locked and active */
        !          2155: 
        !          2156:        if ((entry->ie_bits & MACH_PORT_TYPE_PORT_SET) == 0) {
        !          2157:                is_write_unlock(space);
        !          2158:                return KERN_INVALID_ARGUMENT;
        !          2159:        }
        !          2160: 
        !          2161:        kr = ipc_right_destroy(space, name, entry);
        !          2162:        /* space is unlocked */
        !          2163:        assert(kr == KERN_SUCCESS);
        !          2164:        return kr;
        !          2165: }
        !          2166: 
        !          2167: /*
        !          2168:  *     Routine:        port_set_add [kernel call]
        !          2169:  *     Purpose:
        !          2170:  *             Moves receive rights into the port set.
        !          2171:  *     Conditions:
        !          2172:  *             Nothing locked.
        !          2173:  *     Returns:
        !          2174:  *             KERN_SUCCESS            Moved the receive right.
        !          2175:  *             KERN_INVALID_ARGUMENT   Task is null.
        !          2176:  *             KERN_INVALID_ARGUMENT   Task is not active.
        !          2177:  *             KERN_INVALID_ARGUMENT   port_name doesn't denote port rights.
        !          2178:  *             KERN_NOT_RECEIVER       port_name doesn't denote receive right.
        !          2179:  *             KERN_INVALID_ARGUMENT   set_name doesn't denote a port set.
        !          2180:  *     Additions:
        !          2181:  *             KERN_NOT_RECEIVER       port_name denotes a send-once right.
        !          2182:  *             KERN_NOT_RECEIVER       port_name denotes a dead name.
        !          2183:  */
        !          2184: 
        !          2185: kern_return_t
        !          2186: port_set_add(space, set_name, port_name)
        !          2187:        ipc_space_t space;
        !          2188:        mach_port_t set_name;
        !          2189:        mach_port_t port_name;
        !          2190: {
        !          2191:        ipc_entry_t entry;
        !          2192:        mach_port_type_t type;
        !          2193:        mach_port_urefs_t urefs;
        !          2194:        ipc_port_t port;
        !          2195:        ipc_pset_t pset;
        !          2196:        kern_return_t kr;
        !          2197: 
        !          2198:        if (space == IS_NULL)
        !          2199:                return KERN_INVALID_ARGUMENT;
        !          2200: 
        !          2201:        kr = ipc_right_lookup_write(space, port_name, &entry);
        !          2202:        if (kr != KERN_SUCCESS)
        !          2203:                return KERN_INVALID_ARGUMENT;
        !          2204:        /* space is write-locked and active */
        !          2205: 
        !          2206:        /* use ipc_right_info to check for dead compat entries */
        !          2207: 
        !          2208:        kr = ipc_right_info(space, port_name, entry, &type, &urefs);
        !          2209:        if (kr != KERN_SUCCESS)
        !          2210:                return KERN_INVALID_ARGUMENT; /* space is unlocked */
        !          2211: 
        !          2212:        if ((type & MACH_PORT_TYPE_RECEIVE) == 0) {
        !          2213:                is_write_unlock(space);
        !          2214:                if (type & MACH_PORT_TYPE_PORT_OR_DEAD)
        !          2215:                        return KERN_NOT_RECEIVER;
        !          2216:                else
        !          2217:                        return KERN_INVALID_ARGUMENT;
        !          2218:        }
        !          2219: 
        !          2220:        is_write_to_read_lock(space);
        !          2221:        port = (ipc_port_t) entry->ie_object;
        !          2222:        assert(port != IP_NULL);
        !          2223: 
        !          2224:        entry = ipc_entry_lookup(space, set_name);
        !          2225:        if ((entry == IE_NULL) ||
        !          2226:            ((entry->ie_bits & MACH_PORT_TYPE_PORT_SET) == 0)) {
        !          2227:                is_read_unlock(space);
        !          2228:                return KERN_INVALID_ARGUMENT;
        !          2229:        }
        !          2230: 
        !          2231:        pset = (ipc_pset_t) entry->ie_object;
        !          2232:        assert(pset != IPS_NULL);
        !          2233: 
        !          2234:        kr = ipc_pset_move(space, port, pset);
        !          2235:        /* space is unlocked */
        !          2236:        assert(kr == KERN_SUCCESS);
        !          2237:        return kr;
        !          2238: }
        !          2239: 
        !          2240: /*
        !          2241:  *     Routine:        port_set_remove [kernel call]
        !          2242:  *     Purpose:
        !          2243:  *             Removes the receive rights from the set they are in.
        !          2244:  *     Conditions:
        !          2245:  *             Nothing locked.
        !          2246:  *     Returns:
        !          2247:  *             KERN_SUCCESS            Removed the receive right.
        !          2248:  *             KERN_INVALID_ARGUMENT   Task is null.
        !          2249:  *             KERN_INVALID_ARGUMENT   Task is not active.
        !          2250:  *             KERN_INVALID_ARGUMENT   Name doesn't denote a port right.
        !          2251:  *             KERN_NOT_RECEIVER       Name denotes send rights, not receive.
        !          2252:  *             KERN_NOT_IN_SET         Port isn't in a port set.
        !          2253:  *     Additions:
        !          2254:  *             KERN_NOT_RECEIVER       Name denotes a send-once right.
        !          2255:  *             KERN_NOT_RECEIVER       Name denotes a dead name.
        !          2256:  */
        !          2257: 
        !          2258: kern_return_t
        !          2259: port_set_remove(space, name)
        !          2260:        ipc_space_t space;
        !          2261:        mach_port_t name;
        !          2262: {
        !          2263:        ipc_entry_t entry;
        !          2264:        mach_port_type_t type;
        !          2265:        mach_port_urefs_t urefs;
        !          2266:        ipc_port_t port;
        !          2267:        kern_return_t kr;
        !          2268: 
        !          2269:        if (space == IS_NULL)
        !          2270:                return KERN_INVALID_ARGUMENT;
        !          2271: 
        !          2272:        kr = ipc_right_lookup_write(space, name, &entry);
        !          2273:        if (kr != KERN_SUCCESS)
        !          2274:                return KERN_INVALID_ARGUMENT;
        !          2275:        /* space is write-locked and active */
        !          2276: 
        !          2277:        /* use ipc_right_info to check for dead compat entries */
        !          2278: 
        !          2279:        kr = ipc_right_info(space, name, entry, &type, &urefs);
        !          2280:        if (kr != KERN_SUCCESS)
        !          2281:                return KERN_INVALID_ARGUMENT; /* space is unlocked */
        !          2282: 
        !          2283:        if ((type & (MACH_PORT_TYPE_RECEIVE)) == 0) {
        !          2284:                is_write_unlock(space);
        !          2285:                if (type & MACH_PORT_TYPE_PORT_OR_DEAD)
        !          2286:                        return KERN_NOT_RECEIVER;
        !          2287:                else
        !          2288:                        return KERN_INVALID_ARGUMENT;
        !          2289:        }
        !          2290: 
        !          2291:        is_write_to_read_lock(space);
        !          2292:        port = (ipc_port_t) entry->ie_object;
        !          2293:        assert(port != IP_NULL);
        !          2294: 
        !          2295:        kr = ipc_pset_move(space, port, IPS_NULL);
        !          2296:        /* space is unlocked */
        !          2297:        return kr;
        !          2298: }
        !          2299: 
        !          2300: /*
        !          2301:  *     Routine:        port_set_status [kernel call]
        !          2302:  *     Purpose:
        !          2303:  *             Retrieve list of members of a port set.
        !          2304:  *     Conditions:
        !          2305:  *             Nothing locked.
        !          2306:  *     Returns:
        !          2307:  *             KERN_SUCCESS            Retrieved port set status.
        !          2308:  *             KERN_INVALID_ARGUMENT   Task is null.
        !          2309:  *             KERN_INVALID_ARGUMENT   Task is not active.
        !          2310:  *             KERN_INVALID_ARGUMENT   Name doesn't denote a port set.
        !          2311:  *     Additions:
        !          2312:  *             KERN_RESOURCE_SHORTAGE  Couldn't allocate memory.
        !          2313:  */
        !          2314: 
        !          2315: kern_return_t
        !          2316: port_set_status(space, name, members, membersCnt)
        !          2317:        ipc_space_t space;
        !          2318:        mach_port_t name;
        !          2319:        mach_port_t **members;
        !          2320:        mach_msg_type_number_t *membersCnt;
        !          2321: {
        !          2322:        kern_return_t kr;
        !          2323: 
        !          2324:        kr = mach_port_get_set_status(space, name, members, membersCnt);
        !          2325:        if ((kr != KERN_SUCCESS) && (kr != KERN_RESOURCE_SHORTAGE))
        !          2326:                kr = KERN_INVALID_ARGUMENT;
        !          2327: 
        !          2328:        return kr;
        !          2329: }
        !          2330: 
        !          2331: /*
        !          2332:  *     Routine:        port_insert_send [kernel call]
        !          2333:  *     Purpose:
        !          2334:  *             Inserts send rights to a port into a task,
        !          2335:  *             at a given name.  The name must not be in use.
        !          2336:  *     Conditions:
        !          2337:  *             Nothing locked.
        !          2338:  *     Returns:
        !          2339:  *             KERN_SUCCESS            Inserted send right.
        !          2340:  *             KERN_INVALID_ARGUMENT   Task is null.
        !          2341:  *             KERN_INVALID_ARGUMENT   Task is not active.
        !          2342:  *             KERN_INVALID_ARGUMENT   Port is null or dead.
        !          2343:  *             KERN_INVALID_ARGUMENT   Name is reserved.
        !          2344:  *             KERN_NAME_EXISTS        Name already denotes a right.
        !          2345:  *             KERN_FAILURE            Task already has rights for the port.
        !          2346:  *     Additions:
        !          2347:  *             KERN_RESOURCE_SHORTAGE  Couldn't allocate memory.
        !          2348:  */
        !          2349: 
        !          2350: kern_return_t
        !          2351: port_insert_send(space, port, name)
        !          2352:        ipc_space_t space;
        !          2353:        ipc_port_t port;
        !          2354:        mach_port_t name;
        !          2355: {
        !          2356:        kern_return_t kr;
        !          2357: 
        !          2358:        if ((space == IS_NULL) ||
        !          2359:            !MACH_PORT_VALID(name) ||
        !          2360:            !IP_VALID(port))
        !          2361:                return KERN_INVALID_ARGUMENT;
        !          2362: 
        !          2363:        kr = ipc_object_copyout_name_compat(space, (ipc_object_t) port,
        !          2364:                                            MACH_MSG_TYPE_PORT_SEND, name);
        !          2365:        switch (kr) {
        !          2366:            case KERN_SUCCESS:
        !          2367:            case KERN_NAME_EXISTS:
        !          2368:            case KERN_RESOURCE_SHORTAGE:
        !          2369:                break;
        !          2370: 
        !          2371:            case KERN_RIGHT_EXISTS:
        !          2372:                kr = KERN_FAILURE;
        !          2373:                break;
        !          2374: 
        !          2375:            default:
        !          2376:                kr = KERN_INVALID_ARGUMENT;
        !          2377:                break;
        !          2378:        }
        !          2379: 
        !          2380:        return kr;
        !          2381: }
        !          2382: 
        !          2383: /*
        !          2384:  *     Routine:        port_extract_send [kernel call]
        !          2385:  *     Purpose:
        !          2386:  *             Extracts send rights from "task"'s "his_name" port.
        !          2387:  *             The task is left with no rights for the port.
        !          2388:  *     Conditions:
        !          2389:  *             Nothing locked.
        !          2390:  *     Returns:
        !          2391:  *             KERN_SUCCESS            Extracted send right.
        !          2392:  *             KERN_INVALID_ARGUMENT   Task is null.
        !          2393:  *             KERN_INVALID_ARGUMENT   Task is not active.
        !          2394:  *             KERN_INVALID_ARGUMENT   Name doesn't denote pure send rights.
        !          2395:  */
        !          2396: 
        !          2397: kern_return_t
        !          2398: port_extract_send(space, name, portp)
        !          2399:        ipc_space_t space;
        !          2400:        mach_port_t name;
        !          2401:        ipc_port_t *portp;
        !          2402: {
        !          2403:        kern_return_t kr;
        !          2404: 
        !          2405:        if (space == IS_NULL)
        !          2406:                return KERN_INVALID_ARGUMENT;
        !          2407: 
        !          2408:        kr = ipc_object_copyin_compat(space, name,
        !          2409:                                      MSG_TYPE_PORT, TRUE,
        !          2410:                                      (ipc_object_t *) portp);
        !          2411:        if (kr != KERN_SUCCESS)
        !          2412:                kr = KERN_INVALID_ARGUMENT;
        !          2413: 
        !          2414:        return kr;
        !          2415: }
        !          2416: 
        !          2417: /*
        !          2418:  *     Routine:        port_insert_receive [kernel call]
        !          2419:  *     Purpose:
        !          2420:  *             Inserts receive/ownership rights to a port into a task,
        !          2421:  *             at a given name.
        !          2422:  *     Conditions:
        !          2423:  *             Nothing locked.
        !          2424:  *     Returns:
        !          2425:  *             KERN_SUCCESS            Inserted receive right.
        !          2426:  *             KERN_INVALID_ARGUMENT   Task is null.
        !          2427:  *             KERN_INVALID_ARGUMENT   Task is not active.
        !          2428:  *             KERN_INVALID_ARGUMENT   Port is null.  (Can't be dead.)
        !          2429:  *             KERN_INVALID_ARGUMENT   Name is reserved.
        !          2430:  *             KERN_NAME_EXISTS        Name already denotes a right.
        !          2431:  *             KERN_FAILURE            Task already has rights for the port.
        !          2432:  *     Additions:
        !          2433:  *             KERN_RESOURCE_SHORTAGE  Couldn't allocate memory.
        !          2434:  */
        !          2435: 
        !          2436: kern_return_t
        !          2437: port_insert_receive(space, port, name)
        !          2438:        ipc_space_t space;
        !          2439:        ipc_port_t port;
        !          2440:        mach_port_t name;
        !          2441: {
        !          2442:        kern_return_t kr;
        !          2443: 
        !          2444:        if ((space == IS_NULL) ||
        !          2445:            !MACH_PORT_VALID(name) ||
        !          2446:            !IP_VALID(port))
        !          2447:                return KERN_INVALID_ARGUMENT;
        !          2448: 
        !          2449:        kr = ipc_object_copyout_name_compat(space, (ipc_object_t) port,
        !          2450:                                            MACH_MSG_TYPE_PORT_RECEIVE, name);
        !          2451:        switch (kr) {
        !          2452:            case KERN_SUCCESS:
        !          2453:            case KERN_NAME_EXISTS:
        !          2454:            case KERN_RESOURCE_SHORTAGE:
        !          2455:                break;
        !          2456: 
        !          2457:            case KERN_RIGHT_EXISTS:
        !          2458:                kr = KERN_FAILURE;
        !          2459:                break;
        !          2460: 
        !          2461:            default:
        !          2462:                kr = KERN_INVALID_ARGUMENT;
        !          2463:                break;
        !          2464:        }
        !          2465: 
        !          2466:        return kr;
        !          2467: }
        !          2468: 
        !          2469: /*
        !          2470:  *     Routine:        port_extract_receive [kernel call]
        !          2471:  *     Purpose:
        !          2472:  *             Extracts receive/ownership rights
        !          2473:  *             from "task"'s "his_name" port.
        !          2474:  *
        !          2475:  *             The task is left with no rights for the port.
        !          2476:  *     Conditions:
        !          2477:  *             Nothing locked.
        !          2478:  *     Returns:
        !          2479:  *             KERN_SUCCESS            Extracted receive right.
        !          2480:  *             KERN_INVALID_ARGUMENT   Task is null.
        !          2481:  *             KERN_INVALID_ARGUMENT   Task is not active.
        !          2482:  *             KERN_INVALID_ARGUMENT   Name doesn't denote receive rights.
        !          2483:  */
        !          2484: 
        !          2485: kern_return_t
        !          2486: port_extract_receive(space, name, portp)
        !          2487:        ipc_space_t space;
        !          2488:        mach_port_t name;
        !          2489:        ipc_port_t *portp;
        !          2490: {
        !          2491:        kern_return_t kr;
        !          2492: 
        !          2493:        if (space == IS_NULL)
        !          2494:                return KERN_INVALID_ARGUMENT;
        !          2495: 
        !          2496:        kr = ipc_object_copyin_compat(space, name,
        !          2497:                                      MSG_TYPE_PORT_ALL, TRUE,
        !          2498:                                      (ipc_object_t *) portp);
        !          2499:        if (kr != KERN_SUCCESS)
        !          2500:                kr = KERN_INVALID_ARGUMENT;
        !          2501: 
        !          2502:        return kr;
        !          2503: }
        !          2504: 
        !          2505: #endif MACH_IPC_COMPAT

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