libkern/OSKextLib.cpp

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