xnu-1456.1.26.tar.gz

[apple/xnu.git] / 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__ */

};