FreeBSD/Linux Kernel Cross Reference
sys/libkern/OSKextLib.cpp

     /*
      * Copyright (c) 2008 Apple Inc. All rights reserved.
      *
      * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
      * 
      * This file contains Original Code and/or Modifications of Original Code
      * as defined in and that are subject to the Apple Public Source License
      * Version 2.0 (the 'License'). You may not use this file except in
      * compliance with the License. The rights granted to you under the License
     * may not be used to create, or enable the creation or redistribution of,
     * unlawful or unlicensed copies of an Apple operating system, or to
     * circumvent, violate, or enable the circumvention or violation of, any
     * terms of an Apple operating system software license agreement.
     * 
     * Please obtain a copy of the License at
     * http://www.opensource.apple.com/apsl/ and read it before using this file.
     * 
     * The Original Code and all software distributed under the License are
     * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
     * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
     * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
     * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
     * Please see the License for the specific language governing rights and
     * limitations under the License.
     * 
     * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
     */
    
    extern "C" {
    #include <libkern/OSKextLibPrivate.h>
    #include <libkern/mkext.h>
    
    #include <mach/host_special_ports.h>
    #include <kextd/kextd_mach.h>
    #include <kern/host.h>
    };
    
    #include <libkern/c++/OSContainers.h>
    #include <libkern/c++/OSKext.h>
    #include <libkern/OSKextLib.h>
    #include <libkern/OSKextLibPrivate.h>
    
    extern "C" {
    
    #if PRAGMA_MARK
    #pragma mark C-based kext interface (loading/loaded kexts only)
    #endif
    /*********************************************************************
    *********************************************************************/
    kern_return_t OSKextLoadKextWithIdentifier(const char * bundle_id)
    {
        return OSKext::loadKextWithIdentifier(bundle_id);
    }
    
    /*********************************************************************
    *********************************************************************/
    uint32_t
    OSKextGetLoadTagForIdentifier(const char * kextIdentifier)
    {
        uint32_t result  = kOSKextInvalidLoadTag;
        OSKext * theKext = NULL;  // must release
    
        if (!kextIdentifier) {
            goto finish;
        }
    
        theKext = OSKext::lookupKextWithIdentifier(kextIdentifier);
        if (theKext && theKext->isLoaded()) {
            result = theKext->getLoadTag();
        }
    finish:
        if (theKext) theKext->release();
        return result;
    }
    
    /*********************************************************************
    *********************************************************************/
    OSReturn OSKextRetainKextWithLoadTag(uint32_t loadTag)
    {
        OSReturn   result = kOSKextReturnNotFound;
        OSKext   * theKext = NULL;  // do not release; as this function is a retain
    
        if (loadTag == kOSKextInvalidLoadTag) {
            result = kOSKextReturnInvalidArgument;
            goto finish;
        }
        theKext = OSKext::lookupKextWithLoadTag(loadTag);
        if (theKext) {
            result = kOSReturnSuccess;
    
            OSKextLog(theKext,
                kOSKextLogDebugLevel |
                kOSKextLogKextBookkeepingFlag,
                "Kext %s (load tag %d) has been retained.",
                theKext->getIdentifierCString(),
                loadTag);
    
           /* Call this after so a log message about autounload comes second.
            */
           theKext->setAutounloadEnabled(true);
       } else {
           OSKextLog(theKext,
               kOSKextLogErrorLevel |
               kOSKextLogKextBookkeepingFlag,
               "Can't retain kext with load tag %d - no such kext is loaded.",
              loadTag);
       }
   finish:
       return result;
   }
   
   /*********************************************************************
   *********************************************************************/
   OSReturn OSKextReleaseKextWithLoadTag(uint32_t loadTag)
   {
       OSReturn result  = kOSKextReturnNotFound;
       OSKext * theKext = NULL;  // must release twice!
       
       if (loadTag == kOSKextInvalidLoadTag) {
           result = kOSKextReturnInvalidArgument;
           goto finish;
       }
       theKext = OSKext::lookupKextWithLoadTag(loadTag);
       if (theKext) {
           result = kOSReturnSuccess;
           OSKext::considerUnloads();  // schedule autounload pass
           theKext->release();  // do the release the caller wants
           theKext->release();  // now do the release on the lookup
           OSKextLog(theKext,
               kOSKextLogDebugLevel |
               kOSKextLogKextBookkeepingFlag,
               "Kext %s (load tag %d) has been released.",
               theKext->getIdentifierCString(),
               loadTag);
       } else {
           OSKextLog(theKext,
               kOSKextLogErrorLevel |
               kOSKextLogKextBookkeepingFlag,
               "Can't release kext with load tag %d - no such kext is loaded.",
              loadTag);
       }
       
       // xxx - should I check that the refcount of the OSKext is above the lower bound?
       // xxx - do we want a OSKextGetRetainCountOfKextWithLoadTag()?
   finish:
       return result;
   }
   
   /*********************************************************************
   * Not to be called by the kext being unloaded!
   *********************************************************************/
   OSReturn OSKextUnloadKextWithLoadTag(uint32_t loadTag)
   {
       return OSKext::removeKextWithLoadTag(loadTag,
           /* terminateServicesAndRemovePersonalitiesFlag */ false);
   }
   
   
   #if PRAGMA_MARK
   #pragma mark Kext Requests
   #endif
   /*********************************************************************
   * Kext Requests
   *********************************************************************/
   OSReturn OSKextRequestResource(
       const char                    * kextIdentifier,
       const char                    * resourceName,
       OSKextRequestResourceCallback   callback,
       void                          * context,
       OSKextRequestTag              * requestTagOut)
   {
       return OSKext::requestResource(kextIdentifier, resourceName,
           callback, context, requestTagOut);
   }
   
   /*********************************************************************
   *********************************************************************/
   OSReturn OSKextCancelRequest(
       OSKextRequestTag    requestTag,
       void             ** contextOut)
   {
       return OSKext::cancelRequest(requestTag, contextOut);
   }
   
   #if PRAGMA_MARK
   #pragma mark MIG Functions & Wrappers
   #endif
   /*********************************************************************
   * This function is for use only by OSKextLib.cpp and OSKext.cpp.
   *
   * xxx - can we cache the kextd port or do we have to get it each time
   * xxx - in case it relaunches?
   *********************************************************************/
   extern void ipc_port_release_send(ipc_port_t);
   
   kern_return_t OSKextPingKextd(void)
   {
       kern_return_t result     = KERN_FAILURE;
       mach_port_t   kextd_port = IPC_PORT_NULL;
   
       result = host_get_kextd_port(host_priv_self(), &kextd_port);
       if (result != KERN_SUCCESS || !IPC_PORT_VALID(kextd_port)) {
           OSKextLog(/* kext */ NULL,
               kOSKextLogErrorLevel |
               kOSKextLogIPCFlag,
               "Can't get kextd port.");
           goto finish;
       }
   
       result = kextd_ping(kextd_port);
       if (result != KERN_SUCCESS) {
           OSKextLog(/* kext */ NULL,
               kOSKextLogErrorLevel |
               kOSKextLogIPCFlag,
               "kextd ping failed (0x%x).", (int)result);
           goto finish;
       }
   
   finish:
       if (IPC_PORT_VALID(kextd_port)) {
           ipc_port_release_send(kextd_port);
       }
   
       return result;
   }
   
   /*********************************************************************
   * IMPORTANT: Once we have done the vm_map_copyout(), we *must* return
   * KERN_SUCCESS or the kernel map gets messed up (reason as yet
   * unknown). We use op_result to return the real result of our work.
   *********************************************************************/
   kern_return_t kext_request(
       host_priv_t                             hostPriv,
       /* in only */  uint32_t                 clientLogSpec,
       /* in only */  vm_offset_t              requestIn,
       /* in only */  mach_msg_type_number_t   requestLengthIn,
       /* out only */ vm_offset_t            * responseOut,
       /* out only */ mach_msg_type_number_t * responseLengthOut,
       /* out only */ vm_offset_t            * logDataOut,
       /* out only */ mach_msg_type_number_t * logDataLengthOut,
       /* out only */ kern_return_t          * op_result)
   {
       kern_return_t     result          = KERN_FAILURE;
       vm_map_address_t  map_addr        = 0;     // do not free/deallocate
       char            * request         = NULL;  // must vm_deallocate
   
       mkext2_header   * mkextHeader     = NULL;  // do not release
       bool              isMkext         = false;
   
       char            * response        = NULL;  // must kmem_free
       uint32_t          responseLength  = 0;
       char            * logData         = NULL;  // must kmem_free
       uint32_t          logDataLength   = 0;
   
      /* MIG doesn't pass "out" parameters as empty, so clear them immediately
       * just in case, or MIG will try to copy out bogus data.
       */    
       *op_result = KERN_FAILURE;
       *responseOut = NULL;
       *responseLengthOut = 0;
       *logDataOut = NULL;
       *logDataLengthOut = 0;
   
      /* Check for input. Don't discard what isn't there, though.
       */
       if (!requestLengthIn || !requestIn) {
                   OSKextLog(/* kext */ NULL,
               kOSKextLogErrorLevel |
               kOSKextLogIPCFlag,
               "Invalid request from user space (no data).");
           *op_result = KERN_INVALID_ARGUMENT;
           goto finish;
       }
   
      /* Once we have done the vm_map_copyout(), we *must* return KERN_SUCCESS
       * or the kernel map gets messed up (reason as yet unknown). We will use
       * op_result to return the real result of our work.
       */
       result = vm_map_copyout(kernel_map, &map_addr, (vm_map_copy_t)requestIn);
       if (result != KERN_SUCCESS) {
           OSKextLog(/* kext */ NULL,
               kOSKextLogErrorLevel |
               kOSKextLogIPCFlag,
               "vm_map_copyout() failed for request from user space.");
           vm_map_copy_discard((vm_map_copy_t)requestIn);
           goto finish;
       }
       request = CAST_DOWN(char *, map_addr);
   
      /* Check if request is an mkext; this is always a load request
       * and requires root access. If it isn't an mkext, see if it's
       * an XML request, and check the request to see if that requires
       * root access.
       */
       if (requestLengthIn > sizeof(mkext2_header)) {
           mkextHeader = (mkext2_header *)request;
           if (MKEXT_GET_MAGIC(mkextHeader) == MKEXT_MAGIC &&
               MKEXT_GET_SIGNATURE(mkextHeader) == MKEXT_SIGN) {
   
               isMkext = true;
           }
       }
   
       if (isMkext) {
   #ifdef SECURE_KERNEL
           // xxx - something tells me if we have a secure kernel we don't even
           // xxx - want to log a message here. :-)
           *op_result = KERN_NOT_SUPPORTED;
           goto finish;
   #else
           // xxx - can we find out if calling task is kextd?
           // xxx - can we find the name of the calling task?
           if (hostPriv == HOST_PRIV_NULL) {
               OSKextLog(/* kext */ NULL,
                   kOSKextLogErrorLevel |
                   kOSKextLogLoadFlag | kOSKextLogIPCFlag,
                   "Attempt by non-root process to load a kext.");
               *op_result = kOSKextReturnNotPrivileged;
               goto finish;
           }
   
           *op_result = OSKext::loadFromMkext((OSKextLogSpec)clientLogSpec,
               request, requestLengthIn,
               &logData, &logDataLength);
   
   #endif /* defined(SECURE_KERNEL) */
   
       } else {
   
          /* If the request isn't an mkext, then is should be XML. Parse it
           * if possible and hand the request over to OSKext.
           */
           *op_result = OSKext::handleRequest(hostPriv,
               (OSKextLogSpec)clientLogSpec,
               request, requestLengthIn,
               &response, &responseLength,
               &logData, &logDataLength);
       }
   
       if (response && responseLength > 0) {
           kern_return_t copyin_result;
   
           copyin_result = vm_map_copyin(kernel_map,
               CAST_USER_ADDR_T(response), responseLength,
               /* src_destroy */ false, (vm_map_copy_t *)responseOut);
           if (copyin_result == KERN_SUCCESS) {
               *responseLengthOut = responseLength;
           } else {
               OSKextLog(/* kext */ NULL,
                   kOSKextLogErrorLevel |
                   kOSKextLogIPCFlag,
                   "Failed to copy response to request from user space.");
               *op_result = copyin_result;  // xxx - should we map to our own code?
               *responseOut = NULL;
               *responseLengthOut = 0;
               goto finish;
           }
       }
   
       if (logData && logDataLength > 0) {
           kern_return_t copyin_result;
   
           copyin_result = vm_map_copyin(kernel_map,
               CAST_USER_ADDR_T(logData), logDataLength,
               /* src_destroy */ false, (vm_map_copy_t *)logDataOut);
           if (copyin_result == KERN_SUCCESS) {
               *logDataLengthOut = logDataLength;
           } else {
               OSKextLog(/* kext */ NULL,
                   kOSKextLogErrorLevel |
                   kOSKextLogIPCFlag,
                   "Failed to copy log data for request from user space.");
               *op_result = copyin_result;  // xxx - should we map to our own code?
               *logDataOut = NULL;
               *logDataLengthOut = 0;
               goto finish;
           }
       }
   
   finish:
       if (request) {
           (void)vm_deallocate(kernel_map, (vm_offset_t)request, requestLengthIn);
       }
       if (response) {
           kmem_free(kernel_map, (vm_offset_t)response, responseLength);
       }
       if (logData) {
           kmem_free(kernel_map, (vm_offset_t)logData, logDataLength);
       }
   
       return result;
   }
   
   /*********************************************************************
   * Gets the vm_map for the current kext
   *********************************************************************/
   extern vm_offset_t sectPRELINKB;
   extern int sectSizePRELINK;
   extern int kth_started;
   extern vm_map_t g_kext_map;
   
   vm_map_t
   kext_get_vm_map(kmod_info_t *info)
   {
       vm_map_t kext_map = NULL;
   
       /* Set the vm map */
       if ((info->address >= sectPRELINKB) && 
               (info->address < (sectPRELINKB + sectSizePRELINK)))
       {
           kext_map = kernel_map;
       } else {
           kext_map = g_kext_map;
       }
   
       return kext_map;
   }
   
   
   #if PRAGMA_MARK
   /********************************************************************/
   #pragma mark Weak linking support
   /********************************************************************/
   #endif
   void
   kext_weak_symbol_referenced(void)
   {
       panic("A kext referenced an unresolved weak symbol\n");
   }
   
   const void *gOSKextUnresolved = (const void *)&kext_weak_symbol_referenced;
   
   #if PRAGMA_MARK
   #pragma mark Kernel-Internal C Functions
   #endif
   /*********************************************************************
   * Called from startup.c.
   *********************************************************************/
   void OSKextRemoveKextBootstrap(void)
   {
       OSKext::removeKextBootstrap();
       return;
   }
   
   /*********************************************************************
   *********************************************************************/
   void kext_dump_panic_lists(int (*printf_func)(const char * fmt, ...))
   {
       OSKext::printKextPanicLists(printf_func);
       return;
   }
   
   #if PRAGMA_MARK
   #pragma mark Kmod Compatibility Functions
   #endif
   /*********************************************************************
   **********************************************************************
   *                    KMOD COMPATIBILITY FUNCTIONS                    *
   *              (formerly in kmod.c, or C++ bridges from)             *
   **********************************************************************
   **********************************************************************
   * These two functions are used in various places in the kernel, but
   * are not exported. We might rename them at some point to start with
   * kext_ or OSKext.
   *
   * kmod_panic_dump() must not be called outside of a panic context.
   * kmod_dump_log() must not be called in a panic context.
   *********************************************************************/
   void
   kmod_panic_dump(vm_offset_t * addr, unsigned int cnt)
   {
       extern int kdb_printf(const char *format, ...) __printflike(1,2);
   
       OSKext::printKextsInBacktrace(addr, cnt, &kdb_printf,
           /* takeLock? */ false);
       return;
   }
   
   /********************************************************************/
   void kmod_dump_log(vm_offset_t *addr, unsigned int cnt);
   
   void
   kmod_dump_log(
       vm_offset_t * addr,
       unsigned int cnt)
   {
       OSKext::printKextsInBacktrace(addr, cnt, &printf, /* lock? */ true);
   }
   
   /*********************************************************************
   * Compatibility implementation for kmod_get_info() host_priv routine.
   * Only supported on old 32-bit architectures.
   *********************************************************************/
   #if __ppc__ || __i386__
   kern_return_t
   kext_get_kmod_info(
       kmod_info_array_t      * kmod_list,
       mach_msg_type_number_t * kmodCount)
   {
       return OSKext::getKmodInfo(kmod_list, kmodCount);
   }
   #endif /* __ppc__ || __i386__ */
   
   };

Cache object: cd82e14fd17c620f215ceaa5de9adab3