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
The data volume on the phone: the read path mended, the write window agreed with the loader
vcvkkda2f69976de7
diff --git a/README.md b/README.mdindex e7bb542..c195268 100644--- a/README.md+++ b/README.md@@ -33,7 +33,8 @@| Кнопки: на телефоне настоящие — питание (боковая кнопка iPhone) и громкость; в QEMU — клавишами | Зарядка под нашим ядром (телефон только разряжается) || Большое ядро на 2,4 ГГц, загрузка до экрана блокировки ~20 с (телефон) | || Safari: открывает страницы (на телефоне — через его Wi-Fi), его службы — из криптекса App, как на iPhone (см. «Только APFS, как на iPhone») | |-| Снимки экрана и запись экрана с телефона | Сохранение данных: /private/var в памяти, каждая загрузка — «новое устройство» |+| Снимки экрана и запись экрана с телефона | |+| Сохранение данных: то, что iOS записала в `/private/var`, переживает перезагрузку телефона — архивом в разделе `darwin` (`var_store=1 ufs_write=1`, см. «Том данных между загрузками») | || Звук iOS в QEMU (см. ниже; с громкостью; «Сейчас играет» — с оговоркой) | Динамики и микрофоны самого телефона: под нашим ядром они молчат |Это стенд для исследования, а не прошивка: сеанс длится заданное число секунд, потом ядро возвращается в загрузчик@@ -150,7 +151,7 @@ codec DMA TX_CDC_DMA_TX_3 и звуковой процессор в поток,разблокировано: программы записывают в неё пароли и читают их обратно (wifid — пароли сетей, подключённых изНастроек). Это не защищённая связка: Secure Enclave нет, ключи классов защиты заменяет обратимоепреобразование в ядре (`iokit/Kernel/MiniAppleKeyStore.cpp`), и всё записанное лежит в `/private/var`, то есть в- памяти, и пропадает при следующем старте. Проверка: `/redwood/bin/keychain_test` (подписывается `ldid`+ памяти; без `var_store=1` оно пропадает при следующем старте (см. «Том данных между загрузками»). Проверка: `/redwood/bin/keychain_test` (подписывается `ldid`с группой доступа к связке; без `ldid` связка такой программе отказывает).- **Wi-Fi телефона (опытно): `wifi=1`.** Радио телефона подключается к одной сети WPA2 с паролем, и iOS выходитчерез него в интернет: адрес по DHCP, DNS, HTTPS. Нужны прошивка радио в `fw-wifi/` (см. `wifi_step=N` в@@ -869,7 +870,7 @@ APFS, и все их читает тот же драйвер APFS ядра, чт| криптекс OS (общий кеш dyld) | образ `Cryptex1,SystemOS` на томе Preboot, привит (`graftdmg`) на `/private/preboot/Cryptexes/OS`, куда ведёт `/System/Cryptexes/OS` | образ Apple как есть (2,5 ГБ) — контейнер 1 раздела `darwin` на флеше, на том же месте (или второй контейнер `flashboot.apfs`: пересобранный, 1 ГБ); в `system.apfs` — каталог `/System/Cryptexes/OS` || криптекс App (службы Safari) | `Cryptex1,AppOS` на `/private/preboot/Cryptexes/App`, куда ведёт `/System/Cryptexes/App` | образ Apple байт в байт (10 МБ) — контейнер 2 раздела `darwin`, на том же месте (или третий контейнер `flashboot.apfs`); в `system.apfs` — каталог `/System/Cryptexes/App` || Preboot | том Preboot | загрузочный том `flashboot.apfs` (`stage0`, прошивки звукового процессора, точки монтирования), после смены корня — на `/private/preboot` |-| Data (`/private/var`) | том Data | ramfs: каждая загрузка — «новое устройство» |+| Data (`/private/var`) | том Data | ramfs; с `var_store=1` его содержимое переживает перезагрузку — архивом в свободном месте раздела `darwin` (см. «Том данных между загрузками») || — | — | `root.apfs` на `/redwood`: наш init, программы, библиотеки-вставки, задания launchd, прошивки GPU и Wi-Fi || образ | контейнеров | размер | был packfs |@@ -962,7 +963,7 @@ IPSW, — лежат в разделе `darwin` сразу за томом iOS,| 0–1 374 207 | 0 | том iOS (`rootfs.apfs`), не тронут | `9f430a58…` || 1 374 208–2 039 807 | 5 628 755 968 | криптекс OS: `096-04666-078.dmg` (`Cryptex1,SystemOS`), том `SydneyF20F66.D22D221SystemCryptex` | `2279bf44…` || 2 039 808–2 042 367 | 8 355 053 568 | криптекс App: `096-03536-083.dmg` (`Cryptex1,AppOS`), том `AppCryptex` | `6b9d1f09…` |-| 2 042 368–5 242 874 | 8 365 539 328 | нули: контейнера 3 нет, ядро отвечает `EINVAL` | |+| 2 042 368–5 242 874 | 8 365 539 328 | нули: контейнера 3 нет, ядро отвечает `EINVAL`; с 2 097 152 здесь лежит архив тома данных (см. «Том данных между загрузками») — единственное, куда порт пишет | |**Как записано.** Только из Android и только `tools/darwin-write.py`. Перед каждой записью он читает с телефоназаново и сверяет с константами: GPT логического устройства 0 (CRC заголовка и таблицы, запись 34 «darwin», её GUID@@ -1003,6 +1004,107 @@ iOS, на блок за концом раздела, нули в суперблОтпечаток флеша после всех этих загрузок (обзор загрузчика и сторона Android) — тот же, что до записи.+### Том данных между загрузками++`/private/var` — файловая система в памяти (`bsd/miscfs/ramfs`): `init` монтирует её пустой при каждой загрузке и+создаёт в ней каталоги шаблона, который iOS носит в своём образе (`ios165/mkvarskel.py` → `ios165/var.skel`,+`init.c`, `mount_writable`). Поэтому ничто, что iOS туда записала, не переживало ту самую загрузку, в которую+было записано: ни раскладка домашнего экрана (`/var/mobile/Library/SpringBoard/IconState.plist`), ни данные+приложений (`/var/mobile/Containers/Data/Application/…`), ни снимки окон, ни запечённые обои — каждая загрузка+была «новым устройством». Том в памяти потому, что драйвер APFS ядра читает и не пишет, а оба пути ядра к+накопителю телефона были «только чтение по построению».++Сделан не «APFS на запись», а копия дерева. `/redwood/bin/var_store` (`userland/src/var_store.c`) упаковывает+`/private/var` в простой архив и пишет его в единственное место флеша, которое принадлежит порту и которое ничто+в нём не читает, — в раздел `darwin`, за томом iOS и двумя криптексами; `init` при следующей загрузке+распаковывает архив поверх шаблона (`var_store=1`). Имя, которое есть и в шаблоне, и в архиве, выходит таким,+каким его сохранили; что сделал шаблон, а в архиве этого нет, остаётся нетронутым.++| блоки `darwin` (по 4 КБ) | с байта | что |+|---|---|---|+| 0–2 042 367 | 0 | том iOS и криптексы (см. «Криптексы на флеше»); запись сюда отказывается |+| 2 042 368–2 097 151 | 8 365 539 328 | свободно |+| 2 097 152–2 621 439 | 8 589 934 592 | слот 0 архива: заголовок (один блок), за ним архив, 2 ГиБ всего |+| 2 621 440–3 145 727 | 10 737 418 240 | слот 1 архива |+| 3 145 728–5 242 874 | 12 884 901 888 | свободно |++**Два слота по очереди.** Пишется тот, в котором не лежит самый свежий хороший архив: сначала его заголовок+затирается нулями, потом идёт архив, и только в конце записывается заголовок. Поэтому прерванное сохранение+(телефон сброшен посередине) теряет сохранение, а не хранилище: в другом слоте остаётся архив с прошлого раза, а+`load` берёт слот с наибольшим номером поколения, у которого сходятся и контрольная сумма заголовка, и сумма+содержимого. Архив при загрузке читается дважды: первый раз — только чтобы проверить сумму, и лишь потом+создаются файлы. Так порванное хранилище оставляет `/private/var` ровно таким, каким его сделал шаблон, и не+может помешать телефону загрузиться.++**Что в архиве.** На каждую запись — вид (каталог, файл, символьная или жёсткая ссылка), права, владелец и+группа, флаги файла, время изменения, расширенные атрибуты (в них iOS держит метаданные контейнеров и многое+другое) и содержимое; путь — относительно `/private/var`, и распаковка отказывается делать имя, которое ведёт за+его пределы. Каталог попадает в архив дважды: перед своим содержимым и, маленькой записью, после него — иначе его+время изменения сбивалось бы созданием того, что в нём лежит. Жёсткая ссылка — это имя и имя, под которым этот же+inode встретился впервые. Не сохраняются сокеты, очереди и устройства (демоны новой загрузки делают свои) и+содержимое каталогов `tmp`, `run`, `vm`, `log`, `logs`, `db/diagnostics`, `db/uuidtext`, `jb` — там либо то, что+имеет смысл только в своей загрузке, либо то, что и так прививается из образа при каждой загрузке.++**Запись во флеш из ядра — новое, и ограничена трижды, и по умолчанию выключена** (`ufs_write=1`).++- Блочные устройства драйвера по-прежнему не пишут вовсе: `ufs_strategy` отвечает `EROFS`, а открытие на запись+ отказывается, — так что ничто, что смонтировано с такого устройства, писать не может.+- Записи принимает одно символьное устройство — `/dev/rufs_darwin`, — целыми блоками и только с блока 2 042 368:+ том iOS, криптексы и всё за концом раздела отказываются (`EROFS`). Раздел при этом должен быть тем самым, с+ которым порт настраивали: имя, первый LBA, число блоков, размер блока, первая логическая единица.+- Загрузчик проверяет то же самое заново и вдобавок GUID типа и уникальный GUID записи GPT (те же константы, что+ у `tools/darwin-write.py`), пишет только через `BlockIo` самого раздела, который UEFI ограничивает его+ границами, и каждую запись читает обратно и сверяет по CRC-32, прежде чем ответить ядру. Без `ufs_write=1` на+ его собственной командной строке он не предлагает ядру ни одного раздела, и ядро тогда не просит записи.+- У своего драйвера контроллера (`ufs_native=1`) в белом списке команд записи нет и не появилось. Поэтому на+ время записи его список запросов уходит из контроллера, и флеш снова ведёт драйвер UEFI, которого просит+ загрузчик; чтения в это время идут через загрузчик — медленнее и правильно. Список уходит один раз, с первой+ записи, и возвращается, когда устройство закрыли.+- Страница, через которую ядро говорит с загрузчиком, осталась той же версии и того же размера: поля о записи+ легли в то, что было выравнивающим зазором. Телефон один на несколько рабочих копий, и ядро, собранное до+ записи, читает через загрузчик, собранный после неё, и наоборот.++**Как запускать.**++```sh+CRYPTEXES=flash FLASHBOOT=1 GL=1 REST=1 RC_JOBS=rc.jobs.persist userland/build.sh+./xl ramdisk userland/flashboot.apfs+XL_CMDLINE="root_apfs=ufs_darwin ufs=2 ufs_native=1 ufs_write=1 var_store=1 bootcpu=7 cpus=8 cpufreq=1 touchscreen=1 gpu=1 adsp=1" XL_SECS=220 ./xl run+```++**Что показал телефон.** Два прогона с настоящим холодным сбросом между ними: `./xl reboot` в Android, снова в+загрузчик, `./xl ramdisk userland/flashboot.apfs` (21 МБ за секунду) и загрузка заново. Корень iOS при этом никуда+не девается — он на флеше; в ОЗУ телефона между прогонами только загрузочный том.++| | прогон 1 (14:51) | прогон 2 (14:56, после сброса) |+|---|---|---|+| хранилище в начале загрузки | `no store yet` | слот 0, поколение 1, 15 580 записей, 157 749 256 байт |+| распаковано | — | 6490 каталогов, 2401 файл (155 150 360 байт) |+| `/private/var/redwood-stamp` | `written by run of 1792410683` (своя метка) | `written by run of 1792410683` — **метка прогона 1**, за 276 с до начала этого |+| `IconState.plist` SpringBoard | 3630 байт, время 1792410708 | 3630 байт, время **1792410708** — то же, за 251 с до начала этого прогона |+| сохранено в конце | поколение 1 в слот 0 | поколение 2 в слот 1, 15 384 записи, 134 996 904 байта |+| записей во флеш (со стороны загрузчика) | 40, 157 761 536 байт, всё прочитано обратно и совпало, 0 отказано | 35, 135 008 256 байт, то же, 0 отказано |+| ramfs к концу прогона | 190 МБ | 182 МБ |+| упаковка и запись тома | ~7 с | ~7 с |++То есть на второй загрузке в `/private/var` лежат файлы первой, со временами первой, — и собственный файл-метка, и+то, что писала сама iOS: раскладка домашнего экрана (`IconState.plist`), `TodayViewArchive.plist`,+`SBLastRestoreIdentifier`, контейнеры приложений.++**Чего ещё нет.** Часть файлов на распаковке не поместилась (`No space left on device` на восьми файлах из 2401, в+сумме около 2,6 МБ): весь том идёт в память одним потоком, быстрее, чем `ramfs` успевает находить страницы, и она+отвечает коротким записью. Теперь короткая запись выжидается и повторяется, а файл, который так и не пошёл,+называется по имени в журнале; предел самой `ramfs` стоит отдельной работы. Ссылки в первом прогоне не+восстанавливались вовсе: имя уже было создано шаблоном, и `symlink` отказывал, — теперь имя шаблона уступает+хранилищу.++`var_store=1` — `init` распаковывает хранилище при загрузке; `ufs_write=1` — ядру и загрузчику разрешено писать,+без него сохранить не получится, а распаковать — получится. Сам `var_store`: `save` — упаковать `/private/var`,+`load` — распаковать, `show` — что лежит в обоих слотах, `erase` — забыть оба слота, `stamp ПУТЬ` — дописать в+файл строку о том, когда (метка прогона). Сценарий `userland/rc.jobs.persist` делает всё это по кругу: смотрит+хранилище, печатает строки прошлых прогонов и содержимое `/var/mobile/Library/SpringBoard` с временами, ставит+свою метку, две минуты не мешает iOS и сохраняет том.+## Снимки экранаВсё снято с экрана телефона за один сеанс: образ `GL=1 REST=1`, запуск с `gpu=1`, касания подаёт сценарийdiff --git a/userland/rc.jobs.persist b/userland/rc.jobs.persistindex 2dbcbe1..53710e7 100644--- a/userland/rc.jobs.persist+++ b/userland/rc.jobs.persist@@ -7,6 +7,7 @@# Run it twice over, with ./xl reboot in between: the second run's output holds the first run's# line and the first run's seconds, which is the whole point./redwood/bin/var_store show+/redwood/bin/vol_ls fs /private/var/redwood/bin/vol_ls cat /private/var/redwood-stamp 4096/redwood/bin/vol_ls ls /private/var/mobile/Library/SpringBoard/redwood/bin/var_store stamp /private/var/redwood-stamp@@ -16,4 +17,5 @@ sleep 120/redwood/bin/vol_ls cat /private/var/redwood-stamp 4096/redwood/bin/var_store save/redwood/bin/var_store show-/redwood/bin/vol_ls sysctl kern.redwood.ufs_writes kern.redwood.ufs_write_bytes kern.redwood.ufs_write_errors kern.redwood.ufs_write_refused+# (how many writes went into darwin, and that each was read back, is in the loader's own log at the+# end of the run: "ufs: N writes into darwin, M bytes, read back the same; K refused")diff --git a/userland/src/var_store.c b/userland/src/var_store.cindex bd80612..f41b202 100644--- a/userland/src/var_store.c+++ b/userland/src/var_store.c@@ -696,7 +696,7 @@ save(void)/* ---- unpacking ---- */-static uint64_t made_dirs, made_files, made_links, made_bytes;+static uint64_t made_dirs, made_files, made_links, made_bytes, short_files, lost_bytes;static intwhole_path(const char *relative, uint32_t len)@@ -766,7 +766,7 @@ unpack_one(int make)case ENT_FILE:out_fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, (int)e.mode);if (out_fd < 0) {- printf("var_store: %s: %s\n", path, strerror(errno));+ printf("var_store: %s cannot be made: %s\n", path, strerror(errno));} else {made_files++;}@@ -806,24 +806,49 @@ unpack_one(int make)/* the contents */if (e.kind == ENT_FILE) {static uint8_t piece[256 * 1024];- uint64_t left = e.size;+ uint64_t left = e.size, in_file = 0;while (left > 0) {- uint64_t want = left > sizeof(piece) ? sizeof(piece) : left;+ uint64_t want = left > sizeof(piece) ? sizeof(piece) : left, done = 0;if (!in(piece, want)) {ok = 0;break;}- if (out_fd >= 0 && write(out_fd, piece, (size_t)want) != (ssize_t)want) {- printf("var_store: %s: %s\n", path, strerror(errno));- close(out_fd);- out_fd = -1;+ /*+ * A whole data volume goes in at once, faster than the memory filesystem can find+ * pages for it, and it then says ENOSPC for want of one page rather than for want+ * of room (bsd/miscfs/ramfs, ramfs_grow_slots and the page limit). So a short write+ * is waited out and tried again, and only a file that will not go in at all after a+ * second of trying is given up on -- with its name, so it is known which.+ */+ while (out_fd >= 0 && done < want) {+ ssize_t wrote = write(out_fd, piece + done, (size_t)(want - done));+ static int tries;++ if (wrote > 0) {+ done += (uint64_t)wrote;+ tries = 0;+ continue;+ }+ if (++tries > 200) {+ printf("var_store: %s: %llu of %llu bytes, no more would go in: %s\n",+ path, (unsigned long long)(in_file + done),+ (unsigned long long)e.size, strerror(errno));+ short_files++;+ lost_bytes += e.size - in_file - done;+ close(out_fd);+ out_fd = -1;+ tries = 0;+ break;+ }+ usleep(5000);}+ in_file += done;left -= want;}if (make) {- made_bytes += e.size;+ made_bytes += in_file;}} else if (e.kind == ENT_SYMLINK || e.kind == ENT_HARDLINK) {static char target[MAX_PATH];@@ -835,6 +860,8 @@ unpack_one(int make)} else {target[e.size] = 0;if (make && e.kind == ENT_SYMLINK) {+ /* a name the skeleton made too comes out as the store has it */+ unlink(path);if (symlink(target, path) == 0) {made_links++;}@@ -846,6 +873,7 @@ unpack_one(int make)if (whole_path(target, (uint32_t)e.size)) {strcpy(from, path);strcpy(path, keep);+ unlink(path);if (link(from, path) == 0) {made_links++;}@@ -961,6 +989,10 @@ load(void)printf("var_store: %llu directories, %llu files (%llu bytes), %llu links back in /private/var\n",(unsigned long long)made_dirs, (unsigned long long)made_files, (unsigned long long)made_bytes,(unsigned long long)made_links);+ if (short_files != 0) {+ printf("var_store: %llu files did not fit: %llu bytes of them are not there\n",+ (unsigned long long)short_files, (unsigned long long)lost_bytes);+ }return 1;}diff --git a/xnu/files/bsd/dev/redwood_ufs.c b/xnu/files/bsd/dev/redwood_ufs.cindex daf69f4..7d9d2eb 100644--- a/xnu/files/bsd/dev/redwood_ufs.c+++ b/xnu/files/bsd/dev/redwood_ufs.c@@ -62,7 +62,7 @@ extern void FlushPoC_DcacheRegion(vm_offset_t va, size_t length); /* osfmk/arm/* the page the loader publishes: the same layout as struct loader_block in xnuloader/loader.c */#define BLOCK_MAGIC 0x4b434f4c42574452ULL /* "RDWBLOCK" */-#define BLOCK_VERSION 4+#define BLOCK_VERSION 3#define BLOCK_MAX_PARTS 160#define BLOCK_MAX_UNITS 16#define BLOCK_PART_UNIT 1u /* a whole logical unit, not a partition */@@ -95,6 +95,16 @@ struct loader_block {uint32_t version, size;uint32_t parts, buffer_size;uint64_t buffer_pa;+ /*+ * Which partition the loader will take writes for this run (its index plus one; 0: none) and+ * from which of its blocks. They sit in what was padding, so the page is the size and the+ * version it was and one phone goes on being shared: a loader built before writes existed+ * leaves them zero, which is no write, and a kernel built before them leaves ask.op zero,+ * which is a read.+ */+ uint32_t write_part_plus_one;+ uint32_t write_reserved;+ uint64_t write_first;struct {volatile uint32_t request;uint32_t part;@@ -126,6 +136,9 @@ struct loader_block {} kernel_native __attribute__((aligned(128)));};+_Static_assert(__builtin_offsetof(struct loader_block, ask) == 128,+ "the loader's page must stay the size it was: what is before ask has to fit in its padding");+#define UFS_PAGE 0x4000UL#define UFS_TIMEOUT_MS 20000 /* core 0 answers in well under a second; this is for a dead loader */@@ -162,6 +175,7 @@ static LCK_MTX_DECLARE(ufs_write_mtx, &ufs_lck_grp);/* ufs_write=1 and the one partition it is for: everything else answers EROFS as it always did */static int ufs_write_part = -1;static volatile bool ufs_write_busy; /* a write of ours has this kernel's list out: not a failure */+static bool ufs_write_out, ufs_write_was_native; /* the list is out for writing, and was in before */static uint64_t ufs_writes, ufs_write_bytes, ufs_write_errors, ufs_write_refused;SYSCTL_DECL(_kern_redwood);@@ -457,7 +471,6 @@ static intufs_write(uint32_t part, uint64_t offset, const uint8_t *src, uint64_t len){uint64_t nbs, per;- bool native;int error = 0;if (!ufs_ready || ufs_write_part < 0 || part != (uint32_t)ufs_write_part) {@@ -477,15 +490,21 @@ ufs_write(uint32_t part, uint64_t offset, const uint8_t *src, uint64_t len)per = ufs_buffer_size / nbs;lck_mtx_lock(&ufs_write_mtx);/*- * ufs_native_on goes first, so that a reader about to start sees it and goes the other way- * of its own accord; one already inside this kernel's driver gets an error and is sent the- * other way by ufs_write_busy.+ * The list goes out once, at the first write, and comes back when the device is closed: a+ * whole data volume is written a bufferful at a time, and switching the controller's list+ * for each of those would say so a hundred times over and buy nothing. ufs_native_on is+ * cleared first, so that a reader about to start goes the other way of its own accord; one+ * already inside this kernel's driver gets an error and is sent the other way by+ * ufs_write_busy.*/- native = ufs_native_on;- ufs_write_busy = true;- if (native) {- ufs_native_on = false;- ufs_native_out("a write of the data volume");+ if (!ufs_write_out) {+ ufs_write_was_native = ufs_native_on;+ ufs_write_busy = true;+ ufs_write_out = true;+ if (ufs_write_was_native) {+ ufs_native_on = false;+ ufs_native_out("writing the data volume into darwin");+ }}while (len > 0 && error == 0) {uint64_t count = len / nbs;@@ -505,10 +524,6 @@ ufs_write(uint32_t part, uint64_t offset, const uint8_t *src, uint64_t len)src += count * nbs;len -= count * nbs;}- if (native && ufs_native_in(false) == 0) {- ufs_native_on = true;- }- ufs_write_busy = false;lck_mtx_unlock(&ufs_write_mtx);if (error != 0) {ufs_write_errors++;@@ -516,6 +531,21 @@ ufs_write(uint32_t part, uint64_t offset, const uint8_t *src, uint64_t len)return error;}+/* The writing over: this kernel's own transfer list back in, and reads through it again. */+static void+ufs_write_restore(void)+{+ lck_mtx_lock(&ufs_write_mtx);+ if (ufs_write_out) {+ if (ufs_write_was_native && ufs_native_in(false) == 0) {+ ufs_native_on = true;+ }+ ufs_write_busy = false;+ ufs_write_out = false;+ }+ lck_mtx_unlock(&ufs_write_mtx);+}+/* ---- the devices ---- */static int@@ -546,6 +576,18 @@ ufs_close(__unused dev_t dev, __unused int flags, __unused int devtype, __unusedreturn 0;}+static void ufs_write_restore(void);++/* The last close of /dev/rufs_darwin ends the writing: this kernel's own transfer list goes back in. */+static int+ufs_cclose(dev_t dev, int flags, int devtype, proc_t p)+{+ if (ufs_write_part >= 0 && (uint32_t)minor(dev) == (uint32_t)ufs_write_part) {+ ufs_write_restore();+ }+ return ufs_close(dev, flags, devtype, p);+}+static voidufs_strategy(buf_t bp){@@ -633,11 +675,48 @@ ufs_psize(dev_t dev)return ufs_ready && part < ufs_parts ? (int)ufs_bsize[part] : -1;}+/*+ * A read of /dev/rufs_NAME: a bufferful at a time into memory of this kernel's and out to the+ * reader with uiomove. Not physio, which hands the driver the reader's own address to copy to --+ * and this kernel may not touch user memory itself (PAN): the copy has to go through uiomove.+ * Nothing of this driver is held while it does, for a fault in the reader's memory can come back+ * here as a read of the storage.+ */static intufs_cread(dev_t dev, struct uio *uio, __unused int ioflag){- return physio(ufs_strategy, NULL, dev, B_READ, (u_int (*)(buf_t))ufs_psize, uio,- ufs_bsize[minor(dev) < BLOCK_MAX_PARTS ? minor(dev) : 0]);+ uint32_t part = (uint32_t)minor(dev);+ uint64_t size;+ uint8_t *bounce;+ int error = 0;++ if (!ufs_ready || part >= ufs_parts) {+ return ENXIO;+ }+ size = ufs_part_bytes(part);+ if (uio_offset(uio) < 0) {+ return EINVAL;+ }+ bounce = kalloc_data(ufs_buffer_size, Z_WAITOK);+ if (bounce == NULL) {+ return ENOMEM;+ }+ while (error == 0 && uio_resid(uio) > 0 && (uint64_t)uio_offset(uio) < size) {+ uint64_t at = (uint64_t)uio_offset(uio), want = (uint64_t)uio_resid(uio);++ if (want > ufs_buffer_size) {+ want = ufs_buffer_size;+ }+ if (want > size - at) {+ want = size - at;+ }+ error = ufs_read(part, at, bounce, want);+ if (error == 0) {+ error = uiomove((caddr_t)bounce, (int)want, uio);+ }+ }+ kfree_data(bounce, ufs_buffer_size);+ return error;}/*@@ -697,7 +776,7 @@ static const struct bdevsw ufs_bdevsw = {static const struct cdevsw ufs_cdevsw = {.d_open = ufs_copen,- .d_close = ufs_close,+ .d_close = ufs_cclose,.d_read = ufs_cread,.d_write = ufs_cwrite,.d_ioctl = ufs_ioctl,@@ -1287,16 +1366,27 @@ redwood_ufs_init(void)*/check = 0;if (PE_parse_boot_argn("ufs_write", &check, sizeof(check)) && check == 1) {- for (uint32_t i = 0; i < ufs_parts; i++) {+ uint32_t offered = ufs_page->write_part_plus_one;++ if (offered == 0 || offered > ufs_parts || ufs_page->write_first != UFS_WRITE_FIRST) {+ printf("ufs: the loader offers no partition to write into (ufs_write=1 on its command "+ "line too, and a loader that knows about writes)\n");+ }+ for (uint32_t i = 0; offered != 0 && i < ufs_parts; i++) {const char *why = NULL;if (strncmp((const char *)ufs_page->part[i].name, "darwin", 7) != 0) {continue;}- if (ufs_page->part[i].flags & BLOCK_PART_UNIT) {+ if (i != offered - 1) {+ why = "the loader offers another partition";+ } else if (ufs_page->part[i].flags & BLOCK_PART_UNIT) {why = "it is a whole logical unit, not the partition";- } else if (ufs_page->part[i].lun != 0) {- why = "it is not on logical unit 0";+ } else if (ufs_page->part[i].unit != 0) {+ /* the first unit UEFI lists, which this kernel's own driver reads as LUN 0 and+ * has compared with the loader's reads; the device path this firmware gives+ * says no logical unit number at all, so part[].lun is 0xff for every unit */+ why = "it is not on the first logical unit";} else if (ufs_page->part[i].start_lba != UFS_DARWIN_FIRST) {why = "it does not begin where it did";} else if (ufs_page->part[i].blocks != UFS_DARWIN_BLOCKS) {diff --git a/xnuloader/loader.c b/xnuloader/loader.cindex 867f11a..a5a511e 100644--- a/xnuloader/loader.c+++ b/xnuloader/loader.c@@ -1462,7 +1462,7 @@ ufs_survey(void)* for a write, cleans its own lines of it before it asks.*/#define BLOCK_MAGIC 0x4b434f4c42574452ULL /* "RDWBLOCK" */-#define BLOCK_VERSION 4+#define BLOCK_VERSION 3#define BLOCK_MAX_PARTS 160#define BLOCK_MAX_UNITS 16#define BLOCK_PART_UNIT 1u /* the entry is a whole logical unit, not a partition */@@ -1506,6 +1506,17 @@ struct loader_block {uint32_t version, size;uint32_t parts, buffer_size;uint64_t buffer_pa;+ /*+ * Which partition takes writes this run, as its index among part[] plus one (0: none), and+ * from which of its blocks. They are here, in what was padding before ask, so that the page+ * stays the size and the version it was: one phone is shared between working copies, and a+ * kernel built before writes existed must go on reading through a loader built after them,+ * and the other way about -- a kernel that does not know these fields leaves ask.op zero,+ * which is a read, and a loader that does not know them leaves these zero, which is no write.+ */+ uint32_t write_part_plus_one;+ uint32_t write_reserved;+ uint64_t write_first;/* written by the kernel: what it wants, then request is advanced */struct {volatile uint32_t request;@@ -1545,6 +1556,9 @@ struct loader_block {} kernel_native __attribute__((aligned(128)));};+_Static_assert(__builtin_offsetof(struct loader_block, ask) == 128,+ "the page must stay the size it was: the fields before ask have to fit in what was padding");+/* (8 KB is as far as this target aligns; the kernel maps whole 16 KB pages around both) */static struct loader_block block_shared __attribute__((aligned(0x2000)));static void block_io2_probe(efi_handle h, efi_block_io *bio);@@ -1822,8 +1836,10 @@ block_is_darwin(const efi_partition_info *info, const efi_block_io *bio, const swhy = "its unique GUID is not the one it had";} else if (info->start_lba != BLOCK_DARWIN_FIRST || info->end_lba != BLOCK_DARWIN_LAST) {why = "it does not begin and end where it did";- } else if (bp->lun != 0) {- why = "it is not on logical unit 0";+ } else if (bp->unit != 0) {+ /* the first unit UEFI lists: this firmware's device paths say no logical unit number+ * (device_path_print finds no 3.19 node), so bp->lun is 0xff for every unit */+ why = "it is not on the first logical unit";} else if (bp->block_size != 4096 || bp->blocks != BLOCK_DARWIN_LAST - BLOCK_DARWIN_FIRST + 1) {why = "its blocks are not what they were";} else if (bio->media->read_only) {@@ -1952,6 +1968,10 @@ block_start(void)}hc_refused_reads = 0;hc_log_skips = 0;+ if (block_write_part >= 0) {+ block_shared.write_part_plus_one = (uint32_t)block_write_part + 1;+ block_shared.write_first = BLOCK_WRITE_FIRST;+ }block_shared.magic = BLOCK_MAGIC;block_shared.version = BLOCK_VERSION;block_shared.size = sizeof(block_shared);@@ -2821,6 +2841,10 @@ run_kernel(int have_checkpoint, uint64_t checkpoint)int camera_requested = 0;/* (the loader stays for run after run: what the last run's arguments said must not hold for this one) */gamut_p3 = 0;+ /* a run that does not ask for writes does not get them, whatever an earlier run of this+ * loader asked for (the loader stays resident across runs) */+ block_write_requested = 0;+ block_write_part = -1;for (const char *c = pi.cmdline; *c; c++) {if (starts_with(c, "bootcpu=") && (c == pi.cmdline || c[-1] == ' ') && c[8] >= '0' && c[8] <= '7') {kernel_mpidr = (uint64_t)(c[8] - '0') << PLAT->core_shift;