759148688f
An idle app takes no loop turn: a session's pump blocks until there is news for it, wakes and GPU results reach only their own session, and a hosted app builds no frame while its window has no free shared image. Each window paces at its own display; a texture pass paints only when its window can show the result and is exactly its render target at every scale. The direct compositor renders on the discrete GPU when there is one; Mirror and Extended switch without an output rebuild. Vulkan: a full GPU never makes an app fall back, fail or spin; upload arenas are pooled; pipeline variants a batch needs compile before it; a grab of a hosted window no longer loses the device; the WM's own device is replaceable and apps hear Event::GpuReset. Every process lifts its open-file limit. Cameras: retry after a failed open, rotation kept, a synthetic test camera, Cx::video_inputs. Android: standalone app APKs run on the HAL again, file video decoding, system back gestures, audio underruns grow the buffer. Frame tracing names who keeps an app awake; one main-lag meter for macOS and Linux. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
79 lines
3.5 KiB
Rust
79 lines
3.5 KiB
Rust
// The compositor is Linux-only (the crate's modules are cfg(target_os = "linux")).
|
|
#![cfg(target_os = "linux")]
|
|
|
|
use std::io::Write;
|
|
use std::os::fd::OwnedFd;
|
|
use wayland_server::shm::*;
|
|
|
|
fn tmpfile(tag: &str, len: u64) -> (std::fs::File, std::path::PathBuf) {
|
|
let p = std::env::temp_dir().join(format!("wsrv-shm-{}-{tag}", std::process::id()));
|
|
let f = std::fs::File::options().read(true).write(true).create(true).truncate(true).open(&p).unwrap();
|
|
f.set_len(len).unwrap();
|
|
(f, p)
|
|
}
|
|
|
|
#[test]
|
|
fn reads_and_validates() {
|
|
let (mut f, p) = tmpfile("a", 8192);
|
|
let data: Vec<u8> = (0..8192u32).map(|i| (i % 251) as u8).collect();
|
|
f.write_all(&data).unwrap();
|
|
let pool = Pool::new(OwnedFd::from(f.try_clone().unwrap()), 8192).unwrap();
|
|
let b = BufferSpec::new(pool.len(), 16, 10, 4, 48, ARGB8888).unwrap();
|
|
let mut out = Vec::new();
|
|
copy_rows(&pool, &b, 1, 3, &mut out).unwrap();
|
|
assert_eq!(out.len(), 80);
|
|
assert_eq!(&out[..40], &data[16 + 48..16 + 48 + 40]);
|
|
assert_eq!(&out[40..], &data[16 + 96..16 + 96 + 40]);
|
|
// invalid specs
|
|
assert!(BufferSpec::new(8192, -1, 10, 4, 48, ARGB8888).is_err());
|
|
assert!(BufferSpec::new(8192, 0, 10, 4, 39, ARGB8888).is_err());
|
|
assert!(BufferSpec::new(8192, 8100, 10, 4, 48, ARGB8888).is_err());
|
|
assert!(BufferSpec::new(8192, 0, 10, 4, 48, 77).is_err());
|
|
assert!(BufferSpec::new(usize::MAX, 0, i32::MAX, i32::MAX, i32::MAX, ARGB8888).is_err());
|
|
// pool bigger than the file is refused
|
|
assert_eq!(Pool::new(OwnedFd::from(f.try_clone().unwrap()), 16384).err(), Some(ShmError::TooSmall));
|
|
std::fs::remove_file(p).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn truncation_does_not_crash() {
|
|
let (f, p) = tmpfile("b", 3 * PAGE as u64);
|
|
let pool = Pool::new(OwnedFd::from(f.try_clone().unwrap()), 3 * PAGE).unwrap();
|
|
f.set_len(PAGE as u64).unwrap(); // client shrinks the file
|
|
let mut out = vec![1u8; 3 * PAGE];
|
|
assert_eq!(pool.read(0, &mut out), Err(ShmError::Truncated));
|
|
assert!(out[PAGE..].iter().all(|&b| b == 0)); // lost pages read as zeroes
|
|
// the guard is off again afterwards and a second fault in another page is handled too
|
|
let (f2, p2) = tmpfile("c", 2 * PAGE as u64);
|
|
let pool2 = Pool::new(OwnedFd::from(f2.try_clone().unwrap()), 2 * PAGE).unwrap();
|
|
f2.set_len(0).unwrap();
|
|
let mut o2 = vec![0u8; 2 * PAGE];
|
|
assert_eq!(pool2.read(0, &mut o2), Err(ShmError::Truncated));
|
|
// faults from several threads at once
|
|
let handles: Vec<_> = (0..4).map(|i| {
|
|
let (f, p) = tmpfile(&format!("t{i}"), 2 * PAGE as u64);
|
|
let pool = Pool::new(OwnedFd::from(f.try_clone().unwrap()), 2 * PAGE).unwrap();
|
|
f.set_len(0).unwrap();
|
|
std::thread::spawn(move || {
|
|
let mut o = vec![0u8; 2 * PAGE];
|
|
for _ in 0..50 { let _ = &f; assert_eq!(pool.read(0, &mut o), Err(ShmError::Truncated)); }
|
|
std::fs::remove_file(p).unwrap();
|
|
})
|
|
}).collect();
|
|
for h in handles { h.join().unwrap(); }
|
|
std::fs::remove_file(p).unwrap();
|
|
std::fs::remove_file(p2).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn resize_grows() {
|
|
let (f, p) = tmpfile("d", PAGE as u64);
|
|
let mut pool = Pool::new(OwnedFd::from(f.try_clone().unwrap()), PAGE).unwrap();
|
|
assert!(pool.resize(PAGE / 2).is_err());
|
|
f.set_len(2 * PAGE as u64).unwrap();
|
|
pool.resize(2 * PAGE).unwrap();
|
|
let mut o = [0u8; 8];
|
|
pool.read(2 * PAGE - 8, &mut o).unwrap();
|
|
assert_eq!(pool.read(2 * PAGE - 4, &mut o), Err(ShmError::BadBuffer));
|
|
std::fs::remove_file(p).unwrap();
|
|
}
|