iokit/IOKit/IOUserClient.h

   1 /*
   2  * Copyright (c) 1998-2000 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  * Changes to this API are expected.
  25  */
  26
  27 #ifndef _IOKIT_IOUSERCLIENT_H
  28 #define _IOKIT_IOUSERCLIENT_H
  29
  30 #include <IOKit/IOTypes.h>
  31 #include <IOKit/IOService.h>
  32 #include <IOKit/OSMessageNotification.h>
  33
  34
  35 enum {
  36     kIOUCTypeMask       = 0x0000000f,
  37     kIOUCScalarIScalarO = 0,
  38     kIOUCScalarIStructO = 2,
  39     kIOUCStructIStructO = 3,
  40     kIOUCScalarIStructI = 4,
  41 };
  42
  43 typedef IOReturn (IOService::*IOMethod)(void * p1, void * p2, void * p3,
  44                                         void * p4, void * p5, void * p6 );
  45
  46 typedef IOReturn (IOService::*IOAsyncMethod)(OSAsyncReference asyncRef,
  47                                         void * p1, void * p2, void * p3,
  48                                         void * p4, void * p5, void * p6 );
  49
  50 typedef IOReturn (IOService::*IOTrap)(void * p1, void * p2, void * p3,
  51                                       void * p4, void * p5, void * p6 );
  52
  53 struct IOExternalMethod {
  54     IOService *         object;
  55     IOMethod            func;
  56     IOOptionBits        flags;
  57     IOByteCount         count0;
  58     IOByteCount         count1;
  59 };
  60
  61 struct IOExternalAsyncMethod {
  62     IOService *         object;
  63     IOAsyncMethod       func;
  64     IOOptionBits        flags;
  65     IOByteCount         count0;
  66     IOByteCount         count1;
  67 };
  68
  69 struct IOExternalTrap {
  70     IOService *         object;
  71     IOTrap              func;
  72 };
  73
  74 enum {
  75     kIOUserNotifyMaxMessageSize = 64
  76 };
  77
  78 // keys for clientHasPrivilege
  79 #define kIOClientPrivilegeAdministrator "root"
  80 #define kIOClientPrivilegeLocalUser     "local"
  81
  82 class IOUserClient : public IOService
  83 {
  84     OSDeclareAbstractStructors(IOUserClient)
  85
  86 protected:
  87 /*! @struct ExpansionData
  88     @discussion This structure will be used to expand the capablilties of this class in the future.
  89     */
  90     struct ExpansionData { };
  91
  92 /*! @var reserved
  93     Reserved for future use.  (Internal use only)  */
  94     ExpansionData * reserved;
  95
  96 public:
  97     OSSet * mappings;
  98     void  * __reserved[8];
  99
 100 private:
 101     OSMetaClassDeclareReservedUnused(IOUserClient, 0);
 102     OSMetaClassDeclareReservedUnused(IOUserClient, 1);
 103     OSMetaClassDeclareReservedUnused(IOUserClient, 2);
 104     OSMetaClassDeclareReservedUnused(IOUserClient, 3);
 105     OSMetaClassDeclareReservedUnused(IOUserClient, 4);
 106     OSMetaClassDeclareReservedUnused(IOUserClient, 5);
 107     OSMetaClassDeclareReservedUnused(IOUserClient, 6);
 108     OSMetaClassDeclareReservedUnused(IOUserClient, 7);
 109     OSMetaClassDeclareReservedUnused(IOUserClient, 8);
 110     OSMetaClassDeclareReservedUnused(IOUserClient, 9);
 111     OSMetaClassDeclareReservedUnused(IOUserClient, 10);
 112     OSMetaClassDeclareReservedUnused(IOUserClient, 11);
 113     OSMetaClassDeclareReservedUnused(IOUserClient, 12);
 114     OSMetaClassDeclareReservedUnused(IOUserClient, 13);
 115     OSMetaClassDeclareReservedUnused(IOUserClient, 14);
 116     OSMetaClassDeclareReservedUnused(IOUserClient, 15);
 117
 118 protected:
 119     static IOReturn sendAsyncResult(OSAsyncReference reference,
 120                                     IOReturn result, void *args[], UInt32 numArgs);
 121     static void setAsyncReference(OSAsyncReference asyncRef,
 122                                   mach_port_t wakePort,
 123                                   void *callback, void *refcon);
 124 public:
 125
 126     static void initialize( void );
 127
 128     static void destroyUserReferences( OSObject * obj );
 129
 130     static IOReturn clientHasPrivilege( void * securityToken,
 131                                         const char * privilegeName );
 132
 133     // Currently ignores the all args, just passes up to IOService::init()
 134     virtual bool initWithTask(
 135                     task_t owningTask, void * securityToken, UInt32 type,
 136                     OSDictionary * properties);
 137
 138     virtual bool initWithTask(
 139                     task_t owningTask, void * securityToken, UInt32 type);
 140
 141     virtual void free();
 142
 143     virtual IOReturn clientClose( void );
 144     virtual IOReturn clientDied( void );
 145
 146     virtual IOService * getService( void );
 147
 148     virtual IOReturn registerNotificationPort(
 149                 mach_port_t port, UInt32 type, UInt32 refCon );
 150
 151     virtual IOReturn getNotificationSemaphore( UInt32 notification_type,
 152                                     semaphore_t * semaphore );
 153
 154     virtual IOReturn connectClient( IOUserClient * client );
 155
 156     // memory will be released by user client when last map is destroyed
 157     virtual IOReturn clientMemoryForType( UInt32 type,
 158                                 IOOptionBits * options,
 159                                 IOMemoryDescriptor ** memory );
 160
 161     virtual IOMemoryMap * mapClientMemory( IOOptionBits type,
 162                                     task_t task,
 163                                     IOOptionBits mapFlags = kIOMapAnywhere,
 164                                     IOVirtualAddress atAddress = 0 );
 165     /*!
 166         @function exportObjectToClient
 167         Make an arbitrary OSObject available to the client task.
 168         @param task The task
 169         @param obj The object we want to export to the client
 170         @param clientObj returned value is the client's port name.
 171     */
 172     virtual IOReturn exportObjectToClient(task_t task,
 173                                 OSObject *obj, io_object_t *clientObj);
 174
 175     // Old methods for accessing method vector backward compatiblility only
 176     virtual IOExternalMethod *
 177         getExternalMethodForIndex( UInt32 index );
 178     virtual IOExternalAsyncMethod *
 179         getExternalAsyncMethodForIndex( UInt32 index );
 180
 181     // Methods for accessing method vector.
 182     virtual IOExternalMethod *
 183         getTargetAndMethodForIndex( IOService ** targetP, UInt32 index );
 184     virtual IOExternalAsyncMethod *
 185         getAsyncTargetAndMethodForIndex( IOService ** targetP, UInt32 index );
 186
 187     // Methods for accessing trap vector - old and new style
 188     virtual IOExternalTrap *
 189       getExternalTrapForIndex( UInt32 index );
 190     virtual IOExternalTrap *
 191       getTargetAndTrapForIndex( IOService **targetP, UInt32 index );
 192 };
 193
 194 #endif /* ! _IOKIT_IOUSERCLIENT_H */
 195