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

All seven cores the best setting: the small ones start once the lock screen is there

vcvkk185aa047c224
diff --git a/README.md b/README.md
index 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 #
```sh
tools/mk-mesa.sh
GL=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-шейдер в TrustZone
diff --git a/xnu/files/iokit/Kernel/GenericARMPE.cpp b/xnu/files/iokit/Kernel/GenericARMPE.cpp
index 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);
}