Skip to content

Apple's open-source XNU kernel on Android phones: its own loader and drivers, Metal on the Adreno. Runs from RAM; a reboot gives the phone back to Android.

C

Metal: where the boundary is, what it would cost, and a diagnostic that says what iOS believes

vcvkkfa6a7b11f089
diff --git a/README.md b/README.md
index e7bb542..032700c 100644
--- a/README.md
+++ b/README.md
@@ -400,6 +400,13 @@ P3 поверхности кадров копировались, и этого
пальцев); после паники следующий запуск сам останавливает его и запускает заново. Приложения, использующие Metal
сами, от этого ничего не получают.
+**Metal'я нет, и не предполагается** — почему именно, разобрано в `docs/metal.md`: где проходит граница (одно имя
+класса в реестре IOKit, `IOAcceleratorES`, и бандл в `/System/Library/Extensions` с подклассом приватного
+`_MTLDevice`), кто из iOS 16.5 упирается в её отсутствие и почему дорога туда идёт не через драйвер, а через
+компилятор AIR, которого нет ни в Mesa, ни где-либо ещё. Что система думает про Metal, печатает
+`bin/metal_test` (`src/metal_test.m`, `RC_JOBS=rc.jobs.metal`): службы, которых Metal не находит, GPU, который
+есть под другим именем, молчаливый `nil` у `MTLCreateSystemDefaultDevice()` и то, работает ли CoreImage без него.
+
## Накопитель телефона (UFS)
**Ядро читает флеш телефона** — все 112 разделов GPT шести логических единиц UFS, только чтение, до 920 МБ/с
diff --git a/docs/metal.md b/docs/metal.md
new file mode 100644
index 0000000..f48bb7d
--- /dev/null
+++ b/docs/metal.md
@@ -0,0 +1,235 @@
+# Metal
+
+Разбор: что в iOS 16.5 просит Metal, где проходит граница, которую пришлось бы реализовать, и
+стоит ли её переходить. Всё, что ниже, проверено по извлечённой системе
+(`ios165/rootfs`, кэш `ios165/20F66__iPhone10,3_6/dyld_shared_cache_arm64`), по исходникам порта и
+по журналам прогонов; адреса — невыровненные (unslid) адреса этого кэша.
+
+Коротко: **граница — одно имя в реестре IOKit и один бандл с подклассом приватного класса**, а за
+ней лежит не драйвер, а компилятор чужого промежуточного языка. Честный путь — не писать Metal, а
+знать и показывать, что его нет. Первый шаг — `userland/src/metal_test.m`, он уже сделан.
+
+## 1. Как iOS находит Metal
+
+Вся процедура — пять шагов, и ни один из них не спрашивает ни про возможности устройства, ни про
+что-либо ещё, кроме реестра IOKit.
+
+1. `MTLRegisterDevices` (`Metal`, 306.6.4, `0x181b115ec`) берёт `IOMainPort`, затем
+ `IOServiceMatching("IOAcceleratorES")` — строка `0x181b74481` — и
+ `IOServiceGetMatchingServices`. **Это имя класса и есть всё, чем GPU находится**; других путей
+ нет.
+2. Для каждой найденной службы вызывается `getMetalPluginClassForService` (`0x181a39ba4`). Она
+ читает `IORegistryEntryCreateCFProperty(служба, "MetalPluginName")` и проверяет, что это
+ `CFString`.
+3. Из ответа складывается путь: `"/System/Library/Extensions"` (`0x181b7441b`) + имя +
+ `".bundle"` (`0x181b74436`), и бандл открывается `[NSBundle bundleWithPath:]` (`0x181bc1820`).
+4. Читается второе свойство, `"MetalPluginClassName"`; класс берётся
+ `[bundle classNamed:]` (`0x181bc1920`), а без этого свойства — `[bundle principalClass]`
+ (`0x181bca6c0`). Затем `[класс isSubclassOfClass:_MTLDevice]` (`0x181bc79e0`, ссылка на класс —
+ `0x1dcf08f68`): **не подкласс приватного `_MTLDevice` — выброшен**.
+5. `[[класс alloc] initWithAcceleratorPort:служба]` (`0x181bc6320`) — и этот объект есть устройство.
+
+Код шагов 2–4 Apple заодно выписала словами: в `AGXGPURawCounter` лежит текст сорвавшегося
+`assert` (`0x207d22fff`):
+
+```
+((cfMmetalPluginName = (CFStringRef)IORegistryEntryCreateCFProperty(acceleratorPort,
+ CFSTR("MetalPluginName"), NULL, 0)) != NULL) && CFStringGetCString(...)
+```
+
+На этом телефоне (iPhone10,3, A11) плагин — `/System/Library/Extensions/AGXMetalA11.bundle`:
+`CFBundleExecutable` `AGXMetalA11`, `NSPrincipalClass` `AGXPrincipalDevice`, версия 227.6.3; вход —
+`-[AGXA11Device initWithAcceleratorPort:]`. Сам исполняемый файл лежит в кэше dyld, а не на диске:
+в бандле только `Info.plist`, таблицы счётчиков и девять `.metallib`.
+
+`MTLCreateSystemDefaultDevice` (`0x181a34b3c`) выдаёт одно устройство из этого списка под
+`dispatch_once` (сторож `0x1e1efe9b8`, блок `0x181a3442c`, массив `0x1e1efe9a0`). **Пустой список —
+ответ, данный один раз и сохранённый до конца процесса, молча**: ни строки в журнал, ни кода
+ошибки, ни причины. В iOS 16.5 второго способа спросить нет: `MTLCopyAllDevices` объявлен
+`API_UNAVAILABLE(ios)` и в двоичном файле отсутствует.
+
+## 2. Что здесь есть вместо этого
+
+Ядро порта поднимает Adreno и отдаёт его userland'у, но под другим именем:
+`iokit/Kernel/RedwoodGPU.cpp` (строки 289–307) регистрирует `RedwoodGPU : IOService`,
+`setName("RedwoodGPU")`, `kIOUserClientClassKey = "RedwoodGPUUserClient"`. Ни `IOAcceleratorES`, ни
+`MetalPluginName`, ни `MetalPluginClassName`. Значит, `MTLRegisterDevices` обходит пустой итератор,
+список устройств пуст, и так — в каждом процессе системы.
+
+То есть **Metal не «ломается» — его просто нет, и порт об этом уже говорит правду**, причём в
+единственном месте, куда iOS смотрит. Это важно для выводов ниже: никакого бита возможностей,
+которым можно было бы соврать в ту или другую сторону, здесь не существует.
+
+## 3. Кто просит Metal и что с ними происходит
+
+Metal загружают **153 образа кэша** (`ipsw dyld imports … Metal`). Из тех, до которых порт
+доходит:
+
+| Кто | Что просит | Что сейчас |
+| --- | --- | --- |
+| `QuartzCore` — оконный сервер | `CA::WindowServer::EAGLServer::renderer()` (`0x1882e2548`) **сначала** пробует `CAMetalContextCreate()` (`0x18837b718`) и `CA::OGL::new_metal_context()` (`0x18847efcc`), и только если рендерера так и нет — путь EAGLContext/OpenGL ES | Работает без Metal: за `EAGLContext` стоит `userland/src/eagl.c`. При отказе обоих путей CoreAnimation пишет `CoreAnimation: Failed to initialize Metal or OpenGLES contexts!` — в журналах порта ровно **один раз за прогон**, потому что `inject.c` (`my_renderer`) запоминает отказ; без этого попытка повторялась бы каждый кадр |
+| `CoreImage` | `MTLCreateSystemDefaultDevice`, затем `.metallib` ядер фильтров | Есть путь без Metal (`CGRenderer`, классы `…CPU`), но есть и строка `No Metal renderer available.` (`0x194c477a5`) |
+| `CameraUI`, `CameraEffectsKit`, `CMPhoto`, `CMCapture`, `CameraColorProcessing`, `HDRProcessing`, `RawCamera`, `Portrait`, `AppleDepth`, `DepthProcessorV1` | устройство, очередь, текстурный кэш, свои `.metallib` | `Failed to create default Metal device` (`CameraUI`, `0x1cde2bd26`), `"Error: Metal device must not be NULL"` (`CameraEffectsKit`, `0x1ff99168c` — это `assert`), `Cannot create default metal device` (`AppleDepth`, `0x1e747cd48`) |
+| `AppleCVA`, `AppleCVAPhoto`, `CoreAppleCVA`, `Vision`, `MediaAnalysis`, `Espresso`, `MLCompute`, `MetalPerformanceShaders*` | то же | `AppleCVA` (`0x1beeb40cd`): `Assertion failed: device = (id<MTLDeviceSPI>)MTLCreateSystemDefaultDevice()`; `AppleCVAPhoto` (`0x1af45f0c7`): `MTLCreateSystemDefaultDevice() is nil`; `Espresso`: `Metal device not found.` |
+| `WebCore`, `WebKit`, `WebGPU`, `libANGLE-shared.dylib` | WebGL и WebGPU идут через Metal | Сам Safari работает: страницы рисует CoreGraphics |
+| `SpringBoardFoundation`, `SpringBoardUIServices`, `WallpaperKit`, `PosterBoard`, `PaperBoardUI` | эффекты экрана блокировки | Экран блокировки рисуется; часть эффектов — нет |
+| `SceneKit`, `SpriteKit`, `RealityKit`/`CoreRE`, `ARKitCore`, `AssetViewer` | всё | Ничего не получают |
+
+**Главное наблюдение: отказ Metal нигде не слышен.** Во всех 112 журналах прогонов
+(`darwin-redwood-sileo2/logs`) единственные строки про Metal — наши собственные две
+(`no GPU to draw with…`, `SpringBoard: no GPU draws…`), а в журналах с включённым GL —
+одна строка CoreAnimation за прогон. Тринадцать тысяч упоминаний `MTLCompilerService` в журналах к
+Metal отношения не имеют: это launchd заводит заглушку XPC-службы в домене каждого процесса,
+который слинкован с Metal (`created the implicit endpoint upfront` / `draining messages`), а не
+запуски компилятора.
+
+Что порт теряет на отрисовке окон, измеримо иначе: у рендерера OpenGL ES в QuartzCore нет шейдеров
+примерно для половины из девяноста «функций» CoreAnimation, тогда как у Metal есть все. На деле
+CoreAnimation спросил и получил отказ только по двум из них — 40 `sb3` и 60 `p3c`; остальное, чего
+не хватает, он рисует вовсе без программы, а три такие функции плюс уменьшение в восемь раз
+`eagl.c` рисует своими программами (см. «GPU» в README). Полную перепись даёт `glcensus=1`; в
+журналах, которые есть, он не включался.
+
+## 4. Чем пришлось бы быть реализации
+
+Граница узкая, а то, что за ней, — нет. Размеры (из кэша этого же телефона):
+
+| Что | Байт | Символов | Методов ObjC | Классов |
+| --- | --- | --- | --- | --- |
+| `AGXMetalA11` — драйвер, который пришлось бы заменить | 2 578 880 | 5 798 | 1 158 | 53 |
+| `_MTLDevice` — базовый класс, от которого надо наследоваться | — | — | **549** | 36 ivar'ов |
+| `AGXA11FamilyDevice` — сколько из них переопределено | — | — | 236 | — |
+| `IOGPU` — обёртка над клиентом IOKit | 461 664 | 2 266 | 711 | 36 |
+| `MTLCompiler` — передняя часть компилятора шейдеров | 983 544 | 2 971 | — | — |
+| `AGXCompilerCore` — его задняя часть под AGX | 2 680 736 | 7 509 | — | — |
+| `AppleMetalGLRenderer` — OpenGL ES **поверх** Metal, как это делает сама iOS | 258 256 | 1 092 | 2 | 1 |
+
+Для сравнения — чем порт заменяет графическую библиотеку сейчас: `userland/src/eagl.c` — 3 685
+строк, `src/eagl_slots.txt` — 409 записей таблицы, из которых помечено используемыми QuartzCore
+**62**, написано руками 30, и заменяется **шесть** методов ObjC у `EAGLContext`.
+
+### Что ломается первым
+
+Не объём классов, а **язык шейдеров**. Metal получает программы не текстом, а в виде AIR —
+битового кода LLVM в контейнере `.metallib`; разбирает его `MTLCompiler`, а в машинный код
+превращает задняя часть под конкретный GPU (`AGXCompilerCore`), и делается это в отдельном
+процессе `MTLCompilerService`. Сам контейнер версионирован (`This version of metallib is too old
+and not supported any longer.`, `0x181b6cccb`), а задняя часть компилятора — тоже плагин со своей
+проверкой пути и суффикса (`MTLCompilerPluginInterface::init`). В извлечённом корне девять
+`.metallib` на 3,75 МБ, и Metal знает к ним прямые пути — например
+`/System/Library/Frameworks/CoreImage.framework/CoreImage.metallib` (`0x181b6c367`).
+
+У Mesa компилятор под Adreno (`ir3`) принимает NIR. **Фронтенда AIR нет ни в Mesa, ни где-либо
+ещё**, а обойти его нельзя: всё, что просит Metal — CoreAnimation, CoreImage, MPS, камера — несёт
+с собой уже скомпилированный AIR. Значит, первым сорвётся не отрисовка, а самый первый
+`newLibraryWithData:` на любом системном `.metallib`, то есть раньше, чем что-нибудь будет
+нарисовано.
+
+Второе, что ломается, — и ломается тише: наследование от `_MTLDevice` означает, что мы получаем
+его 36 приватных ivar'ов, разметка которых принадлежит сборке Metal 306.6.4 и нигде не описана, а
+549 его собственных методов эти ivar'ы читают. Ошибка в разметке — порча памяти внутри чужого
+кода, без диагностики.
+
+### Три пути и их цена
+
+**(А) Поверхность Metal над Mesa.** Зарегистрировать в `RedwoodGPU` службу класса
+`IOAcceleratorES` с двумя свойствами, положить в образ `/System/Library/Extensions/RedwoodMetal.bundle`
+(место открыто: `userland/build.sh` собирает корень из файлов iOS по их настоящим путям и уже
+кладёт туда свои — например `/System/Library/Audio/Plug-Ins/HAL/RedwoodAudio.driver`) и реализовать
+граф объектов Metal на Mesa. Цена: ~53 класса и ~1 200 методов драйвера **плюс компилятор
+AIR→NIR**, которого не существует. В единицах этого проекта — не файл и не два, а ещё одна Mesa, и
+худшая её половина — без апстрима.
+
+**(Б) Перевод Metal в тот OpenGL ES, который уже работает.** Строго хуже (А): ту же проблему
+`_MTLDevice` приходится решать целиком, AIR остаётся на входе (то есть нужен AIR→GLSL), а
+единственное, что экономится, — задняя часть под Adreno, то есть именно та часть, которую Mesa и
+так даёт бесплатно. Заодно GLES2/3 не выражает вычислительные конвейеры, argument buffers и
+значительную часть того, за чем Metal и зовут. Показательно, что сама iOS переводит в обратную
+сторону: `AppleMetalGLRenderer.bundle` — это GLES поверх Metal, один класс и 1 092 символа.
+Дешёвое направление — GL→Metal, а у порта уже есть то, что делает его ненужным: настоящий GLES.
+
+**(В) Ни то, ни другое.** Признать, что Metal нет, и добиваться, чтобы выбирались пути без него.
+Цена — отдельные файлы и десятки строк, в привычном для проекта виде. У всего, что порту
+действительно нужно, путь без Metal есть: у CoreImage — `CGRenderer` и процессоры `…CPU`, у
+Espresso и CoreML — процессор и ANE, у декодирования видео — свой блок, а не Metal; у
+CoreAnimation — рендерер OpenGL ES, который порт уже и использует.
+
+**Вывод — (В).** Metal здесь не «недоделан», а упирается в чужой промежуточный язык, и это не та
+стена, которую обходят упорством: её обходят только компилятором AIR, а он сам по себе больше
+всего, что в проекте написано про графику. Частичного Metal при этом не бывает: любая дорога
+внутрь проходит через `newLibraryWith…` и объект состояния конвейера, так что «только вычисления»
+или «только blit» не спасают.
+
+Ограничение честности: драйвер iPhone X (`AGXMetalA11`) переиспользовать нельзя ни в каком виде —
+он порождает поток команд AGX и говорит с ядром по ABI AGX; к Adreno это не имеет отношения.
+
+## 5. Ложный след, который стоит знать
+
+Выглядит соблазнительно: в дереве устройств, которое выкладывает загрузчик, есть
+`graphics-featureset-class` = `APPLE4` и
+`graphics-featureset-fallbacks` = `APPLE3:APPLE3v1:APPLE2:APPLE1:GLES2,0`
+(`xnuloader/identity.h`, скопировано с настоящего iPhone X). Последняя ступень — `GLES2,0`, то
+есть у самой Apple под всеми наборами Metal предусмотрена ступень OpenGL ES. Напрашивается
+действовать как с цветовым охватом: `loader.c`, `dt_identity()` уже переписывает
+`artwork-display-gamut` с `P3` на `sRGB`, чтобы WebKit перестал заводить поверхности по десять бит
+на цвет и страницы перестали выходить чёрными (вернуть прежнее — `gamut=p3`).
+
+**Так делать не нужно.** Эти два свойства MobileGestalt публикует как `GraphicsFeatureSetClass` и
+`GraphicsFeatureSetFallbacks`, а читают их `libMobileGestalt`, `CoreUI` (`CUICatalog`, ключ
+`kMGArtworkGraphicsFeatureSetClass`), `CoreThemeDefinition` и `TextureIO` — то есть **каталоги
+скомпилированного оформления**: какой вариант текстуры достать из `.car`. Ни одно решение о том,
+чем рисовать, на них не завязано. Понизить класс до `GLES2,0` — значит заставить CoreUI брать
+другие варианты картинок, а Metal от этого не появится и не исчезнет. Решение одно и уже
+принимается правильно: есть ли служба `IOAcceleratorES`.
+
+## 6. Первый шаг: `metal_test` (сделан)
+
+Поскольку отказ Metal нигде не слышен, а весь план выше держится на утверждениях о том, кто и как
+падает, первое, что нужно, — это чтобы система сама говорила, что она про Metal думает.
+`userland/src/metal_test.m` (собирается `build.sh`, попадает в `/redwood/bin`, запускается
+`RC_JOBS=rc.jobs.metal`) печатает всю цепочку раздела 1 по шагам:
+
+1. службы класса `IOAcceleratorES` и у каждой — `MetalPluginName` и `MetalPluginClassName`
+ (сейчас: ни одной, и значит Metal не найдёт устройства вовсе);
+2. что в реестре **есть** похожего на GPU — `RedwoodGPU`, `IOGPU`, `AGXAccelerator`,
+ `IOAccelerator` — и с каким `IOUserClientClass`: видно, что GPU поднят, но под другим именем;
+3. бандлы в `/System/Library/Extensions`: грузится ли принципиальный класс каждого и является ли он
+ подклассом `_MTLDevice`, — то есть мог ли бы вообще загрузиться плагин в этом образе, и на каком
+ шаге всё обрывается;
+4. что получает программа: `MTLCreateSystemDefaultDevice()`, а при удаче — имя, `registryID` и
+ поддерживаемые семейства;
+5. что iOS всё равно рассказывает про графику (раздел 5): `GraphicsFeatureSetClass`,
+ `GraphicsFeatureSetFallbacks` и рядом — чтобы было видно, что ответ `APPLE4` не зависит ни от
+ чего;
+6. умеет ли работать фреймворк, у которого путь без Metal есть: CoreImage прогоняет `CIColorInvert` по четырём
+ пикселям и результат читается обратно. Оранжевый `1; 0,5; 0` должен стать примерно
+ `0; 128; 255`. Это единственная здесь проверка, отвечающая на вопрос «может ли эта система
+ вообще обработать изображение», а он нужен и камере, и Фото.
+
+Почему именно это и почему отдельно от всего: программа полезна, даже если дальше ничего не
+случится (вопрос «не из-за Metal ли это?» будет возникать и у камеры, и у Фото, и у WebGL), она
+ничего не меняет в поведении системы, и она же — предпосылка для любой следующей работы: сперва
+измерить, потом трогать. Собирается и запускается она и в QEMU, где ответ про устройство тот же,
+что на телефоне.
+
+Устроено как остальные диагностики порта (`mg_test`, `cg_test`, `font_test`, …):
+
+```sh
+userland/build.sh # obj/metal_test -> root/bin/metal_test
+XL_CMDLINE="... gpu=1" RC_JOBS=rc.jobs.metal ./xl run
+```
+
+## 7. Чего ещё стоит проверить дальше (по убыванию пользы)
+
+- **Переписать перепись.** Прогнать `glcensus=1` на сценариях `rc.jobs.gfx` и `rc.jobs.fps` и
+ получить наконец полное число: по каким функциям CoreAnimation отказано и сколько отрисовок идёт
+ без программы. Сейчас известно только, что спрошено и отказано по двум (40 `sb3`, 60 `p3c`).
+- **Камера и Фото через `metal_test`.** Проверить, проходит ли ядро CoreImage на процессоре, и если
+ да — какие именно шаги конвейера снимка (`CMPhoto`, `HDRProcessing`, `Portrait`) всё же требуют
+ устройства. Это прямо касается ветки `camera`.
+- **Найти, у кого путь без Metal есть, но не выбирается.** Самое вероятное место, где можно что-то
+ выиграть малыми средствами: не подделывать Metal, а подталкивать к уже существующему запасному
+ пути — по образцу `inject.c`, который заменяет записи в таблицах виртуальных функций и уже
+ избавил сервер от попытки Metal каждый кадр.
+- **Не начинать (А) и (Б)** без фронтенда AIR. Если он когда-нибудь появится (чужой проект, не
+ этот), раздел 4 перечисляет, что останется сделать; до тех пор объём работы не уменьшится.
diff --git a/userland/build.sh b/userland/build.sh
index 48b6213..86d3e6d 100755
--- a/userland/build.sh
+++ b/userland/build.sh
@@ -129,6 +129,9 @@ if [ -d $IOS/rootfs/usr/lib ]; then
$DYN -o obj/cpu_test src/cpu_test.c
$DYN -framework CoreFoundation -framework IOSurface -o obj/cow_test src/cow_test.c
$DYN -framework CoreFoundation -framework CoreGraphics -framework IOSurface -o obj/cg_test src/cg_test.c
+ # what iOS here believes about Metal, and what CoreImage does without it (src/metal_test.m)
+ $DYN -fobjc-arc -framework Foundation -framework CoreGraphics -framework CoreImage \
+ -framework IOKit -framework Metal -lMobileGestalt -o obj/metal_test src/metal_test.m
$DYN -o obj/shm_test src/shm_test.c
$DYN -o obj/apfs_mmap_test src/apfs_mmap_test.c
$DYN -o obj/vol_ls src/vol_ls.c
@@ -180,6 +183,7 @@ if [ -d $IOS/rootfs/usr/lib ]; then
[ -f obj/vol_ls ] && cp obj/vol_ls root/bin/
[ -f obj/snap_test ] && cp obj/snap_test root/bin/
[ -f obj/font_test ] && cp obj/font_test root/bin/
+ [ -f obj/metal_test ] && cp obj/metal_test root/bin/
[ -f obj/net_test ] && cp obj/net_test root/bin/
[ -f obj/battery_test ] && cp obj/battery_test root/bin/
[ -f obj/keychain_test ] && cp obj/keychain_test root/bin/
diff --git a/userland/rc.jobs.metal b/userland/rc.jobs.metal
new file mode 100644
index 0000000..b81792e
--- /dev/null
+++ b/userland/rc.jobs.metal
@@ -0,0 +1,6 @@
+# Commands run by the launchd job com.redwood.demo (see com.redwood.demo.plist).
+# What iOS here believes about Metal (RC_JOBS=rc.jobs.metal, a run of half a minute): the services Metal
+# looks for and does not find, the GPU the registry does have under another name, whether a plug-in bundle
+# of this image would load at all, the nil a program gets, what MobileGestalt still says about graphics,
+# and whether CoreImage can run a filter kernel without Metal. See src/metal_test.m and docs/metal.md.
+/redwood/bin/metal_test
diff --git a/userland/src/metal_test.m b/userland/src/metal_test.m
new file mode 100644
index 0000000..4745050
--- /dev/null
+++ b/userland/src/metal_test.m
@@ -0,0 +1,308 @@
+/*
+ * metal_test: what iOS here believes about Metal, and what it does with the answer.
+ *
+ * Nothing in iOS says a word when Metal is missing. A program asks for the system's device with
+ * MTLCreateSystemDefaultDevice(); if there is none it gets nil, with no log line, no error and no
+ * reason, and whatever the caller does next -- fall back, draw nothing, or stop at an assertion --
+ * is all that is ever seen. This prints the whole chain instead, so that a failure somewhere above
+ * can be told from a failure here.
+ *
+ * The chain is short, and every step of it is checked below:
+ *
+ * 1. Metal's MTLRegisterDevices() asks IOKit for the services of class "IOAcceleratorES" --
+ * that name, and no other, is the whole of how a GPU is found;
+ * 2. of each such service it reads two string properties, "MetalPluginName" and
+ * "MetalPluginClassName";
+ * 3. it loads /System/Library/Extensions/<MetalPluginName>.bundle and takes the class named by
+ * MetalPluginClassName, or the bundle's principal class;
+ * 4. the class must be a subclass of Metal's own private _MTLDevice, or it is dropped;
+ * 5. it is sent -initWithAcceleratorPort: with the service, and that object is the device.
+ * MTLCreateSystemDefaultDevice() hands out the one device of that list, under a dispatch_once:
+ * an empty list is an answer given once and kept, silently, for the life of the process.
+ *
+ * So the question "is there Metal" has exactly one answer, and no capability bit anywhere stands
+ * in for it. What iOS publishes about graphics besides -- MobileGestalt's GraphicsFeatureSetClass
+ * and GraphicsFeatureSetFallbacks, from the device tree's "graphics-featureset-class" and
+ * "graphics-featureset-fallbacks" -- is read by CoreUI and CoreThemeDefinition to choose which
+ * compiled artwork to take out of an asset catalog, not by anything that decides how to draw; it
+ * is printed here to show that it says the iPhone X's "APPLE4" whether or not a device exists.
+ *
+ * The last part asks a framework that has a path without Metal whether that path works: CoreImage
+ * runs a filter kernel over four pixels and the result is read back. It is the one thing here that
+ * can answer "can this system process an image at all", which the camera and Photos both need.
+ *
+ * usage: metal_test
+ */
+#import <CoreFoundation/CoreFoundation.h>
+#import <CoreImage/CoreImage.h>
+#import <Foundation/Foundation.h>
+#import <IOKit/IOKitLib.h>
+#import <Metal/Metal.h>
+#import <objc/runtime.h>
+#import <stdio.h>
+
+extern CFTypeRef MGCopyAnswer(CFStringRef key);
+
+#define EXTENSIONS "/System/Library/Extensions"
+
+/* A string property of an IOKit service, or NULL; the caller frees it. */
+static char *
+service_string(io_service_t service, const char *name)
+{
+ CFStringRef key = CFStringCreateWithCString(NULL, name, kCFStringEncodingUTF8);
+ CFTypeRef value = IORegistryEntryCreateCFProperty(service, key, NULL, 0);
+ char *text = NULL;
+
+ CFRelease(key);
+ if (value != NULL) {
+ if (CFGetTypeID(value) == CFStringGetTypeID()) {
+ text = calloc(1, 256);
+ if (text != NULL && !CFStringGetCString(value, text, 256, kCFStringEncodingUTF8)) {
+ free(text);
+ text = NULL;
+ }
+ }
+ CFRelease(value);
+ }
+ return text;
+}
+
+/* Step 1 and 2: the services Metal looks for, and the two properties it reads of each. */
+static int
+accelerators(void)
+{
+ io_iterator_t it = IO_OBJECT_NULL;
+ CFMutableDictionaryRef matching = IOServiceMatching("IOAcceleratorES");
+ kern_return_t kr;
+ io_service_t service;
+ int found = 0;
+
+ if (matching == NULL) {
+ printf("metal_test: IOServiceMatching(\"IOAcceleratorES\") failed\n");
+ return 0;
+ }
+ /* IOServiceGetMatchingServices consumes the dictionary. */
+ kr = IOServiceGetMatchingServices(MACH_PORT_NULL, matching, &it);
+ if (kr != KERN_SUCCESS) {
+ printf("metal_test: IOServiceGetMatchingServices failed, %#x\n", kr);
+ return 0;
+ }
+ while ((service = IOIteratorNext(it)) != IO_OBJECT_NULL) {
+ io_name_t name = { 0 };
+ char *plugin = service_string(service, "MetalPluginName");
+ char *class_name = service_string(service, "MetalPluginClassName");
+
+ IORegistryEntryGetName(service, name);
+ printf("metal_test: IOAcceleratorES \"%s\": MetalPluginName %s, MetalPluginClassName %s\n",
+ name, plugin ? plugin : "(none)", class_name ? class_name : "(none)");
+ free(plugin);
+ free(class_name);
+ IOObjectRelease(service);
+ found++;
+ }
+ IOObjectRelease(it);
+ if (found == 0) {
+ printf("metal_test: none: Metal will find no device at all\n");
+ }
+ return found;
+}
+
+/* What the registry does have that looks like a GPU, whatever its class is called. */
+static void
+gpu_services(void)
+{
+ static const char *const classes[] = { "RedwoodGPU", "IOGPU", "AGXAccelerator", "IOAccelerator" };
+ int found = 0;
+
+ for (size_t i = 0; i < sizeof(classes) / sizeof(classes[0]); i++) {
+ CFMutableDictionaryRef matching = IOServiceMatching(classes[i]);
+ io_iterator_t it = IO_OBJECT_NULL;
+ io_service_t service;
+
+ if (matching == NULL || IOServiceGetMatchingServices(MACH_PORT_NULL, matching, &it) != KERN_SUCCESS) {
+ continue;
+ }
+ while ((service = IOIteratorNext(it)) != IO_OBJECT_NULL) {
+ io_name_t name = { 0 };
+ char *client = service_string(service, "IOUserClientClass");
+
+ IORegistryEntryGetName(service, name);
+ printf("metal_test: %s \"%s\": IOUserClientClass %s\n", classes[i], name,
+ client ? client : "(none)");
+ free(client);
+ IOObjectRelease(service);
+ found++;
+ }
+ IOObjectRelease(it);
+ }
+ if (found == 0) {
+ printf("metal_test: none\n");
+ }
+}
+
+/* Steps 3 and 4: could a plug-in bundle in this image be loaded and taken for a device at all. */
+static void
+plugins(void)
+{
+ NSFileManager *files = [NSFileManager defaultManager];
+ NSArray<NSString *> *entries = [files contentsOfDirectoryAtPath:@EXTENSIONS error:NULL];
+ Class device_class = objc_getClass("_MTLDevice");
+ int bundles = 0;
+
+ printf("metal_test: Metal's own base class _MTLDevice: %s\n", device_class ? "there" : "not there");
+ if (entries == nil) {
+ printf("metal_test: %s is not in this image: no plug-in could be loaded\n", EXTENSIONS);
+ return;
+ }
+ for (NSString *entry in entries) {
+ if (![entry hasSuffix:@".bundle"]) {
+ continue;
+ }
+ NSString *path = [@EXTENSIONS stringByAppendingPathComponent:entry];
+ NSBundle *bundle = [NSBundle bundleWithPath:path];
+ NSString *executable = [bundle objectForInfoDictionaryKey:@"CFBundleExecutable"];
+ NSString *principal = [bundle objectForInfoDictionaryKey:@"NSPrincipalClass"];
+ Class loaded = Nil;
+ const char *verdict;
+
+ bundles++;
+ /* Taking the class is what loads the bundle's code; it is the step that fails first. */
+ loaded = principal != nil ? [bundle classNamed:principal] : [bundle principalClass];
+ if (loaded == Nil) {
+ verdict = "the class does not load";
+ } else if (device_class == Nil) {
+ verdict = "loaded, but there is no _MTLDevice to compare it with";
+ } else if ([loaded isSubclassOfClass:device_class]) {
+ verdict = "loaded, and a _MTLDevice: Metal would take it";
+ } else {
+ verdict = "loaded, but not a _MTLDevice: Metal would drop it";
+ }
+ printf("metal_test: %s: executable %s, principal class %s -- %s\n", [entry UTF8String],
+ executable ? [executable UTF8String] : "(none)",
+ principal ? [principal UTF8String] : "(none)", verdict);
+ }
+ if (bundles == 0) {
+ printf("metal_test: no .bundle in %s\n", EXTENSIONS);
+ }
+}
+
+/* Step 5, as a program sees it. */
+static void
+the_device(void)
+{
+ id<MTLDevice> device = MTLCreateSystemDefaultDevice();
+
+ if (device == nil) {
+ printf("metal_test: MTLCreateSystemDefaultDevice() = nil (and says nothing about why)\n");
+ return;
+ }
+ printf("metal_test: MTLCreateSystemDefaultDevice() = \"%s\", class %s\n",
+ [[device name] UTF8String], class_getName([(id)device class]));
+ printf("metal_test: registry id %llu, unified memory %d, max threads per group %lu, "
+ "Apple family 1/4 %d/%d\n", (unsigned long long)[device registryID], (int)[device hasUnifiedMemory],
+ (unsigned long)[device maxThreadsPerThreadgroup].width,
+ (int)[device supportsFamily:MTLGPUFamilyApple1], (int)[device supportsFamily:MTLGPUFamilyApple4]);
+}
+
+/* What iOS publishes about graphics besides: artwork, not rendering (see the note above). */
+static void
+gestalt(void)
+{
+ static const char *const keys[] = {
+ "GraphicsFeatureSetClass", "GraphicsFeatureSetFallbacks", "ArtworkDeviceSubType",
+ "HasExtendedColorDisplay", "main-screen-class", "DeviceSupportsMetal",
+ };
+
+ for (size_t i = 0; i < sizeof(keys) / sizeof(keys[0]); i++) {
+ CFStringRef key = CFStringCreateWithCString(NULL, keys[i], kCFStringEncodingUTF8);
+ CFTypeRef answer = MGCopyAnswer(key);
+ CFStringRef text = answer ? CFCopyDescription(answer) : NULL;
+ char line[256] = "(none)";
+
+ if (text != NULL) {
+ CFStringGetCString(text, line, sizeof(line), kCFStringEncodingUTF8);
+ CFRelease(text);
+ }
+ printf("metal_test: %s = %s\n", keys[i], line);
+ if (answer != NULL) {
+ CFRelease(answer);
+ }
+ CFRelease(key);
+ }
+}
+
+/*
+ * A framework that has a path without Metal: CoreImage. A filter kernel is run over four pixels
+ * and the result read back, which tells whether this system can process an image at all.
+ */
+static void
+coreimage(void)
+{
+ @autoreleasepool {
+ CIContext *context = [CIContext contextWithOptions:nil];
+ CIImage *source, *result;
+ CIFilter *filter;
+ CGImageRef image;
+ CGRect rect = CGRectMake(0, 0, 4, 4);
+ unsigned char pixels[4 * 4 * 4];
+ CGColorSpaceRef space;
+ CGContextRef bitmap;
+
+ if (context == nil) {
+ printf("metal_test: no CIContext: CoreImage cannot work here\n");
+ return;
+ }
+ printf("metal_test: CIContext: %s\n", class_getName([context class]));
+ /* orange, inverted by a kernel: 1, 0.5, 0 -> 0, 0.5, 1 */
+ source = [[CIImage imageWithColor:[CIColor colorWithRed:1.0 green:0.5 blue:0.0]]
+ imageByCroppingToRect:rect];
+ filter = [CIFilter filterWithName:@"CIColorInvert"];
+ if (filter == nil) {
+ printf("metal_test: no CIColorInvert filter\n");
+ return;
+ }
+ [filter setValue:source forKey:kCIInputImageKey];
+ result = [filter valueForKey:kCIOutputImageKey];
+ if (result == nil) {
+ printf("metal_test: the filter gave no image\n");
+ return;
+ }
+ image = [context createCGImage:result fromRect:rect];
+ if (image == NULL) {
+ printf("metal_test: CoreImage did not render: a filter kernel cannot run here\n");
+ return;
+ }
+ memset(pixels, 0, sizeof(pixels));
+ space = CGColorSpaceCreateDeviceRGB();
+ bitmap = CGBitmapContextCreate(pixels, 4, 4, 8, 4 * 4, space,
+ kCGImageAlphaPremultipliedLast | kCGBitmapByteOrder32Big);
+ if (bitmap != NULL) {
+ CGContextDrawImage(bitmap, rect, image);
+ printf("metal_test: CoreImage rendered: first pixel %u %u %u %u (inverted orange is about 0 128 255 255)\n",
+ pixels[0], pixels[1], pixels[2], pixels[3]);
+ CGContextRelease(bitmap);
+ } else {
+ printf("metal_test: CoreImage rendered, but the pixels could not be read back\n");
+ }
+ CGColorSpaceRelease(space);
+ CGImageRelease(image);
+ }
+}
+
+int
+main(void)
+{
+ printf("metal_test: the services Metal looks for (IOAcceleratorES)\n");
+ accelerators();
+ printf("metal_test: what the registry has that is a GPU\n");
+ gpu_services();
+ printf("metal_test: the plug-in bundles of %s\n", EXTENSIONS);
+ plugins();
+ printf("metal_test: the device a program gets\n");
+ the_device();
+ printf("metal_test: what iOS publishes about graphics (artwork, not rendering)\n");
+ gestalt();
+ printf("metal_test: CoreImage, which has a path without Metal\n");
+ coreimage();
+ return 0;
+}