iokit/Kernel/IOUserClient.cpp

   1 /*
   2  * Copyright (c) 1998-2004 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * The contents of this file constitute Original Code as defined in and
   7  * are subject to the Apple Public Source License Version 1.1 (the
   8  * "License").  You may not use this file except in compliance with the
   9  * License.  Please obtain a copy of the License at
  10  * http://www.apple.com/publicsource and read it before using this file.
  11  *
  12  * This Original Code and all software distributed under the License are
  13  * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  14  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  15  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
  17  * License for the specific language governing rights and limitations
  18  * under the License.
  19  *
  20  * @APPLE_LICENSE_HEADER_END@
  21  */
  22
  23
  24 #include <IOKit/IOKitServer.h>
  25 #include <IOKit/IOKitKeysPrivate.h>
  26 #include <IOKit/IOUserClient.h>
  27 #include <IOKit/IOService.h>
  28 #include <IOKit/IOService.h>
  29 #include <IOKit/IORegistryEntry.h>
  30 #include <IOKit/IOCatalogue.h>
  31 #include <IOKit/IOMemoryDescriptor.h>
  32 #include <IOKit/IOLib.h>
  33
  34 #include <IOKit/assert.h>
  35
  36 #include "IOServicePrivate.h"
  37
  38 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  39
  40 // definitions we should get from osfmk
  41
  42 //typedef struct ipc_port * ipc_port_t;
  43 typedef natural_t ipc_kobject_type_t;
  44
  45 #define IKOT_IOKIT_SPARE        27
  46 #define IKOT_IOKIT_CONNECT      29
  47 #define IKOT_IOKIT_OBJECT       30
  48
  49 extern "C" {
  50
  51 extern ipc_port_t iokit_alloc_object_port( io_object_t obj,
  52                         ipc_kobject_type_t type );
  53
  54 extern kern_return_t iokit_destroy_object_port( ipc_port_t port );
  55
  56 extern mach_port_name_t iokit_make_send_right( task_t task,
  57                                 io_object_t obj, ipc_kobject_type_t type );
  58
  59 extern kern_return_t iokit_mod_send_right( task_t task, mach_port_name_t name, mach_port_delta_t delta );
  60
  61 extern io_object_t iokit_lookup_connect_ref(io_object_t clientRef, ipc_space_t task);
  62
  63 extern io_object_t iokit_lookup_connect_ref_current_task(io_object_t clientRef);
  64
  65 extern ipc_port_t master_device_port;
  66
  67 extern void iokit_retain_port( ipc_port_t port );
  68 extern void iokit_release_port( ipc_port_t port );
  69
  70 extern kern_return_t iokit_switch_object_port( ipc_port_t port, io_object_t obj, ipc_kobject_type_t type );
  71
  72 #include <mach/mach_traps.h>
  73 #include <vm/vm_map.h>
  74
  75 } /* extern "C" */
  76
  77
  78 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  79
  80 // IOMachPort maps OSObjects to ports, avoiding adding an ivar to OSObject.
  81
  82 class IOMachPort : public OSObject
  83 {
  84     OSDeclareDefaultStructors(IOMachPort)
  85 public:
  86     OSObject *  object;
  87     ipc_port_t  port;
  88     UInt32      mscount;
  89     UInt8       holdDestroy;
  90
  91     static IOMachPort * portForObject( OSObject * obj,
  92                                 ipc_kobject_type_t type );
  93     static bool noMoreSendersForObject( OSObject * obj,
  94                                 ipc_kobject_type_t type, mach_port_mscount_t * mscount );
  95     static void releasePortForObject( OSObject * obj,
  96                                 ipc_kobject_type_t type );
  97     static void setHoldDestroy( OSObject * obj, ipc_kobject_type_t type );
  98
  99     static OSDictionary * dictForType( ipc_kobject_type_t type );
 100
 101     static mach_port_name_t makeSendRightForTask( task_t task,
 102                                 io_object_t obj, ipc_kobject_type_t type );
 103
 104     virtual void free();
 105 };
 106
 107 #define super OSObject
 108 OSDefineMetaClassAndStructors(IOMachPort, OSObject)
 109
 110 static IOLock *         gIOObjectPortLock;
 111
 112 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 113
 114 // not in dictForType() for debugging ease
 115 static OSDictionary *   gIOObjectPorts;
 116 static OSDictionary *   gIOConnectPorts;
 117
 118 OSDictionary * IOMachPort::dictForType( ipc_kobject_type_t type )
 119 {
 120     OSDictionary **             dict;
 121
 122     if( IKOT_IOKIT_OBJECT == type )
 123         dict = &gIOObjectPorts;
 124     else if( IKOT_IOKIT_CONNECT == type )
 125         dict = &gIOConnectPorts;
 126     else
 127         return( 0 );
 128
 129     if( 0 == *dict)
 130         *dict = OSDictionary::withCapacity( 1 );
 131
 132     return( *dict );
 133 }
 134
 135 IOMachPort * IOMachPort::portForObject ( OSObject * obj,
 136                                 ipc_kobject_type_t type )
 137 {
 138     IOMachPort *        inst = 0;
 139     OSDictionary *      dict;
 140
 141     IOTakeLock( gIOObjectPortLock);
 142
 143     do {
 144
 145         dict = dictForType( type );
 146         if( !dict)
 147             continue;
 148
 149         if( (inst = (IOMachPort *)
 150                 dict->getObject( (const OSSymbol *) obj ))) {
 151             inst->mscount++;
 152             inst->retain();
 153             continue;
 154         }
 155
 156         inst = new IOMachPort;
 157         if( inst && !inst->init()) {
 158             inst = 0;
 159             continue;
 160         }
 161
 162         inst->port = iokit_alloc_object_port( obj, type );
 163         if( inst->port) {
 164             // retains obj
 165             dict->setObject( (const OSSymbol *) obj, inst );
 166             inst->mscount++;
 167
 168         } else {
 169             inst->release();
 170             inst = 0;
 171         }
 172
 173     } while( false );
 174
 175     IOUnlock( gIOObjectPortLock);
 176
 177     return( inst );
 178 }
 179
 180 bool IOMachPort::noMoreSendersForObject( OSObject * obj,
 181                                 ipc_kobject_type_t type, mach_port_mscount_t * mscount )
 182 {
 183     OSDictionary *      dict;
 184     IOMachPort *        machPort;
 185     bool                destroyed = true;
 186
 187     IOTakeLock( gIOObjectPortLock);
 188
 189     if( (dict = dictForType( type ))) {
 190         obj->retain();
 191
 192         machPort = (IOMachPort *) dict->getObject( (const OSSymbol *) obj );
 193         if( machPort) {
 194             destroyed = (machPort->mscount == *mscount);
 195             if( destroyed)
 196                 dict->removeObject( (const OSSymbol *) obj );
 197             else
 198                 *mscount = machPort->mscount;
 199         }
 200         obj->release();
 201     }
 202
 203     IOUnlock( gIOObjectPortLock);
 204
 205     return( destroyed );
 206 }
 207
 208 void IOMachPort::releasePortForObject( OSObject * obj,
 209                                 ipc_kobject_type_t type )
 210 {
 211     OSDictionary *      dict;
 212     IOMachPort *        machPort;
 213
 214     IOTakeLock( gIOObjectPortLock);
 215
 216     if( (dict = dictForType( type ))) {
 217         obj->retain();
 218         machPort = (IOMachPort *) dict->getObject( (const OSSymbol *) obj );
 219         if( machPort && !machPort->holdDestroy)
 220             dict->removeObject( (const OSSymbol *) obj );
 221         obj->release();
 222     }
 223
 224     IOUnlock( gIOObjectPortLock);
 225 }
 226
 227 void IOMachPort::setHoldDestroy( OSObject * obj, ipc_kobject_type_t type )
 228 {
 229     OSDictionary *      dict;
 230     IOMachPort *        machPort;
 231
 232     IOLockLock( gIOObjectPortLock );
 233
 234     if( (dict = dictForType( type ))) {
 235         machPort = (IOMachPort *) dict->getObject( (const OSSymbol *) obj );
 236         if( machPort)
 237             machPort->holdDestroy = true;
 238     }
 239
 240     IOLockUnlock( gIOObjectPortLock );
 241 }
 242
 243 void IOUserClient::destroyUserReferences( OSObject * obj )
 244 {
 245     IOMachPort::releasePortForObject( obj, IKOT_IOKIT_OBJECT );
 246
 247     // panther, 3160200
 248     // IOMachPort::releasePortForObject( obj, IKOT_IOKIT_CONNECT );
 249
 250     OSDictionary * dict;
 251
 252     IOTakeLock( gIOObjectPortLock);
 253     obj->retain();
 254
 255     if( (dict = IOMachPort::dictForType( IKOT_IOKIT_CONNECT )))
 256     {
 257         IOMachPort * port;
 258         port = (IOMachPort *) dict->getObject( (const OSSymbol *) obj );
 259         if (port)
 260         {
 261             IOUserClient * uc;
 262             if ((uc = OSDynamicCast(IOUserClient, obj)) && uc->mappings)
 263             {
 264                 dict->setObject((const OSSymbol *) uc->mappings, port);
 265                 iokit_switch_object_port(port->port, uc->mappings, IKOT_IOKIT_CONNECT);
 266
 267                 uc->mappings->release();
 268                 uc->mappings = 0;
 269             }
 270             dict->removeObject( (const OSSymbol *) obj );
 271         }
 272     }
 273     obj->release();
 274     IOUnlock( gIOObjectPortLock);
 275 }
 276
 277 mach_port_name_t IOMachPort::makeSendRightForTask( task_t task,
 278                                 io_object_t obj, ipc_kobject_type_t type )
 279 {
 280     return( iokit_make_send_right( task, obj, type ));
 281 }
 282
 283 void IOMachPort::free( void )
 284 {
 285     if( port)
 286         iokit_destroy_object_port( port );
 287     super::free();
 288 }
 289
 290 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 291
 292 class IOUserNotification : public OSIterator
 293 {
 294     OSDeclareDefaultStructors(IOUserNotification)
 295
 296     IONotifier  *       holdNotify;
 297     IOLock      *       lock;
 298
 299 public:
 300
 301     virtual bool init( void );
 302     virtual void free();
 303
 304     virtual void setNotification( IONotifier * obj );
 305
 306     virtual void reset();
 307     virtual bool isValid();
 308 };
 309
 310 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 311
 312 extern "C" {
 313
 314 // functions called from osfmk/device/iokit_rpc.c
 315
 316 void
 317 iokit_add_reference( io_object_t obj )
 318 {
 319     if( obj)
 320         obj->retain();
 321 }
 322
 323 void
 324 iokit_remove_reference( io_object_t obj )
 325 {
 326     if( obj)
 327         obj->release();
 328 }
 329
 330 ipc_port_t
 331 iokit_port_for_object( io_object_t obj, ipc_kobject_type_t type )
 332 {
 333     IOMachPort * machPort;
 334     ipc_port_t   port;
 335
 336     if( (machPort = IOMachPort::portForObject( obj, type ))) {
 337
 338         port = machPort->port;
 339         if( port)
 340             iokit_retain_port( port );
 341
 342         machPort->release();
 343
 344     } else
 345         port = NULL;
 346
 347     return( port );
 348 }
 349
 350 kern_return_t
 351 iokit_client_died( io_object_t obj, ipc_port_t /* port */,
 352                         ipc_kobject_type_t type, mach_port_mscount_t * mscount )
 353 {
 354     IOUserClient *      client;
 355     IOMemoryMap *       map;
 356     IOUserNotification * notify;
 357
 358     if( !IOMachPort::noMoreSendersForObject( obj, type, mscount ))
 359         return( kIOReturnNotReady );
 360
 361     if( IKOT_IOKIT_CONNECT == type)
 362     {
 363         if( (client = OSDynamicCast( IOUserClient, obj )))
 364             client->clientDied();
 365     }
 366     else if( IKOT_IOKIT_OBJECT == type)
 367     {
 368         if( (map = OSDynamicCast( IOMemoryMap, obj )))
 369             map->taskDied();
 370         else if( (notify = OSDynamicCast( IOUserNotification, obj )))
 371             notify->setNotification( 0 );
 372     }
 373
 374     return( kIOReturnSuccess );
 375 }
 376
 377 };      /* extern "C" */
 378
 379 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 380
 381 class IOServiceUserNotification : public IOUserNotification
 382 {
 383     OSDeclareDefaultStructors(IOServiceUserNotification)
 384
 385     struct PingMsg {
 386         mach_msg_header_t               msgHdr;
 387         OSNotificationHeader            notifyHeader;
 388     };
 389
 390     enum { kMaxOutstanding = 1024 };
 391
 392     PingMsg *           pingMsg;
 393     vm_size_t           msgSize;
 394     OSArray     *       newSet;
 395     OSObject    *       lastEntry;
 396     bool                armed;
 397
 398 public:
 399
 400     virtual bool init( mach_port_t port, natural_t type,
 401                        OSAsyncReference reference );
 402     virtual void free();
 403
 404     static bool _handler( void * target,
 405                           void * ref, IOService * newService );
 406     virtual bool handler( void * ref, IOService * newService );
 407
 408     virtual OSObject * getNextObject();
 409 };
 410
 411 class IOServiceMessageUserNotification : public IOUserNotification
 412 {
 413     OSDeclareDefaultStructors(IOServiceMessageUserNotification)
 414
 415     struct PingMsg {
 416         mach_msg_header_t               msgHdr;
 417         mach_msg_body_t                 msgBody;
 418         mach_msg_port_descriptor_t      ports[1];
 419         OSNotificationHeader            notifyHeader;
 420     };
 421
 422     PingMsg *           pingMsg;
 423     vm_size_t           msgSize;
 424
 425 public:
 426
 427     virtual bool init( mach_port_t port, natural_t type,
 428                        OSAsyncReference reference, vm_size_t extraSize );
 429     virtual void free();
 430
 431     static IOReturn _handler( void * target, void * ref,
 432                               UInt32 messageType, IOService * provider,
 433                               void * messageArgument, vm_size_t argSize );
 434     virtual IOReturn handler( void * ref,
 435                               UInt32 messageType, IOService * provider,
 436                               void * messageArgument, vm_size_t argSize );
 437
 438     virtual OSObject * getNextObject();
 439 };
 440
 441 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 442
 443 #undef super
 444 #define super OSIterator
 445 OSDefineMetaClass( IOUserNotification, OSIterator )
 446 OSDefineAbstractStructors( IOUserNotification, OSIterator )
 447
 448 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 449
 450 bool IOUserNotification::init( void )
 451 {
 452     if( !super::init())
 453         return( false );
 454
 455     lock = IOLockAlloc();
 456     if( !lock)
 457         return( false );
 458
 459     return( true );
 460 }
 461
 462 void IOUserNotification::free( void )
 463 {
 464     if( holdNotify)
 465         holdNotify->remove();
 466     // can't be in handler now
 467
 468     if( lock)
 469         IOLockFree( lock );
 470
 471     super::free();
 472 }
 473
 474
 475 void IOUserNotification::setNotification( IONotifier * notify )
 476 {
 477     IONotifier * previousNotify;
 478
 479     IOLockLock( gIOObjectPortLock);
 480
 481     previousNotify = holdNotify;
 482     holdNotify = notify;
 483
 484     IOLockUnlock( gIOObjectPortLock);
 485
 486     if( previousNotify)
 487         previousNotify->remove();
 488 }
 489
 490 void IOUserNotification::reset()
 491 {
 492     // ?
 493 }
 494
 495 bool IOUserNotification::isValid()
 496 {
 497     return( true );
 498 }
 499
 500 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 501
 502 #undef super
 503 #define super IOUserNotification
 504 OSDefineMetaClassAndStructors(IOServiceUserNotification, IOUserNotification)
 505
 506 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 507
 508 bool IOServiceUserNotification::init( mach_port_t port, natural_t type,
 509                                 OSAsyncReference reference )
 510 {
 511     newSet = OSArray::withCapacity( 1 );
 512     if( !newSet)
 513         return( false );
 514
 515     msgSize = sizeof( PingMsg) + 0;
 516     pingMsg = (PingMsg *) IOMalloc( msgSize);
 517     if( !pingMsg)
 518         return( false );
 519
 520     bzero( pingMsg, msgSize);
 521
 522     pingMsg->msgHdr.msgh_remote_port    = port;
 523     pingMsg->msgHdr.msgh_bits           = MACH_MSGH_BITS(
 524                                             MACH_MSG_TYPE_COPY_SEND /*remote*/,
 525                                             MACH_MSG_TYPE_MAKE_SEND /*local*/);
 526     pingMsg->msgHdr.msgh_size           = msgSize;
 527     pingMsg->msgHdr.msgh_id             = kOSNotificationMessageID;
 528
 529     pingMsg->notifyHeader.size = 0;
 530     pingMsg->notifyHeader.type = type;
 531     bcopy( reference, pingMsg->notifyHeader.reference, sizeof(OSAsyncReference) );
 532
 533     return( super::init() );
 534 }
 535
 536 void IOServiceUserNotification::free( void )
 537 {
 538     PingMsg   * _pingMsg;
 539     vm_size_t   _msgSize;
 540     OSArray   * _newSet;
 541     OSObject  * _lastEntry;
 542
 543     _pingMsg   = pingMsg;
 544     _msgSize   = msgSize;
 545     _lastEntry = lastEntry;
 546     _newSet    = newSet;
 547
 548     super::free();
 549
 550     if( _pingMsg && _msgSize)
 551         IOFree( _pingMsg, _msgSize);
 552
 553     if( _lastEntry)
 554         _lastEntry->release();
 555
 556     if( _newSet)
 557         _newSet->release();
 558 }
 559
 560 bool IOServiceUserNotification::_handler( void * target,
 561                                     void * ref, IOService * newService )
 562 {
 563     return( ((IOServiceUserNotification *) target)->handler( ref, newService ));
 564 }
 565
 566 bool IOServiceUserNotification::handler( void * ref,
 567                                 IOService * newService )
 568 {
 569     unsigned int        count;
 570     kern_return_t       kr;
 571     ipc_port_t          port = NULL;
 572     bool                sendPing = false;
 573
 574     IOTakeLock( lock );
 575
 576     count = newSet->getCount();
 577     if( count < kMaxOutstanding) {
 578
 579         newSet->setObject( newService );
 580         if( (sendPing = (armed && (0 == count))))
 581             armed = false;
 582     }
 583
 584     IOUnlock( lock );
 585
 586     if( kIOServiceTerminatedNotificationType == pingMsg->notifyHeader.type)
 587         IOMachPort::setHoldDestroy( newService, IKOT_IOKIT_OBJECT );
 588
 589     if( sendPing) {
 590         if( (port = iokit_port_for_object( this, IKOT_IOKIT_OBJECT ) ))
 591             pingMsg->msgHdr.msgh_local_port = port;
 592         else
 593             pingMsg->msgHdr.msgh_local_port = NULL;
 594
 595         kr = mach_msg_send_from_kernel( &pingMsg->msgHdr,
 596                                         pingMsg->msgHdr.msgh_size);
 597         if( port)
 598             iokit_release_port( port );
 599
 600         if( KERN_SUCCESS != kr)
 601             IOLog("%s: mach_msg_send_from_kernel {%x}\n", __FILE__, kr );
 602     }
 603
 604     return( true );
 605 }
 606
 607 OSObject * IOServiceUserNotification::getNextObject()
 608 {
 609     unsigned int        count;
 610     OSObject *          result;
 611
 612     IOTakeLock( lock );
 613
 614     if( lastEntry)
 615         lastEntry->release();
 616
 617     count = newSet->getCount();
 618     if( count ) {
 619         result = newSet->getObject( count - 1 );
 620         result->retain();
 621         newSet->removeObject( count - 1);
 622     } else {
 623         result = 0;
 624         armed = true;
 625     }
 626     lastEntry = result;
 627
 628     IOUnlock( lock );
 629
 630     return( result );
 631 }
 632
 633 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 634
 635 OSDefineMetaClassAndStructors(IOServiceMessageUserNotification, IOUserNotification)
 636
 637 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 638
 639 bool IOServiceMessageUserNotification::init( mach_port_t port, natural_t type,
 640                        OSAsyncReference reference, vm_size_t extraSize )
 641 {
 642
 643     extraSize += sizeof(IOServiceInterestContent);
 644     msgSize = sizeof( PingMsg) + extraSize;
 645     pingMsg = (PingMsg *) IOMalloc( msgSize);
 646     if( !pingMsg)
 647         return( false );
 648
 649     bzero( pingMsg, msgSize);
 650
 651     pingMsg->msgHdr.msgh_remote_port    = port;
 652     pingMsg->msgHdr.msgh_bits           = MACH_MSGH_BITS_COMPLEX
 653                                         |  MACH_MSGH_BITS(
 654                                             MACH_MSG_TYPE_COPY_SEND /*remote*/,
 655                                             MACH_MSG_TYPE_MAKE_SEND /*local*/);
 656     pingMsg->msgHdr.msgh_size           = msgSize;
 657     pingMsg->msgHdr.msgh_id             = kOSNotificationMessageID;
 658
 659     pingMsg->msgBody.msgh_descriptor_count = 1;
 660
 661     pingMsg->ports[0].name              = 0;
 662     pingMsg->ports[0].disposition       = MACH_MSG_TYPE_MAKE_SEND;
 663     pingMsg->ports[0].type              = MACH_MSG_PORT_DESCRIPTOR;
 664
 665     pingMsg->notifyHeader.size          = extraSize;
 666     pingMsg->notifyHeader.type          = type;
 667     bcopy( reference, pingMsg->notifyHeader.reference, sizeof(OSAsyncReference) );
 668
 669     return( super::init() );
 670 }
 671
 672 void IOServiceMessageUserNotification::free( void )
 673 {
 674     PingMsg *   _pingMsg;
 675     vm_size_t   _msgSize;
 676
 677     _pingMsg   = pingMsg;
 678     _msgSize   = msgSize;
 679
 680     super::free();
 681
 682     if( _pingMsg && _msgSize)
 683         IOFree( _pingMsg, _msgSize);
 684 }
 685
 686 IOReturn IOServiceMessageUserNotification::_handler( void * target, void * ref,
 687                                             UInt32 messageType, IOService * provider,
 688                                             void * argument, vm_size_t argSize )
 689 {
 690     return( ((IOServiceMessageUserNotification *) target)->handler(
 691                                 ref, messageType, provider, argument, argSize));
 692 }
 693
 694 IOReturn IOServiceMessageUserNotification::handler( void * ref,
 695                                     UInt32 messageType, IOService * provider,
 696                                     void * messageArgument, vm_size_t argSize )
 697 {
 698     kern_return_t               kr;
 699     ipc_port_t                  thisPort, providerPort;
 700     IOServiceInterestContent *  data = (IOServiceInterestContent *)
 701                                        pingMsg->notifyHeader.content;
 702
 703     data->messageType = messageType;
 704     if( argSize == 0) {
 705         argSize = sizeof( messageArgument);
 706         data->messageArgument[0] = messageArgument;
 707     } else {
 708         if( argSize > kIOUserNotifyMaxMessageSize)
 709             argSize = kIOUserNotifyMaxMessageSize;
 710         bcopy( messageArgument, data->messageArgument, argSize );
 711     }
 712     pingMsg->msgHdr.msgh_size = sizeof( PingMsg)
 713         + sizeof( IOServiceInterestContent )
 714         - sizeof( data->messageArgument)
 715         + argSize;
 716
 717     providerPort = iokit_port_for_object( provider, IKOT_IOKIT_OBJECT );
 718     pingMsg->ports[0].name = providerPort;
 719     thisPort = iokit_port_for_object( this, IKOT_IOKIT_OBJECT );
 720     pingMsg->msgHdr.msgh_local_port = thisPort;
 721     kr = mach_msg_send_from_kernel( &pingMsg->msgHdr,
 722                                     pingMsg->msgHdr.msgh_size);
 723     if( thisPort)
 724         iokit_release_port( thisPort );
 725     if( providerPort)
 726         iokit_release_port( providerPort );
 727
 728     if( KERN_SUCCESS != kr)
 729         IOLog("%s: mach_msg_send_from_kernel {%x}\n", __FILE__, kr );
 730
 731     return( kIOReturnSuccess );
 732 }
 733
 734 OSObject * IOServiceMessageUserNotification::getNextObject()
 735 {
 736     return( 0 );
 737 }
 738
 739 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 740
 741 #undef super
 742 #define super IOService
 743 OSDefineMetaClassAndAbstractStructors( IOUserClient, IOService )
 744
 745 void IOUserClient::initialize( void )
 746 {
 747     gIOObjectPortLock = IOLockAlloc();
 748
 749     assert( gIOObjectPortLock );
 750 }
 751
 752 void IOUserClient::setAsyncReference(OSAsyncReference asyncRef,
 753                                      mach_port_t wakePort,
 754                                      void *callback, void *refcon)
 755 {
 756     asyncRef[kIOAsyncReservedIndex] = (natural_t) wakePort;
 757     asyncRef[kIOAsyncCalloutFuncIndex] = (natural_t) callback;
 758     asyncRef[kIOAsyncCalloutRefconIndex] = (natural_t) refcon;
 759 }
 760
 761 inline OSDictionary * CopyConsoleUser(UInt32 uid)
 762 {
 763         OSArray * array;
 764         OSDictionary * user = 0;
 765
 766         if ((array = OSDynamicCast(OSArray,
 767             IORegistryEntry::getRegistryRoot()->copyProperty(gIOConsoleUsersKey))))
 768         {
 769             for (unsigned int idx = 0;
 770                     (user = OSDynamicCast(OSDictionary, array->getObject(idx)));
 771                     idx++) {
 772             OSNumber * num;
 773
 774             if ((num = OSDynamicCast(OSNumber, user->getObject(gIOConsoleSessionUIDKey)))
 775               && (uid == num->unsigned32BitValue())) {
 776                 user->retain();
 777                 break;
 778             }
 779             }
 780             array->release();
 781         }
 782     return user;
 783 }
 784
 785 IOReturn IOUserClient::clientHasPrivilege( void * securityToken,
 786                                             const char * privilegeName )
 787 {
 788     kern_return_t           kr;
 789     security_token_t        token;
 790     mach_msg_type_number_t  count;
 791     task_t                  task;
 792     OSDictionary *          user;
 793     bool                    secureConsole;
 794
 795     if ((secureConsole = !strcmp(privilegeName, kIOClientPrivilegeSecureConsoleProcess)))
 796         task = (task_t)((IOUCProcessToken *)securityToken)->token;
 797     else
 798         task = (task_t)securityToken;
 799
 800     count = TASK_SECURITY_TOKEN_COUNT;
 801     kr = task_info( task, TASK_SECURITY_TOKEN, (task_info_t) &token, &count );
 802
 803     if (KERN_SUCCESS != kr)
 804     {}
 805     else if (!strcmp(privilegeName, kIOClientPrivilegeAdministrator)) {
 806         if (0 != token.val[0])
 807             kr = kIOReturnNotPrivileged;
 808     } else if (!strcmp(privilegeName, kIOClientPrivilegeLocalUser)) {
 809         user = CopyConsoleUser(token.val[0]);
 810         if ( user )
 811             user->release();
 812         else
 813             kr = kIOReturnNotPrivileged;
 814     } else if (secureConsole || !strcmp(privilegeName, kIOClientPrivilegeConsoleUser)) {
 815         user = CopyConsoleUser(token.val[0]);
 816         if ( user ) {
 817             if (user->getObject(gIOConsoleSessionOnConsoleKey) != kOSBooleanTrue)
 818                 kr = kIOReturnNotPrivileged;
 819             else if ( secureConsole ) {
 820                 OSNumber * pid = OSDynamicCast(OSNumber, user->getObject(gIOConsoleSessionSecureInputPIDKey));
 821                 if ( pid && pid->unsigned32BitValue() != ((IOUCProcessToken *)securityToken)->pid)
 822                     kr = kIOReturnNotPrivileged;
 823             }
 824             user->release();
 825         }
 826         else
 827             kr = kIOReturnNotPrivileged;
 828     } else
 829         kr = kIOReturnUnsupported;
 830
 831     return (kr);
 832 }
 833
 834 bool IOUserClient::initWithTask(task_t owningTask,
 835                                 void * securityID,
 836                                 UInt32 type )
 837 {
 838     if( getPropertyTable())
 839         return true;
 840     else
 841         return super::init();
 842 }
 843
 844 bool IOUserClient::initWithTask(task_t owningTask,
 845                                 void * securityID,
 846                                 UInt32 type,
 847                                 OSDictionary * properties )
 848 {
 849     bool ok;
 850
 851     ok = super::init( properties );
 852     ok &= initWithTask( owningTask, securityID, type );
 853
 854     return( ok );
 855 }
 856
 857 void IOUserClient::free()
 858 {
 859     if( mappings)
 860         mappings->release();
 861
 862     super::free();
 863 }
 864
 865 IOReturn IOUserClient::clientDied( void )
 866 {
 867     return( clientClose());
 868 }
 869
 870 IOReturn IOUserClient::clientClose( void )
 871 {
 872     return( kIOReturnUnsupported );
 873 }
 874
 875 IOService * IOUserClient::getService( void )
 876 {
 877     return( 0 );
 878 }
 879
 880 IOReturn IOUserClient::registerNotificationPort(
 881                 mach_port_t     /* port */,
 882                 UInt32          /* type */,
 883                 UInt32          /* refCon */)
 884 {
 885     return( kIOReturnUnsupported);
 886 }
 887
 888 IOReturn IOUserClient::getNotificationSemaphore( UInt32 notification_type,
 889                                     semaphore_t * semaphore )
 890 {
 891     return( kIOReturnUnsupported);
 892 }
 893
 894 IOReturn IOUserClient::connectClient( IOUserClient * /* client */ )
 895 {
 896     return( kIOReturnUnsupported);
 897 }
 898
 899 IOReturn IOUserClient::clientMemoryForType( UInt32 type,
 900                                 IOOptionBits * options,
 901                                 IOMemoryDescriptor ** memory )
 902 {
 903     return( kIOReturnUnsupported);
 904 }
 905
 906 IOMemoryMap * IOUserClient::mapClientMemory(
 907         IOOptionBits            type,
 908         task_t                  task,
 909         IOOptionBits            mapFlags,
 910         IOVirtualAddress        atAddress )
 911 {
 912     IOReturn            err;
 913     IOOptionBits        options = 0;
 914     IOMemoryDescriptor * memory;
 915     IOMemoryMap *       map = 0;
 916
 917     err = clientMemoryForType( (UInt32) type, &options, &memory );
 918
 919     if( memory && (kIOReturnSuccess == err)) {
 920
 921         options = (options & ~kIOMapUserOptionsMask)
 922                 | (mapFlags & kIOMapUserOptionsMask);
 923         map = memory->map( task, atAddress, options );
 924         memory->release();
 925     }
 926
 927     return( map );
 928 }
 929
 930 IOReturn IOUserClient::exportObjectToClient(task_t task,
 931                         OSObject *obj, io_object_t *clientObj)
 932 {
 933     mach_port_name_t    name;
 934
 935     name = IOMachPort::makeSendRightForTask( task, obj, IKOT_IOKIT_OBJECT );
 936     assert( name );
 937
 938     *(mach_port_name_t *)clientObj = name;
 939     return kIOReturnSuccess;
 940 }
 941
 942 IOExternalMethod * IOUserClient::getExternalMethodForIndex( UInt32 /* index */)
 943 {
 944     return( 0 );
 945 }
 946
 947 IOExternalAsyncMethod * IOUserClient::getExternalAsyncMethodForIndex( UInt32 /* index */)
 948 {
 949     return( 0 );
 950 }
 951
 952 IOExternalMethod * IOUserClient::
 953 getTargetAndMethodForIndex(IOService **targetP, UInt32 index)
 954 {
 955     IOExternalMethod *method = getExternalMethodForIndex(index);
 956
 957     if (method)
 958         *targetP = (IOService *) method->object;
 959
 960     return method;
 961 }
 962
 963 IOExternalAsyncMethod * IOUserClient::
 964 getAsyncTargetAndMethodForIndex(IOService ** targetP, UInt32 index)
 965 {
 966     IOExternalAsyncMethod *method = getExternalAsyncMethodForIndex(index);
 967
 968     if (method)
 969         *targetP = (IOService *) method->object;
 970
 971     return method;
 972 }
 973
 974 IOExternalTrap * IOUserClient::
 975 getExternalTrapForIndex(UInt32 index)
 976 {
 977         return NULL;
 978 }
 979
 980 IOExternalTrap * IOUserClient::
 981 getTargetAndTrapForIndex(IOService ** targetP, UInt32 index)
 982 {
 983       IOExternalTrap *trap = getExternalTrapForIndex(index);
 984
 985       if (trap) {
 986               *targetP = trap->object;
 987       }
 988
 989       return trap;
 990 }
 991
 992 IOReturn IOUserClient::sendAsyncResult(OSAsyncReference reference,
 993                                        IOReturn result, void *args[], UInt32 numArgs)
 994 {
 995     struct ReplyMsg {
 996         mach_msg_header_t       msgHdr;
 997         OSNotificationHeader    notifyHdr;
 998         IOAsyncCompletionContent asyncContent;
 999         void *                  args[kMaxAsyncArgs];
1000     };
1001     ReplyMsg replyMsg;
1002     mach_port_t replyPort;
1003     kern_return_t kr;
1004
1005     // If no reply port, do nothing.
1006     replyPort = (mach_port_t) reference[0];
1007     if(replyPort == MACH_PORT_NULL)
1008         return kIOReturnSuccess;
1009
1010     if(numArgs > kMaxAsyncArgs)
1011         return kIOReturnMessageTooLarge;
1012     replyMsg.msgHdr.msgh_bits = MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND /*remote*/,
1013                                                 0 /*local*/);
1014     replyMsg.msgHdr.msgh_size =
1015         sizeof(replyMsg) - (kMaxAsyncArgs-numArgs)*sizeof(void *);
1016     replyMsg.msgHdr.msgh_remote_port = replyPort;
1017     replyMsg.msgHdr.msgh_local_port = 0;
1018     replyMsg.msgHdr.msgh_id = kOSNotificationMessageID;
1019
1020     replyMsg.notifyHdr.size = sizeof(IOAsyncCompletionContent)
1021                             + numArgs*sizeof(void *);
1022     replyMsg.notifyHdr.type = kIOAsyncCompletionNotificationType;
1023     bcopy( reference, replyMsg.notifyHdr.reference, sizeof(OSAsyncReference));
1024
1025     replyMsg.asyncContent.result = result;
1026     if(numArgs > 0)
1027         bcopy(args, replyMsg.args, sizeof(void *)*numArgs);
1028      kr = mach_msg_send_from_kernel( &replyMsg.msgHdr,
1029             replyMsg.msgHdr.msgh_size);
1030     if( KERN_SUCCESS != kr)
1031         IOLog("%s: mach_msg_send_from_kernel {%x}\n", __FILE__, kr );
1032     return kr;
1033 }
1034
1035 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1036
1037 extern "C" {
1038
1039 #define CHECK(cls,obj,out)                      \
1040         cls * out;                              \
1041         if( !(out = OSDynamicCast( cls, obj)))  \
1042             return( kIOReturnBadArgument )
1043
1044 /* Routine io_object_get_class */
1045 kern_return_t is_io_object_get_class(
1046         io_object_t object,
1047         io_name_t className )
1048 {
1049         const OSMetaClass* my_obj = NULL;
1050
1051     if( !object)
1052         return( kIOReturnBadArgument );
1053
1054         my_obj = object->getMetaClass();
1055         if (!my_obj) {
1056                 return (kIOReturnNotFound);
1057         }
1058
1059     strcpy( className, my_obj->getClassName());
1060     return( kIOReturnSuccess );
1061 }
1062
1063 /* Routine io_object_get_superclass */
1064 kern_return_t is_io_object_get_superclass(
1065         mach_port_t master_port,
1066         io_name_t obj_name,
1067         io_name_t class_name)
1068 {
1069         const OSMetaClass* my_obj = NULL;
1070         const OSMetaClass* superclass = NULL;
1071         const OSSymbol *my_name = NULL;
1072         const char *my_cstr = NULL;
1073
1074         if (!obj_name || !class_name)
1075                 return (kIOReturnBadArgument);
1076
1077     if( master_port != master_device_port)
1078         return( kIOReturnNotPrivileged);
1079
1080         my_name = OSSymbol::withCString(obj_name);
1081
1082         if (my_name) {
1083                 my_obj = OSMetaClass::getMetaClassWithName(my_name);
1084                 my_name->release();
1085         }
1086         if (my_obj) {
1087                 superclass = my_obj->getSuperClass();
1088         }
1089
1090         if (!superclass)  {
1091                 return( kIOReturnNotFound );
1092         }
1093
1094         my_cstr = superclass->getClassName();
1095
1096         if (my_cstr) {
1097                 strncpy(class_name, my_cstr, sizeof(io_name_t)-1);
1098                 return( kIOReturnSuccess );
1099         }
1100         return (kIOReturnNotFound);
1101 }
1102
1103 /* Routine io_object_get_bundle_identifier */
1104 kern_return_t is_io_object_get_bundle_identifier(
1105         mach_port_t master_port,
1106         io_name_t obj_name,
1107         io_name_t bundle_name)
1108 {
1109         const OSMetaClass* my_obj = NULL;
1110         const OSSymbol *my_name = NULL;
1111         const OSSymbol *identifier = NULL;
1112         const char *my_cstr = NULL;
1113
1114         if (!obj_name || !bundle_name)
1115                 return (kIOReturnBadArgument);
1116
1117     if( master_port != master_device_port)
1118         return( kIOReturnNotPrivileged);
1119
1120         my_name = OSSymbol::withCString(obj_name);
1121
1122         if (my_name) {
1123                 my_obj = OSMetaClass::getMetaClassWithName(my_name);
1124                 my_name->release();
1125         }
1126
1127         if (my_obj) {
1128                 identifier = my_obj->getKmodName();
1129         }
1130         if (!identifier) {
1131                 return( kIOReturnNotFound );
1132         }
1133
1134         my_cstr = identifier->getCStringNoCopy();
1135         if (my_cstr) {
1136                 strncpy(bundle_name, identifier->getCStringNoCopy(), sizeof(io_name_t)-1);
1137                 return( kIOReturnSuccess );
1138         }
1139
1140         return (kIOReturnBadArgument);
1141 }
1142
1143 /* Routine io_object_conforms_to */
1144 kern_return_t is_io_object_conforms_to(
1145         io_object_t object,
1146         io_name_t className,
1147         boolean_t *conforms )
1148 {
1149     if( !object)
1150         return( kIOReturnBadArgument );
1151
1152     *conforms = (0 != object->metaCast( className ));
1153     return( kIOReturnSuccess );
1154 }
1155
1156 /* Routine io_object_get_retain_count */
1157 kern_return_t is_io_object_get_retain_count(
1158         io_object_t object,
1159         int *retainCount )
1160 {
1161     if( !object)
1162         return( kIOReturnBadArgument );
1163
1164     *retainCount = object->getRetainCount();
1165     return( kIOReturnSuccess );
1166 }
1167
1168 /* Routine io_iterator_next */
1169 kern_return_t is_io_iterator_next(
1170         io_object_t iterator,
1171         io_object_t *object )
1172 {
1173     OSObject *  obj;
1174
1175     CHECK( OSIterator, iterator, iter );
1176
1177     obj = iter->getNextObject();
1178     if( obj) {
1179         obj->retain();
1180         *object = obj;
1181         return( kIOReturnSuccess );
1182     } else
1183         return( kIOReturnNoDevice );
1184 }
1185
1186 /* Routine io_iterator_reset */
1187 kern_return_t is_io_iterator_reset(
1188         io_object_t iterator )
1189 {
1190     CHECK( OSIterator, iterator, iter );
1191
1192     iter->reset();
1193
1194     return( kIOReturnSuccess );
1195 }
1196
1197 /* Routine io_iterator_is_valid */
1198 kern_return_t is_io_iterator_is_valid(
1199         io_object_t iterator,
1200         boolean_t *is_valid )
1201 {
1202     CHECK( OSIterator, iterator, iter );
1203
1204     *is_valid = iter->isValid();
1205
1206     return( kIOReturnSuccess );
1207 }
1208
1209 /* Routine io_service_match_property_table */
1210 kern_return_t is_io_service_match_property_table(
1211         io_service_t _service,
1212         io_string_t matching,
1213         boolean_t *matches )
1214 {
1215     CHECK( IOService, _service, service );
1216
1217     kern_return_t       kr;
1218     OSObject *          obj;
1219     OSDictionary *      dict;
1220
1221     obj = OSUnserializeXML( matching );
1222
1223     if( (dict = OSDynamicCast( OSDictionary, obj))) {
1224         *matches = service->passiveMatch( dict );
1225         kr = kIOReturnSuccess;
1226     } else
1227         kr = kIOReturnBadArgument;
1228
1229     if( obj)
1230         obj->release();
1231
1232     return( kr );
1233 }
1234
1235 /* Routine io_service_match_property_table_ool */
1236 kern_return_t is_io_service_match_property_table_ool(
1237         io_object_t service,
1238         io_buf_ptr_t matching,
1239         mach_msg_type_number_t matchingCnt,
1240         natural_t *result,
1241         boolean_t *matches )
1242 {
1243     kern_return_t       kr;
1244     vm_offset_t         data;
1245     vm_map_offset_t     map_data;
1246
1247     kr = vm_map_copyout( kernel_map, &map_data, (vm_map_copy_t) matching );
1248     data = CAST_DOWN(vm_offset_t, map_data);
1249
1250     if( KERN_SUCCESS == kr) {
1251         // must return success after vm_map_copyout() succeeds
1252         *result = is_io_service_match_property_table( service,
1253                 (char *) data, matches );
1254         vm_deallocate( kernel_map, data, matchingCnt );
1255     }
1256
1257     return( kr );
1258 }
1259
1260 /* Routine io_service_get_matching_services */
1261 kern_return_t is_io_service_get_matching_services(
1262         mach_port_t master_port,
1263         io_string_t matching,
1264         io_iterator_t *existing )
1265 {
1266     kern_return_t       kr;
1267     OSObject *          obj;
1268     OSDictionary *      dict;
1269
1270     if( master_port != master_device_port)
1271         return( kIOReturnNotPrivileged);
1272
1273     obj = OSUnserializeXML( matching );
1274
1275     if( (dict = OSDynamicCast( OSDictionary, obj))) {
1276         *existing = IOService::getMatchingServices( dict );
1277         kr = kIOReturnSuccess;
1278     } else
1279         kr = kIOReturnBadArgument;
1280
1281     if( obj)
1282         obj->release();
1283
1284     return( kr );
1285 }
1286
1287 /* Routine io_service_get_matching_services_ool */
1288 kern_return_t is_io_service_get_matching_services_ool(
1289         mach_port_t master_port,
1290         io_buf_ptr_t matching,
1291         mach_msg_type_number_t matchingCnt,
1292         natural_t *result,
1293         io_object_t *existing )
1294 {
1295     kern_return_t       kr;
1296     vm_offset_t         data;
1297     vm_map_offset_t     map_data;
1298
1299     kr = vm_map_copyout( kernel_map, &map_data, (vm_map_copy_t) matching );
1300     data = CAST_DOWN(vm_offset_t, map_data);
1301
1302     if( KERN_SUCCESS == kr) {
1303         // must return success after vm_map_copyout() succeeds
1304         *result = is_io_service_get_matching_services( master_port,
1305                         (char *) data, existing );
1306         vm_deallocate( kernel_map, data, matchingCnt );
1307     }
1308
1309     return( kr );
1310 }
1311
1312 /* Routine io_service_add_notification */
1313 kern_return_t is_io_service_add_notification(
1314         mach_port_t master_port,
1315         io_name_t notification_type,
1316         io_string_t matching,
1317         mach_port_t port,
1318         io_async_ref_t reference,
1319         mach_msg_type_number_t referenceCnt,
1320         io_object_t * notification )
1321 {
1322     IOServiceUserNotification * userNotify = 0;
1323     IONotifier *                notify = 0;
1324     const OSSymbol *            sym;
1325     OSDictionary *              dict;
1326     IOReturn                    err;
1327     unsigned long int           userMsgType;
1328
1329
1330     if( master_port != master_device_port)
1331         return( kIOReturnNotPrivileged);
1332
1333     do {
1334         err = kIOReturnNoResources;
1335
1336         if( !(sym = OSSymbol::withCString( notification_type )))
1337             err = kIOReturnNoResources;
1338
1339         if( !(dict = OSDynamicCast( OSDictionary,
1340                     OSUnserializeXML( matching )))) {
1341             err = kIOReturnBadArgument;
1342             continue;
1343         }
1344
1345         if( (sym == gIOPublishNotification)
1346          || (sym == gIOFirstPublishNotification))
1347             userMsgType = kIOServicePublishNotificationType;
1348         else if( (sym == gIOMatchedNotification)
1349               || (sym == gIOFirstMatchNotification))
1350             userMsgType = kIOServiceMatchedNotificationType;
1351         else if( sym == gIOTerminatedNotification)
1352             userMsgType = kIOServiceTerminatedNotificationType;
1353         else
1354             userMsgType = kLastIOKitNotificationType;
1355
1356         userNotify = new IOServiceUserNotification;
1357
1358         if( userNotify && !userNotify->init( port, userMsgType,
1359                                              reference)) {
1360             userNotify->release();
1361             userNotify = 0;
1362         }
1363         if( !userNotify)
1364             continue;
1365
1366         notify = IOService::addNotification( sym, dict,
1367                                              &userNotify->_handler, userNotify );
1368         if( notify) {
1369             dict = 0;
1370             *notification = userNotify;
1371             userNotify->setNotification( notify );
1372             err = kIOReturnSuccess;
1373         } else
1374             err = kIOReturnUnsupported;
1375
1376     } while( false );
1377
1378     if( sym)
1379         sym->release();
1380     if( dict)
1381         dict->release();
1382
1383     return( err );
1384 }
1385
1386 /* Routine io_service_add_notification_ool */
1387 kern_return_t is_io_service_add_notification_ool(
1388         mach_port_t master_port,
1389         io_name_t notification_type,
1390         io_buf_ptr_t matching,
1391         mach_msg_type_number_t matchingCnt,
1392         mach_port_t wake_port,
1393         io_async_ref_t reference,
1394         mach_msg_type_number_t referenceCnt,
1395         natural_t *result,
1396         io_object_t *notification )
1397 {
1398     kern_return_t       kr;
1399     vm_offset_t         data;
1400     vm_map_offset_t     map_data;
1401
1402     kr = vm_map_copyout( kernel_map, &map_data, (vm_map_copy_t) matching );
1403     data = CAST_DOWN(vm_offset_t, map_data);
1404
1405     if( KERN_SUCCESS == kr) {
1406         // must return success after vm_map_copyout() succeeds
1407         *result = is_io_service_add_notification( master_port, notification_type,
1408                         (char *) data, wake_port, reference, referenceCnt, notification );
1409         vm_deallocate( kernel_map, data, matchingCnt );
1410     }
1411
1412     return( kr );
1413 }
1414
1415
1416 /* Routine io_service_add_notification_old */
1417 kern_return_t is_io_service_add_notification_old(
1418         mach_port_t master_port,
1419         io_name_t notification_type,
1420         io_string_t matching,
1421         mach_port_t port,
1422         natural_t ref,
1423         io_object_t * notification )
1424 {
1425     return( is_io_service_add_notification( master_port, notification_type,
1426             matching, port, &ref, 1, notification ));
1427 }
1428
1429 /* Routine io_service_add_message_notification */
1430 kern_return_t is_io_service_add_interest_notification(
1431         io_object_t _service,
1432         io_name_t type_of_interest,
1433         mach_port_t port,
1434         io_async_ref_t reference,
1435         mach_msg_type_number_t referenceCnt,
1436         io_object_t * notification )
1437 {
1438
1439     IOServiceMessageUserNotification *  userNotify = 0;
1440     IONotifier *                        notify = 0;
1441     const OSSymbol *                    sym;
1442     IOReturn                            err;
1443
1444     CHECK( IOService, _service, service );
1445
1446     err = kIOReturnNoResources;
1447     if( (sym = OSSymbol::withCString( type_of_interest ))) do {
1448
1449         userNotify = new IOServiceMessageUserNotification;
1450
1451         if( userNotify && !userNotify->init( port, kIOServiceMessageNotificationType,
1452                                              reference, kIOUserNotifyMaxMessageSize )) {
1453             userNotify->release();
1454             userNotify = 0;
1455         }
1456         if( !userNotify)
1457             continue;
1458
1459         notify = service->registerInterest( sym,
1460                                     &userNotify->_handler, userNotify );
1461         if( notify) {
1462             *notification = userNotify;
1463             userNotify->setNotification( notify );
1464             err = kIOReturnSuccess;
1465         } else
1466             err = kIOReturnUnsupported;
1467
1468         sym->release();
1469
1470     } while( false );
1471
1472     return( err );
1473 }
1474
1475 /* Routine io_service_acknowledge_notification */
1476 kern_return_t is_io_service_acknowledge_notification(
1477         io_object_t _service,
1478         natural_t notify_ref,
1479         natural_t response )
1480 {
1481     CHECK( IOService, _service, service );
1482
1483     return( service->acknowledgeNotification( (IONotificationRef) notify_ref,
1484                                               (IOOptionBits) response ));
1485
1486 }
1487
1488 /* Routine io_connect_get_semaphore */
1489 kern_return_t is_io_connect_get_notification_semaphore(
1490         io_connect_t connection,
1491         natural_t notification_type,
1492         semaphore_t *semaphore )
1493 {
1494     CHECK( IOUserClient, connection, client );
1495
1496     return( client->getNotificationSemaphore( (UInt32) notification_type,
1497                                               semaphore ));
1498 }
1499
1500 /* Routine io_registry_get_root_entry */
1501 kern_return_t is_io_registry_get_root_entry(
1502         mach_port_t master_port,
1503         io_object_t *root )
1504 {
1505     IORegistryEntry *   entry;
1506
1507     if( master_port != master_device_port)
1508         return( kIOReturnNotPrivileged);
1509
1510     entry = IORegistryEntry::getRegistryRoot();
1511     if( entry)
1512         entry->retain();
1513     *root = entry;
1514
1515     return( kIOReturnSuccess );
1516 }
1517
1518 /* Routine io_registry_create_iterator */
1519 kern_return_t is_io_registry_create_iterator(
1520         mach_port_t master_port,
1521         io_name_t plane,
1522         int options,
1523         io_object_t *iterator )
1524 {
1525     if( master_port != master_device_port)
1526         return( kIOReturnNotPrivileged);
1527
1528     *iterator = IORegistryIterator::iterateOver(
1529         IORegistryEntry::getPlane( plane ), options );
1530
1531     return( *iterator ? kIOReturnSuccess : kIOReturnBadArgument );
1532 }
1533
1534 /* Routine io_registry_entry_create_iterator */
1535 kern_return_t is_io_registry_entry_create_iterator(
1536         io_object_t registry_entry,
1537         io_name_t plane,
1538         int options,
1539         io_object_t *iterator )
1540 {
1541     CHECK( IORegistryEntry, registry_entry, entry );
1542
1543     *iterator = IORegistryIterator::iterateOver( entry,
1544         IORegistryEntry::getPlane( plane ), options );
1545
1546     return( *iterator ? kIOReturnSuccess : kIOReturnBadArgument );
1547 }
1548
1549 /* Routine io_registry_iterator_enter */
1550 kern_return_t is_io_registry_iterator_enter_entry(
1551         io_object_t iterator )
1552 {
1553     CHECK( IORegistryIterator, iterator, iter );
1554
1555     iter->enterEntry();
1556
1557     return( kIOReturnSuccess );
1558 }
1559
1560 /* Routine io_registry_iterator_exit */
1561 kern_return_t is_io_registry_iterator_exit_entry(
1562         io_object_t iterator )
1563 {
1564     bool        didIt;
1565
1566     CHECK( IORegistryIterator, iterator, iter );
1567
1568     didIt = iter->exitEntry();
1569
1570     return( didIt ? kIOReturnSuccess : kIOReturnNoDevice );
1571 }
1572
1573 /* Routine io_registry_entry_from_path */
1574 kern_return_t is_io_registry_entry_from_path(
1575         mach_port_t master_port,
1576         io_string_t path,
1577         io_object_t *registry_entry )
1578 {
1579     IORegistryEntry *   entry;
1580
1581     if( master_port != master_device_port)
1582         return( kIOReturnNotPrivileged);
1583
1584     entry = IORegistryEntry::fromPath( path );
1585
1586     *registry_entry = entry;
1587
1588     return( kIOReturnSuccess );
1589 }
1590
1591 /* Routine io_registry_entry_in_plane */
1592 kern_return_t is_io_registry_entry_in_plane(
1593         io_object_t registry_entry,
1594         io_name_t plane,
1595         boolean_t *inPlane )
1596 {
1597     CHECK( IORegistryEntry, registry_entry, entry );
1598
1599     *inPlane = entry->inPlane( IORegistryEntry::getPlane( plane ));
1600
1601     return( kIOReturnSuccess );
1602 }
1603
1604
1605 /* Routine io_registry_entry_get_path */
1606 kern_return_t is_io_registry_entry_get_path(
1607         io_object_t registry_entry,
1608         io_name_t plane,
1609         io_string_t path )
1610 {
1611     int         length;
1612     CHECK( IORegistryEntry, registry_entry, entry );
1613
1614     length = sizeof( io_string_t);
1615     if( entry->getPath( path, &length, IORegistryEntry::getPlane( plane )))
1616         return( kIOReturnSuccess );
1617     else
1618         return( kIOReturnBadArgument );
1619 }
1620
1621
1622 /* Routine io_registry_entry_get_name */
1623 kern_return_t is_io_registry_entry_get_name(
1624         io_object_t registry_entry,
1625         io_name_t name )
1626 {
1627     CHECK( IORegistryEntry, registry_entry, entry );
1628
1629     strncpy( name, entry->getName(), sizeof( io_name_t));
1630
1631     return( kIOReturnSuccess );
1632 }
1633
1634 /* Routine io_registry_entry_get_name_in_plane */
1635 kern_return_t is_io_registry_entry_get_name_in_plane(
1636         io_object_t registry_entry,
1637         io_name_t planeName,
1638         io_name_t name )
1639 {
1640     const IORegistryPlane * plane;
1641     CHECK( IORegistryEntry, registry_entry, entry );
1642
1643     if( planeName[0])
1644         plane = IORegistryEntry::getPlane( planeName );
1645     else
1646         plane = 0;
1647
1648     strncpy( name, entry->getName( plane), sizeof( io_name_t));
1649
1650     return( kIOReturnSuccess );
1651 }
1652
1653 /* Routine io_registry_entry_get_location_in_plane */
1654 kern_return_t is_io_registry_entry_get_location_in_plane(
1655         io_object_t registry_entry,
1656         io_name_t planeName,
1657         io_name_t location )
1658 {
1659     const IORegistryPlane * plane;
1660     CHECK( IORegistryEntry, registry_entry, entry );
1661
1662     if( planeName[0])
1663         plane = IORegistryEntry::getPlane( planeName );
1664     else
1665         plane = 0;
1666
1667     const char * cstr = entry->getLocation( plane );
1668
1669     if( cstr) {
1670         strncpy( location, cstr, sizeof( io_name_t));
1671         return( kIOReturnSuccess );
1672     } else
1673         return( kIOReturnNotFound );
1674 }
1675
1676 // Create a vm_map_copy_t or kalloc'ed data for memory
1677 // to be copied out. ipc will free after the copyout.
1678
1679 static kern_return_t copyoutkdata( void * data, vm_size_t len,
1680                                     io_buf_ptr_t * buf )
1681 {
1682     kern_return_t       err;
1683     vm_map_copy_t       copy;
1684
1685     err = vm_map_copyin( kernel_map, CAST_USER_ADDR_T(data), len,
1686                     false /* src_destroy */, &copy);
1687
1688     assert( err == KERN_SUCCESS );
1689     if( err == KERN_SUCCESS )
1690         *buf = (char *) copy;
1691
1692     return( err );
1693 }
1694
1695 /* Routine io_registry_entry_get_property */
1696 kern_return_t is_io_registry_entry_get_property_bytes(
1697         io_object_t registry_entry,
1698         io_name_t property_name,
1699         io_scalar_inband_t buf,
1700         mach_msg_type_number_t *dataCnt )
1701 {
1702     OSObject    *       obj;
1703     OSData      *       data;
1704     OSString    *       str;
1705     OSBoolean   *       boo;
1706     OSNumber    *       off;
1707     UInt64              offsetBytes;
1708     unsigned int        len = 0;
1709     const void *        bytes = 0;
1710     IOReturn            ret = kIOReturnSuccess;
1711
1712     CHECK( IORegistryEntry, registry_entry, entry );
1713
1714     obj = entry->copyProperty(property_name);
1715     if( !obj)
1716         return( kIOReturnNoResources );
1717
1718     // One day OSData will be a common container base class
1719     // until then...
1720     if( (data = OSDynamicCast( OSData, obj ))) {
1721         len = data->getLength();
1722         bytes = data->getBytesNoCopy();
1723
1724     } else if( (str = OSDynamicCast( OSString, obj ))) {
1725         len = str->getLength() + 1;
1726         bytes = str->getCStringNoCopy();
1727
1728     } else if( (boo = OSDynamicCast( OSBoolean, obj ))) {
1729         len = boo->isTrue() ? sizeof("Yes") : sizeof("No");
1730         bytes = boo->isTrue() ? "Yes" : "No";
1731
1732     } else if( (off = OSDynamicCast( OSNumber, obj ))) {
1733         offsetBytes = off->unsigned64BitValue();
1734         len = off->numberOfBytes();
1735         bytes = &offsetBytes;
1736 #ifdef __BIG_ENDIAN__
1737         bytes = (const void *)
1738                 (((UInt32) bytes) + (sizeof( UInt64) - len));
1739 #endif
1740
1741     } else
1742         ret = kIOReturnBadArgument;
1743
1744     if( bytes) {
1745         if( *dataCnt < len)
1746             ret = kIOReturnIPCError;
1747         else {
1748             *dataCnt = len;
1749             bcopy( bytes, buf, len );
1750         }
1751     }
1752     obj->release();
1753
1754     return( ret );
1755 }
1756
1757 /* Routine io_registry_entry_get_property */
1758 kern_return_t is_io_registry_entry_get_property(
1759         io_object_t registry_entry,
1760         io_name_t property_name,
1761         io_buf_ptr_t *properties,
1762         mach_msg_type_number_t *propertiesCnt )
1763 {
1764     kern_return_t       err;
1765     vm_size_t           len;
1766     OSObject *          obj;
1767
1768     CHECK( IORegistryEntry, registry_entry, entry );
1769
1770     obj = entry->copyProperty(property_name);
1771     if( !obj)
1772         return( kIOReturnNotFound );
1773
1774     OSSerialize * s = OSSerialize::withCapacity(4096);
1775     if( !s) {
1776         obj->release();
1777         return( kIOReturnNoMemory );
1778     }
1779     s->clearText();
1780
1781     if( obj->serialize( s )) {
1782         len = s->getLength();
1783         *propertiesCnt = len;
1784         err = copyoutkdata( s->text(), len, properties );
1785
1786     } else
1787         err = kIOReturnUnsupported;
1788
1789     s->release();
1790     obj->release();
1791
1792     return( err );
1793 }
1794
1795 /* Routine io_registry_entry_get_property_recursively */
1796 kern_return_t is_io_registry_entry_get_property_recursively(
1797         io_object_t registry_entry,
1798         io_name_t plane,
1799         io_name_t property_name,
1800         int options,
1801         io_buf_ptr_t *properties,
1802         mach_msg_type_number_t *propertiesCnt )
1803 {
1804     kern_return_t       err;
1805     vm_size_t           len;
1806     OSObject *          obj;
1807
1808     CHECK( IORegistryEntry, registry_entry, entry );
1809
1810     obj = entry->copyProperty( property_name,
1811                                IORegistryEntry::getPlane( plane ), options);
1812     if( !obj)
1813         return( kIOReturnNotFound );
1814
1815     OSSerialize * s = OSSerialize::withCapacity(4096);
1816     if( !s) {
1817         obj->release();
1818         return( kIOReturnNoMemory );
1819     }
1820
1821     s->clearText();
1822
1823     if( obj->serialize( s )) {
1824         len = s->getLength();
1825         *propertiesCnt = len;
1826         err = copyoutkdata( s->text(), len, properties );
1827
1828     } else
1829         err = kIOReturnUnsupported;
1830
1831     s->release();
1832     obj->release();
1833
1834     return( err );
1835 }
1836
1837 /* Routine io_registry_entry_get_properties */
1838 kern_return_t is_io_registry_entry_get_properties(
1839         io_object_t registry_entry,
1840         io_buf_ptr_t *properties,
1841         mach_msg_type_number_t *propertiesCnt )
1842 {
1843     kern_return_t       err;
1844     vm_size_t           len;
1845
1846     CHECK( IORegistryEntry, registry_entry, entry );
1847
1848     OSSerialize * s = OSSerialize::withCapacity(4096);
1849     if( !s)
1850         return( kIOReturnNoMemory );
1851
1852     s->clearText();
1853
1854     if( entry->serializeProperties( s )) {
1855         len = s->getLength();
1856         *propertiesCnt = len;
1857         err = copyoutkdata( s->text(), len, properties );
1858
1859     } else
1860         err = kIOReturnUnsupported;
1861
1862     s->release();
1863
1864     return( err );
1865 }
1866
1867 /* Routine io_registry_entry_set_properties */
1868 kern_return_t is_io_registry_entry_set_properties
1869 (
1870         io_object_t registry_entry,
1871         io_buf_ptr_t properties,
1872         mach_msg_type_number_t propertiesCnt,
1873         natural_t * result)
1874 {
1875     OSObject *          obj;
1876     kern_return_t       err;
1877     IOReturn            res;
1878     vm_offset_t         data;
1879     vm_map_offset_t     map_data;
1880
1881     CHECK( IORegistryEntry, registry_entry, entry );
1882
1883     err = vm_map_copyout( kernel_map, &map_data, (vm_map_copy_t) properties );
1884     data = CAST_DOWN(vm_offset_t, map_data);
1885
1886     if( KERN_SUCCESS == err) {
1887
1888         // must return success after vm_map_copyout() succeeds
1889         obj = OSUnserializeXML( (const char *) data );
1890         vm_deallocate( kernel_map, data, propertiesCnt );
1891
1892         if( obj) {
1893             res = entry->setProperties( obj );
1894             obj->release();
1895         } else
1896             res = kIOReturnBadArgument;
1897     } else
1898         res = err;
1899
1900     *result = res;
1901     return( err );
1902 }
1903
1904 /* Routine io_registry_entry_get_child_iterator */
1905 kern_return_t is_io_registry_entry_get_child_iterator(
1906         io_object_t registry_entry,
1907         io_name_t plane,
1908         io_object_t *iterator )
1909 {
1910     CHECK( IORegistryEntry, registry_entry, entry );
1911
1912     *iterator = entry->getChildIterator(
1913         IORegistryEntry::getPlane( plane ));
1914
1915     return( kIOReturnSuccess );
1916 }
1917
1918 /* Routine io_registry_entry_get_parent_iterator */
1919 kern_return_t is_io_registry_entry_get_parent_iterator(
1920         io_object_t registry_entry,
1921         io_name_t plane,
1922         io_object_t *iterator)
1923 {
1924     CHECK( IORegistryEntry, registry_entry, entry );
1925
1926     *iterator = entry->getParentIterator(
1927         IORegistryEntry::getPlane( plane ));
1928
1929     return( kIOReturnSuccess );
1930 }
1931
1932 /* Routine io_service_get_busy_state */
1933 kern_return_t is_io_service_get_busy_state(
1934         io_object_t _service,
1935         int *busyState )
1936 {
1937     CHECK( IOService, _service, service );
1938
1939     *busyState = service->getBusyState();
1940
1941     return( kIOReturnSuccess );
1942 }
1943
1944 /* Routine io_service_get_state */
1945 kern_return_t is_io_service_get_state(
1946         io_object_t _service,
1947         uint64_t *state )
1948 {
1949     CHECK( IOService, _service, service );
1950
1951     *state = service->getState();
1952
1953     return( kIOReturnSuccess );
1954 }
1955
1956 /* Routine io_service_wait_quiet */
1957 kern_return_t is_io_service_wait_quiet(
1958         io_object_t _service,
1959         mach_timespec_t wait_time )
1960 {
1961     CHECK( IOService, _service, service );
1962
1963     return( service->waitQuiet( &wait_time ));
1964 }
1965
1966 /* Routine io_service_request_probe */
1967 kern_return_t is_io_service_request_probe(
1968         io_object_t _service,
1969         int options )
1970 {
1971     CHECK( IOService, _service, service );
1972
1973     return( service->requestProbe( options ));
1974 }
1975
1976
1977 /* Routine io_service_open */
1978 kern_return_t is_io_service_open(
1979         io_object_t _service,
1980         task_t owningTask,
1981         int connect_type,
1982         io_object_t *connection )
1983 {
1984     IOUserClient        *       client;
1985     IOReturn                    err;
1986
1987     CHECK( IOService, _service, service );
1988
1989     err = service->newUserClient( owningTask, (void *) owningTask,
1990                 connect_type, &client );
1991
1992     if( err == kIOReturnSuccess) {
1993         assert( OSDynamicCast(IOUserClient, client) );
1994         *connection = client;
1995     }
1996
1997     return( err);
1998 }
1999
2000 /* Routine io_service_close */
2001 kern_return_t is_io_service_close(
2002         io_object_t connection )
2003 {
2004     OSSet * mappings;
2005     if ((mappings = OSDynamicCast(OSSet, connection)))
2006         return( kIOReturnSuccess );
2007
2008     CHECK( IOUserClient, connection, client );
2009
2010     client->clientClose();
2011
2012     return( kIOReturnSuccess );
2013 }
2014
2015 /* Routine io_connect_get_service */
2016 kern_return_t is_io_connect_get_service(
2017         io_object_t connection,
2018         io_object_t *service )
2019 {
2020     IOService * theService;
2021
2022     CHECK( IOUserClient, connection, client );
2023
2024     theService = client->getService();
2025     if( theService)
2026         theService->retain();
2027
2028     *service = theService;
2029
2030     return( theService ? kIOReturnSuccess : kIOReturnUnsupported );
2031 }
2032
2033 /* Routine io_connect_set_notification_port */
2034 kern_return_t is_io_connect_set_notification_port(
2035         io_object_t connection,
2036         int notification_type,
2037         mach_port_t port,
2038         int reference)
2039 {
2040     CHECK( IOUserClient, connection, client );
2041
2042     return( client->registerNotificationPort( port, notification_type,
2043                                                 reference ));
2044 }
2045
2046 kern_return_t is_io_connect_map_memory(
2047         io_object_t     connect,
2048         int             type,
2049         task_t          task,
2050         vm_address_t *  mapAddr,
2051         vm_size_t    *  mapSize,
2052         int             flags )
2053 {
2054     IOReturn            err;
2055     IOMemoryMap *       map;
2056
2057     CHECK( IOUserClient, connect, client );
2058
2059     map = client->mapClientMemory( type, task, flags, *mapAddr );
2060
2061     if( map) {
2062         *mapAddr = map->getVirtualAddress();
2063         if( mapSize)
2064             *mapSize = map->getLength();
2065
2066         if( task != current_task()) {
2067             // push a name out to the task owning the map,
2068             // so we can clean up maps
2069 #if IOASSERT
2070             mach_port_name_t name =
2071 #endif
2072             IOMachPort::makeSendRightForTask(
2073                                     task, map, IKOT_IOKIT_OBJECT );
2074             assert( name );
2075
2076         } else {
2077             // keep it with the user client
2078             IOLockLock( gIOObjectPortLock);
2079             if( 0 == client->mappings)
2080                 client->mappings = OSSet::withCapacity(2);
2081             if( client->mappings)
2082                 client->mappings->setObject( map);
2083             IOLockUnlock( gIOObjectPortLock);
2084             map->release();
2085         }
2086         err = kIOReturnSuccess;
2087
2088     } else
2089         err = kIOReturnBadArgument;
2090
2091     return( err );
2092 }
2093
2094 IOMemoryMap * IOUserClient::removeMappingForDescriptor(IOMemoryDescriptor * mem)
2095 {
2096     OSIterator *  iter;
2097     IOMemoryMap * map = 0;
2098
2099     IOLockLock(gIOObjectPortLock);
2100
2101     iter = OSCollectionIterator::withCollection(mappings);
2102     if(iter)
2103     {
2104         while ((map = OSDynamicCast(IOMemoryMap, iter->getNextObject())))
2105         {
2106             if(mem == map->getMemoryDescriptor())
2107             {
2108                 map->retain();
2109                 mappings->removeObject(map);
2110                 break;
2111             }
2112         }
2113         iter->release();
2114     }
2115
2116     IOLockUnlock(gIOObjectPortLock);
2117
2118     return (map);
2119 }
2120
2121 kern_return_t is_io_connect_unmap_memory(
2122         io_object_t     connect,
2123         int             type,
2124         task_t          task,
2125         vm_address_t    mapAddr )
2126 {
2127     IOReturn            err;
2128     IOOptionBits        options = 0;
2129     IOMemoryDescriptor * memory;
2130     IOMemoryMap *       map;
2131
2132     CHECK( IOUserClient, connect, client );
2133
2134     err = client->clientMemoryForType( (UInt32) type, &options, &memory );
2135
2136     if( memory && (kIOReturnSuccess == err)) {
2137
2138         options = (options & ~kIOMapUserOptionsMask)
2139                 | kIOMapAnywhere | kIOMapReference;
2140
2141         map = memory->map( task, mapAddr, options );
2142         memory->release();
2143         if( map)
2144         {
2145             IOLockLock( gIOObjectPortLock);
2146             if( client->mappings)
2147                 client->mappings->removeObject( map);
2148             IOLockUnlock( gIOObjectPortLock);
2149
2150             mach_port_name_t name = 0;
2151             if (task != current_task())
2152                 name = IOMachPort::makeSendRightForTask( task, map, IKOT_IOKIT_OBJECT );
2153             if (name)
2154             {
2155                 map->unmap();
2156                 err = iokit_mod_send_right( task, name, -2 );
2157                 err = kIOReturnSuccess;
2158             }
2159             else
2160                 IOMachPort::releasePortForObject( map, IKOT_IOKIT_OBJECT );
2161             if (task == current_task())
2162                 map->release();
2163         }
2164         else
2165             err = kIOReturnBadArgument;
2166     }
2167
2168     return( err );
2169 }
2170
2171
2172 /* Routine io_connect_add_client */
2173 kern_return_t is_io_connect_add_client(
2174         io_object_t connection,
2175         io_object_t connect_to)
2176 {
2177     CHECK( IOUserClient, connection, client );
2178     CHECK( IOUserClient, connect_to, to );
2179
2180     return( client->connectClient( to ) );
2181 }
2182
2183
2184 /* Routine io_connect_set_properties */
2185 kern_return_t is_io_connect_set_properties(
2186         io_object_t connection,
2187         io_buf_ptr_t properties,
2188         mach_msg_type_number_t propertiesCnt,
2189         natural_t * result)
2190 {
2191     return( is_io_registry_entry_set_properties( connection, properties, propertiesCnt, result ));
2192 }
2193
2194
2195 /* Routine io_connect_method_scalarI_scalarO */
2196 kern_return_t is_io_connect_method_scalarI_scalarO(
2197         io_object_t     connect,
2198         UInt32          index,
2199         void *          input[],
2200         IOByteCount     inputCount,
2201         void *          output[],
2202         IOByteCount *   outputCount )
2203 {
2204     IOReturn            err;
2205     IOExternalMethod *  method;
2206     IOService *         object;
2207     IOMethod            func;
2208
2209     CHECK( IOUserClient, connect, client);
2210     if( (method = client->getTargetAndMethodForIndex(&object, index))) {
2211       do {
2212         err = kIOReturnBadArgument;
2213         if( kIOUCScalarIScalarO != (method->flags & kIOUCTypeMask))
2214             continue;
2215         if( inputCount != method->count0)
2216             continue;
2217         if( *outputCount != method->count1)
2218             continue;
2219
2220         func = method->func;
2221
2222         switch( inputCount) {
2223
2224             case 6:
2225                 err = (object->*func)(  input[0], input[1], input[2],
2226                                         input[3], input[4], input[5] );
2227                 break;
2228             case 5:
2229                 err = (object->*func)(  input[0], input[1], input[2],
2230                                         input[3], input[4],
2231                                         &output[0] );
2232                 break;
2233             case 4:
2234                 err = (object->*func)(  input[0], input[1], input[2],
2235                                         input[3],
2236                                         &output[0], &output[1] );
2237                 break;
2238             case 3:
2239                 err = (object->*func)(  input[0], input[1], input[2],
2240                                         &output[0], &output[1], &output[2] );
2241                 break;
2242             case 2:
2243                 err = (object->*func)(  input[0], input[1],
2244                                         &output[0], &output[1], &output[2],
2245                                         &output[3] );
2246                 break;
2247             case 1:
2248                 err = (object->*func)(  input[0],
2249                                         &output[0], &output[1], &output[2],
2250                                         &output[3], &output[4] );
2251                 break;
2252             case 0:
2253                 err = (object->*func)(  &output[0], &output[1], &output[2],
2254                                         &output[3], &output[4], &output[5] );
2255                 break;
2256
2257             default:
2258                 IOLog("%s: Bad method table\n", client->getName());
2259         }
2260       } while( false);
2261
2262     } else
2263         err = kIOReturnUnsupported;
2264
2265     return( err);
2266 }
2267
2268 /* Routine io_connect_method_scalarI_structureO */
2269 kern_return_t is_io_connect_method_scalarI_structureO(
2270         io_object_t     connect,
2271         UInt32          index,
2272         void *          input[],
2273         IOByteCount     inputCount,
2274         void *          output,
2275         IOByteCount *   outputCount )
2276 {
2277     IOReturn            err;
2278     IOExternalMethod *  method;
2279     IOService *         object;
2280     IOMethod            func;
2281
2282     CHECK( IOUserClient, connect, client);
2283
2284     if( (method = client->getTargetAndMethodForIndex(&object, index)) ) {
2285       do {
2286         err = kIOReturnBadArgument;
2287         if( kIOUCScalarIStructO != (method->flags & kIOUCTypeMask))
2288             continue;
2289         if( inputCount != method->count0)
2290             continue;
2291         if( (0xffffffff != method->count1)
2292                 && (*outputCount != method->count1))
2293             continue;
2294
2295         func = method->func;
2296
2297         switch( inputCount) {
2298
2299             case 5:
2300                 err = (object->*func)(  input[0], input[1], input[2],
2301                                         input[3], input[4],
2302                                         output );
2303                 break;
2304             case 4:
2305                 err = (object->*func)(  input[0], input[1], input[2],
2306                                         input[3],
2307                                         output, (void *)outputCount );
2308                 break;
2309             case 3:
2310                 err = (object->*func)(  input[0], input[1], input[2],
2311                                         output, (void *)outputCount, 0 );
2312                 break;
2313             case 2:
2314                 err = (object->*func)(  input[0], input[1],
2315                                         output, (void *)outputCount, 0, 0 );
2316                 break;
2317             case 1:
2318                 err = (object->*func)(  input[0],
2319                                         output, (void *)outputCount, 0, 0, 0 );
2320                 break;
2321             case 0:
2322                 err = (object->*func)(  output, (void *)outputCount, 0, 0, 0, 0 );
2323                 break;
2324
2325             default:
2326                 IOLog("%s: Bad method table\n", client->getName());
2327         }
2328       } while( false);
2329
2330     } else
2331         err = kIOReturnUnsupported;
2332
2333     return( err);
2334 }
2335
2336 /* Routine io_connect_method_scalarI_structureI */
2337 kern_return_t is_io_connect_method_scalarI_structureI(
2338         io_connect_t    connect,
2339         UInt32          index,
2340         void *          input[],
2341         IOByteCount     inputCount,
2342         UInt8 *         inputStruct,
2343         IOByteCount     inputStructCount )
2344 {
2345     IOReturn            err;
2346     IOExternalMethod *  method;
2347     IOService *         object;
2348     IOMethod            func;
2349
2350     CHECK( IOUserClient, connect, client);
2351
2352     if( (method = client->getTargetAndMethodForIndex(&object, index)) ) {
2353       do {
2354         err = kIOReturnBadArgument;
2355         if( kIOUCScalarIStructI != (method->flags & kIOUCTypeMask))
2356             continue;
2357         if( (0xffffffff != method->count0)
2358                 && (inputCount != method->count0))
2359             continue;
2360         if( (0xffffffff != method->count1)
2361                 && (inputStructCount != method->count1))
2362             continue;
2363
2364         func = method->func;
2365
2366         switch( inputCount) {
2367
2368             case 5:
2369                 err = (object->*func)( input[0], input[1], input[2],
2370                                         input[3], input[4],
2371                                         inputStruct );
2372                 break;
2373             case 4:
2374                 err = (object->*func)( input[0], input[1], input[2],
2375                                         input[3],
2376                                         inputStruct, (void *)inputStructCount );
2377                 break;
2378             case 3:
2379                 err = (object->*func)( input[0], input[1], input[2],
2380                                         inputStruct, (void *)inputStructCount,
2381                                         0 );
2382                 break;
2383             case 2:
2384                 err = (object->*func)( input[0], input[1],
2385                                         inputStruct, (void *)inputStructCount,
2386                                         0, 0 );
2387                 break;
2388             case 1:
2389                 err = (object->*func)( input[0],
2390                                         inputStruct, (void *)inputStructCount,
2391                                         0, 0, 0 );
2392                 break;
2393             case 0:
2394                 err = (object->*func)( inputStruct, (void *)inputStructCount,
2395                                         0, 0, 0, 0 );
2396                 break;
2397
2398             default:
2399                 IOLog("%s: Bad method table\n", client->getName());
2400         }
2401       } while( false);
2402
2403     } else
2404         err = kIOReturnUnsupported;
2405
2406     return( err);
2407 }
2408
2409 /* Routine io_connect_method_structureI_structureO */
2410 kern_return_t is_io_connect_method_structureI_structureO(
2411         io_object_t     connect,
2412         UInt32          index,
2413         UInt8 *         input,
2414         IOByteCount     inputCount,
2415         UInt8 *         output,
2416         IOByteCount *   outputCount )
2417 {
2418     IOReturn            err;
2419     IOExternalMethod *  method;
2420     IOService *         object;
2421     IOMethod            func;
2422
2423     CHECK( IOUserClient, connect, client);
2424
2425     if( (method = client->getTargetAndMethodForIndex(&object, index)) ) {
2426       do {
2427         err = kIOReturnBadArgument;
2428         if( kIOUCStructIStructO != (method->flags & kIOUCTypeMask))
2429             continue;
2430         if( (0xffffffff != method->count0)
2431                 && (inputCount != method->count0))
2432             continue;
2433         if( (0xffffffff != method->count1)
2434                 && (*outputCount != method->count1))
2435             continue;
2436
2437         func = method->func;
2438
2439         if( method->count1) {
2440             if( method->count0) {
2441                 err = (object->*func)( input, output,
2442                                         (void *)inputCount, outputCount, 0, 0 );
2443             } else {
2444                 err = (object->*func)( output, outputCount, 0, 0, 0, 0 );
2445             }
2446         } else {
2447                 err = (object->*func)( input, (void *)inputCount, 0, 0, 0, 0 );
2448         }
2449
2450       } while( false);
2451
2452     } else
2453         err = kIOReturnUnsupported;
2454
2455     return( err);
2456 }
2457
2458 kern_return_t is_io_async_method_scalarI_scalarO(
2459         io_object_t     connect,
2460         mach_port_t     wakePort,
2461         io_async_ref_t          reference,
2462         mach_msg_type_number_t  referenceCnt,
2463         UInt32          index,
2464         void *          input[],
2465         IOByteCount     inputCount,
2466         void *          output[],
2467         IOByteCount *   outputCount )
2468 {
2469     IOReturn            err;
2470     IOExternalAsyncMethod *method;
2471     IOService *         object;
2472     IOAsyncMethod       func;
2473
2474     CHECK( IOUserClient, connect, client);
2475     if( (method = client->getAsyncTargetAndMethodForIndex(&object, index)) ) {
2476       do {
2477         err = kIOReturnBadArgument;
2478         if( kIOUCScalarIScalarO != (method->flags & kIOUCTypeMask))
2479             continue;
2480         if( inputCount != method->count0)
2481             continue;
2482         if( *outputCount != method->count1)
2483             continue;
2484
2485         reference[0] = (natural_t) wakePort;
2486         func = method->func;
2487
2488         switch( inputCount) {
2489
2490             case 6:
2491                 err = (object->*func)(  reference,
2492                                         input[0], input[1], input[2],
2493                                         input[3], input[4], input[5] );
2494                 break;
2495             case 5:
2496                 err = (object->*func)(  reference,
2497                                         input[0], input[1], input[2],
2498                                         input[3], input[4],
2499                                         &output[0] );
2500                 break;
2501             case 4:
2502                 err = (object->*func)(  reference,
2503                                         input[0], input[1], input[2],
2504                                         input[3],
2505                                         &output[0], &output[1] );
2506                 break;
2507             case 3:
2508                 err = (object->*func)(  reference,
2509                                         input[0], input[1], input[2],
2510                                         &output[0], &output[1], &output[2] );
2511                 break;
2512             case 2:
2513                 err = (object->*func)(  reference,
2514                                         input[0], input[1],
2515                                         &output[0], &output[1], &output[2],
2516                                         &output[3] );
2517                 break;
2518             case 1:
2519                 err = (object->*func)(  reference,
2520                                         input[0],
2521                                         &output[0], &output[1], &output[2],
2522                                         &output[3], &output[4] );
2523                 break;
2524             case 0:
2525                 err = (object->*func)(  reference,
2526                                         &output[0], &output[1], &output[2],
2527                                         &output[3], &output[4], &output[5] );
2528                 break;
2529
2530             default:
2531                 IOLog("%s: Bad method table\n", client->getName());
2532         }
2533       } while( false);
2534
2535     } else
2536         err = kIOReturnUnsupported;
2537
2538     return( err);
2539 }
2540
2541 kern_return_t is_io_async_method_scalarI_structureO(
2542         io_object_t     connect,
2543         mach_port_t     wakePort,
2544         io_async_ref_t          reference,
2545         mach_msg_type_number_t  referenceCnt,
2546         UInt32          index,
2547         void *          input[],
2548         IOByteCount     inputCount,
2549         void *          output,
2550         IOByteCount *   outputCount )
2551 {
2552     IOReturn            err;
2553     IOExternalAsyncMethod *method;
2554     IOService *         object;
2555     IOAsyncMethod       func;
2556
2557     CHECK( IOUserClient, connect, client);
2558
2559     if( (method = client->getAsyncTargetAndMethodForIndex(&object, index)) ) {
2560       do {
2561         err = kIOReturnBadArgument;
2562         if( kIOUCScalarIStructO != (method->flags & kIOUCTypeMask))
2563             continue;
2564         if( inputCount != method->count0)
2565             continue;
2566         if( (0xffffffff != method->count1)
2567                 && (*outputCount != method->count1))
2568             continue;
2569
2570         reference[0] = (natural_t) wakePort;
2571         func = method->func;
2572
2573         switch( inputCount) {
2574
2575             case 5:
2576                 err = (object->*func)(  reference,
2577                                         input[0], input[1], input[2],
2578                                         input[3], input[4],
2579                                         output );
2580                 break;
2581             case 4:
2582                 err = (object->*func)(  reference,
2583                                         input[0], input[1], input[2],
2584                                         input[3],
2585                                         output, (void *)outputCount );
2586                 break;
2587             case 3:
2588                 err = (object->*func)(  reference,
2589                                         input[0], input[1], input[2],
2590                                         output, (void *)outputCount, 0 );
2591                 break;
2592             case 2:
2593                 err = (object->*func)(  reference,
2594                                         input[0], input[1],
2595                                         output, (void *)outputCount, 0, 0 );
2596                 break;
2597             case 1:
2598                 err = (object->*func)(  reference,
2599                                         input[0],
2600                                         output, (void *)outputCount, 0, 0, 0 );
2601                 break;
2602             case 0:
2603                 err = (object->*func)(  reference,
2604                                         output, (void *)outputCount, 0, 0, 0, 0 );
2605                 break;
2606
2607             default:
2608                 IOLog("%s: Bad method table\n", client->getName());
2609         }
2610       } while( false);
2611
2612     } else
2613         err = kIOReturnUnsupported;
2614
2615     return( err);
2616 }
2617
2618 kern_return_t is_io_async_method_scalarI_structureI(
2619             io_connect_t        connect,
2620             mach_port_t         wakePort,
2621             io_async_ref_t          reference,
2622             mach_msg_type_number_t  referenceCnt,
2623             UInt32              index,
2624             void *              input[],
2625             IOByteCount inputCount,
2626             UInt8 *             inputStruct,
2627             IOByteCount inputStructCount )
2628 {
2629     IOReturn            err;
2630     IOExternalAsyncMethod *method;
2631     IOService *         object;
2632     IOAsyncMethod       func;
2633
2634     CHECK( IOUserClient, connect, client);
2635
2636     if( (method = client->getAsyncTargetAndMethodForIndex(&object, index)) ) {
2637       do {
2638         err = kIOReturnBadArgument;
2639         if( kIOUCScalarIStructI != (method->flags & kIOUCTypeMask))
2640             continue;
2641         if( (0xffffffff != method->count0)
2642                 && (inputCount != method->count0))
2643             continue;
2644         if( (0xffffffff != method->count1)
2645                 && (inputStructCount != method->count1))
2646             continue;
2647
2648         reference[0] = (natural_t) wakePort;
2649         func = method->func;
2650
2651         switch( inputCount) {
2652
2653             case 5:
2654                 err = (object->*func)(  reference,
2655                                         input[0], input[1], input[2],
2656                                         input[3], input[4],
2657                                         inputStruct );
2658                 break;
2659             case 4:
2660                 err = (object->*func)(  reference,
2661                                         input[0], input[1], input[2],
2662                                         input[3],
2663                                         inputStruct, (void *)inputStructCount );
2664                 break;
2665             case 3:
2666                 err = (object->*func)(  reference,
2667                                         input[0], input[1], input[2],
2668                                         inputStruct, (void *)inputStructCount,
2669                                         0 );
2670                 break;
2671             case 2:
2672                 err = (object->*func)(  reference,
2673                                         input[0], input[1],
2674                                         inputStruct, (void *)inputStructCount,
2675                                         0, 0 );
2676                 break;
2677             case 1:
2678                 err = (object->*func)(  reference,
2679                                         input[0],
2680                                         inputStruct, (void *)inputStructCount,
2681                                         0, 0, 0 );
2682                 break;
2683             case 0:
2684                 err = (object->*func)(  reference,
2685                                         inputStruct, (void *)inputStructCount,
2686                                         0, 0, 0, 0 );
2687                 break;
2688
2689             default:
2690                 IOLog("%s: Bad method table\n", client->getName());
2691         }
2692       } while( false);
2693
2694     } else
2695         err = kIOReturnUnsupported;
2696
2697     return( err);
2698 }
2699
2700 kern_return_t is_io_async_method_structureI_structureO(
2701         io_object_t     connect,
2702         mach_port_t wakePort,
2703         io_async_ref_t          reference,
2704         mach_msg_type_number_t  referenceCnt,
2705         UInt32          index,
2706         UInt8 *         input,
2707         IOByteCount     inputCount,
2708         UInt8 *         output,
2709         IOByteCount *   outputCount )
2710 {
2711     IOReturn            err;
2712     IOExternalAsyncMethod *method;
2713     IOService *         object;
2714     IOAsyncMethod       func;
2715
2716     CHECK( IOUserClient, connect, client);
2717
2718     if( (method = client->getAsyncTargetAndMethodForIndex(&object, index)) ) {
2719       do {
2720         err = kIOReturnBadArgument;
2721         if( kIOUCStructIStructO != (method->flags & kIOUCTypeMask))
2722             continue;
2723         if( (0xffffffff != method->count0)
2724                 && (inputCount != method->count0))
2725             continue;
2726         if( (0xffffffff != method->count1)
2727                 && (*outputCount != method->count1))
2728             continue;
2729
2730         reference[0] = (natural_t) wakePort;
2731         func = method->func;
2732
2733         if( method->count1) {
2734             if( method->count0) {
2735                 err = (object->*func)( reference,
2736                                        input, output,
2737                                         (void *)inputCount, outputCount, 0, 0 );
2738             } else {
2739                 err = (object->*func)( reference,
2740                                        output, outputCount, 0, 0, 0, 0 );
2741             }
2742         } else {
2743                 err = (object->*func)( reference,
2744                                        input, (void *)inputCount, 0, 0, 0, 0 );
2745         }
2746
2747       } while( false);
2748
2749     } else
2750         err = kIOReturnUnsupported;
2751
2752     return( err);
2753 }
2754 /* Routine io_make_matching */
2755 kern_return_t is_io_make_matching(
2756         mach_port_t     master_port,
2757         UInt32          type,
2758         IOOptionBits    options,
2759         UInt8 *         input,
2760         IOByteCount     inputCount,
2761         io_string_t     matching )
2762 {
2763     OSSerialize *       s;
2764     IOReturn            err = kIOReturnSuccess;
2765     OSDictionary *      dict;
2766
2767     if( master_port != master_device_port)
2768         return( kIOReturnNotPrivileged);
2769
2770     switch( type) {
2771
2772         case kIOServiceMatching:
2773             dict = IOService::serviceMatching( gIOServiceKey );
2774             break;
2775
2776         case kIOBSDNameMatching:
2777             dict = IOBSDNameMatching( (const char *) input );
2778             break;
2779
2780         case kIOOFPathMatching:
2781             dict = IOOFPathMatching( (const char *) input,
2782                                     matching, sizeof( io_string_t));
2783             break;
2784
2785         default:
2786             dict = 0;
2787     }
2788
2789     if( !dict)
2790         return( kIOReturnUnsupported);
2791
2792     do {
2793         s = OSSerialize::withCapacity(4096);
2794         if( !s) {
2795             err = kIOReturnNoMemory;
2796             continue;
2797         }
2798         s->clearText();
2799         if( !dict->serialize( s )) {
2800             err = kIOReturnUnsupported;
2801             continue;
2802         }
2803
2804         if( s->getLength() > sizeof( io_string_t)) {
2805             err = kIOReturnNoMemory;
2806             continue;
2807         } else
2808             strcpy( matching, s->text());
2809
2810     } while( false);
2811
2812     if( s)
2813         s->release();
2814     if( dict)
2815         dict->release();
2816
2817     return( err);
2818 }
2819
2820 /* Routine io_catalog_send_data */
2821 kern_return_t is_io_catalog_send_data(
2822         mach_port_t             master_port,
2823         int                     flag,
2824         io_buf_ptr_t            inData,
2825         mach_msg_type_number_t  inDataCount,
2826         natural_t *             result)
2827 {
2828     OSObject * obj = 0;
2829     vm_offset_t data;
2830     kern_return_t kr = kIOReturnError;
2831
2832     //printf("io_catalog_send_data called. flag: %d\n", flag);
2833
2834     if( master_port != master_device_port)
2835         return kIOReturnNotPrivileged;
2836
2837     // FIXME: This is a hack. Should have own function for removeKernelLinker()
2838     if(flag != kIOCatalogRemoveKernelLinker && ( !inData || !inDataCount) )
2839         return kIOReturnBadArgument;
2840
2841     if (inData) {
2842         vm_map_offset_t map_data;
2843
2844         kr = vm_map_copyout( kernel_map, &map_data, (vm_map_copy_t)inData);
2845         data = CAST_DOWN(vm_offset_t, map_data);
2846
2847         if( kr != KERN_SUCCESS)
2848             return kr;
2849
2850         // must return success after vm_map_copyout() succeeds
2851
2852         if( inDataCount ) {
2853             obj = (OSObject *)OSUnserializeXML((const char *)data);
2854             vm_deallocate( kernel_map, data, inDataCount );
2855             if( !obj) {
2856                 *result = kIOReturnNoMemory;
2857                 return( KERN_SUCCESS);
2858             }
2859         }
2860     }
2861
2862     switch ( flag ) {
2863         case kIOCatalogAddDrivers:
2864         case kIOCatalogAddDriversNoMatch: {
2865                 OSArray * array;
2866
2867                 array = OSDynamicCast(OSArray, obj);
2868                 if ( array ) {
2869                     if ( !gIOCatalogue->addDrivers( array ,
2870                                           flag == kIOCatalogAddDrivers) ) {
2871                         kr = kIOReturnError;
2872                     }
2873                 }
2874                 else {
2875                     kr = kIOReturnBadArgument;
2876                 }
2877             }
2878             break;
2879
2880         case kIOCatalogRemoveDrivers:
2881         case kIOCatalogRemoveDriversNoMatch: {
2882                 OSDictionary * dict;
2883
2884                 dict = OSDynamicCast(OSDictionary, obj);
2885                 if ( dict ) {
2886                     if ( !gIOCatalogue->removeDrivers( dict,
2887                                           flag == kIOCatalogRemoveDrivers ) ) {
2888                         kr = kIOReturnError;
2889                     }
2890                 }
2891                 else {
2892                     kr = kIOReturnBadArgument;
2893                 }
2894             }
2895             break;
2896
2897         case kIOCatalogStartMatching: {
2898                 OSDictionary * dict;
2899
2900                 dict = OSDynamicCast(OSDictionary, obj);
2901                 if ( dict ) {
2902                     if ( !gIOCatalogue->startMatching( dict ) ) {
2903                         kr = kIOReturnError;
2904                     }
2905                 }
2906                 else {
2907                     kr = kIOReturnBadArgument;
2908                 }
2909             }
2910             break;
2911
2912         case kIOCatalogRemoveKernelLinker: {
2913                 if (gIOCatalogue->removeKernelLinker() != KERN_SUCCESS) {
2914                     kr = kIOReturnError;
2915                 } else {
2916                     kr = kIOReturnSuccess;
2917                 }
2918             }
2919             break;
2920
2921         default:
2922             kr = kIOReturnBadArgument;
2923             break;
2924     }
2925
2926     if (obj) obj->release();
2927
2928     *result = kr;
2929     return( KERN_SUCCESS);
2930 }
2931
2932 /* Routine io_catalog_terminate */
2933 kern_return_t is_io_catalog_terminate(
2934         mach_port_t master_port,
2935         int flag,
2936         io_name_t name )
2937 {
2938     kern_return_t          kr;
2939
2940     if( master_port != master_device_port )
2941         return kIOReturnNotPrivileged;
2942
2943     kr = IOUserClient::clientHasPrivilege( (void *) current_task(),
2944                                             kIOClientPrivilegeAdministrator );
2945     if( kIOReturnSuccess != kr)
2946         return( kr );
2947
2948     switch ( flag ) {
2949         case kIOCatalogServiceTerminate:
2950             OSIterator *        iter;
2951             IOService *         service;
2952
2953             iter = IORegistryIterator::iterateOver(gIOServicePlane,
2954                                         kIORegistryIterateRecursively);
2955             if ( !iter )
2956                 return kIOReturnNoMemory;
2957
2958             do {
2959                 iter->reset();
2960                 while( (service = (IOService *)iter->getNextObject()) ) {
2961                     if( service->metaCast(name)) {
2962                         if ( !service->terminate( kIOServiceRequired
2963                                                 | kIOServiceSynchronous) ) {
2964                             kr = kIOReturnUnsupported;
2965                             break;
2966                         }
2967                     }
2968                 }
2969             } while( !service && !iter->isValid());
2970             iter->release();
2971             break;
2972
2973         case kIOCatalogModuleUnload:
2974         case kIOCatalogModuleTerminate:
2975             kr = gIOCatalogue->terminateDriversForModule(name,
2976                                         flag == kIOCatalogModuleUnload);
2977             break;
2978
2979         default:
2980             kr = kIOReturnBadArgument;
2981             break;
2982     }
2983
2984     return( kr );
2985 }
2986
2987 /* Routine io_catalog_get_data */
2988 kern_return_t is_io_catalog_get_data(
2989         mach_port_t             master_port,
2990         int                     flag,
2991         io_buf_ptr_t            *outData,
2992         mach_msg_type_number_t  *outDataCount)
2993 {
2994     kern_return_t kr = kIOReturnSuccess;
2995     OSSerialize * s;
2996
2997     if( master_port != master_device_port)
2998         return kIOReturnNotPrivileged;
2999
3000     //printf("io_catalog_get_data called. flag: %d\n", flag);
3001
3002     s = OSSerialize::withCapacity(4096);
3003     if ( !s )
3004         return kIOReturnNoMemory;
3005
3006     s->clearText();
3007
3008     kr = gIOCatalogue->serializeData(flag, s);
3009
3010     if ( kr == kIOReturnSuccess ) {
3011         vm_offset_t data;
3012         vm_map_copy_t copy;
3013         vm_size_t size;
3014
3015         size = s->getLength();
3016         kr = vm_allocate(kernel_map, &data, size, VM_FLAGS_ANYWHERE);
3017         if ( kr == kIOReturnSuccess ) {
3018             bcopy(s->text(), (void *)data, size);
3019             kr = vm_map_copyin(kernel_map, (vm_map_address_t)data,
3020                                (vm_map_size_t)size, true, &copy);
3021             *outData = (char *)copy;
3022             *outDataCount = size;
3023         }
3024     }
3025
3026     s->release();
3027
3028     return kr;
3029 }
3030
3031 /* Routine io_catalog_get_gen_count */
3032 kern_return_t is_io_catalog_get_gen_count(
3033         mach_port_t             master_port,
3034         int                     *genCount)
3035 {
3036     if( master_port != master_device_port)
3037         return kIOReturnNotPrivileged;
3038
3039     //printf("io_catalog_get_gen_count called.\n");
3040
3041     if ( !genCount )
3042         return kIOReturnBadArgument;
3043
3044     *genCount = gIOCatalogue->getGenerationCount();
3045
3046     return kIOReturnSuccess;
3047 }
3048
3049 /* Routine io_catalog_module_loaded */
3050 kern_return_t is_io_catalog_module_loaded(
3051         mach_port_t             master_port,
3052         io_name_t               name)
3053 {
3054     if( master_port != master_device_port)
3055         return kIOReturnNotPrivileged;
3056
3057     //printf("io_catalog_module_loaded called. name %s\n", name);
3058
3059     if ( !name )
3060         return kIOReturnBadArgument;
3061
3062     gIOCatalogue->moduleHasLoaded(name);
3063
3064     return kIOReturnSuccess;
3065 }
3066
3067 kern_return_t is_io_catalog_reset(
3068         mach_port_t             master_port,
3069         int                     flag)
3070 {
3071     if( master_port != master_device_port)
3072         return kIOReturnNotPrivileged;
3073
3074     switch ( flag ) {
3075         case kIOCatalogResetDefault:
3076             gIOCatalogue->reset();
3077             break;
3078
3079         default:
3080             return kIOReturnBadArgument;
3081     }
3082
3083     return kIOReturnSuccess;
3084 }
3085
3086 kern_return_t iokit_user_client_trap(struct iokit_user_client_trap_args *args)
3087 {
3088     kern_return_t result = kIOReturnBadArgument;
3089     IOUserClient *userClient;
3090
3091     if ((userClient = OSDynamicCast(IOUserClient,
3092             iokit_lookup_connect_ref_current_task((OSObject *)(args->userClientRef))))) {
3093         IOExternalTrap *trap;
3094         IOService *target = NULL;
3095
3096         trap = userClient->getTargetAndTrapForIndex(&target, args->index);
3097
3098         if (trap && target) {
3099             IOTrap func;
3100
3101             func = trap->func;
3102
3103             if (func) {
3104                 result = (target->*func)(args->p1, args->p2, args->p3, args->p4, args->p5, args->p6);
3105             }
3106         }
3107
3108         userClient->release();
3109     }
3110
3111     return result;
3112 }
3113
3114 };      /* extern "C" */
3115
3116 OSMetaClassDefineReservedUnused(IOUserClient, 0);
3117 OSMetaClassDefineReservedUnused(IOUserClient, 1);
3118 OSMetaClassDefineReservedUnused(IOUserClient, 2);
3119 OSMetaClassDefineReservedUnused(IOUserClient, 3);
3120 OSMetaClassDefineReservedUnused(IOUserClient, 4);
3121 OSMetaClassDefineReservedUnused(IOUserClient, 5);
3122 OSMetaClassDefineReservedUnused(IOUserClient, 6);
3123 OSMetaClassDefineReservedUnused(IOUserClient, 7);
3124 OSMetaClassDefineReservedUnused(IOUserClient, 8);
3125 OSMetaClassDefineReservedUnused(IOUserClient, 9);
3126 OSMetaClassDefineReservedUnused(IOUserClient, 10);
3127 OSMetaClassDefineReservedUnused(IOUserClient, 11);
3128 OSMetaClassDefineReservedUnused(IOUserClient, 12);
3129 OSMetaClassDefineReservedUnused(IOUserClient, 13);
3130 OSMetaClassDefineReservedUnused(IOUserClient, 14);
3131 OSMetaClassDefineReservedUnused(IOUserClient, 15);
3132