libkern/OSKextLib.cpp

   1 /*
   2  * Copyright (c) 2008 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
  41 #if PRAGMA_MARK
  42 #pragma mark C-based kext interface (loading/loaded kexts only)
  43 #endif
  44 /*********************************************************************
  45 *********************************************************************/
  46 kern_return_t OSKextLoadKextWithIdentifier(const char * bundle_id)
  47 {
  48     return OSKext::loadKextWithIdentifier(bundle_id);
  49 }
  50
  51 /*********************************************************************
  52 *********************************************************************/
  53 uint32_t
  54 OSKextGetLoadTagForIdentifier(const char * kextIdentifier)
  55 {
  56     uint32_t result  = kOSKextInvalidLoadTag;
  57     OSKext * theKext = NULL;  // must release
  58
  59     if (!kextIdentifier) {
  60         goto finish;
  61     }
  62
  63     theKext = OSKext::lookupKextWithIdentifier(kextIdentifier);
  64     if (theKext && theKext->isLoaded()) {
  65         result = theKext->getLoadTag();
  66     }
  67 finish:
  68     if (theKext) theKext->release();
  69     return result;
  70 }
  71
  72 /*********************************************************************
  73 *********************************************************************/
  74 OSReturn OSKextRetainKextWithLoadTag(uint32_t loadTag)
  75 {
  76     OSReturn   result = kOSKextReturnNotFound;
  77     OSKext   * theKext = NULL;  // do not release; as this function is a retain
  78
  79     if (loadTag == kOSKextInvalidLoadTag) {
  80         result = kOSKextReturnInvalidArgument;
  81         goto finish;
  82     }
  83     theKext = OSKext::lookupKextWithLoadTag(loadTag);
  84     if (theKext) {
  85         result = kOSReturnSuccess;
  86
  87         OSKextLog(theKext,
  88             kOSKextLogDebugLevel |
  89             kOSKextLogKextBookkeepingFlag,
  90             "Kext %s (load tag %d) has been retained.",
  91             theKext->getIdentifierCString(),
  92             loadTag);
  93
  94        /* Call this after so a log message about autounload comes second.
  95         */
  96         theKext->setAutounloadEnabled(true);
  97     } else {
  98         OSKextLog(theKext,
  99             kOSKextLogErrorLevel |
 100             kOSKextLogKextBookkeepingFlag,
 101             "Can't retain kext with load tag %d - no such kext is loaded.",
 102            loadTag);
 103     }
 104 finish:
 105     return result;
 106 }
 107
 108 /*********************************************************************
 109 *********************************************************************/
 110 OSReturn OSKextReleaseKextWithLoadTag(uint32_t loadTag)
 111 {
 112     OSReturn result  = kOSKextReturnNotFound;
 113     OSKext * theKext = NULL;  // must release twice!
 114
 115     if (loadTag == kOSKextInvalidLoadTag) {
 116         result = kOSKextReturnInvalidArgument;
 117         goto finish;
 118     }
 119     theKext = OSKext::lookupKextWithLoadTag(loadTag);
 120     if (theKext) {
 121         result = kOSReturnSuccess;
 122         OSKext::considerUnloads();  // schedule autounload pass
 123         theKext->release();  // do the release the caller wants
 124         theKext->release();  // now do the release on the lookup
 125         OSKextLog(theKext,
 126             kOSKextLogDebugLevel |
 127             kOSKextLogKextBookkeepingFlag,
 128             "Kext %s (load tag %d) has been released.",
 129             theKext->getIdentifierCString(),
 130             loadTag);
 131     } else {
 132         OSKextLog(theKext,
 133             kOSKextLogErrorLevel |
 134             kOSKextLogKextBookkeepingFlag,
 135             "Can't release kext with load tag %d - no such kext is loaded.",
 136            loadTag);
 137     }
 138
 139     // xxx - should I check that the refcount of the OSKext is above the lower bound?
 140     // xxx - do we want a OSKextGetRetainCountOfKextWithLoadTag()?
 141 finish:
 142     return result;
 143 }
 144
 145 /*********************************************************************
 146 * Not to be called by the kext being unloaded!
 147 *********************************************************************/
 148 OSReturn OSKextUnloadKextWithLoadTag(uint32_t loadTag)
 149 {
 150     return OSKext::removeKextWithLoadTag(loadTag,
 151         /* terminateServicesAndRemovePersonalitiesFlag */ false);
 152 }
 153
 154
 155 #if PRAGMA_MARK
 156 #pragma mark Kext Requests
 157 #endif
 158 /*********************************************************************
 159 * Kext Requests
 160 *********************************************************************/
 161 OSReturn OSKextRequestResource(
 162     const char                    * kextIdentifier,
 163     const char                    * resourceName,
 164     OSKextRequestResourceCallback   callback,
 165     void                          * context,
 166     OSKextRequestTag              * requestTagOut)
 167 {
 168     return OSKext::requestResource(kextIdentifier, resourceName,
 169         callback, context, requestTagOut);
 170 }
 171
 172 /*********************************************************************
 173 *********************************************************************/
 174 OSReturn OSKextCancelRequest(
 175     OSKextRequestTag    requestTag,
 176     void             ** contextOut)
 177 {
 178     return OSKext::cancelRequest(requestTag, contextOut);
 179 }
 180
 181 #if PRAGMA_MARK
 182 #pragma mark MIG Functions & Wrappers
 183 #endif
 184 /*********************************************************************
 185 * IMPORTANT: Once we have done the vm_map_copyout(), we *must* return
 186 * KERN_SUCCESS or the kernel map gets messed up (reason as yet
 187 * unknown). We use op_result to return the real result of our work.
 188 *********************************************************************/
 189 kern_return_t kext_request(
 190     host_priv_t                             hostPriv,
 191     /* in only */  uint32_t                 clientLogSpec,
 192     /* in only */  vm_offset_t              requestIn,
 193     /* in only */  mach_msg_type_number_t   requestLengthIn,
 194     /* out only */ vm_offset_t            * responseOut,
 195     /* out only */ mach_msg_type_number_t * responseLengthOut,
 196     /* out only */ vm_offset_t            * logDataOut,
 197     /* out only */ mach_msg_type_number_t * logDataLengthOut,
 198     /* out only */ kern_return_t          * op_result)
 199 {
 200     kern_return_t     result          = KERN_FAILURE;
 201     vm_map_address_t  map_addr        = 0;     // do not free/deallocate
 202     char            * request         = NULL;  // must vm_deallocate
 203
 204     mkext2_header   * mkextHeader     = NULL;  // do not release
 205     bool              isMkext         = false;
 206
 207     char            * response        = NULL;  // must kmem_free
 208     uint32_t          responseLength  = 0;
 209     char            * logData         = NULL;  // must kmem_free
 210     uint32_t          logDataLength   = 0;
 211
 212    /* MIG doesn't pass "out" parameters as empty, so clear them immediately
 213     * just in case, or MIG will try to copy out bogus data.
 214     */
 215     *op_result = KERN_FAILURE;
 216     *responseOut = NULL;
 217     *responseLengthOut = 0;
 218     *logDataOut = NULL;
 219     *logDataLengthOut = 0;
 220
 221    /* Check for input. Don't discard what isn't there, though.
 222     */
 223     if (!requestLengthIn || !requestIn) {
 224                 OSKextLog(/* kext */ NULL,
 225             kOSKextLogErrorLevel |
 226             kOSKextLogIPCFlag,
 227             "Invalid request from user space (no data).");
 228         *op_result = KERN_INVALID_ARGUMENT;
 229         goto finish;
 230     }
 231
 232    /* Once we have done the vm_map_copyout(), we *must* return KERN_SUCCESS
 233     * or the kernel map gets messed up (reason as yet unknown). We will use
 234     * op_result to return the real result of our work.
 235     */
 236     result = vm_map_copyout(kernel_map, &map_addr, (vm_map_copy_t)requestIn);
 237     if (result != KERN_SUCCESS) {
 238         OSKextLog(/* kext */ NULL,
 239             kOSKextLogErrorLevel |
 240             kOSKextLogIPCFlag,
 241             "vm_map_copyout() failed for request from user space.");
 242         vm_map_copy_discard((vm_map_copy_t)requestIn);
 243         goto finish;
 244     }
 245     request = CAST_DOWN(char *, map_addr);
 246
 247    /* Check if request is an mkext; this is always a load request
 248     * and requires root access. If it isn't an mkext, see if it's
 249     * an XML request, and check the request to see if that requires
 250     * root access.
 251     */
 252     if (requestLengthIn > sizeof(mkext2_header)) {
 253         mkextHeader = (mkext2_header *)request;
 254         if (MKEXT_GET_MAGIC(mkextHeader) == MKEXT_MAGIC &&
 255             MKEXT_GET_SIGNATURE(mkextHeader) == MKEXT_SIGN) {
 256
 257             isMkext = true;
 258         }
 259     }
 260
 261     if (isMkext) {
 262 #ifdef SECURE_KERNEL
 263         // xxx - something tells me if we have a secure kernel we don't even
 264         // xxx - want to log a message here. :-)
 265         *op_result = KERN_NOT_SUPPORTED;
 266         goto finish;
 267 #else
 268         // xxx - can we find out if calling task is kextd?
 269         // xxx - can we find the name of the calling task?
 270         if (hostPriv == HOST_PRIV_NULL) {
 271             OSKextLog(/* kext */ NULL,
 272                 kOSKextLogErrorLevel |
 273                 kOSKextLogLoadFlag | kOSKextLogIPCFlag,
 274                 "Attempt by non-root process to load a kext.");
 275             *op_result = kOSKextReturnNotPrivileged;
 276             goto finish;
 277         }
 278
 279         *op_result = OSKext::loadFromMkext((OSKextLogSpec)clientLogSpec,
 280             request, requestLengthIn,
 281             &logData, &logDataLength);
 282
 283 #endif /* defined(SECURE_KERNEL) */
 284
 285     } else {
 286
 287        /* If the request isn't an mkext, then is should be XML. Parse it
 288         * if possible and hand the request over to OSKext.
 289         */
 290         *op_result = OSKext::handleRequest(hostPriv,
 291             (OSKextLogSpec)clientLogSpec,
 292             request, requestLengthIn,
 293             &response, &responseLength,
 294             &logData, &logDataLength);
 295     }
 296
 297     if (response && responseLength > 0) {
 298         kern_return_t copyin_result;
 299
 300         copyin_result = vm_map_copyin(kernel_map,
 301             CAST_USER_ADDR_T(response), responseLength,
 302             /* src_destroy */ false, (vm_map_copy_t *)responseOut);
 303         if (copyin_result == KERN_SUCCESS) {
 304             *responseLengthOut = responseLength;
 305         } else {
 306             OSKextLog(/* kext */ NULL,
 307                 kOSKextLogErrorLevel |
 308                 kOSKextLogIPCFlag,
 309                 "Failed to copy response to request from user space.");
 310             *op_result = copyin_result;  // xxx - should we map to our own code?
 311             *responseOut = NULL;
 312             *responseLengthOut = 0;
 313             goto finish;
 314         }
 315     }
 316
 317     if (logData && logDataLength > 0) {
 318         kern_return_t copyin_result;
 319
 320         copyin_result = vm_map_copyin(kernel_map,
 321             CAST_USER_ADDR_T(logData), logDataLength,
 322             /* src_destroy */ false, (vm_map_copy_t *)logDataOut);
 323         if (copyin_result == KERN_SUCCESS) {
 324             *logDataLengthOut = logDataLength;
 325         } else {
 326             OSKextLog(/* kext */ NULL,
 327                 kOSKextLogErrorLevel |
 328                 kOSKextLogIPCFlag,
 329                 "Failed to copy log data for request from user space.");
 330             *op_result = copyin_result;  // xxx - should we map to our own code?
 331             *logDataOut = NULL;
 332             *logDataLengthOut = 0;
 333             goto finish;
 334         }
 335     }
 336
 337 finish:
 338     if (request) {
 339         (void)vm_deallocate(kernel_map, (vm_offset_t)request, requestLengthIn);
 340     }
 341     if (response) {
 342         kmem_free(kernel_map, (vm_offset_t)response, responseLength);
 343     }
 344     if (logData) {
 345         kmem_free(kernel_map, (vm_offset_t)logData, logDataLength);
 346     }
 347
 348     return result;
 349 }
 350
 351 /*********************************************************************
 352 * Gets the vm_map for the current kext
 353 *********************************************************************/
 354 extern vm_offset_t segPRELINKB;
 355 extern unsigned long segSizePRELINK;
 356 extern int kth_started;
 357 extern vm_map_t g_kext_map;
 358
 359 vm_map_t
 360 kext_get_vm_map(kmod_info_t *info)
 361 {
 362     vm_map_t kext_map = NULL;
 363
 364     /* Set the vm map */
 365     if ((info->address >= segPRELINKB) &&
 366             (info->address < (segPRELINKB + segSizePRELINK)))
 367     {
 368         kext_map = kernel_map;
 369     } else {
 370         kext_map = g_kext_map;
 371     }
 372
 373     return kext_map;
 374 }
 375
 376
 377 #if PRAGMA_MARK
 378 /********************************************************************/
 379 #pragma mark Weak linking support
 380 /********************************************************************/
 381 #endif
 382 void
 383 kext_weak_symbol_referenced(void)
 384 {
 385     panic("A kext referenced an unresolved weak symbol\n");
 386 }
 387
 388 const void *gOSKextUnresolved = (const void *)&kext_weak_symbol_referenced;
 389
 390 #if PRAGMA_MARK
 391 #pragma mark Kernel-Internal C Functions
 392 #endif
 393 /*********************************************************************
 394 * Called from startup.c.
 395 *********************************************************************/
 396 void OSKextRemoveKextBootstrap(void)
 397 {
 398     OSKext::removeKextBootstrap();
 399     return;
 400 }
 401
 402 #if CONFIG_DTRACE
 403 /*********************************************************************
 404 *********************************************************************/
 405 void OSKextRegisterKextsWithDTrace(void)
 406 {
 407     OSKext::registerKextsWithDTrace();
 408     return;
 409 }
 410 #endif /* CONFIG_DTRACE */
 411
 412 /*********************************************************************
 413 *********************************************************************/
 414 void kext_dump_panic_lists(int (*printf_func)(const char * fmt, ...))
 415 {
 416     OSKext::printKextPanicLists(printf_func);
 417     return;
 418 }
 419
 420 #if PRAGMA_MARK
 421 #pragma mark Kmod Compatibility Functions
 422 #endif
 423 /*********************************************************************
 424 **********************************************************************
 425 *                    KMOD COMPATIBILITY FUNCTIONS                    *
 426 *              (formerly in kmod.c, or C++ bridges from)             *
 427 **********************************************************************
 428 **********************************************************************
 429 * These two functions are used in various places in the kernel, but
 430 * are not exported. We might rename them at some point to start with
 431 * kext_ or OSKext.
 432 *
 433 * kmod_panic_dump() must not be called outside of a panic context.
 434 * kmod_dump_log() must not be called in a panic context.
 435 *********************************************************************/
 436 void
 437 kmod_panic_dump(vm_offset_t * addr, unsigned int cnt)
 438 {
 439     extern int kdb_printf(const char *format, ...) __printflike(1,2);
 440
 441     OSKext::printKextsInBacktrace(addr, cnt, &kdb_printf,
 442         /* takeLock? */ false);
 443     return;
 444 }
 445
 446 /********************************************************************/
 447 void kmod_dump_log(vm_offset_t *addr, unsigned int cnt);
 448
 449 void
 450 kmod_dump_log(
 451     vm_offset_t * addr,
 452     unsigned int cnt)
 453 {
 454     OSKext::printKextsInBacktrace(addr, cnt, &printf, /* lock? */ true);
 455 }
 456
 457 /*********************************************************************
 458 * Compatibility implementation for kmod_get_info() host_priv routine.
 459 * Only supported on old 32-bit architectures.
 460 *********************************************************************/
 461 #if __i386__
 462 kern_return_t
 463 kext_get_kmod_info(
 464     kmod_info_array_t      * kmod_list,
 465     mach_msg_type_number_t * kmodCount)
 466 {
 467     return OSKext::getKmodInfo(kmod_list, kmodCount);
 468 }
 469 #endif /* __i386__ */
 470
 471 #if PRAGMA_MARK
 472 #pragma mark Loaded Kext Summary
 473 #endif
 474
 475 void
 476 OSKextLoadedKextSummariesUpdated(void)
 477 {
 478     // Do nothing.
 479 }
 480
 481 };