Project Chimera
Меню

Исходники

401 строк · 21 КиБ

code/crates/chl-wine/src/vkbasalt.rs

1//! Слой vkBasalt из комплекта: чтобы постобработка работала без установки
2//! пакета в систему.
3//!
4//! Раньше лаунчер выставлял `ENABLE_VKBASALT=1`, а самого слоя не было ни в
5//! системе, ни в комплекте (24 сентября: `pacman -Q vkbasalt` — «не найден»,
6//! в `implicit_layer.d` только MangoHud) — и эффекты молча не делали ничего.
7//! В официальных репозиториях Arch vkBasalt нет, только в AUR, так что
8//! рассчитывать на системный пакет нельзя.
9//!
10//! Библиотеки собираются в контейнере комплекта (`packaging/bundle`, 64 и 32
11//! бита) и лежат в `<комплект>/layers/vkbasalt/`. Загрузчик Vulkan узнаёт о
12//! слое по описанию в `$XDG_DATA_HOME/vulkan/implicit_layer.d/` — этот каталог
13//! читают все загрузчики, и контейнер Steam (pressure-vessel) тоже: там же
14//! Steam кладёт свой `steamfossilize`. Описание указывает абсолютным путём в
15//! комплект и включается только при `ENABLE_VKBASALT=1`, то есть без этой
16//! переменной слой не грузится ни в одну программу.
17//!
18//! Библиотеки намеренно не проходят замыкание зависимостей комплекта: слой
19//! грузится в процесс игры, где уже есть libstdc++ и libX11 хоста, и вторая
20//! копия из комплекта там была бы вредна. Отсюда и требование к хосту —
21//! libstdc++ от GCC 13 и новее (`GLIBCXX_3.4.32`), glibc 2.32.
22
23use std::path::{Path, PathBuf};
24
25/// Откуда возьмётся слой на этом запуске.
26#[derive(Debug, Clone, PartialEq, Eq)]
27pub enum Layer {
28 /// vkBasalt установлен в систему — берётся он, своё не регистрируется.
29 System(PathBuf),
30 /// Из комплекта; описания записаны сюда.
31 Bundled(Vec<PathBuf>),
32 /// Мы внутри контейнера Steam, комплект есть, а описания слоя хост не
33 /// передал: оно ни разу не записывалось на хосте (лаунчер не открывали
34 /// после установки). Изнутри контейнера его не записать — см. [`ensure`].
35 NotRegistered,
36 /// Нет ни там, ни там (сборка из исходников без комплекта).
37 Missing,
38}
39
40/// Имя слоя в описании — у системного пакета и у нашего одно и то же.
41const LAYER_NAME: &str = "VK_LAYER_VKBASALT_post_processing";
42
43/// Префикс имени наших описаний — по нему они отличаются от системного
44/// vkBasalt и от чужих слоёв в том же каталоге.
45const OUR_PREFIX: &str = "chimera-vkbasalt";
46
47/// Кусок пути библиотеки из комплекта (см. [`bundled_libs`]) — по нему наше
48/// описание узнаётся и там, где его переименовали.
49const OUR_LAYOUT: &str = "/layers/vkbasalt/";
50
51/// Системные каталоги неявных слоёв (как их ищет загрузчик Vulkan).
52fn system_dirs() -> Vec<PathBuf> {
53 let mut dirs = vec![PathBuf::from("/etc/vulkan/implicit_layer.d")];
54 let data = std::env::var("XDG_DATA_DIRS").unwrap_or_else(|_| "/usr/local/share:/usr/share".into());
55 dirs.extend(data.split(':').filter(|d| !d.is_empty()).map(|d| Path::new(d).join("vulkan/implicit_layer.d")));
56 dirs
57}
58
59/// Мы внутри контейнера Steam (pressure-vessel). Обёртка игр Steam
60/// работает именно там: инструмент совместимости просит Steam Linux
61/// Runtime (`require_tool_appid`).
62///
63/// Там свой каталог описаний `~/.local/share/vulkan/implicit_layer.d`
64/// подменён пустым, а описания хоста pressure-vessel собирает в
65/// `/usr/lib/pressure-vessel/overrides/share/vulkan/implicit_layer.d` под
66/// именами вида `5-x86_64-linux-gnu.json` (проверено 27 сентября в
67/// SteamLinuxRuntime_4). Поиск по имени файла там не находит ни системный
68/// vkBasalt, ни наш — отсюда ложное «слоя нет» в журнале обёртки, когда
69/// слой в игру загружался.
70pub fn in_steam_container() -> bool {
71 std::env::var("container").is_ok_and(|v| v == "pressure-vessel")
72 || Path::new("/run/pressure-vessel").is_dir()
73}
74
75/// Что за описание слоя лежит в `json`: библиотека vkBasalt по нему, если
76/// это vkBasalt и библиотека на месте.
77///
78/// Библиотека без каталога (`libvkbasalt.so`) — так пишет системный пакет:
79/// её ищет динамический загрузчик, и проверить её здесь нечем — считаем,
80/// что есть. Относительный путь — от каталога описания, как у загрузчика
81/// Vulkan.
82pub fn library_of(json: &Path) -> Option<PathBuf> {
83 let text = std::fs::read_to_string(json).ok()?;
84 let v: serde_json::Value = serde_json::from_str(&text).ok()?;
85 let layer = &v["layer"];
86 if layer["name"].as_str() != Some(LAYER_NAME) {
87 return None;
88 }
89 let lib = Path::new(layer["library_path"].as_str()?);
90 if lib.components().count() == 1 {
91 return Some(lib.to_path_buf());
92 }
93 let lib = if lib.is_absolute() { lib.to_path_buf() } else { json.parent()?.join(lib) };
94 lib.is_file().then_some(lib)
95}
96
97/// Все рабочие описания vkBasalt в каталогах `dirs`: (описание, библиотека).
98fn descriptions(dirs: &[PathBuf]) -> Vec<(PathBuf, PathBuf)> {
99 let mut out = Vec::new();
100 for dir in dirs {
101 let Ok(entries) = std::fs::read_dir(dir) else { continue };
102 let mut found: Vec<PathBuf> = entries
103 .flatten()
104 .map(|e| e.path())
105 .filter(|p| p.extension().is_some_and(|e| e == "json"))
106 .collect();
107 found.sort();
108 out.extend(found.into_iter().filter_map(|json| library_of(&json).map(|lib| (json, lib))));
109 }
110 out
111}
112
113/// Наше ли это описание: библиотека лежит в раскладке комплекта.
114fn is_ours(lib: &Path) -> bool {
115 lib.to_string_lossy().contains(OUR_LAYOUT)
116}
117
118/// Описание vkBasalt, установленного в систему, — не наше.
119pub fn system_layer() -> Option<PathBuf> {
120 descriptions(&system_dirs()).into_iter().find(|(_, lib)| !is_ours(lib)).map(|(json, _)| json)
121}
122
123/// Библиотеки слоя в комплекте: (архитектура для описания, путь).
124pub fn bundled_libs(bundle_root: &Path) -> Vec<(&'static str, PathBuf)> {
125 let base = bundle_root.join("layers/vkbasalt");
126 [("64", base.join("x86_64/libvkbasalt.so")), ("32", base.join("i386/libvkbasalt.so"))]
127 .into_iter()
128 .filter(|(_, p)| p.is_file())
129 .collect()
130}
131
132/// Описание слоя для загрузчика Vulkan. Имя, функции и переменные — те же,
133/// что в `vkBasalt.json` самого проекта; `library_arch` — чтобы загрузчик не
134/// пробовал 32-битную библиотеку в 64-битном процессе (и наоборот) и не
135/// сыпал об этом ошибками.
136pub fn layer_json(lib: &Path, arch: &str) -> String {
137 let doc = serde_json::json!({
138 "file_format_version": "1.2.1",
139 "layer": {
140 "name": LAYER_NAME,
141 "type": "GLOBAL",
142 "library_path": lib,
143 "library_arch": arch,
144 "api_version": "1.3.223",
145 "implementation_version": "1",
146 "description": "vkBasalt из комплекта Chimera-Launcher",
147 "functions": {
148 "vkGetInstanceProcAddr": "vkBasalt_GetInstanceProcAddr",
149 "vkGetDeviceProcAddr": "vkBasalt_GetDeviceProcAddr"
150 },
151 "enable_environment": { "ENABLE_VKBASALT": "1" },
152 "disable_environment": { "DISABLE_VKBASALT": "1" }
153 }
154 });
155 serde_json::to_string_pretty(&doc).unwrap_or_default() + "\n"
156}
157
158/// Каталог наших описаний: `$XDG_DATA_HOME/vulkan/implicit_layer.d`.
159pub fn registration_dir() -> Option<PathBuf> {
160 let data = std::env::var_os("XDG_DATA_HOME")
161 .map(PathBuf::from)
162 .filter(|p| p.is_absolute())
163 .or_else(|| std::env::var_os("HOME").map(|h| PathBuf::from(h).join(".local/share")))?;
164 Some(data.join("vulkan/implicit_layer.d"))
165}
166
167/// Наши рабочие описания там, где их увидит загрузчик Vulkan этого
168/// процесса: в своём каталоге и — внутри контейнера Steam — среди
169/// перенесённых с хоста.
170fn ours_visible() -> Vec<PathBuf> {
171 let mut dirs: Vec<PathBuf> = registration_dir().into_iter().collect();
172 dirs.extend(system_dirs());
173 descriptions(&dirs).into_iter().filter(|(_, lib)| is_ours(lib)).map(|(json, _)| json).collect()
174}
175
176/// Что есть сейчас, ничего не записывая, — для диагностики.
177pub fn status(bundle_root: Option<&Path>) -> Layer {
178 if let Some(p) = system_layer() {
179 return Layer::System(p);
180 }
181 match ours_visible() {
182 found if !found.is_empty() => Layer::Bundled(found),
183 _ if in_steam_container() && bundle_root.is_some_and(|r| !bundled_libs(r).is_empty()) => {
184 Layer::NotRegistered
185 }
186 _ => Layer::Missing,
187 }
188}
189
190/// Готовит слой к запуску. Пишет описания только если их содержимое
191/// поменялось (переехал комплект) — обычный запуск диска не трогает.
192///
193/// Внутри контейнера Steam ничего не пишет: свой каталог описаний там —
194/// пустышка поверх настоящего, запись в неё пропала бы вместе с
195/// контейнером, а список слоёв для игры pressure-vessel уже собрал при
196/// старте. Там — только [`status`].
197pub fn ensure(bundle_root: Option<&Path>) -> Layer {
198 if in_steam_container() {
199 return status(bundle_root);
200 }
201 if let Some(p) = system_layer() {
202 return Layer::System(p);
203 }
204 let Some(dir) = registration_dir() else { return Layer::Missing };
205 let libs = bundle_root.map(bundled_libs).unwrap_or_default();
206 if libs.is_empty() {
207 // Не из комплекта (сборка из исходников), но описание уже записано
208 // раньше и библиотека по нему на месте — слой рабочий.
209 return match ours_visible() {
210 found if found.is_empty() => Layer::Missing,
211 found => Layer::Bundled(found),
212 };
213 }
214 let mut written = Vec::new();
215 for (arch, lib) in libs {
216 let path = dir.join(format!("{OUR_PREFIX}.{}.json", if arch == "64" { "x86_64" } else { "i686" }));
217 let body = layer_json(&lib, arch);
218 let same = std::fs::read_to_string(&path).is_ok_and(|old| old == body);
219 if !same && chl_core::paths::write_atomically(&path, &body).is_err() {
220 continue;
221 }
222 written.push(path);
223 }
224 if written.is_empty() { Layer::Missing } else { Layer::Bundled(written) }
225}
226
227// ─── Что слою нужно от системы ─────────────────────────────────────────────
228
229/// Версии библиотек, которых слой требует от хоста: наибольшие
230/// `GLIBCXX_3.4.N` и `GLIBC_2.N` среди имён версий в самой библиотеке.
231///
232/// Берутся из файла, а не записаны числами в код: требование зависит от
233/// компилятора, которым собран комплект, и число в коде разошлось бы с ним
234/// при первой же пересборке образа.
235#[derive(Debug, Clone, Default, PartialEq, Eq)]
236pub struct Needs {
237 pub glibcxx: Option<String>,
238 pub glibc: Option<String>,
239}
240
241pub fn needs(lib: &Path) -> Needs {
242 let Ok(bytes) = std::fs::read(lib) else { return Needs::default() };
243 Needs { glibcxx: max_version(&bytes, "GLIBCXX_"), glibc: max_version(&bytes, "GLIBC_") }
244}
245
246/// Наибольшая версия вида `<prefix>X.Y[.Z]` среди строк файла, оканчивающихся
247/// нулём (так лежат имена версий в `.dynstr`).
248fn max_version(bytes: &[u8], prefix: &str) -> Option<String> {
249 let p = prefix.as_bytes();
250 let mut best: Option<(Vec<u64>, String)> = None;
251 let mut i = 0;
252 while let Some(off) = bytes[i..].windows(p.len()).position(|w| w == p) {
253 let start = i + off;
254 i = start + p.len();
255 // Начало строки: перед именем — ноль (иначе это хвост другого имени,
256 // `GLIBC_` внутри `GLIBCXX_` сюда не попадёт: там `X`, а не `_`).
257 if start > 0 && bytes[start - 1] != 0 {
258 continue;
259 }
260 let tail = &bytes[i..];
261 let len = tail.iter().position(|b| !(b.is_ascii_digit() || *b == b'.')).unwrap_or(tail.len());
262 if tail.get(len) != Some(&0) || len == 0 {
263 continue;
264 }
265 let ver = String::from_utf8_lossy(&tail[..len]).into_owned();
266 let nums: Vec<u64> = ver.split('.').filter_map(|n| n.parse().ok()).collect();
267 if best.as_ref().is_none_or(|(b, _)| nums > *b) {
268 best = Some((nums, ver));
269 }
270 }
271 best.map(|(_, v)| format!("{prefix}{v}"))
272}
273
274/// Есть ли в библиотеке хоста имя версии `version` (`GLIBCXX_3.4.32`).
275/// Имена определённых версий лежат в `.dynstr` строками с нулём на конце.
276pub fn defines_version(lib: &Path, version: &str) -> bool {
277 let Ok(bytes) = std::fs::read(lib) else { return false };
278 let mut needle = Vec::with_capacity(version.len() + 2);
279 needle.push(0);
280 needle.extend_from_slice(version.as_bytes());
281 needle.push(0);
282 bytes.windows(needle.len()).any(|w| w == needle.as_slice())
283}
284
285/// `libstdc++.so.6` хоста для 64 или 32 бит — там, где её держат
286/// распространённые раскладки: `/usr/lib` (Arch), `/usr/lib64` (Fedora),
287/// `/usr/lib/<триплет>` (Debian, Ubuntu), `/usr/lib32` (32 бита в Arch).
288pub fn host_libstdcxx(arch: &str) -> Option<PathBuf> {
289 let dirs: &[&str] = if arch == "32" {
290 &["/usr/lib32", "/usr/lib/i386-linux-gnu", "/lib/i386-linux-gnu", "/usr/lib"]
291 } else {
292 &["/usr/lib64", "/usr/lib/x86_64-linux-gnu", "/lib/x86_64-linux-gnu", "/usr/lib"]
293 };
294 dirs.iter().map(|d| Path::new(d).join("libstdc++.so.6")).find(|p| {
295 // В `/usr/lib` на Fedora лежит 32-битная — различаем по заголовку ELF.
296 let mut head = [0u8; 5];
297 let read = std::fs::File::open(p).and_then(|mut f| std::io::Read::read_exact(&mut f, &mut head));
298 read.is_ok() && head[..4] == *b"\x7fELF" && head[4] == if arch == "32" { 1 } else { 2 }
299 })
300}
301
302#[cfg(test)]
303mod tests {
304 use super::*;
305
306 #[test]
307 fn описание_включается_только_переменной() {
308 let v: serde_json::Value = serde_json::from_str(&layer_json(Path::new("/b/layers/vkbasalt/x86_64/libvkbasalt.so"), "64")).unwrap();
309 let layer = &v["layer"];
310 assert_eq!(layer["name"], "VK_LAYER_VKBASALT_post_processing");
311 assert_eq!(layer["enable_environment"]["ENABLE_VKBASALT"], "1");
312 assert_eq!(layer["library_path"], "/b/layers/vkbasalt/x86_64/libvkbasalt.so");
313 assert_eq!(layer["library_arch"], "64");
314 }
315
316 fn tmp(name: &str) -> PathBuf {
317 let dir = std::env::temp_dir().join(format!("chl-vkb-{name}-{}", std::process::id()));
318 let _ = std::fs::remove_dir_all(&dir);
319 std::fs::create_dir_all(&dir).unwrap();
320 dir
321 }
322
323 /// Так описания выглядят внутри контейнера Steam: переименованы
324 /// pressure-vessel'ом, а наше узнаётся по пути библиотеки.
325 #[test]
326 fn описание_узнаётся_по_содержимому_а_не_по_имени_файла() {
327 let dir = tmp("pv");
328 let lib = dir.join("app/layers/vkbasalt/x86_64/libvkbasalt.so");
329 std::fs::create_dir_all(lib.parent().unwrap()).unwrap();
330 std::fs::write(&lib, b"x").unwrap();
331 let layers = dir.join("implicit_layer.d");
332 std::fs::create_dir_all(&layers).unwrap();
333 std::fs::write(layers.join("5-x86_64-linux-gnu.json"), layer_json(&lib, "64")).unwrap();
334 // Чужой слой рядом не мешает.
335 std::fs::write(
336 layers.join("4-x86_64-linux-gnu.json"),
337 r#"{"layer":{"name":"VK_LAYER_MANGOHUD_overlay_x86_64","library_path":"/run/host/usr/lib/mangohud/libMangoHud.so"}}"#,
338 )
339 .unwrap();
340 let found = descriptions(std::slice::from_ref(&layers));
341 assert_eq!(found.len(), 1);
342 assert!(is_ours(&found[0].1));
343 std::fs::remove_dir_all(&dir).ok();
344 }
345
346 #[test]
347 fn системный_пакет_с_библиотекой_без_пути_считается_рабочим() {
348 let dir = tmp("sys");
349 std::fs::write(
350 dir.join("vkBasalt.json"),
351 r#"{"layer":{"name":"VK_LAYER_VKBASALT_post_processing","library_path":"libvkbasalt.so"}}"#,
352 )
353 .unwrap();
354 let found = descriptions(std::slice::from_ref(&dir));
355 assert_eq!(found.len(), 1);
356 assert!(!is_ours(&found[0].1));
357 std::fs::remove_dir_all(&dir).ok();
358 }
359
360 #[test]
361 fn описание_без_библиотеки_не_в_счёт() {
362 let dir = tmp("gone");
363 std::fs::write(dir.join("chimera-vkbasalt.x86_64.json"), layer_json(Path::new("/нет/layers/vkbasalt/x86_64/libvkbasalt.so"), "64")).unwrap();
364 assert!(descriptions(std::slice::from_ref(&dir)).is_empty());
365 std::fs::remove_dir_all(&dir).ok();
366 }
367
368 #[test]
369 fn требования_берутся_наибольшие_из_имён_версий() {
370 let dir = tmp("needs");
371 let lib = dir.join("libvkbasalt.so");
372 let body: &[u8] = b"\x7fELF\0GLIBC_2.2.5\0GLIBC_2.32\0GLIBC_2.4\0GLIBCXX_3.4.9\0GLIBCXX_3.4.32\0GLIBCXX_3.4.29\0CXXABI_1.3.13\0xGLIBC_9.9\0";
373 std::fs::write(&lib, body).unwrap();
374 let n = needs(&lib);
375 assert_eq!(n.glibcxx.as_deref(), Some("GLIBCXX_3.4.32"));
376 assert_eq!(n.glibc.as_deref(), Some("GLIBC_2.32"));
377 assert!(defines_version(&lib, "GLIBCXX_3.4.29"));
378 assert!(!defines_version(&lib, "GLIBCXX_3.4.3"));
379 std::fs::remove_dir_all(&dir).ok();
380 }
381
382 #[test]
383 fn без_комплекта_и_системы_слоя_нет() {
384 let dir = std::env::temp_dir().join(format!("chl-vkb-{}", std::process::id()));
385 std::fs::create_dir_all(&dir).unwrap();
386 assert!(bundled_libs(&dir).is_empty());
387 std::fs::remove_dir_all(&dir).ok();
388 }
389
390 #[test]
391 fn библиотеки_комплекта_находятся_по_раскладке() {
392 let dir = std::env::temp_dir().join(format!("chl-vkb-lay-{}", std::process::id()));
393 std::fs::create_dir_all(dir.join("layers/vkbasalt/x86_64")).unwrap();
394 std::fs::write(dir.join("layers/vkbasalt/x86_64/libvkbasalt.so"), b"x").unwrap();
395 let libs = bundled_libs(&dir);
396 assert_eq!(libs.len(), 1);
397 assert_eq!(libs[0].0, "64");
398 std::fs::remove_dir_all(&dir).ok();
399 }
400}
401