Skip to content

Run a virtual iPhone on an Apple Silicon Mac.

Swift
9.2 KB
Raw Blame
#include "VPhoneIOS18GPUTransport.h"
#include "../MISFix/MISFixDetour.h"
#include <IOKit/IOKitLib.h>
#include <dlfcn.h>
#include <fcntl.h>
#include <os/lock.h>
#include <stdatomic.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

// iOS 18's GPU userland on a cloudOS 26.1 kernel. `cfw install` writes the
// marker only for that pairing, with the iOS 18 paravirtual driver installed.
// The calls come from IOGPU.framework inside the shared cache and from the
// driver bundle, so IOKit's entry points are detoured rather than interposed;
// see MISFix/MISFixDetour.h.
#define VP_IOS18_GPU_MARKER "/usr/lib/vphone-ios18-gpu"

// MISFixDetour reports each install through these. SystemHook is in every
// process, so its success line is dropped; failures are reported below.
void MISFixNote(const char *format, ...) { (void)format; }
const char *MISFixCallerImage(const void *address) { (void)address; return "?"; }

// MARK: - Device connections

// Only IOGPU device clients are translated: every other user client in the
// process, including IOGPU's other client types, keeps its selectors.
enum { VP_DEVICE_SLOTS = 32 };
static io_connect_t vpDevices[VP_DEVICE_SLOTS];
static atomic_int vpDeviceCount;
static os_unfair_lock vpDeviceLock = OS_UNFAIR_LOCK_INIT;

// A closed name can come back from another IOServiceOpen, which always
// replaces whatever this table remembered about it.
static void vpForgetLocked(io_connect_t connection) {
    for (int index = 0; index < VP_DEVICE_SLOTS; index++) {
        if (vpDevices[index] != connection) continue;
        vpDevices[index] = MACH_PORT_NULL;
        atomic_fetch_sub(&vpDeviceCount, 1);
    }
}

static bool vpIsDevice(io_connect_t connection) {
    if (connection == MACH_PORT_NULL || atomic_load_explicit(&vpDeviceCount, memory_order_relaxed) == 0) return false;
    bool found = false;
    os_unfair_lock_lock(&vpDeviceLock);
    for (int index = 0; index < VP_DEVICE_SLOTS && !found; index++) found = vpDevices[index] == connection;
    os_unfair_lock_unlock(&vpDeviceLock);
    return found;
}

static void vpNoteFirstDevice(void) {
    static atomic_bool noted;
    if (atomic_exchange(&noted, true)) return;
    int fd = open("/var/mobile/Library/Caches/vphone-systemhook.log", O_WRONLY | O_APPEND | O_CLOEXEC);
    if (fd < 0) return;
    dprintf(fd, "pid=%d ios18-gpu=%s device opened\n", getpid(), getprogname());
    close(fd);
}

// MARK: - IOKit detours

static kern_return_t (*vpServiceOpen)(io_service_t, task_port_t, uint32_t, io_connect_t *);
static kern_return_t vpServiceOpenHook(io_service_t service, task_port_t task, uint32_t type, io_connect_t *connection) {
    kern_return_t result = vpServiceOpen(service, task, type, connection);
    if (result != KERN_SUCCESS || !connection) return result;
    bool device = (type & 0xffff) == VP_IOS18_GPU_DEVICE_CLIENT && IOObjectConformsTo(service, "IOGPU");
    bool added = false;
    os_unfair_lock_lock(&vpDeviceLock);
    vpForgetLocked(*connection);
    for (int index = 0; device && index < VP_DEVICE_SLOTS && !added; index++) {
        if (vpDevices[index] != MACH_PORT_NULL) continue;
        vpDevices[index] = *connection;
        atomic_fetch_add(&vpDeviceCount, 1);
        added = true;
    }
    os_unfair_lock_unlock(&vpDeviceLock);
    if (added) vpNoteFirstDevice();
    // Untranslated, this client would call the wrong methods.
    if (device && !added) {
        IOServiceClose(*connection);
        *connection = MACH_PORT_NULL;
        return kIOReturnNoResources;
    }
    return result;
}

static kern_return_t (*vpServiceClose)(io_connect_t);
static kern_return_t vpServiceCloseHook(io_connect_t connection) {
    os_unfair_lock_lock(&vpDeviceLock);
    vpForgetLocked(connection);
    os_unfair_lock_unlock(&vpDeviceLock);
    return vpServiceClose(connection);
}

static kern_return_t (*vpCallMethod)(mach_port_t, uint32_t, const uint64_t *, uint32_t, const void *, size_t,
    uint64_t *, uint32_t *, void *, size_t *);
static kern_return_t vpCallMethodHook(mach_port_t connection, uint32_t selector,
    const uint64_t *input, uint32_t inputCount, const void *inputStruct, size_t inputStructSize,
    uint64_t *output, uint32_t *outputCount, void *outputStruct, size_t *outputStructSize) {
    if (!vpIsDevice(connection))
        return vpCallMethod(connection, selector, input, inputCount, inputStruct, inputStructSize,
            output, outputCount, outputStruct, outputStructSize);
    uint32_t modern;
    VPIOS18GPUSelectorAction action = vpIOS18GPUSelector(selector, &modern);
    if (action == VPIOS18GPUAnswerLocally) return KERN_SUCCESS;

    if (selector == VP_IOS18_GPU_RESOURCE_CREATE && outputStruct && outputStructSize &&
        *outputStructSize >= VP_IOS18_GPU_RESOURCE_HEADER) {
        size_t legacySize = *outputStructSize, size = legacySize + VP_IOS18_GPU_RESOURCE_GROWTH;
        uint8_t *reply = calloc(1, size);
        if (!reply) return kIOReturnNoMemory;
        kern_return_t result = vpCallMethod(connection, modern, input, inputCount, inputStruct, inputStructSize,
            output, outputCount, reply, &size);
        if (result == KERN_SUCCESS && !vpIOS18GPUResourceReply(outputStruct, legacySize, reply, size))
            result = kIOReturnBadArgument;
        free(reply);
        if (result == KERN_SUCCESS) *outputStructSize = legacySize;
        return result;
    }
    if (selector == VP_IOS18_GPU_SUBMIT && input && inputCount == VP_IOS18_GPU_SUBMIT_SCALARS_IN && inputStruct &&
        (!outputCount || *outputCount == 0)) {
        uint64_t scalars[VP_IOS18_GPU_SUBMIT_SCALARS_IN], stamp[VP_IOS18_GPU_SUBMIT_SCALARS_OUT] = {0};
        memcpy(scalars, input, sizeof(scalars));
        size_t size = (size_t)scalars[2] * VP_IOS18_GPU_SUBMIT_ENTRY_MODERN;
        uint8_t *entries = scalars[2] <= VP_IOS18_GPU_SUBMIT_MAX_ENTRIES ? malloc(size ? size : 1) : NULL;
        if (!entries) return kIOReturnBadArgument;
        kern_return_t result = kIOReturnBadArgument;
        if (vpIOS18GPUSubmitEntries(entries, inputStruct, inputStructSize, scalars)) {
            scalars[3] = VP_IOS18_GPU_SUBMIT_ENTRY_MODERN;
            uint32_t count = VP_IOS18_GPU_SUBMIT_SCALARS_OUT;
            result = vpCallMethod(connection, modern, scalars, inputCount, entries, size,
                stamp, &count, outputStruct, outputStructSize);
        }
        free(entries);
        return result;
    }
    if (selector == VP_IOS18_GPU_DEVICE_INFO && outputStruct && outputStructSize &&
        *outputStructSize == VP_IOS18_GPU_DEVICE_INFO_LEGACY) {
        uint8_t reply[VP_IOS18_GPU_DEVICE_INFO_MODERN] = {0};
        size_t size = sizeof(reply);
        kern_return_t result = vpCallMethod(connection, modern, input, inputCount, inputStruct, inputStructSize,
            output, outputCount, reply, &size);
        if (result != KERN_SUCCESS) return result;
        if (size != sizeof(reply)) return kIOReturnBadArgument;
        vpIOS18GPUDeviceInfoReply(outputStruct, reply);
        *outputStructSize = VP_IOS18_GPU_DEVICE_INFO_LEGACY;
        return KERN_SUCCESS;
    }
    return vpCallMethod(connection, modern, input, inputCount, inputStruct, inputStructSize,
        output, outputCount, outputStruct, outputStructSize);
}

static kern_return_t (*vpCallAsyncMethod)(mach_port_t, uint32_t, mach_port_t, uint64_t *, uint32_t,
    const uint64_t *, uint32_t, const void *, size_t, uint64_t *, uint32_t *, void *, size_t *);
static kern_return_t vpCallAsyncMethodHook(mach_port_t connection, uint32_t selector, mach_port_t wake,
    uint64_t *reference, uint32_t referenceCount, const uint64_t *input, uint32_t inputCount,
    const void *inputStruct, size_t inputStructSize, uint64_t *output, uint32_t *outputCount,
    void *outputStruct, size_t *outputStructSize) {
    uint32_t modern = selector;
    if (vpIsDevice(connection) && vpIOS18GPUSelector(selector, &modern) == VPIOS18GPUAnswerLocally)
        return KERN_SUCCESS;
    return vpCallAsyncMethod(connection, modern, wake, reference, referenceCount, input, inputCount,
        inputStruct, inputStructSize, output, outputCount, outputStruct, outputStructSize);
}

// MARK: - Install

void vpInstallIOS18GPUTransport(void) {
    if (getpid() == 1 || !strcmp(getprogname(), "xpcproxy") || access(VP_IOS18_GPU_MARKER, F_OK) != 0) return;
    // Device connections are only recorded once IOServiceOpen is detoured,
    // which happens last: until both call paths translate, none is.
    MISFixDetourResult call = MISFixDetour("IOConnectCallMethod", (void *)&IOConnectCallMethod,
        (void *)vpCallMethodHook, (void **)&vpCallMethod);
    MISFixDetourResult async = call ? call : MISFixDetour("IOConnectCallAsyncMethod",
        (void *)&IOConnectCallAsyncMethod, (void *)vpCallAsyncMethodHook, (void **)&vpCallAsyncMethod);
    MISFixDetourResult closing = async ? async : MISFixDetour("IOServiceClose", (void *)&IOServiceClose,
        (void *)vpServiceCloseHook, (void **)&vpServiceClose);
    MISFixDetourResult open = async ? async : MISFixDetour("IOServiceOpen", (void *)&IOServiceOpen,
        (void *)vpServiceOpenHook, (void **)&vpServiceOpen);
    if (call || async || closing || open)
        fprintf(stderr, "[ios18-gpu] %s transport: call=%s async=%s close=%s open=%s\n", getprogname(),
            MISFixDetourDescribe(call), MISFixDetourDescribe(async), MISFixDetourDescribe(closing),
            MISFixDetourDescribe(open));
}