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_space_basic_info
 295  *      Purpose:
 296  *              Returns basic information about an IPC space.
 297  *      Conditions:
 298  *              Nothing locked.
 299  *      Returns:
 300  *              KERN_SUCCESS            Returned information.
 301  *              KERN_FAILURE            The call is not supported.
 302  *              KERN_INVALID_TASK       The space is dead.
 303  */
 304
 305 #if !MACH_IPC_DEBUG
 306 kern_return_t
 307 mach_port_space_basic_info(
 308         __unused ipc_space_t                    space,
 309         __unused ipc_info_space_basic_t         *infop)
 310 {
 311         return KERN_FAILURE;
 312 }
 313 #else
 314 kern_return_t
 315 mach_port_space_basic_info(
 316         ipc_space_t                     space,
 317         ipc_info_space_basic_t          *infop)
 318 {
 319         if (space == IS_NULL)
 320                 return KERN_INVALID_TASK;
 321
 322
 323         is_read_lock(space);
 324         if (!is_active(space)) {
 325                 is_read_unlock(space);
 326                 return KERN_INVALID_TASK;
 327         }
 328
 329         /* get the basic space info */
 330         infop->iisb_genno_mask = MACH_PORT_NGEN(MACH_PORT_DEAD);
 331         infop->iisb_table_size = space->is_table_size;
 332         infop->iisb_table_next = space->is_table_next->its_size;
 333         infop->iisb_table_inuse = space->is_table_size - space->is_table_free - 1;
 334         infop->iisb_reserved[0] = 0;
 335         infop->iisb_reserved[1] = 0;
 336
 337         is_read_unlock(space);
 338
 339         return KERN_SUCCESS;
 340 }
 341 #endif /* MACH_IPC_DEBUG */
 342
 343 /*
 344  *      Routine:        mach_port_dnrequest_info
 345  *      Purpose:
 346  *              Returns information about the dead-name requests
 347  *              registered with the named receive right.
 348  *      Conditions:
 349  *              Nothing locked.
 350  *      Returns:
 351  *              KERN_SUCCESS            Retrieved information.
 352  *              KERN_INVALID_TASK       The space is null.
 353  *              KERN_INVALID_TASK       The space is dead.
 354  *              KERN_INVALID_NAME       The name doesn't denote a right.
 355  *              KERN_INVALID_RIGHT      Name doesn't denote receive rights.
 356  */
 357
 358 #if !MACH_IPC_DEBUG
 359 kern_return_t
 360 mach_port_dnrequest_info(
 361         __unused ipc_space_t            space,
 362         __unused mach_port_name_t       name,
 363         __unused unsigned int   *totalp,
 364         __unused unsigned int   *usedp)
 365 {
 366         return KERN_FAILURE;
 367 }
 368 #else
 369 kern_return_t
 370 mach_port_dnrequest_info(
 371         ipc_space_t                     space,
 372         mach_port_name_t                name,
 373         unsigned int                    *totalp,
 374         unsigned int                    *usedp)
 375 {
 376         unsigned int total, used;
 377         ipc_port_t port;
 378         kern_return_t kr;
 379
 380         if (space == IS_NULL)
 381                 return KERN_INVALID_TASK;
 382
 383         kr = ipc_port_translate_receive(space, name, &port);
 384         if (kr != KERN_SUCCESS)
 385                 return kr;
 386         /* port is locked and active */
 387
 388         if (port->ip_requests == IPR_NULL) {
 389                 total = 0;
 390                 used = 0;
 391         } else {
 392                 ipc_port_request_t requests = port->ip_requests;
 393                 ipc_port_request_index_t index;
 394
 395                 total = requests->ipr_size->its_size;
 396
 397                 for (index = 1, used = 0;
 398                      index < total; index++) {
 399                         ipc_port_request_t ipr = &requests[index];
 400
 401                         if (ipr->ipr_name != MACH_PORT_NULL)
 402                                 used++;
 403                 }
 404         }
 405         ip_unlock(port);
 406
 407         *totalp = total;
 408         *usedp = used;
 409         return KERN_SUCCESS;
 410 }
 411 #endif /* MACH_IPC_DEBUG */
 412
 413 /*
 414  *      Routine:        mach_port_kobject [kernel call]
 415  *      Purpose:
 416  *              Retrieve the type and address of the kernel object
 417  *              represented by a send or receive right. Returns
 418  *              the kernel address in a mach_vm_address_t to
 419  *              mask potential differences in kernel address space
 420  *              size.
 421  *      Conditions:
 422  *              Nothing locked.
 423  *      Returns:
 424  *              KERN_SUCCESS            Retrieved kernel object info.
 425  *              KERN_INVALID_TASK       The space is null.
 426  *              KERN_INVALID_TASK       The space is dead.
 427  *              KERN_INVALID_NAME       The name doesn't denote a right.
 428  *              KERN_INVALID_RIGHT      Name doesn't denote
 429  *                                      send or receive rights.
 430  */
 431
 432 #if !MACH_IPC_DEBUG
 433 kern_return_t
 434 mach_port_kobject(
 435         __unused ipc_space_t            space,
 436         __unused mach_port_name_t       name,
 437         __unused natural_t              *typep,
 438         __unused mach_vm_address_t      *addrp)
 439 {
 440         return KERN_FAILURE;
 441 }
 442 #else
 443 kern_return_t
 444 mach_port_kobject(
 445         ipc_space_t                     space,
 446         mach_port_name_t                name,
 447         natural_t                       *typep,
 448         mach_vm_address_t               *addrp)
 449 {
 450         ipc_entry_t entry;
 451         ipc_port_t port;
 452         kern_return_t kr;
 453         mach_vm_address_t kaddr;
 454
 455         if (space == IS_NULL)
 456                 return KERN_INVALID_TASK;
 457
 458         kr = ipc_right_lookup_read(space, name, &entry);
 459         if (kr != KERN_SUCCESS)
 460                 return kr;
 461         /* space is read-locked and active */
 462
 463         if ((entry->ie_bits & MACH_PORT_TYPE_SEND_RECEIVE) == 0) {
 464                 is_read_unlock(space);
 465                 return KERN_INVALID_RIGHT;
 466         }
 467
 468         port = (ipc_port_t) entry->ie_object;
 469         assert(port != IP_NULL);
 470
 471         ip_lock(port);
 472         is_read_unlock(space);
 473
 474         if (!ip_active(port)) {
 475                 ip_unlock(port);
 476                 return KERN_INVALID_RIGHT;
 477         }
 478
 479         *typep = (unsigned int) ip_kotype(port);
 480         kaddr = (mach_vm_address_t)port->ip_kobject;
 481         ip_unlock(port);
 482
 483
 484         if (0 != kaddr && is_ipc_kobject(*typep))
 485                 *addrp = VM_KERNEL_UNSLIDE_OR_PERM(kaddr);
 486         else
 487                 *addrp = 0;
 488
 489         return KERN_SUCCESS;
 490 }
 491 #endif /* MACH_IPC_DEBUG */
 492 /*
 493  *      Routine:        mach_port_kernel_object [Legacy kernel call]
 494  *      Purpose:
 495  *              Retrieve the type and address of the kernel object
 496  *              represented by a send or receive right. Hard-coded
 497  *              to return only the low-order 32-bits of the kernel
 498  *              object.
 499  *      Conditions:
 500  *              Nothing locked.
 501  *      Returns:
 502  *              KERN_SUCCESS            Retrieved kernel object info.
 503  *              KERN_INVALID_TASK       The space is null.
 504  *              KERN_INVALID_TASK       The space is dead.
 505  *              KERN_INVALID_NAME       The name doesn't denote a right.
 506  *              KERN_INVALID_RIGHT      Name doesn't denote
 507  *                                      send or receive rights.
 508  */
 509
 510 #if !MACH_IPC_DEBUG
 511 kern_return_t
 512 mach_port_kernel_object(
 513         __unused ipc_space_t            space,
 514         __unused mach_port_name_t       name,
 515         __unused unsigned int           *typep,
 516         __unused unsigned int           *addrp)
 517 {
 518         return KERN_FAILURE;
 519 }
 520 #else
 521 kern_return_t
 522 mach_port_kernel_object(
 523         ipc_space_t                     space,
 524         mach_port_name_t                name,
 525         unsigned int                    *typep,
 526         unsigned int                    *addrp)
 527 {
 528         mach_vm_address_t addr = 0;
 529         kern_return_t kr;
 530
 531         kr = mach_port_kobject(space, name, typep, &addr);
 532         *addrp = (unsigned int) addr;
 533         return kr;
 534 }
 535 #endif /* MACH_IPC_DEBUG */