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 | |
| 23 | use std::path::{Path, PathBuf}; |
| 24 | |
| 25 | /// Откуда возьмётся слой на этом запуске. |
| 26 | #[derive(Debug, Clone, PartialEq, Eq)] |
| 27 | pub 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 | /// Имя слоя в описании — у системного пакета и у нашего одно и то же. |
| 41 | const LAYER_NAME: &str = "VK_LAYER_VKBASALT_post_processing"; |
| 42 | |
| 43 | /// Префикс имени наших описаний — по нему они отличаются от системного |
| 44 | /// vkBasalt и от чужих слоёв в том же каталоге. |
| 45 | const OUR_PREFIX: &str = "chimera-vkbasalt"; |
| 46 | |
| 47 | /// Кусок пути библиотеки из комплекта (см. [`bundled_libs`]) — по нему наше |
| 48 | /// описание узнаётся и там, где его переименовали. |
| 49 | const OUR_LAYOUT: &str = "/layers/vkbasalt/"; |
| 50 | |
| 51 | /// Системные каталоги неявных слоёв (как их ищет загрузчик Vulkan). |
| 52 | fn 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 | /// слой в игру загружался. |
| 70 | pub 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. |
| 82 | pub 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`: (описание, библиотека). |
| 98 | fn 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 | /// Наше ли это описание: библиотека лежит в раскладке комплекта. |
| 114 | fn is_ours(lib: &Path) -> bool { |
| 115 | lib.to_string_lossy().contains(OUR_LAYOUT) |
| 116 | } |
| 117 | |
| 118 | /// Описание vkBasalt, установленного в систему, — не наше. |
| 119 | pub fn system_layer() -> Option<PathBuf> { |
| 120 | descriptions(&system_dirs()).into_iter().find(|(_, lib)| !is_ours(lib)).map(|(json, _)| json) |
| 121 | } |
| 122 | |
| 123 | /// Библиотеки слоя в комплекте: (архитектура для описания, путь). |
| 124 | pub 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 | /// сыпал об этом ошибками. |
| 136 | pub 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`. |
| 159 | pub 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 | /// перенесённых с хоста. |
| 170 | fn 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 | /// Что есть сейчас, ничего не записывая, — для диагностики. |
| 177 | pub 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`]. |
| 197 | pub 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)] |
| 236 | pub struct Needs { |
| 237 | pub glibcxx: Option<String>, |
| 238 | pub glibc: Option<String>, |
| 239 | } |
| 240 | |
| 241 | pub 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`). |
| 248 | fn 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` строками с нулём на конце. |
| 276 | pub 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). |
| 288 | pub 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)] |
| 303 | mod 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 |