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
All seven cores the best setting: the small ones start once the lock screen is there
vcvkk185aa047c224
diff --git a/README.md b/README.mdindex 6722a71..82c36ce 100644--- a/README.md+++ b/README.md@@ -29,7 +29,7 @@| Системные жесты: свайп снизу — «домой» и переключатель приложений, свайп от левого края — «назад», Пункт управления | Без `gpu=1` (программный рендер; в QEMU всегда) часы экрана блокировки просто белые, без «вибрации» под цвет обоев, и верх обоев под ними не затемнён || Запуск приложений: Настройки (вглубь), Часы, Календарь, Фото, Заметки и др.; расширения приложений (виджеты «Погода» и «Календарь» на домашнем экране рисуют своё содержимое — на телефоне; в QEMU им не хватает скорости) | Metal (приложения, рисующие через него сами); отрисовка самим Adreno есть, но пока опытная — см. «GPU» || Сенсорный экран телефона (Goodix GT9916), мультитач, пробуждение касанием | Без `cpus=N` работает одно ядро процессора |-| Несколько ядер процессора (`cpus=4`: четыре больших ядра телефона) | |+| Несколько ядер процессора (`cpus=8`: все семь, что не заняты загрузчиком; малые — после больших) | || Кнопки: на телефоне настоящие — питание (боковая кнопка iPhone) и громкость; в QEMU — клавишами | Зарядка под нашим ядром (телефон только разряжается) || Большое ядро на 2,4 ГГц, загрузка до экрана блокировки ~20 с (телефон) | Safari (лежит в отдельном «App cryptex», которого у нас нет) || Снимки экрана и запись экрана с телефона | Сохранение данных: /private/var в памяти, каждая загрузка — «новое устройство» |@@ -132,7 +132,7 @@ AUDIO=pipewire qemu/run-ios.sh 1200 -display gtk > logs/qemu.log # или AUDстрокой, пароль второй (оба файла в git не попадают; `userland/build.sh` кладёт второй в малый образ, накомандную строку ядра он не идёт, в журнал пишутся только длины). Затем `tools/mk-ath11k.sh`, `./xnu-build.sh`,`GL=1 REST=1 userland/build.sh`, и к обычной командной строке сеанса добавляется одно слово:- `XL_CMDLINE="touchscreen=1 cpufreq=1 bootcpu=7 cpus=4 gpu=1 wifi=1" ./xl run`. Радио поднимается рядом с+ `XL_CMDLINE="touchscreen=1 cpufreq=1 bootcpu=7 cpus=8 gpu=1 wifi=1" ./xl run`. Радио поднимается рядом сзагрузкой системы и её не задерживает (сеть есть через 12 секунд после старта ядра), интерфейс — тот же `en0`;настроить его просит configd задание `com.redwood.wifi`, которое есть в каждом образе и без `wifi=1` ничего неделает. Без прошивки ядро говорит об этом одной строкой и идёт дальше; без файла сети радио поднимается, но ни к@@ -169,7 +169,7 @@ AUDIO=pipewire qemu/run-ios.sh 1200 -display gtk > logs/qemu.log # или AUD```sh./xl enter # Android → fastboot → наш загрузчик в ОЗУ (fastboot boot), он поднимает свой USB-канал./xl ramdisk # залить образ системы в ОЗУ телефона (2,5 ГБ, ~80 с) — один раз на сеанс загрузчика-XL_SECS=900 XL_CMDLINE="touchscreen=1 cpufreq=1 bootcpu=7 cpus=4" ./xl run # 15 минут iOS+XL_SECS=900 XL_CMDLINE="touchscreen=1 cpufreq=1 bootcpu=7 cpus=8" ./xl run # 15 минут iOS./xl screenshot shot.png # что осталось на экране после возврата./xl reboot # обратно в Android```@@ -213,7 +213,7 @@ XL_SECS=900 XL_CMDLINE="touchscreen=1 cpufreq=1 bootcpu=7 cpus=4" ./xl run #| `buttons=0` | не читать кнопки телефона. Вместе с `touchscreen=1` они включены: питание — боковая кнопка, громкость вверх и вниз (опрос микросхемы питания раз в 16 мс, только чтение). Не держать питание дольше 5 с: 10–15 с сбрасывают телефон || `autounlock=0` | экран блокировки остаётся, пока его не смахнут вверх, как на iPhone. По умолчанию SpringBoard сам убирает его через 10 с (на случай, если сенсор ещё не ожил) || `bootcpu=7` | запустить ядро на самом большом ядре процессора (загрузчик остаётся на нулевом и наблюдает) |-| `cpus=N` | использовать N ядер процессора: то, на котором ядро запущено, и ещё N−1 ближайших к нему по номеру (после 7 — 6, 5, 4, потом малые 3, 2, 1); их запускает само ядро через PSCI. `cpumask=M` — выбрать по позиции в этом порядке (бит 0 — загрузочное). Без параметра — одно ядро. На телефоне ядру достаётся не больше семи: нулевое занято загрузчиком, который наблюдает за сеансом. Малые ядра (Cortex-A55, в 2,5 раза медленнее больших) загрузчик помечает в дереве устройств (`small-core`), и планировщик берёт их, только когда все большие заняты: каждое малое — пара своему большому, как второй поток ядра с гиперпотоками у XNU, но без его ограничений, а поток с малого ядра переводится на большое, как только то освободилось. `small_cores=0` — все ядра одинаковы, как было раньше (тогда `cpus=8` заметно медленнее `cpus=4`); `small_cores=1` — пары ровно как у гиперпотоков XNU. Нужен загрузчик от 15 октября (`./xl reload`): со старым малые ядра не помечены |+| `cpus=N` | использовать N ядер процессора: то, на котором ядро запущено, и ещё N−1 ближайших к нему по номеру (после 7 — 6, 5, 4, потом малые 3, 2, 1); их запускает само ядро через PSCI. `cpumask=M` — выбрать по позиции в этом порядке (бит 0 — загрузочное). Без параметра — одно ядро. На телефоне ядру достаётся не больше семи: нулевое занято загрузчиком, который наблюдает за сеансом. Малые ядра (Cortex-A55, в 2,5 раза медленнее больших) загрузчик помечает в дереве устройств (`small-core`), и планировщик берёт их, только когда все большие заняты: каждое малое — пара своему большому, как второй поток ядра с гиперпотоками у XNU, но без его ограничений, а поток с малого ядра переводится на большое, как только то освободилось. `small_cores=0` — все ядра одинаковы, как было раньше (тогда `cpus=8` заметно медленнее `cpus=4`); `small_cores=1` — пары ровно как у гиперпотоков XNU. Малые ядра запускаются через 28 с после остальных, когда экран блокировки уже готов (`small_cores_after=S`, 0 — сразу). Нужен загрузчик от 15 октября (`./xl reload`): со старым малые ядра не помечены. Лучший вариант — `cpus=8` || `cpuload=MS` | каждые MS миллисекунд строка `tl: u` о том, насколько было занято каждое ядро процессора (в процентах; `tools/frames.py` показывает это по жестам) || `cpufreq=1` | поднять частоту до максимума (иначе 300 МГц) всем группам ядер, в которых есть наши || `rec_secs=N` | записывать экран N секунд (`rec_start=S`, `rec_mb=M`, не больше 640); потом `./xl recording out.mp4`. `rec_ring=1` — по кругу: когда память кончилась, запись идёт поверх самых старых кадров, и к концу сеанса в ней последнее (для того, что случается раз за долгий сеанс: сеанс кончают сразу после — пятью пальцами); `rec_step=N` — каждый N-й пиксель вместо третьего (4 — в 1,8 раза больше кадров). Память на запись отнимается у системы на весь сеанс: с `rec_mb=640` в долгом сеансе iOS убивала процессы ради памяти, вплоть до SpringBoard (респринги), с 256 — нет. `XL_REC_KEEP=1 ./xl recording` оставляет саму запись в `logs/recording.raw`; `tools/recording.py logs/recording.raw out.mp4 --frames DIR` раскладывает её на кадры с именами по времени ядра в миллисекундах — тому же, что в строках `glframes=1` |@@ -251,10 +251,12 @@ XL_SECS=900 XL_CMDLINE="touchscreen=1 cpufreq=1 bootcpu=7 cpus=4" ./xl run #том же сценарии `cpus=4` (четыре больших ядра: 7, 6, 5, 4) дал 929 кадров вместо 671 на одном ядре, пики 35кадров/с вместо 19, SpringBoard готов на 7 секунд раньше. Все семь (`cpus=8`) раньше были хуже четырёх:планировщик не знал, что ядра 1–3 малые, и сажал на них интерфейс (84 % кадров дольше 16,7 мс против 46 %,-копирование кадра на панель 15 мс вместо 4). Теперь малые ядра помечены (см. `cpus=N` в таблице), и `cpus=8`-вровень с `cpus=4` по кадрам (`rc.jobs.fps`, трижды: 39 % и 35 % кадров дольше 16,7 мс, 8 % и 7 % дольше 33 мс),-а вся работа запуска кончается на 2–4 с раньше (36–38 с против 40); экран блокировки при этом готов на ~1 с-позже (27,5 с против 26,7: малые ядра делят с большими память и кэш, пока все семь заняты запуском). Паника «Ticket spinlock … timeout» значила бы, что ядрам тесно+копирование кадра на панель 15 мс вместо 4). Теперь малые ядра помечены (см. `cpus=N` в таблице), и **`cpus=8`+не медленнее `cpus=4` ни в чём**: по кадрам вровень (`rc.jobs.fps`, трижды, с голосом за память и двумя кадрами в+очереди: 28–29 % кадров дольше 16,7 мс и 6 % дольше 33 мс у обоих), экран блокировки готов через 25,2–25,3 с после+старта ядра (у `cpus=4` — 25,3–25,5), а вся работа запуска кончается раньше (36 с против 38). Для этого малые ядра+запускаются через 28 с после остальных (`small_cores_after=S`, 0 — сразу): когда они работали с самого начала,+экран блокировки был готов на 1,5 с позже (они делят с большими память и кэш, пока все семь заняты запуском). Паника «Ticket spinlock … timeout» значила бы, что ядрам тесново времени (в QEMU загрузчик сам увеличивает эти сроки в 20 раз): помогает `ml-timeout-global-scale=4`.## GPU@@ -278,7 +280,7 @@ XL_SECS=900 XL_CMDLINE="touchscreen=1 cpufreq=1 bootcpu=7 cpus=4" ./xl run #```shtools/mk-mesa.shGL=1 REST=1 userland/build.sh-XL_CMDLINE="touchscreen=1 cpufreq=1 bootcpu=7 cpus=4 gpu=1" ./xl run+XL_CMDLINE="touchscreen=1 cpufreq=1 bootcpu=7 cpus=8 gpu=1" ./xl run````gpu=1` — всё, что нужно сказать: ядро само запускает GPU и само выгружает и загружает zap-шейдер в TrustZonediff --git a/xnu/files/iokit/Kernel/GenericARMPE.cpp b/xnu/files/iokit/Kernel/GenericARMPE.cppindex 4ed7f0f..cfaa292 100644--- a/xnu/files/iokit/Kernel/GenericARMPE.cpp+++ b/xnu/files/iokit/Kernel/GenericARMPE.cpp@@ -18,6 +18,7 @@ extern "C" {#include <IOKit/IOLib.h>#include <IOKit/IOCPU.h>#include <kern/clock.h>+#include <kern/thread_call.h>#include "MiniDrivers.h"@@ -221,7 +222,7 @@ GenericARMPE::start(IOService * provider)* one the kernel has a number for, register them all -- that settles the CPU count --* and then start them, the boot processor (number master_cpu) first.*/- GenericARMCPU * cpus[MAX_CPUS] = {};+ static GenericARMCPU * cpus[MAX_CPUS]; /* (static: the slower cores may be started later, see below) */unsigned int count = 0;OSIterator * iter = getChildIterator(gIOServicePlane);if (iter != NULL) {@@ -254,12 +255,41 @@ GenericARMPE::start(IOService * provider)if (count > 1) {psci_smp_init();}+ /*+ * The slower cores (an L2 access penalty, the loader's "small-core") are started 28 seconds+ * later (boot-arg small_cores_after=S; 0: at once). With all seven from the start the lock+ * screen came 1.5 s later than with the four big ones alone (26.5-27.0 s after the kernel+ * began instead of 25.3-25.5: start-up's other work shares memory and cache with+ * SpringBoard's), while that work as a whole was done earlier (34 s instead of 38). With+ * the slower cores joining once the lock screen is there: 25.3 s and 36 s.+ */+ uint32_t later = 28;+ static thread_call_t later_call;++ PE_parse_boot_argn("small_cores_after", &later, sizeof(later));cpus[master_cpu]->run();for (unsigned int number = 0; number < MAX_CPUS; number++) {if (cpus[number] != NULL && number != (unsigned int)master_cpu) {+ if (later != 0 && ml_get_topology_info()->cpus[number].l2_access_penalty != 0) {+ continue;+ }cpus[number]->run();}}+ if (later != 0) {+ uint64_t deadline;++ later_call = thread_call_allocate([](thread_call_param_t, thread_call_param_t) {+ for (unsigned int number = 0; number < MAX_CPUS; number++) {+ if (cpus[number] != NULL && ml_get_topology_info()->cpus[number].l2_access_penalty != 0) {+ cpus[number]->run();+ }+ }+ IOLog("GenericARMPE: the slower cores started too: %u processors running\n", processor_avail_count);+ }, NULL);+ clock_interval_to_deadline(later, NSEC_PER_SEC, &deadline);+ thread_call_enter_delayed(later_call, deadline);+ }if (count > 1) {IOLog("GenericARMPE: %u of %u processors are running\n", processor_avail_count, count);}