OcAppleKernelLib.h

Go to the documentation of this file.

 
#ifndef OC_APPLE_KERNEL_LIB_H
#define OC_APPLE_KERNEL_LIB_H
 
#include <IndustryStandard/AppleMkext.h>
#include <Library/OcCpuLib.h>
#include <Library/OcMachoLib.h>
#include <Library/OcXmlLib.h>
#include <Protocol/SimpleFileSystem.h>
 
#define PRELINK_KERNEL_IDENTIFIER      "__kernel__"
#define PRELINK_KPI_IDENTIFIER_PREFIX  "com.apple.kpi."
 
#define PRELINK_INFO_SEGMENT          "__PRELINK_INFO"
#define PRELINK_INFO_SECTION          "__info"
#define PRELINK_TEXT_SEGMENT          "__PRELINK_TEXT"
#define PRELINK_TEXT_SECTION          "__text"
#define PRELINK_STATE_SEGMENT         "__PRELINK_STATE"
#define PRELINK_STATE_SECTION_KERNEL  "__kernel"
#define PRELINK_STATE_SECTION_KEXTS   "__kexts"
 
#define PRELINK_INFO_DICTIONARY_KEY                "_PrelinkInfoDictionary"
#define PRELINK_INFO_KMOD_INFO_KEY                 "_PrelinkKmodInfo"
#define PRELINK_INFO_BUNDLE_PATH_KEY               "_PrelinkBundlePath"
#define PRELINK_INFO_EXECUTABLE_RELATIVE_PATH_KEY  "_PrelinkExecutableRelativePath"
#define PRELINK_INFO_EXECUTABLE_LOAD_ADDR_KEY      "_PrelinkExecutableLoadAddr"
#define PRELINK_INFO_EXECUTABLE_SOURCE_ADDR_KEY    "_PrelinkExecutableSourceAddr"
#define PRELINK_INFO_EXECUTABLE_SIZE_KEY           "_PrelinkExecutableSize"
#define PRELINK_INFO_LINK_STATE_ADDR_KEY           "_PrelinkLinkState"
#define PRELINK_INFO_LINK_STATE_SIZE_KEY           "_PrelinkLinkStateSize"
 
#define INFO_BUNDLE_IDENTIFIER_KEY          "CFBundleIdentifier"
#define INFO_BUNDLE_EXECUTABLE_KEY          "CFBundleExecutable"
#define INFO_BUNDLE_LIBRARIES_KEY           "OSBundleLibraries"
#define INFO_BUNDLE_LIBRARIES_64_KEY        "OSBundleLibraries_x86_64"
#define INFO_BUNDLE_VERSION_KEY             "CFBundleVersion"
#define INFO_BUNDLE_COMPATIBLE_VERSION_KEY  "OSBundleCompatibleVersion"
#define INFO_BUNDLE_OS_BUNDLE_REQUIRED_KEY  "OSBundleRequired"
 
#define OS_BUNDLE_REQUIRED_ROOT       "Root"
#define OS_BUNDLE_REQUIRED_SAFE_BOOT  "Safe Boot"
 
#define MKEXT_INFO_DICTIONARIES_KEY         "_MKEXTInfoDictionaries"
#define MKEXT_BUNDLE_PATH_KEY               "_MKEXTBundlePath"
#define MKEXT_EXECUTABLE_RELATIVE_PATH_KEY  "_MKEXTExecutableRelativePath"
#define MKEXT_EXECUTABLE_KEY                "_MKEXTExecutable"
 
#define PRELINK_INFO_INTEGER_ATTRIBUTES  "size=\"64\""
#define MKEXT_INFO_INTEGER_ATTRIBUTES    "size=\"32\""
 
#define KC_REGION_SEGMENT_PREFIX  "__REGION"
#define KC_REGION0_SEGMENT        "__REGION0"
#define KC_TEXT_SEGMENT           "__TEXT"
#define KC_LINKEDIT_SEGMENT       "__LINKEDIT"
#define KC_MOSCOW_SEGMENT         "__MOSCOW101"
 
//
// Maximum allowed size of kext bundle version (CFBundleVersion) string.
//
#define MAX_INFO_BUNDLE_VERSION_KEY_SIZE  32
 
//
// Kernel cache types.
//
typedef enum KERNEL_CACHE_TYPE_ {
  CacheTypeNone,
  CacheTypeCacheless,
  CacheTypeMkext,
  CacheTypePrelinked
} KERNEL_CACHE_TYPE;
 
//
// Macro to print kernel cache type.
//
#define PRINT_KERNEL_CACHE_TYPE(a)  (\
  (a)   == CacheTypeCacheless ? "Cacheless" : \
  ((a)  == CacheTypeMkext     ? "Mkext" : \
  (((a) == CacheTypePrelinked ? "Prelinked" : "Kernel"))))
 
//
// As PageCount is UINT16, we can only index 2^16 * 4096 Bytes with one chain.
//
#define PRELINKED_KEXTS_MAX_SIZE  (BIT16 * MACHO_PAGE_SIZE)
 
//
// Failsafe default for plist reserve allocation.
//
#define PRELINK_INFO_RESERVE_SIZE  (5U * 1024U * 1024U)
 
//
// Size to reserve per kext for plist expansion.
// Additional properties are added to prelinked and mkext v2, this should account for those.
//
#define PLIST_EXPANSION_SIZE  512
 
//
// Make integral kernel version (major, minor, revision).
//
#define KERNEL_VERSION(A, B, C)  ((A) * 10000 + (B) * 100 + (C))
 
//
// Darwin versions for each release.
//
#define KERNEL_VERSION_TIGER          8
#define KERNEL_VERSION_LEOPARD        9
#define KERNEL_VERSION_SNOW_LEOPARD   10
#define KERNEL_VERSION_LION           11
#define KERNEL_VERSION_MOUNTAIN_LION  12
#define KERNEL_VERSION_MAVERICKS      13
#define KERNEL_VERSION_YOSEMITE       14
#define KERNEL_VERSION_EL_CAPITAN     15
#define KERNEL_VERSION_SIERRA         16
#define KERNEL_VERSION_HIGH_SIERRA    17
#define KERNEL_VERSION_MOJAVE         18
#define KERNEL_VERSION_CATALINA       19
#define KERNEL_VERSION_BIG_SUR        20
#define KERNEL_VERSION_MONTEREY       21
#define KERNEL_VERSION_VENTURA        22
#define KERNEL_VERSION_SONOMA         23
#define KERNEL_VERSION_SEQUOIA        24
#define KERNEL_VERSION_TAHOE          25
 
//
// Minimum kernel versions for each release.
//
#define KERNEL_VERSION_TIGER_MIN          KERNEL_VERSION (KERNEL_VERSION_TIGER, 0, 0)
#define KERNEL_VERSION_LEOPARD_MIN        KERNEL_VERSION (KERNEL_VERSION_LEOPARD, 0, 0)
#define KERNEL_VERSION_SNOW_LEOPARD_MIN   KERNEL_VERSION (KERNEL_VERSION_SNOW_LEOPARD, 0, 0)
#define KERNEL_VERSION_LION_MIN           KERNEL_VERSION (KERNEL_VERSION_LION, 0, 0)
#define KERNEL_VERSION_MOUNTAIN_LION_MIN  KERNEL_VERSION (KERNEL_VERSION_MOUNTAIN_LION, 0, 0)
#define KERNEL_VERSION_MAVERICKS_MIN      KERNEL_VERSION (KERNEL_VERSION_MAVERICKS, 0, 0)
#define KERNEL_VERSION_YOSEMITE_MIN       KERNEL_VERSION (KERNEL_VERSION_YOSEMITE, 0, 0)
#define KERNEL_VERSION_EL_CAPITAN_MIN     KERNEL_VERSION (KERNEL_VERSION_EL_CAPITAN, 0, 0)
#define KERNEL_VERSION_SIERRA_MIN         KERNEL_VERSION (KERNEL_VERSION_SIERRA, 0, 0)
#define KERNEL_VERSION_HIGH_SIERRA_MIN    KERNEL_VERSION (KERNEL_VERSION_HIGH_SIERRA, 0, 0)
#define KERNEL_VERSION_MOJAVE_MIN         KERNEL_VERSION (KERNEL_VERSION_MOJAVE, 0, 0)
#define KERNEL_VERSION_CATALINA_MIN       KERNEL_VERSION (KERNEL_VERSION_CATALINA, 0, 0)
#define KERNEL_VERSION_BIG_SUR_MIN        KERNEL_VERSION (KERNEL_VERSION_BIG_SUR, 0, 0)
#define KERNEL_VERSION_MONTEREY_MIN       KERNEL_VERSION (KERNEL_VERSION_MONTEREY, 0, 0)
#define KERNEL_VERSION_VENTURA_MIN        KERNEL_VERSION (KERNEL_VERSION_VENTURA, 0, 0)
#define KERNEL_VERSION_SONOMA_MIN         KERNEL_VERSION (KERNEL_VERSION_SONOMA, 0, 0)
#define KERNEL_VERSION_SEQUOIA_MIN        KERNEL_VERSION (KERNEL_VERSION_SEQUOIA, 0, 0)
#define KERNEL_VERSION_TAHOE_MIN          KERNEL_VERSION (KERNEL_VERSION_TAHOE, 0, 0)
 
//
// Maximum kernel versions for each release.
//
#define KERNEL_VERSION_TIGER_MAX          (KERNEL_VERSION_LEOPARD_MIN - 1)
#define KERNEL_VERSION_LEOPARD_MAX        (KERNEL_VERSION_SNOW_LEOPARD_MIN - 1)
#define KERNEL_VERSION_SNOW_LEOPARD_MAX   (KERNEL_VERSION_LION_MIN - 1)
#define KERNEL_VERSION_LION_MAX           (KERNEL_VERSION_MOUNTAIN_LION_MIN - 1)
#define KERNEL_VERSION_MOUNTAIN_LION_MAX  (KERNEL_VERSION_MAVERICKS_MIN - 1)
#define KERNEL_VERSION_MAVERICKS_MAX      (KERNEL_VERSION_YOSEMITE_MIN - 1)
#define KERNEL_VERSION_YOSEMITE_MAX       (KERNEL_VERSION_EL_CAPITAN_MIN - 1)
#define KERNEL_VERSION_EL_CAPITAN_MAX     (KERNEL_VERSION_SIERRA_MIN - 1)
#define KERNEL_VERSION_SIERRA_MAX         (KERNEL_VERSION_HIGH_SIERRA_MIN - 1)
#define KERNEL_VERSION_HIGH_SIERRA_MAX    (KERNEL_VERSION_MOJAVE_MIN - 1)
#define KERNEL_VERSION_MOJAVE_MAX         (KERNEL_VERSION_CATALINA_MIN - 1)
#define KERNEL_VERSION_CATALINA_MAX       (KERNEL_VERSION_BIG_SUR_MIN - 1)
#define KERNEL_VERSION_BIG_SUR_MAX        (KERNEL_VERSION_MONTEREY_MIN - 1)
#define KERNEL_VERSION_MONTEREY_MAX       (KERNEL_VERSION_VENTURA_MIN - 1)
#define KERNEL_VERSION_VENTURA_MAX        (KERNEL_VERSION_SONOMA_MIN - 1)
#define KERNEL_VERSION_SONOMA_MAX         (KERNEL_VERSION_SEQUOIA_MIN - 1)
 
//
// Prelinked context used for kernel modification.
//
typedef struct {
  //
  // Current version of prelinkedkernel. It takes a reference of user-allocated
  // memory block from pool, and grows if needed.
  //
  UINT8                                  *Prelinked;
  //
  // Exportable prelinkedkernel size, i.e. the payload size. Also references user field.
  //
  UINT32                                 PrelinkedSize;
  //
  // Currently allocated prelinkedkernel size, used for reduced rellocations.
  //
  UINT32                                 PrelinkedAllocSize;
  //
  // Current last virtual address (kext source files and plist are put here).
  //
  UINT64                                 PrelinkedLastAddress;
  //
  // Current last virtual load address (kexts are loaded here after kernel startup).
  //
  UINT64                                 PrelinkedLastLoadAddress;
  //
  // Mach-O context for prelinkedkernel.
  //
  OC_MACHO_CONTEXT                       PrelinkedMachContext;
  //
  // Pointer to PRELINK_INFO_SEGMENT.
  //
  MACH_SEGMENT_COMMAND_ANY               *PrelinkedInfoSegment;
  //
  // Pointer to PRELINK_INFO_SECTION.
  //
  MACH_SECTION_ANY                       *PrelinkedInfoSection;
  //
  // Pointer to PRELINK_TEXT_SEGMENT (for prelinkedkernel, NULL for KC).
  // As of macOS 13 Developer Beta 3, this segment may have corrupted
  // information.
  //
  MACH_SEGMENT_COMMAND_ANY               *PrelinkedTextSegment;
  //
  // Pointer to PRELINK_TEXT_SECTION.
  //
  MACH_SECTION_ANY                       *PrelinkedTextSection;
  //
  // Pointer to PRELINK_STATE_SEGMENT (for 10.6.8).
  //
  MACH_SEGMENT_COMMAND_ANY               *PrelinkedStateSegment;
  //
  // Pointer to PRELINK_STATE_SECTION_KERNEL (for 10.6.8).
  //
  MACH_SECTION_ANY                       *PrelinkedStateSectionKernel;
  //
  // Pointer to PRELINK_STATE_SECTION_KEXTS (for 10.6.8).
  //
  MACH_SECTION_ANY                       *PrelinkedStateSectionKexts;
  //
  // Contents of PRELINK_STATE_SECTION_KERNEL section (for 10.6.8).
  //
  VOID                                   *PrelinkedStateKernel;
  //
  // Contents of PRELINK_STATE_SECTION_KEXTS (for 10.6.8).
  //
  VOID                                   *PrelinkedStateKexts;
  //
  // PRELINK_STATE_SECTION_KEXTS original load address.
  //
  UINT64                                 PrelinkedStateKextsAddress;
  //
  // PRELINK_STATE_SECTION_KERNEL section size (for 10.6.8).
  //
  UINT32                                 PrelinkedStateKernelSize;
  //
  // PRELINK_STATE_SECTION_KEXTS section size (for 10.6.8).
  //
  UINT32                                 PrelinkedStateKextsSize;
  //
  // Pointer to KC_LINKEDIT_SEGMENT (for KC mode).
  //
  MACH_SEGMENT_COMMAND_ANY               *LinkEditSegment;
  //
  // Pointer to KC_REGION0_SEGMENT (for KC mode).
  //
  MACH_SEGMENT_COMMAND_64                *RegionSegment;
  //
  // Mach-O context for inner prelinkedkernel (for KC mode).
  //
  OC_MACHO_CONTEXT                       InnerMachContext;
  //
  // Pointer to PRELINK_INFO_SEGMENT in the inner prelinkedkernel.
  //
  MACH_SEGMENT_COMMAND_64                *InnerInfoSegment;
  //
  // Pointer to PRELINK_INFO_SECTION in the inner prelinkedkernel.
  //
  MACH_SECTION_64                        *InnerInfoSection;
  //
  // Copy of prelinkedkernel PRELINK_INFO_SECTION used for XML_DOCUMENT.
  // Freed upon context destruction.
  //
  CHAR8                                  *PrelinkedInfo;
  //
  // Parsed instance of PlistInfo. New entries are added here.
  //
  XML_DOCUMENT                           *PrelinkedInfoDocument;
  //
  // Reference for PRELINK_INFO_DICTIONARY_KEY in PlistDocument.
  // This reference is used for quick path during kext injection.
  //
  XML_NODE                               *KextList;
  //
  // Plist scratch buffer used when updating values.
  //
  CHAR8                                  *KextScratchBuffer;
  //
  // Buffers allocated from pool for internal needs.
  //
  VOID                                   **PooledBuffers;
  //
  // Currently used pooled buffers.
  //
  UINT32                                 PooledBuffersCount;
  //
  // Currently allocated pooled buffers. PooledBuffersAllocCount >= PooledBuffersCount.
  //
  UINT32                                 PooledBuffersAllocCount;
  VOID                                   *LinkBuffer;
  UINT32                                 LinkBufferSize;
  //
  // Used for caching all prelinked kexts.
  // I.e. this contains kernel, injected kexts, and kexts used as dependencies.
  //
  LIST_ENTRY                             PrelinkedKexts;
  //
  // Used for caching prelinked kexts, which we inject.
  // This is a sublist of PrelinkedKexts.
  //
  LIST_ENTRY                             InjectedKexts;
  //
  // Whether this kernel is a kernel collection (used by macOS 11.0+).
  //
  BOOLEAN                                IsKernelCollection;
  //
  // Kext segment file location for kernel collection.
  //
  UINT32                                 KextsFileOffset;
  //
  // Kext segment memory location for kernel collection.
  //
  UINT64                                 KextsVmAddress;
  //
  // Kext fixup chain for kernel collection.
  //
  MACH_DYLD_CHAINED_STARTS_IN_SEGMENT    *KextsFixupChains;
  //
  // Kernel virtual base.
  //
  UINT64                                 VirtualBase;
  //
  // Prelinked is 32-bit.
  //
  BOOLEAN                                Is32Bit;
} PRELINKED_CONTEXT;
 
//
// Kernel and kext patching context.
//
typedef struct {
  //
  // Mach-O context for patched binary.
  //
  OC_MACHO_CONTEXT    MachContext;
  //
  // Virtual base of text segment.
  //
  UINT64              VirtualBase;
  //
  // File offset.
  //
  UINT64              FileOffset;
  //
  // Virtual kmod_info_t address.
  //
  UINT64              VirtualKmod;
  //
  // Pointer to KXLD state (read only, it is allocated in PrelinkedStateKexts).
  //
  CONST VOID          *KxldState;
  //
  // Pointer to KXLD state (read only, it is allocated in PrelinkedStateKexts).
  //
  UINT32              KxldStateSize;
  //
  // Binary is 32-bit.
  //
  BOOLEAN             Is32Bit;
  //
  // Patcher context is contained within a kernel collection.
  //
  BOOLEAN             IsKernelCollection;
} PATCHER_CONTEXT;
 
//
// Kernel and kext patch description.
//
typedef struct {
  //
  // Comment or NULL.
  //
  CONST CHAR8    *Comment;
  //
  // Symbol base or NULL (0 base is used then).
  //
  CONST CHAR8    *Base;
  //
  // Find bytes or NULL (data is written to base then).
  //
  CONST UINT8    *Find;
  //
  // Replace bytes.
  //
  CONST UINT8    *Replace;
  //
  // Find mask or NULL.
  //
  CONST UINT8    *Mask;
  //
  // Replace mask or NULL.
  //
  CONST UINT8    *ReplaceMask;
  //
  // Patch size.
  //
  UINT32         Size;
  //
  // Replace count or 0 for all.
  //
  UINT32         Count;
  //
  // Skip count or 0 to start from 1 match.
  //
  UINT32         Skip;
  //
  // Limit replacement size to this value or 0, which assumes table size.
  //
  UINT32         Limit;
} PATCHER_GENERIC_PATCH;
 
//
// Context for cacheless boot (S/L/E).
//
typedef struct {
  //
  // Extensions directory EFI_FILE_PROTOCOL instance.
  //
  EFI_FILE_PROTOCOL    *ExtensionsDir;
  //
  // Extensions directory filename. This is freed by the caller.
  //
  CONST CHAR16         *ExtensionsDirFileName;
  //
  // List of injected kexts.
  //
  LIST_ENTRY           InjectedKexts;
  //
  // List of dependencies that need to be injected.
  //
  LIST_ENTRY           InjectedDependencies;
  //
  // List of kext patches for built-in shipping kexts.
  //
  LIST_ENTRY           PatchedKexts;
  //
  // List of built-in shipping kexts.
  //
  LIST_ENTRY           BuiltInKexts;
  //
  // Current kernel version.
  //
  UINT32               KernelVersion;
  //
  // System is booting in 32-bit mode.
  //
  BOOLEAN              Is32Bit;
  //
  // Flag to indicate if above list is valid. List is built during the first read from SLE.
  //
  BOOLEAN              BuiltInKextsValid;
} CACHELESS_CONTEXT;
 
//
// Mkext context.
//
typedef struct {
  //
  // Current version of mkext. It takes a reference of user-allocated
  // memory block from pool, and grows if needed.
  //
  UINT8               *Mkext;
  //
  // Exportable mkext size, i.e. the payload size. Also references user field.
  //
  UINT32              MkextSize;
  //
  // Currently allocated mkext size, used for reduced rellocations.
  //
  UINT32              MkextAllocSize;
  //
  // Mkext header.
  //
  MKEXT_HEADER_ANY    *MkextHeader;
  //
  // Version.
  //
  UINT32              MkextVersion;
  //
  // CPU type.
  //
  BOOLEAN             Is32Bit;
  //
  // Current number of kexts.
  //
  UINT32              NumKexts;
  //
  // Max kexts for allocation.
  //
  UINT32              NumMaxKexts;
  //
  // Offset of mkext plist.
  //
  UINT32              MkextInfoOffset;
  //
  // Copy of mkext plist used for XML_DOCUMENT.
  // Freed upon context destruction.
  //
  UINT8               *MkextInfo;
  //
  // Parsed instance of mkext plist. New entries are added here.
  //
  XML_DOCUMENT        *MkextInfoDocument;
  //
  // Array of kexts.
  //
  XML_NODE            *MkextKexts;
  //
  // List of cached kexts, used for patching and blocking.
  //
  LIST_ENTRY          CachedKexts;
} MKEXT_CONTEXT;
 
//
// Kernel quirk names.
//
typedef enum {
  //
  // Apply MSR E2 patches to AppleIntelCPUPowerManagement kext.
  //
  KernelQuirkAppleCpuPmCfgLock,
  //
  // Apply MSR E2 patches to XNU kernel (XCPM).
  //
  KernelQuirkAppleXcpmCfgLock,
  //
  // Apply extra MSR patches to XNU kernel (XCPM).
  //
  KernelQuirkAppleXcpmExtraMsrs,
  //
  // Apply max MSR_IA32_PERF_CONTROL patches to XNU kernel (XCPM).
  //
  KernelQuirkAppleXcpmForceBoost,
  //
  // Apply regiser base change patch for customised PCI serial device to XNU.
  //
  KernelQuirkCustomPciSerialDevice,
  //
  // Apply custom AppleSMBIOS kext GUID patch for Custom UpdateSMBIOSMode.
  //
  KernelQuirkCustomSmbiosGuid1,
  KernelQuirkCustomSmbiosGuid2,
  //
  // Apply VT-d disabling patches to IOPCIFamily kext to disable IOMapper in macOS.
  //
  KernelQuirkDisableIoMapper,
  //
  // Disable mapping PCI bridge device memory in IOMMU (VT-d) to resolve compatibility issues.
  //
  KernelQuirkDisableIoMapperMapping,
  //
  // Disable AppleRTC checksum writing.
  //
  KernelQuirkDisableRtcChecksum,
  //
  // Apply dummy power management patches to AppleIntelCPUPowerManagement in macOS.
  //
  KernelQuirkDummyPowerManagement,
  //
  // Apply feature flags patches to IOBluetoothFamily kext to ensure full Bluetooth functionality.
  //
  KernelQuirkExtendBTFeatureFlags,
  //
  // Apply icon type patches to IOAHCIPort kext to force internal disk icons.
  //
  KernelQuirkExternalDiskIcons,
  //
  // Enable Aquantia AQtion AQC-107s support.
  //
  KernelQuirkForceAquantiaEthernet,
  //
  // Force SecureBoot support for all CPUs.
  //
  KernelQuirkForceSecureBootScheme,
  //
  // Apply PCI bar size patches to IOPCIFamily kext for compatibility with select configuration.
  //
  KernelQuirkIncreasePciBarSize,
  //
  // Disable LAPIC interrupt kernel panic on AP cores.
  //
  KernelQuirkLapicKernelPanic,
  //
  // Replace the 64-bit commpage bcopy implementation with one that does not use SSSE3.
  //
  KernelQuirkLegacyCommpage,
  //
  // Apply kernel patches to remove kext dumping in the panic log.
  //
  KernelQuirkPanicNoKextDump,
  //
  // Disable power state change timeout kernel panic (10.15+).
  //
  KernelQuirkPowerTimeoutKernelPanic,
  //
  // Remove kernel __LINKEDIT jetisson.
  //
  KernelQuirkSegmentJettison,
  //
  // Set custom APFS trim timeout.
  //
  KernelQuirkSetApfsTrimTimeout,
  //
  // Apply vendor patches to IOAHCIFamily kext to enable native features for third-party drives,
  // such as TRIM on SSDs or hibernation support on 10.15.
  //
  KernelQuirkThirdPartyDrives,
  //
  // Apply port limit patches to AppleUSBXHCI and AppleUSBXHCIPCI kexts.
  //
  KernelQuirkXhciPortLimit1,
  KernelQuirkXhciPortLimit2,
  KernelQuirkXhciPortLimit3,
 
  KernelQuirkMax
} KERNEL_QUIRK_NAME;
 
typedef
EFI_STATUS
(KERNEL_QUIRK_PATCH_FUNCTION) (
  IN OUT PATCHER_CONTEXT  *Patcher OPTIONAL,
  IN     UINT32           KernelVersion
  );
 
//
// Kernel quirk.
//
typedef struct {
  //
  // Target bundle identifier. NULL for kernel.
  //
  CONST CHAR8                    *Identifier;
  //
  // Quirk patch function.
  //
  KERNEL_QUIRK_PATCH_FUNCTION    *PatchFunction;
} KERNEL_QUIRK;
 
EFI_STATUS
KernelApplyQuirk (
  IN     KERNEL_QUIRK_NAME  Name,
  IN OUT PATCHER_CONTEXT    *Patcher OPTIONAL,
  IN     UINT32             KernelVersion
  );
 
EFI_STATUS
ReadAppleKernel (
  IN     EFI_FILE_PROTOCOL  *File,
  IN     BOOLEAN            Prefer32Bit,
  OUT BOOLEAN               *Is32Bit,
  OUT UINT8                 **Kernel,
  OUT UINT32                *KernelSize,
  OUT UINT32                *AllocatedSize,
  IN     UINT32             ReservedSize,
  OUT UINT8                 *Digest  OPTIONAL
  );
 
EFI_STATUS
ReadAppleMkext (
  IN     EFI_FILE_PROTOCOL  *File,
  IN     BOOLEAN            Prefer32Bit,
  OUT UINT8                 **Mkext,
  OUT UINT32                *MkextSize,
  OUT UINT32                *AllocatedSize,
  IN     UINT32             ReservedSize,
  IN     UINT32             NumReservedKexts
  );
 
UINT32
OcParseDarwinVersion (
  IN  CONST CHAR8  *String
  );
 
UINT32
OcKernelReadDarwinVersion (
  IN  CONST UINT8  *Kernel,
  IN  UINT32       KernelSize
  );
 
BOOLEAN
OcMatchDarwinVersion (
  IN  UINT32  CurrentVersion OPTIONAL,
  IN  UINT32  MinVersion     OPTIONAL,
  IN  UINT32  MaxVersion     OPTIONAL
  );
 
EFI_STATUS
PrelinkedContextInit (
  IN OUT  PRELINKED_CONTEXT  *Context,
  IN OUT  UINT8              *Prelinked,
  IN      UINT32             PrelinkedSize,
  IN      UINT32             PrelinkedAllocSize,
  IN      BOOLEAN            Is32Bit
  );
 
VOID
PrelinkedContextFree (
  IN OUT  PRELINKED_CONTEXT  *Context
  );
 
EFI_STATUS
PrelinkedDependencyInsert (
  IN OUT  PRELINKED_CONTEXT  *Context,
  IN      VOID               *Buffer
  );
 
EFI_STATUS
PrelinkedInjectPrepare (
  IN OUT PRELINKED_CONTEXT  *Context,
  IN     UINT32             LinkedExpansion,
  IN     UINT32             ReservedExeSize
  );
 
EFI_STATUS
PrelinkedInjectComplete (
  IN OUT PRELINKED_CONTEXT  *Context
  );
 
EFI_STATUS
PrelinkedReserveKextSize (
  IN OUT UINT32   *ReservedInfoSize,
  IN OUT UINT32   *ReservedExeSize,
  IN     UINT32   InfoPlistSize,
  IN     UINT8    *Executable OPTIONAL,
  IN     UINT32   ExecutableSize OPTIONAL,
  IN     BOOLEAN  Is32Bit
  );
 
EFI_STATUS
PrelinkedInjectKext (
  IN OUT PRELINKED_CONTEXT  *Context,
  IN     CONST CHAR8        *Identifier OPTIONAL,
  IN     CONST CHAR8        *BundlePath,
  IN     CONST CHAR8        *InfoPlist,
  IN     UINT32             InfoPlistSize,
  IN     CONST CHAR8        *ExecutablePath OPTIONAL,
  IN OUT CONST UINT8        *Executable OPTIONAL,
  IN     UINT32             ExecutableSize OPTIONAL,
  OUT    CHAR8              BundleVersion[MAX_INFO_BUNDLE_VERSION_KEY_SIZE] OPTIONAL
  );
 
EFI_STATUS
PrelinkedContextApplyPatch (
  IN OUT PRELINKED_CONTEXT      *Context,
  IN     CONST CHAR8            *Identifier,
  IN     PATCHER_GENERIC_PATCH  *Patch
  );
 
EFI_STATUS
PrelinkedContextApplyQuirk (
  IN OUT PRELINKED_CONTEXT  *Context,
  IN     KERNEL_QUIRK_NAME  Quirk,
  IN     UINT32             KernelVersion
  );
 
EFI_STATUS
PrelinkedContextBlock (
  IN OUT PRELINKED_CONTEXT  *Context,
  IN     CONST CHAR8        *Identifier,
  IN     BOOLEAN            Exclude
  );
 
EFI_STATUS
KcRebuildMachHeader (
  IN OUT PRELINKED_CONTEXT  *Context
  );
 
UINT32
KcGetSegmentFixupChainsSize (
  IN UINT32  SegmentSize
  );
 
EFI_STATUS
KcInitKextFixupChains (
  IN OUT PRELINKED_CONTEXT  *Context,
  IN     UINT32             SegChainSize,
  IN     UINT32             ReservedSize
  );
 
VOID
KcKextIndexFixups (
  IN OUT PRELINKED_CONTEXT  *Context,
  IN     OC_MACHO_CONTEXT   *MachContext
  );
 
UINT32
KcGetKextSize (
  IN PRELINKED_CONTEXT  *Context,
  IN UINT64             SourceAddress
  );
 
EFI_STATUS
KcKextApplyFileDelta (
  IN     PRELINKED_CONTEXT  *PrelinkedContext,
  IN OUT OC_MACHO_CONTEXT   *Context,
  IN     UINT32             Delta
  );
 
UINT64
KcFixupValue (
  IN UINT64       Value,
  IN CONST CHAR8  *Name OPTIONAL
  );
 
EFI_STATUS
PatcherInitContextFromPrelinked (
  IN OUT PATCHER_CONTEXT    *Context,
  IN OUT PRELINKED_CONTEXT  *Prelinked,
  IN     CONST CHAR8        *Name
  );
 
EFI_STATUS
PatcherInitContextFromMkext (
  IN OUT PATCHER_CONTEXT  *Context,
  IN OUT MKEXT_CONTEXT    *Mkext,
  IN     CONST CHAR8      *Name
  );
 
EFI_STATUS
PatcherInitContextFromBuffer (
  IN OUT PATCHER_CONTEXT  *Context,
  IN OUT UINT8            *Buffer,
  IN     UINT32           BufferSize,
  IN     BOOLEAN          Use32Bit
  );
 
EFI_STATUS
PatcherGetSymbolAddress (
  IN OUT PATCHER_CONTEXT  *Context,
  IN     CONST CHAR8      *Name,
  IN OUT UINT8            **Address
  );
 
EFI_STATUS
PatcherGetSymbolValue (
  IN OUT PATCHER_CONTEXT  *Context,
  IN     CONST CHAR8      *Name,
  IN OUT UINT64           *Value
  );
 
EFI_STATUS
PatcherGetSymbolAddressValue (
  IN OUT PATCHER_CONTEXT  *Context,
  IN     CONST CHAR8      *Name,
  IN OUT UINT8            **Address,
  IN OUT UINT64           *Value
  );
 
EFI_STATUS
PatcherApplyGenericPatch (
  IN OUT PATCHER_CONTEXT        *Context,
  IN     PATCHER_GENERIC_PATCH  *Patch
  );
 
EFI_STATUS
PatcherExcludePrelinkedKext (
  IN     CONST CHAR8        *Identifier,
  IN OUT PATCHER_CONTEXT    *PatcherContext,
  IN OUT PRELINKED_CONTEXT  *PrelinkedContext
  );
 
EFI_STATUS
PatcherExcludeMkextKext (
  IN OUT MKEXT_CONTEXT  *MkextContext,
  IN     CONST CHAR8    *Identifier
  );
 
EFI_STATUS
PatcherBlockKext (
  IN OUT PATCHER_CONTEXT  *Context
  );
 
BOOLEAN
KextFindKmodAddress (
  IN  OC_MACHO_CONTEXT  *ExecutableContext,
  IN  UINT64            LoadAddress,
  IN  UINT32            Size,
  OUT UINT64            *Kmod
  );
 
VOID
PatchSetApfsTimeout (
  IN UINT32  Timeout
  );
 
VOID
PatchSetPciSerialDevice (
  IN  UINTN   RegisterBase,
  IN  UINT32  RegisterStride
  );
 
EFI_STATUS
PatchKernelCpuId (
  IN OUT PATCHER_CONTEXT  *Patcher,
  IN     OC_CPU_INFO      *CpuInfo,
  IN     UINT32           *Data,
  IN     UINT32           *DataMask,
  IN     UINT32           KernelVersion
  );
 
EFI_STATUS
PatchProvideCurrentCpuInfo (
  IN OUT PATCHER_CONTEXT  *Patcher,
  IN     OC_CPU_INFO      *CpuInfo,
  IN     UINT32           KernelVersion
  );
 
EFI_STATUS
CachelessContextInit (
  IN OUT CACHELESS_CONTEXT  *Context,
  IN     CONST CHAR16       *FileName,
  IN     EFI_FILE_PROTOCOL  *ExtensionsDir,
  IN     UINT32             KernelVersion,
  IN     BOOLEAN            Is32Bit
  );
 
VOID
CachelessContextFree (
  IN OUT CACHELESS_CONTEXT  *Context
  );
 
EFI_STATUS
CachelessContextAddKext (
  IN OUT CACHELESS_CONTEXT  *Context,
  IN     CONST CHAR8        *InfoPlist,
  IN     UINT32             InfoPlistSize,
  IN     UINT8              *Executable OPTIONAL,
  IN     UINT32             ExecutableSize OPTIONAL,
  OUT    CHAR8              BundleVersion[MAX_INFO_BUNDLE_VERSION_KEY_SIZE] OPTIONAL
  );
 
EFI_STATUS
CachelessContextForceKext (
  IN OUT CACHELESS_CONTEXT  *Context,
  IN     CONST CHAR8        *Identifier
  );
 
EFI_STATUS
CachelessContextAddPatch (
  IN OUT CACHELESS_CONTEXT      *Context,
  IN     CONST CHAR8            *Identifier,
  IN     PATCHER_GENERIC_PATCH  *Patch
  );
 
EFI_STATUS
CachelessContextAddQuirk (
  IN OUT CACHELESS_CONTEXT  *Context,
  IN     KERNEL_QUIRK_NAME  Quirk
  );
 
EFI_STATUS
CachelessContextBlock (
  IN OUT CACHELESS_CONTEXT  *Context,
  IN     CONST CHAR8        *Identifier,
  IN     BOOLEAN            Exclude
  );
 
EFI_STATUS
CachelessContextOverlayExtensionsDir (
  IN OUT CACHELESS_CONTEXT  *Context,
  OUT EFI_FILE_PROTOCOL     **File
  );
 
EFI_STATUS
CachelessContextPerformInject (
  IN OUT CACHELESS_CONTEXT  *Context,
  IN     CONST CHAR16       *FileName,
  OUT EFI_FILE_PROTOCOL     **VirtualFile
  );
 
EFI_STATUS
CachelessContextHookBuiltin (
  IN OUT CACHELESS_CONTEXT  *Context,
  IN     CONST CHAR16       *FileName,
  IN     EFI_FILE_PROTOCOL  *File,
  OUT EFI_FILE_PROTOCOL     **VirtualFile
  );
 
EFI_STATUS
MkextDecompress (
  IN     CONST UINT8  *Buffer,
  IN     UINT32       BufferSize,
  IN     UINT32       NumReservedKexts,
  IN OUT UINT8        *OutBuffer OPTIONAL,
  IN     UINT32       OutBufferSize OPTIONAL,
  IN OUT UINT32       *OutMkextSize
  );
 
BOOLEAN
MkextCheckCpuType (
  IN UINT8          *Mkext,
  IN UINT32         MkextSize,
  IN MACH_CPU_TYPE  CpuType
  );
 
EFI_STATUS
MkextContextInit (
  IN OUT  MKEXT_CONTEXT  *Context,
  IN OUT  UINT8          *Mkext,
  IN      UINT32         MkextSize,
  IN      UINT32         MkextAllocSize
  );
 
VOID
MkextContextFree (
  IN OUT MKEXT_CONTEXT  *Context
  );
 
EFI_STATUS
MkextReserveKextSize (
  IN OUT UINT32   *ReservedInfoSize,
  IN OUT UINT32   *ReservedExeSize,
  IN     UINT32   InfoPlistSize,
  IN     UINT8    *Executable OPTIONAL,
  IN     UINT32   ExecutableSize OPTIONAL,
  IN     BOOLEAN  Is32Bit
  );
 
EFI_STATUS
MkextInjectKext (
  IN OUT MKEXT_CONTEXT  *Context,
  IN     CONST CHAR8    *Identifier OPTIONAL,
  IN     CONST CHAR8    *BundlePath,
  IN     CONST CHAR8    *InfoPlist,
  IN     UINT32         InfoPlistSize,
  IN     UINT8          *Executable OPTIONAL,
  IN     UINT32         ExecutableSize OPTIONAL,
  OUT    CHAR8          BundleVersion[MAX_INFO_BUNDLE_VERSION_KEY_SIZE] OPTIONAL
  );
 
EFI_STATUS
MkextContextApplyPatch (
  IN OUT MKEXT_CONTEXT          *Context,
  IN     CONST CHAR8            *Identifier,
  IN     PATCHER_GENERIC_PATCH  *Patch
  );
 
EFI_STATUS
MkextContextApplyQuirk (
  IN OUT MKEXT_CONTEXT      *Context,
  IN     KERNEL_QUIRK_NAME  Quirk,
  IN     UINT32             KernelVersion
  );
 
EFI_STATUS
MkextContextBlock (
  IN OUT MKEXT_CONTEXT  *Context,
  IN     CONST CHAR8    *Identifier,
  IN     BOOLEAN        Exclude
  );
 
EFI_STATUS
MkextInjectPatchComplete (
  IN OUT MKEXT_CONTEXT  *Context
  );
 
#endif // OC_APPLE_KERNEL_LIB_H