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 105kern_return_t 106mach_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 114kern_return_t 115mach_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 155kern_return_t 156mach_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 167kern_return_t 168mach_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, ©); 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 306kern_return_t 307mach_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 314kern_return_t 315mach_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 359kern_return_t 360mach_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 369kern_return_t 370mach_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 433kern_return_t 434mach_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 443kern_return_t 444mach_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 if (0 != kaddr && is_ipc_kobject(*typep)) 484 *addrp = VM_KERNEL_UNSLIDE_OR_PERM(kaddr); 485 else 486 *addrp = 0; 487 488 return KERN_SUCCESS; 489} 490#endif /* MACH_IPC_DEBUG */ 491/* 492 * Routine: mach_port_kernel_object [Legacy kernel call] 493 * Purpose: 494 * Retrieve the type and address of the kernel object 495 * represented by a send or receive right. Hard-coded 496 * to return only the low-order 32-bits of the kernel 497 * object. 498 * Conditions: 499 * Nothing locked. 500 * Returns: 501 * KERN_SUCCESS Retrieved kernel object info. 502 * KERN_INVALID_TASK The space is null. 503 * KERN_INVALID_TASK The space is dead. 504 * KERN_INVALID_NAME The name doesn't denote a right. 505 * KERN_INVALID_RIGHT Name doesn't denote 506 * send or receive rights. 507 */ 508 509#if !MACH_IPC_DEBUG 510kern_return_t 511mach_port_kernel_object( 512 __unused ipc_space_t space, 513 __unused mach_port_name_t name, 514 __unused unsigned int *typep, 515 __unused unsigned int *addrp) 516{ 517 return KERN_FAILURE; 518} 519#else 520kern_return_t 521mach_port_kernel_object( 522 ipc_space_t space, 523 mach_port_name_t name, 524 unsigned int *typep, 525 unsigned int *addrp) 526{ 527 mach_vm_address_t addr = 0; 528 kern_return_t kr; 529 530 kr = mach_port_kobject(space, name, typep, &addr); 531 *addrp = (unsigned int) addr; 532 return kr; 533} 534#endif /* MACH_IPC_DEBUG */ 535