osfmk/ipc/mach_debug.c

   1 /*
   2  * Copyright (c) 2000-2004 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. The rights granted to you under the License
  10  * may not be used to create, or enable the creation or redistribution of,
  11  * unlawful or unlicensed copies of an Apple operating system, or to
  12  * circumvent, violate, or enable the circumvention or violation of, any
  13  * terms of an Apple operating system software license agreement.
  14  *
  15  * Please obtain a copy of the License at
  16  * http://www.opensource.apple.com/apsl/ and read it before using this file.
  17  *
  18  * The Original Code and all software distributed under the License are
  19  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  20  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  21  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  23  * Please see the License for the specific language governing rights and
  24  * limitations under the License.
  25  *
  26  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  27  */
  28 /*
  29  * @OSF_COPYRIGHT@
  30  */
  31 /*
  32  * Mach Operating System
  33  * Copyright (c) 1991,1990 Carnegie Mellon University
  34  * All Rights Reserved.
  35  *
  36  * Permission to use, copy, modify and distribute this software and its
  37  * documentation is hereby granted, provided that both the copyright
  38  * notice and this permission notice appear in all copies of the
  39  * software, derivative works or modified versions, and any portions
  40  * thereof, and that both notices appear in supporting documentation.
  41  *
  42  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
  43  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
  44  * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
  45  *
  46  * Carnegie Mellon requests users of this software to return to
  47  *
  48  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
  49  *  School of Computer Science
  50  *  Carnegie Mellon University
  51  *  Pittsburgh PA 15213-3890
  52  *
  53  * any improvements or extensions that they make and grant Carnegie Mellon
  54  * the rights to redistribute these changes.
  55  */
  56 /*
  57  */
  58 /*
  59  *      File:   ipc/mach_debug.c
  60  *      Author: Rich Draves
  61  *      Date:   1989
  62  *
  63  *      Exported IPC debug calls.
  64  */
  65 #include <mach_ipc_debug.h>
  66
  67 #include <mach/vm_param.h>
  68 #include <mach/kern_return.h>
  69 #include <mach/machine/vm_types.h>
  70 #include <mach/mach_host_server.h>
  71 #include <mach/mach_port_server.h>
  72 #include <mach_debug/ipc_info.h>
  73 #include <mach_debug/hash_info.h>
  74
  75 #if MACH_IPC_DEBUG
  76 #include <kern/host.h>
  77 #include <kern/misc_protos.h>
  78 #include <vm/vm_map.h>
  79 #include <vm/vm_kern.h>
  80 #include <ipc/port.h>
  81 #include <ipc/ipc_types.h>
  82 #include <ipc/ipc_space.h>
  83 #include <ipc/ipc_port.h>
  84 #include <ipc/ipc_hash.h>
  85 #include <ipc/ipc_table.h>
  86 #include <ipc/ipc_right.h>
  87 #endif
  88
  89 /*
  90  *      Routine:        mach_port_get_srights [kernel call]
  91  *      Purpose:
  92  *              Retrieve the number of extant send rights
  93  *              that a receive right has.
  94  *      Conditions:
  95  *              Nothing locked.
  96  *      Returns:
  97  *              KERN_SUCCESS            Retrieved number of send rights.
  98  *              KERN_INVALID_TASK       The space is null.
  99  *              KERN_INVALID_TASK       The space is dead.
 100  *              KERN_INVALID_NAME       The name doesn't denote a right.
 101  *              KERN_INVALID_RIGHT      Name doesn't denote receive rights.
 102  */
 103
 104 #if !MACH_IPC_DEBUG
 105 kern_return_t
 106 mach_port_get_srights(
 107         __unused ipc_space_t            space,
 108         __unused mach_port_name_t       name,
 109         __unused mach_port_rights_t     *srightsp)
 110 {
 111         return KERN_FAILURE;
 112 }
 113 #else
 114 kern_return_t
 115 mach_port_get_srights(
 116         ipc_space_t             space,
 117         mach_port_name_t        name,
 118         mach_port_rights_t      *srightsp)
 119 {
 120         ipc_port_t port;
 121         kern_return_t kr;
 122         mach_port_rights_t srights;
 123
 124         if (space == IS_NULL)
 125                 return KERN_INVALID_TASK;
 126
 127         kr = ipc_port_translate_receive(space, name, &port);
 128         if (kr != KERN_SUCCESS)
 129                 return kr;
 130         /* port is locked and active */
 131
 132         srights = port->ip_srights;
 133         ip_unlock(port);
 134
 135         *srightsp = srights;
 136         return KERN_SUCCESS;
 137 }
 138 #endif /* MACH_IPC_DEBUG */
 139
 140
 141 /*
 142  *      Routine:        mach_port_space_info
 143  *      Purpose:
 144  *              Returns information about an IPC space.
 145  *      Conditions:
 146  *              Nothing locked.  Obeys CountInOut protocol.
 147  *      Returns:
 148  *              KERN_SUCCESS            Returned information.
 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 #if !MACH_IPC_DEBUG
 155 kern_return_t
 156 mach_port_space_info(
 157         __unused ipc_space_t                    space,
 158         __unused ipc_info_space_t               *infop,
 159         __unused ipc_info_name_array_t  *tablep,
 160         __unused mach_msg_type_number_t         *tableCntp,
 161         __unused ipc_info_tree_name_array_t *treep,
 162         __unused mach_msg_type_number_t         *treeCntp)
 163 {
 164         return KERN_FAILURE;
 165 }
 166 #else
 167 kern_return_t
 168 mach_port_space_info(
 169         ipc_space_t                     space,
 170         ipc_info_space_t                *infop,
 171         ipc_info_name_array_t           *tablep,
 172         mach_msg_type_number_t          *tableCntp,
 173         __unused ipc_info_tree_name_array_t     *treep,
 174         __unused mach_msg_type_number_t         *treeCntp)
 175 {
 176         ipc_info_name_t *table_info;
 177         vm_offset_t table_addr;
 178         vm_size_t table_size, table_size_needed;
 179         ipc_entry_t table;
 180         ipc_entry_num_t tsize;
 181         mach_port_index_t index;
 182         kern_return_t kr;
 183         vm_map_copy_t copy;
 184
 185
 186         if (space == IS_NULL)
 187                 return KERN_INVALID_TASK;
 188
 189         /* start with in-line memory */
 190
 191         table_size = 0;
 192
 193         for (;;) {
 194                 is_read_lock(space);
 195                 if (!is_active(space)) {
 196                         is_read_unlock(space);
 197                         if (table_size != 0)
 198                                 kmem_free(ipc_kernel_map,
 199                                           table_addr, table_size);
 200                         return KERN_INVALID_TASK;
 201                 }
 202
 203                 table_size_needed =
 204                         vm_map_round_page((space->is_table_size
 205                                            * sizeof(ipc_info_name_t)),
 206                                           VM_MAP_PAGE_MASK(ipc_kernel_map));
 207
 208                 if (table_size_needed == table_size)
 209                         break;
 210
 211                 is_read_unlock(space);
 212
 213                 if (table_size != table_size_needed) {
 214                         if (table_size != 0)
 215                                 kmem_free(ipc_kernel_map, table_addr, table_size);
 216                         kr = kmem_alloc(ipc_kernel_map, &table_addr, table_size_needed);
 217                         if (kr != KERN_SUCCESS) {
 218                                 return KERN_RESOURCE_SHORTAGE;
 219                         }
 220                         table_size = table_size_needed;
 221                 }
 222
 223         }
 224         /* space is read-locked and active; we have enough wired memory */
 225
 226         /* get the overall space info */
 227         infop->iis_genno_mask = MACH_PORT_NGEN(MACH_PORT_DEAD);
 228         infop->iis_table_size = space->is_table_size;
 229         infop->iis_table_next = space->is_table_next->its_size;
 230
 231         /* walk the table for this space */
 232         table = space->is_table;
 233         tsize = space->is_table_size;
 234         table_info = (ipc_info_name_array_t)table_addr;
 235         for (index = 0; index < tsize; index++) {
 236                 ipc_info_name_t *iin = &table_info[index];
 237                 ipc_entry_t entry = &table[index];
 238                 ipc_entry_bits_t bits;
 239
 240                 bits = entry->ie_bits;
 241                 iin->iin_name = MACH_PORT_MAKE(index, IE_BITS_GEN(bits));
 242                 iin->iin_collision = 0;
 243                 iin->iin_type = IE_BITS_TYPE(bits);
 244                 if ((entry->ie_bits & MACH_PORT_TYPE_PORT_RIGHTS) != MACH_PORT_TYPE_NONE &&
 245                     entry->ie_request != IE_REQ_NONE) {
 246                         ipc_port_t port = (ipc_port_t) entry->ie_object;
 247
 248                         assert(IP_VALID(port));
 249                         ip_lock(port);
 250                         iin->iin_type |= ipc_port_request_type(port, iin->iin_name, entry->ie_request);
 251                         ip_unlock(port);
 252                 }
 253
 254                 iin->iin_urefs = IE_BITS_UREFS(bits);
 255                 iin->iin_object = (natural_t)VM_KERNEL_ADDRPERM((uintptr_t)entry->ie_object);
 256                 iin->iin_next = entry->ie_next;
 257                 iin->iin_hash = entry->ie_index;
 258         }
 259
 260         is_read_unlock(space);
 261
 262         /* prepare the table out-of-line data for return */
 263         if (table_size > 0) {
 264                 if (table_size > infop->iis_table_size * sizeof(ipc_info_name_t))
 265                         bzero((char *)&table_info[infop->iis_table_size],
 266                               table_size - infop->iis_table_size * sizeof(ipc_info_name_t));
 267
 268                 kr = vm_map_unwire(
 269                         ipc_kernel_map,
 270                         vm_map_trunc_page(table_addr,
 271                                           VM_MAP_PAGE_MASK(ipc_kernel_map)),
 272                         vm_map_round_page(table_addr + table_size,
 273                                           VM_MAP_PAGE_MASK(ipc_kernel_map)),
 274                         FALSE);
 275                 assert(kr == KERN_SUCCESS);
 276                 kr = vm_map_copyin(ipc_kernel_map, (vm_map_address_t)table_addr,
 277                                    (vm_map_size_t)table_size, TRUE, &copy);
 278                 assert(kr == KERN_SUCCESS);
 279                 *tablep = (ipc_info_name_t *)copy;
 280                 *tableCntp = infop->iis_table_size;
 281         } else {
 282                 *tablep = (ipc_info_name_t *)0;
 283                 *tableCntp = 0;
 284         }
 285
 286         /* splay tree is obsolete, no work to do... */
 287         *treep = (ipc_info_tree_name_t *)0;
 288         *treeCntp = 0;
 289         return KERN_SUCCESS;
 290 }
 291 #endif /* MACH_IPC_DEBUG */
 292
 293 /*
 294  *      Routine:        mach_port_dnrequest_info
 295  *      Purpose:
 296  *              Returns information about the dead-name requests
 297  *              registered with the named receive right.
 298  *      Conditions:
 299  *              Nothing locked.
 300  *      Returns:
 301  *              KERN_SUCCESS            Retrieved information.
 302  *              KERN_INVALID_TASK       The space is null.
 303  *              KERN_INVALID_TASK       The space is dead.
 304  *              KERN_INVALID_NAME       The name doesn't denote a right.
 305  *              KERN_INVALID_RIGHT      Name doesn't denote receive rights.
 306  */
 307
 308 #if !MACH_IPC_DEBUG
 309 kern_return_t
 310 mach_port_dnrequest_info(
 311         __unused ipc_space_t            space,
 312         __unused mach_port_name_t       name,
 313         __unused unsigned int   *totalp,
 314         __unused unsigned int   *usedp)
 315 {
 316         return KERN_FAILURE;
 317 }
 318 #else
 319 kern_return_t
 320 mach_port_dnrequest_info(
 321         ipc_space_t                     space,
 322         mach_port_name_t                name,
 323         unsigned int                    *totalp,
 324         unsigned int                    *usedp)
 325 {
 326         unsigned int total, used;
 327         ipc_port_t port;
 328         kern_return_t kr;
 329
 330         if (space == IS_NULL)
 331                 return KERN_INVALID_TASK;
 332
 333         kr = ipc_port_translate_receive(space, name, &port);
 334         if (kr != KERN_SUCCESS)
 335                 return kr;
 336         /* port is locked and active */
 337
 338         if (port->ip_requests == IPR_NULL) {
 339                 total = 0;
 340                 used = 0;
 341         } else {
 342                 ipc_port_request_t requests = port->ip_requests;
 343                 ipc_port_request_index_t index;
 344
 345                 total = requests->ipr_size->its_size;
 346
 347                 for (index = 1, used = 0;
 348                      index < total; index++) {
 349                         ipc_port_request_t ipr = &requests[index];
 350
 351                         if (ipr->ipr_name != MACH_PORT_NULL)
 352                                 used++;
 353                 }
 354         }
 355         ip_unlock(port);
 356
 357         *totalp = total;
 358         *usedp = used;
 359         return KERN_SUCCESS;
 360 }
 361 #endif /* MACH_IPC_DEBUG */
 362
 363 /*
 364  *      Routine:        mach_port_kobject [kernel call]
 365  *      Purpose:
 366  *              Retrieve the type and address of the kernel object
 367  *              represented by a send or receive right. Returns
 368  *              the kernel address in a mach_vm_address_t to
 369  *              mask potential differences in kernel address space
 370  *              size.
 371  *      Conditions:
 372  *              Nothing locked.
 373  *      Returns:
 374  *              KERN_SUCCESS            Retrieved kernel object info.
 375  *              KERN_INVALID_TASK       The space is null.
 376  *              KERN_INVALID_TASK       The space is dead.
 377  *              KERN_INVALID_NAME       The name doesn't denote a right.
 378  *              KERN_INVALID_RIGHT      Name doesn't denote
 379  *                                      send or receive rights.
 380  */
 381
 382 #if !MACH_IPC_DEBUG
 383 kern_return_t
 384 mach_port_kobject(
 385         __unused ipc_space_t            space,
 386         __unused mach_port_name_t       name,
 387         __unused natural_t              *typep,
 388         __unused mach_vm_address_t      *addrp)
 389 {
 390         return KERN_FAILURE;
 391 }
 392 #else
 393 kern_return_t
 394 mach_port_kobject(
 395         ipc_space_t                     space,
 396         mach_port_name_t                name,
 397         natural_t                       *typep,
 398         mach_vm_address_t               *addrp)
 399 {
 400         ipc_entry_t entry;
 401         ipc_port_t port;
 402         kern_return_t kr;
 403         mach_vm_address_t kaddr;
 404
 405         if (space == IS_NULL)
 406                 return KERN_INVALID_TASK;
 407
 408         kr = ipc_right_lookup_read(space, name, &entry);
 409         if (kr != KERN_SUCCESS)
 410                 return kr;
 411         /* space is read-locked and active */
 412
 413         if ((entry->ie_bits & MACH_PORT_TYPE_SEND_RECEIVE) == 0) {
 414                 is_read_unlock(space);
 415                 return KERN_INVALID_RIGHT;
 416         }
 417
 418         port = (ipc_port_t) entry->ie_object;
 419         assert(port != IP_NULL);
 420
 421         ip_lock(port);
 422         is_read_unlock(space);
 423
 424         if (!ip_active(port)) {
 425                 ip_unlock(port);
 426                 return KERN_INVALID_RIGHT;
 427         }
 428
 429         *typep = (unsigned int) ip_kotype(port);
 430         kaddr = (mach_vm_address_t)port->ip_kobject;
 431         ip_unlock(port);
 432
 433         if (0 != kaddr && is_ipc_kobject(*typep))
 434                 *addrp = VM_KERNEL_ADDRPERM(VM_KERNEL_UNSLIDE(kaddr));
 435         else
 436                 *addrp = 0;
 437
 438         return KERN_SUCCESS;
 439 }
 440 #endif /* MACH_IPC_DEBUG */
 441 /*
 442  *      Routine:        mach_port_kernel_object [Legacy kernel call]
 443  *      Purpose:
 444  *              Retrieve the type and address of the kernel object
 445  *              represented by a send or receive right. Hard-coded
 446  *              to return only the low-order 32-bits of the kernel
 447  *              object.
 448  *      Conditions:
 449  *              Nothing locked.
 450  *      Returns:
 451  *              KERN_SUCCESS            Retrieved kernel object info.
 452  *              KERN_INVALID_TASK       The space is null.
 453  *              KERN_INVALID_TASK       The space is dead.
 454  *              KERN_INVALID_NAME       The name doesn't denote a right.
 455  *              KERN_INVALID_RIGHT      Name doesn't denote
 456  *                                      send or receive rights.
 457  */
 458
 459 #if !MACH_IPC_DEBUG
 460 kern_return_t
 461 mach_port_kernel_object(
 462         __unused ipc_space_t            space,
 463         __unused mach_port_name_t       name,
 464         __unused unsigned int           *typep,
 465         __unused unsigned int           *addrp)
 466 {
 467         return KERN_FAILURE;
 468 }
 469 #else
 470 kern_return_t
 471 mach_port_kernel_object(
 472         ipc_space_t                     space,
 473         mach_port_name_t                name,
 474         unsigned int                    *typep,
 475         unsigned int                    *addrp)
 476 {
 477         mach_vm_address_t addr = 0;
 478         kern_return_t kr;
 479
 480         kr = mach_port_kobject(space, name, typep, &addr);
 481         *addrp = (unsigned int) addr;
 482         return kr;
 483 }
 484 #endif /* MACH_IPC_DEBUG */