The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

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

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 /*
    2  * Copyright (c) 2008-2016 Apple Inc. All rights reserved.
    3  *
    4  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
    5  *
    6  * This file contains Original Code and/or Modifications of Original Code
    7  * as defined in and that are subject to the Apple Public Source License
    8  * Version 2.0 (the 'License'). You may not use this file except in
    9  * compliance with the License. The rights granted to you under the License
   10  * may not be used to create, or enable the creation or redistribution of,
   11  * unlawful or unlicensed copies of an Apple operating system, or to
   12  * circumvent, violate, or enable the circumvention or violation of, any
   13  * terms of an Apple operating system software license agreement.
   14  *
   15  * Please obtain a copy of the License at
   16  * http://www.opensource.apple.com/apsl/ and read it before using this file.
   17  *
   18  * The Original Code and all software distributed under the License are
   19  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
   20  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
   21  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
   22  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
   23  * Please see the License for the specific language governing rights and
   24  * limitations under the License.
   25  *
   26  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
   27  */
   28 
   29 extern "C" {
   30 #include <libkern/OSKextLibPrivate.h>
   31 #include <libkern/mkext.h>
   32 };
   33 
   34 #include <libkern/c++/OSContainers.h>
   35 #include <libkern/c++/OSKext.h>
   36 #include <libkern/OSKextLib.h>
   37 #include <libkern/OSKextLibPrivate.h>
   38 
   39 extern "C" {
   40 #if PRAGMA_MARK
   41 #pragma mark C-based kext interface (loading/loaded kexts only)
   42 #endif
   43 /*********************************************************************
   44 *********************************************************************/
   45 kern_return_t
   46 OSKextLoadKextWithIdentifier(const char * bundle_id)
   47 {
   48         return OSKext::loadKextWithIdentifier(bundle_id);
   49 }
   50 
   51 uint32_t OSKextGetLoadTagForIdentifier(const char * kextIdentifier);
   52 /*********************************************************************
   53 *********************************************************************/
   54 uint32_t
   55 OSKextGetLoadTagForIdentifier(const char * kextIdentifier)
   56 {
   57         uint32_t result  = kOSKextInvalidLoadTag;
   58         OSKext * theKext = NULL; // must release
   59 
   60         if (!kextIdentifier) {
   61                 goto finish;
   62         }
   63 
   64         theKext = OSKext::lookupKextWithIdentifier(kextIdentifier);
   65         if (theKext && theKext->isLoaded()) {
   66                 result = theKext->getLoadTag();
   67         }
   68 finish:
   69         if (theKext) {
   70                 theKext->release();
   71         }
   72         return result;
   73 }
   74 
   75 /*********************************************************************
   76 *********************************************************************/
   77 
   78 // FIXME: Implementation of this function is hidden from the static analyzer.
   79 // The analyzer is worried about the lack of release and suggests
   80 // refactoring the code into the typical non-owning container pattern.
   81 // Feel free to remove the #ifndef and address the warning!
   82 #ifndef __clang_analyzer__
   83 OSReturn
   84 OSKextRetainKextWithLoadTag(uint32_t loadTag)
   85 {
   86         OSReturn   result = kOSKextReturnNotFound;
   87         OSKext   * theKext = NULL;// do not release; as this function is a retain
   88 
   89         if (loadTag == kOSKextInvalidLoadTag) {
   90                 result = kOSKextReturnInvalidArgument;
   91                 goto finish;
   92         }
   93         theKext = OSKext::lookupKextWithLoadTag(loadTag);
   94         if (theKext) {
   95                 result = kOSReturnSuccess;
   96 
   97                 OSKextLog(theKext,
   98                     kOSKextLogDebugLevel |
   99                     kOSKextLogKextBookkeepingFlag,
  100                     "Kext %s (load tag %d) has been retained.",
  101                     theKext->getIdentifierCString(),
  102                     loadTag);
  103 
  104                 /* Call this after so a log message about autounload comes second.
  105                  */
  106                 theKext->setAutounloadEnabled(true);
  107         } else {
  108                 OSKextLog(theKext,
  109                     kOSKextLogErrorLevel |
  110                     kOSKextLogKextBookkeepingFlag,
  111                     "Can't retain kext with load tag %d - no such kext is loaded.",
  112                     loadTag);
  113         }
  114 finish:
  115         return result;
  116 }
  117 #endif // __clang_analyzer__
  118 
  119 /*********************************************************************
  120 *********************************************************************/
  121 
  122 // FIXME: Implementation of this function is hidden from the static analyzer.
  123 // The analyzer is worried about the double release and suggests
  124 // refactoring the code into the typical non-owning container pattern.
  125 // Feel free to remove the #ifndef and address the warning!
  126 #ifndef __clang_analyzer__
  127 OSReturn
  128 OSKextReleaseKextWithLoadTag(uint32_t loadTag)
  129 {
  130         OSReturn result  = kOSKextReturnNotFound;
  131         OSKext * theKext = NULL; // must release twice!
  132 
  133         if (loadTag == kOSKextInvalidLoadTag) {
  134                 result = kOSKextReturnInvalidArgument;
  135                 goto finish;
  136         }
  137         theKext = OSKext::lookupKextWithLoadTag(loadTag);
  138         if (theKext) {
  139                 result = kOSReturnSuccess;
  140                 OSKext::considerUnloads(); // schedule autounload pass
  141                 theKext->release(); // do the release the caller wants
  142                 theKext->release(); // now do the release on the lookup
  143                 OSKextLog(theKext,
  144                     kOSKextLogDebugLevel |
  145                     kOSKextLogKextBookkeepingFlag,
  146                     "Kext %s (load tag %d) has been released.",
  147                     theKext->getIdentifierCString(),
  148                     loadTag);
  149         } else {
  150                 OSKextLog(theKext,
  151                     kOSKextLogErrorLevel |
  152                     kOSKextLogKextBookkeepingFlag,
  153                     "Can't release kext with load tag %d - no such kext is loaded.",
  154                     loadTag);
  155         }
  156 
  157         // xxx - should I check that the refcount of the OSKext is above the lower bound?
  158         // xxx - do we want a OSKextGetRetainCountOfKextWithLoadTag()?
  159 finish:
  160         return result;
  161 }
  162 #endif // __clang_analyzer__
  163 
  164 /*********************************************************************
  165 * Not to be called by the kext being unloaded!
  166 *********************************************************************/
  167 OSReturn
  168 OSKextUnloadKextWithLoadTag(uint32_t loadTag)
  169 {
  170         return OSKext::removeKextWithLoadTag(loadTag,
  171                    /* terminateServicesAndRemovePersonalitiesFlag */ false);
  172 }
  173 
  174 
  175 #if PRAGMA_MARK
  176 #pragma mark Kext Requests
  177 #endif
  178 /*********************************************************************
  179 * Kext Requests
  180 *********************************************************************/
  181 OSReturn
  182 OSKextRequestResource(
  183         const char                    * kextIdentifier,
  184         const char                    * resourceName,
  185         OSKextRequestResourceCallback   callback,
  186         void                          * context,
  187         OSKextRequestTag              * requestTagOut)
  188 {
  189         return OSKext::requestResource(kextIdentifier, resourceName,
  190                    callback, context, requestTagOut);
  191 }
  192 
  193 /*********************************************************************
  194 *********************************************************************/
  195 OSReturn
  196 OSKextCancelRequest(
  197         OSKextRequestTag    requestTag,
  198         void             ** contextOut)
  199 {
  200         return OSKext::cancelRequest(requestTag, contextOut);
  201 }
  202 
  203 #if PRAGMA_MARK
  204 #pragma mark MIG Functions & Wrappers
  205 #endif
  206 /*********************************************************************
  207 * IMPORTANT: vm_map_copyout_size() consumes the requestIn copy
  208 * object on success. Therefore once it has been invoked successfully,
  209 * this routine *must* return KERN_SUCCESS, regardless of our actual
  210 * result. Our contract with the caller is that requestIn must be
  211 * caller-deallocated if we return an error. We use op_result to return
  212 * the real result of our work.
  213 *********************************************************************/
  214 kern_return_t
  215 kext_request(
  216         host_priv_t                             hostPriv,
  217         /* in only */ uint32_t                 clientLogSpec,
  218         /* in only */ vm_offset_t              requestIn,
  219         /* in only */ mach_msg_type_number_t   requestLengthIn,
  220         /* out only */ vm_offset_t            * responseOut,
  221         /* out only */ mach_msg_type_number_t * responseLengthOut,
  222         /* out only */ vm_offset_t            * logDataOut,
  223         /* out only */ mach_msg_type_number_t * logDataLengthOut,
  224         /* out only */ kern_return_t          * op_result)
  225 {
  226         kern_return_t     result          = KERN_FAILURE;
  227         vm_map_address_t  map_addr        = 0; // do not free/deallocate
  228         char            * request         = NULL;// must vm_deallocate
  229 
  230         mkext2_header   * mkextHeader     = NULL;// do not release
  231         bool              isMkext         = false;
  232 
  233         char            * response        = NULL;// must kmem_free
  234         uint32_t          responseLength  = 0;
  235         char            * logData         = NULL;// must kmem_free
  236         uint32_t          logDataLength   = 0;
  237 
  238         /* MIG doesn't pass "out" parameters as empty, so clear them immediately
  239          * just in case, or MIG will try to copy out bogus data.
  240          */
  241         *op_result = KERN_FAILURE;
  242         *responseOut = 0;
  243         *responseLengthOut = 0;
  244         *logDataOut = 0;
  245         *logDataLengthOut = 0;
  246 
  247         /* Check for input. Don't discard what isn't there, though.
  248          */
  249         if (!requestLengthIn || !requestIn) {
  250                 OSKextLog(/* kext */ NULL,
  251                     kOSKextLogErrorLevel |
  252                     kOSKextLogIPCFlag,
  253                     "Invalid request from user space (no data).");
  254                 *op_result = KERN_INVALID_ARGUMENT;
  255                 goto finish;
  256         }
  257 
  258         result = vm_map_copyout_size(kernel_map, &map_addr, (vm_map_copy_t)requestIn, requestLengthIn);
  259         if (result != KERN_SUCCESS) {
  260                 OSKextLog(/* kext */ NULL,
  261                     kOSKextLogErrorLevel |
  262                     kOSKextLogIPCFlag,
  263                     "vm_map_copyout() failed for request from user space.");
  264                 /*
  265                  * If we return an error it is our caller's responsibility to
  266                  * deallocate the requestIn copy object, so do not deallocate it
  267                  * here. See comment above.
  268                  */
  269                 goto finish;
  270         }
  271         request = CAST_DOWN(char *, map_addr);
  272 
  273         /* Check if request is an mkext; this is always a load request
  274          * and requires root access. If it isn't an mkext, see if it's
  275          * an XML request, and check the request to see if that requires
  276          * root access.
  277          */
  278         if (requestLengthIn > sizeof(mkext2_header)) {
  279                 mkextHeader = (mkext2_header *)request;
  280                 if (MKEXT_GET_MAGIC(mkextHeader) == MKEXT_MAGIC &&
  281                     MKEXT_GET_SIGNATURE(mkextHeader) == MKEXT_SIGN) {
  282                         isMkext = true;
  283                 }
  284         }
  285 
  286         if (isMkext) {
  287 #if defined(SECURE_KERNEL) || !CONFIG_KXLD
  288                 // xxx - something tells me if we have a secure kernel we don't even
  289                 // xxx - want to log a message here. :-)
  290                 *op_result = KERN_NOT_SUPPORTED;
  291                 goto finish;
  292 #else
  293                 // xxx - can we find out if calling task is kextd?
  294                 // xxx - can we find the name of the calling task?
  295                 if (hostPriv == HOST_PRIV_NULL) {
  296                         OSKextLog(/* kext */ NULL,
  297                             kOSKextLogErrorLevel |
  298                             kOSKextLogLoadFlag | kOSKextLogIPCFlag,
  299                             "Attempt by non-root process to load a kext.");
  300                         *op_result = kOSKextReturnNotPrivileged;
  301                         goto finish;
  302                 }
  303 
  304                 *op_result = OSKext::loadFromMkext((OSKextLogSpec)clientLogSpec,
  305                     request, requestLengthIn,
  306                     &logData, &logDataLength);
  307 
  308 #endif /* defined(SECURE_KERNEL) */
  309         } else {
  310                 /* If the request isn't an mkext, then is should be XML. Parse it
  311                  * if possible and hand the request over to OSKext.
  312                  */
  313                 *op_result = OSKext::handleRequest(hostPriv,
  314                     (OSKextLogSpec)clientLogSpec,
  315                     request, requestLengthIn,
  316                     &response, &responseLength,
  317                     &logData, &logDataLength);
  318         }
  319 
  320         if (response && responseLength > 0) {
  321                 kern_return_t copyin_result;
  322 
  323                 copyin_result = vm_map_copyin(kernel_map,
  324                     CAST_USER_ADDR_T(response), responseLength,
  325                     /* src_destroy */ false, (vm_map_copy_t *)responseOut);
  326                 if (copyin_result == KERN_SUCCESS) {
  327                         *responseLengthOut = responseLength;
  328                 } else {
  329                         OSKextLog(/* kext */ NULL,
  330                             kOSKextLogErrorLevel |
  331                             kOSKextLogIPCFlag,
  332                             "Failed to copy response to request from user space.");
  333                         *op_result = copyin_result; // xxx - should we map to our own code?
  334                         *responseOut = 0;
  335                         *responseLengthOut = 0;
  336                         goto finish;
  337                 }
  338         }
  339 
  340         if (logData && logDataLength > 0) {
  341                 kern_return_t copyin_result;
  342 
  343                 copyin_result = vm_map_copyin(kernel_map,
  344                     CAST_USER_ADDR_T(logData), logDataLength,
  345                     /* src_destroy */ false, (vm_map_copy_t *)logDataOut);
  346                 if (copyin_result == KERN_SUCCESS) {
  347                         *logDataLengthOut = logDataLength;
  348                 } else {
  349                         OSKextLog(/* kext */ NULL,
  350                             kOSKextLogErrorLevel |
  351                             kOSKextLogIPCFlag,
  352                             "Failed to copy log data for request from user space.");
  353                         *op_result = copyin_result; // xxx - should we map to our own code?
  354                         *logDataOut = 0;
  355                         *logDataLengthOut = 0;
  356                         goto finish;
  357                 }
  358         }
  359 
  360 finish:
  361         if (request) {
  362                 (void)vm_deallocate(kernel_map, (vm_offset_t)request, requestLengthIn);
  363         }
  364         if (response) {
  365                 /* 11981737 - clear uninitialized data in last page */
  366                 kmem_free(kernel_map, (vm_offset_t)response, round_page(responseLength));
  367         }
  368         if (logData) {
  369                 /* 11981737 - clear uninitialized data in last page */
  370                 kmem_free(kernel_map, (vm_offset_t)logData, round_page(logDataLength));
  371         }
  372 
  373         return result;
  374 }
  375 
  376 /*********************************************************************
  377 * Gets the vm_map for the current kext
  378 *********************************************************************/
  379 extern vm_offset_t segPRELINKTEXTB;
  380 extern vm_offset_t segLINKB;
  381 extern unsigned long segSizePRELINKTEXT;
  382 extern vm_map_t g_kext_map;
  383 
  384 vm_map_t
  385 kext_get_vm_map(kmod_info_t *info)
  386 {
  387         vm_map_t kext_map = NULL;
  388         kc_format_t kcformat;
  389 
  390         if (PE_get_primary_kc_format(&kcformat) && kcformat == KCFormatFileset) {
  391                 /* Check if the kext is from the boot KC */
  392                 assert(segLINKB >= (segPRELINKTEXTB + segSizePRELINKTEXT));
  393                 if ((info->address >= segPRELINKTEXTB) &&
  394                     (info->address < segLINKB)) {
  395                         kext_map = kernel_map;
  396                 } else {
  397                         kext_map = g_kext_map;
  398                 }
  399         } else {
  400                 if ((info->address >= segPRELINKTEXTB) &&
  401                     (info->address < (segPRELINKTEXTB + segSizePRELINKTEXT))) {
  402                         kext_map = kernel_map;
  403                 } else {
  404                         kext_map = g_kext_map;
  405                 }
  406         }
  407 
  408         return kext_map;
  409 }
  410 
  411 
  412 #if PRAGMA_MARK
  413 /********************************************************************/
  414 #pragma mark Weak linking support
  415 /********************************************************************/
  416 #endif
  417 void
  418 kext_weak_symbol_referenced(void)
  419 {
  420         panic("A kext referenced an unresolved weak symbol");
  421 }
  422 
  423 const void * const gOSKextUnresolved = (const void *)&kext_weak_symbol_referenced;
  424 
  425 #if PRAGMA_MARK
  426 #pragma mark Kernel-Internal C Functions
  427 #endif
  428 /*********************************************************************
  429 * Called from startup.c.
  430 *********************************************************************/
  431 void
  432 OSKextRemoveKextBootstrap(void)
  433 {
  434         OSKext::removeKextBootstrap();
  435         return;
  436 }
  437 
  438 #if CONFIG_DTRACE
  439 /*********************************************************************
  440 *********************************************************************/
  441 void
  442 OSKextRegisterKextsWithDTrace(void)
  443 {
  444         OSKext::registerKextsWithDTrace();
  445         return;
  446 }
  447 #endif /* CONFIG_DTRACE */
  448 
  449 /*********************************************************************
  450 *********************************************************************/
  451 void
  452 kext_dump_panic_lists(int (*printf_func)(const char * fmt, ...))
  453 {
  454         OSKext::printKextPanicLists(printf_func);
  455         return;
  456 }
  457 
  458 #if PRAGMA_MARK
  459 #pragma mark Kmod Compatibility Functions
  460 #endif
  461 /*********************************************************************
  462 **********************************************************************
  463 *                    KMOD COMPATIBILITY FUNCTIONS                    *
  464 *              (formerly in kmod.c, or C++ bridges from)             *
  465 **********************************************************************
  466 **********************************************************************
  467 * These two functions are used in various places in the kernel, but
  468 * are not exported. We might rename them at some point to start with
  469 * kext_ or OSKext.
  470 *
  471 * kmod_panic_dump() must not be called outside of a panic context.
  472 * kmod_dump_log() must not be called in a panic context.
  473 *********************************************************************/
  474 void
  475 kmod_panic_dump(vm_offset_t * addr, unsigned int cnt)
  476 {
  477         extern int paniclog_append_noflush(const char *format, ...) __printflike(1, 2);
  478 
  479         OSKext::printKextsInBacktrace(addr, cnt, &paniclog_append_noflush, 0);
  480 
  481         return;
  482 }
  483 
  484 /********************************************************************/
  485 void kmod_dump_log(vm_offset_t *addr, unsigned int cnt, boolean_t doUnslide);
  486 
  487 void
  488 kmod_dump_log(
  489         vm_offset_t * addr,
  490         unsigned int cnt,
  491         boolean_t doUnslide)
  492 {
  493         uint32_t flags = OSKext::kPrintKextsLock;
  494         if (doUnslide) {
  495                 flags |= OSKext::kPrintKextsUnslide;
  496         }
  497         OSKext::printKextsInBacktrace(addr, cnt, &printf, flags);
  498 }
  499 
  500 void *
  501 OSKextKextForAddress(const void *addr)
  502 {
  503         return OSKext::kextForAddress(addr);
  504 }
  505 
  506 
  507 /*********************************************************************
  508 * Compatibility implementation for kmod_get_info() host_priv routine.
  509 * Only supported on old 32-bit architectures.
  510 *********************************************************************/
  511 
  512 #if PRAGMA_MARK
  513 #pragma mark Loaded Kext Summary
  514 #endif
  515 
  516 void
  517 OSKextLoadedKextSummariesUpdated(void)
  518 {
  519         // Do nothing.
  520 }
  521 };

Cache object: 479f061d837a0ca7054ba4650577bfe0


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.