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

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.md
index 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.persist
index 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.c
index 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 int
whole_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.c
index 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 int
ufs_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, __unused
return 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 void
ufs_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 int
ufs_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.c
index 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 s
why = "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;