vasilito/RedBear-OS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Run rustfmt on the entire graphics subsystem

Browse Source
This commit is contained in:
bjorn3
2024-07-19 21:24:48 +02:00
parent 25a98ba914
commit 747898dfb2
9 changed files with 225 additions and 157 deletions
Download Patch File Download Diff File Expand all files Collapse all files
graphics/bgad/src/scheme.rs
+9 -6
View File
@@ -1,8 +1,8 @@
use std::fs::File;
use std::io::Write;
use std::str;
use syscall::{Error, Result, SchemeMut, EACCES, EINVAL, MODE_CHR};
use syscall::data::Stat;
use syscall::{Error, Result, SchemeMut, EACCES, EINVAL, MODE_CHR};
use crate::bga::Bga;
@@ -14,10 +14,13 @@ pub struct BgaScheme {
impl BgaScheme {
pub fn update_size(&mut self) {
if let Some(ref mut display) = self.display {
let _ = display.write(&orbclient::ResizeEvent {
width: self.bga.width() as u32,
height: self.bga.height() as u32,
}.to_event());
let _ = display.write(
&orbclient::ResizeEvent {
width: self.bga.width() as u32,
height: self.bga.height() as u32,
}
.to_event(),
);
}
}
}
@@ -32,7 +35,7 @@ impl SchemeMut for BgaScheme {
}
fn dup(&mut self, file: usize, buf: &[u8]) -> Result<usize> {
if ! buf.is_empty() {
if !buf.is_empty() {
return Err(Error::new(EINVAL));
}
graphics/fbcond/src/display.rs
+9 -8
View File
@@ -1,3 +1,4 @@
use libredox::flag;
use std::fs::OpenOptions;
use std::mem;
use std::os::unix::fs::OpenOptionsExt;
@@ -8,7 +9,6 @@ use std::{
os::unix::io::{AsRawFd, FromRawFd},
slice,
};
use libredox::flag;
use syscall::{O_CLOEXEC, O_NONBLOCK, O_RDWR};
// Keep synced with vesad
@@ -67,15 +67,16 @@ impl Display {
let display_path =
std::str::from_utf8(&buffer[..written]).expect("init: display path UTF-8 check failed");
let display_file = libredox::call::open(display_path, (O_CLOEXEC | O_NONBLOCK | O_RDWR) as _, 0)
.map(|socket| unsafe { File::from_raw_fd(socket as RawFd) })
.unwrap_or_else(|err| {
panic!("failed to open display {}: {}", display_path, err);
});
let display_file =
libredox::call::open(display_path, (O_CLOEXEC | O_NONBLOCK | O_RDWR) as _, 0)
.map(|socket| unsafe { File::from_raw_fd(socket as RawFd) })
.unwrap_or_else(|err| {
panic!("failed to open display {}: {}", display_path, err);
});
let mut buf: [u8; 4096] = [0; 4096];
let count =
libredox::call::fpath(display_file.as_raw_fd() as usize, &mut buf).unwrap_or_else(|e| {
let count = libredox::call::fpath(display_file.as_raw_fd() as usize, &mut buf)
.unwrap_or_else(|e| {
panic!("Could not read display path with fpath(): {e}");
});
graphics/fbcond/src/scheme.rs
+7 -5
View File
@@ -47,11 +47,13 @@ impl FbconScheme {
for &vt_i in vt_ids {
let display = Display::open_vt(vt_i).expect("Failed to open display for vt");
event_queue.subscribe(
display.input_handle.as_raw_fd().as_raw_fd() as usize,
VtIndex(vt_i),
event::EventFlags::READ,
).expect("Failed to subscribe to input events for vt");
event_queue
.subscribe(
display.input_handle.as_raw_fd().as_raw_fd() as usize,
VtIndex(vt_i),
event::EventFlags::READ,
)
.expect("Failed to subscribe to input events for vt");
vts.insert(VtIndex(vt_i), TextScreen::new(display));
}
graphics/vesad/src/framebuffer.rs
+6 -9
View File
@@ -1,7 +1,4 @@
use std::{
ptr,
slice
};
use std::{ptr, slice};
pub struct FrameBuffer {
pub phys: usize,
@@ -49,15 +46,15 @@ impl FrameBuffer {
let virt = common::physmap(
self.phys,
size * 4,
common::Prot { read: true, write: true },
common::Prot {
read: true,
write: true,
},
common::MemoryType::WriteCombining,
)? as *mut u32;
//TODO: should we clear the framebuffer here?
ptr::write_bytes(virt, 0, size);
Ok(slice::from_raw_parts_mut(
virt,
size
))
Ok(slice::from_raw_parts_mut(virt, size))
}
}
graphics/vesad/src/main.rs
+52 -40
View File
@@ -9,7 +9,7 @@ use syscall::{Packet, SchemeMut, EVENT_READ};
use crate::{
framebuffer::FrameBuffer,
scheme::{DisplayScheme, HandleKind}
scheme::{DisplayScheme, HandleKind},
};
mod display;
@@ -25,38 +25,36 @@ fn main() {
}
let width = usize::from_str_radix(
&env::var("FRAMEBUFFER_WIDTH")
.expect("FRAMEBUFFER_WIDTH not set"),
16
).expect("failed to parse FRAMEBUFFER_WIDTH");
&env::var("FRAMEBUFFER_WIDTH").expect("FRAMEBUFFER_WIDTH not set"),
16,
)
.expect("failed to parse FRAMEBUFFER_WIDTH");
let height = usize::from_str_radix(
&env::var("FRAMEBUFFER_HEIGHT")
.expect("FRAMEBUFFER_HEIGHT not set"),
16
).expect("failed to parse FRAMEBUFFER_HEIGHT");
&env::var("FRAMEBUFFER_HEIGHT").expect("FRAMEBUFFER_HEIGHT not set"),
16,
)
.expect("failed to parse FRAMEBUFFER_HEIGHT");
let phys = usize::from_str_radix(
&env::var("FRAMEBUFFER_ADDR")
.expect("FRAMEBUFFER_ADDR not set"),
16
).expect("failed to parse FRAMEBUFFER_ADDR");
&env::var("FRAMEBUFFER_ADDR").expect("FRAMEBUFFER_ADDR not set"),
16,
)
.expect("failed to parse FRAMEBUFFER_ADDR");
let stride = usize::from_str_radix(
&env::var("FRAMEBUFFER_STRIDE")
.expect("FRAMEBUFFER_STRIDE not set"),
16
).expect("failed to parse FRAMEBUFFER_STRIDE");
&env::var("FRAMEBUFFER_STRIDE").expect("FRAMEBUFFER_STRIDE not set"),
16,
)
.expect("failed to parse FRAMEBUFFER_STRIDE");
println!("vesad: {}x{} stride {} at 0x{:X}", width, height, stride, phys);
println!(
"vesad: {}x{} stride {} at 0x{:X}",
width, height, stride, phys
);
if phys == 0 {
return;
}
let mut framebuffers = vec![FrameBuffer::new(
phys,
width,
height,
stride,
)];
let mut framebuffers = vec![FrameBuffer::new(phys, width, height, stride)];
//TODO: ideal maximum number of outputs?
for i in 1..1024 {
@@ -65,23 +63,20 @@ fn main() {
Some(fb) => {
println!(
"vesad: framebuffer {}: {}x{} stride {} at 0x{:X}",
i,
fb.width,
fb.height,
fb.stride,
fb.phys
i, fb.width, fb.height, fb.stride, fb.phys
);
framebuffers.push(fb);
},
}
None => {
eprintln!("vesad: framebuffer {}: failed to parse '{}'", i, var);
},
}
},
Err(_err) => break,
};
}
redox_daemon::Daemon::new(|daemon| inner(daemon, framebuffers, &spec)).expect("failed to create daemon");
redox_daemon::Daemon::new(|daemon| inner(daemon, framebuffers, &spec))
.expect("failed to create daemon");
}
fn inner(daemon: redox_daemon::Daemon, framebuffers: Vec<FrameBuffer>, spec: &[()]) -> ! {
let mut socket = File::create(":display.vesa").expect("vesad: failed to create display scheme");
@@ -97,17 +92,26 @@ fn inner(daemon: redox_daemon::Daemon, framebuffers: Vec<FrameBuffer>, spec: &[(
let mut blocked = Vec::new();
loop {
let mut packet = Packet::default();
if socket.read(&mut packet).expect("vesad: failed to read display scheme") == 0 {
if socket
.read(&mut packet)
.expect("vesad: failed to read display scheme")
== 0
{
//TODO: Handle blocked
break;
}
// If it is a read packet, and there is no data, block it. Otherwise, handle packet
if packet.a == syscall::number::SYS_READ && packet.d > 0 && scheme.can_read(packet.b).is_none() {
if packet.a == syscall::number::SYS_READ
&& packet.d > 0
&& scheme.can_read(packet.b).is_none()
{
blocked.push(packet);
} else {
scheme.handle(&mut packet);
socket.write(&packet).expect("vesad: failed to write display scheme");
socket
.write(&packet)
.expect("vesad: failed to write display scheme");
}
// If there are blocked readers, and data is available, handle them
@@ -117,7 +121,9 @@ fn inner(daemon: redox_daemon::Daemon, framebuffers: Vec<FrameBuffer>, spec: &[(
if scheme.can_read(blocked[i].b).is_some() {
let mut packet = blocked.remove(i);
scheme.handle(&mut packet);
socket.write(&packet).expect("vesad: failed to write display scheme");
socket
.write(&packet)
.expect("vesad: failed to write display scheme");
} else {
i += 1;
}
@@ -132,11 +138,15 @@ fn inner(daemon: redox_daemon::Daemon, framebuffers: Vec<FrameBuffer>, spec: &[(
// Can't use scheme.can_read() because we borrow handles as mutable.
// (and because it'd treat O_NONBLOCK sockets differently)
let count = if let HandleKind::Screen(vt_i, screen_i) = handle.kind {
scheme.vts.get(&vt_i)
scheme
.vts
.get(&vt_i)
.and_then(|screens| screens.get(&screen_i))
.and_then(|screen| screen.can_read())
.unwrap_or(0)
} else { 0 };
} else {
0
};
if count > 0 {
if !handle.notified_read {
@@ -149,10 +159,12 @@ fn inner(daemon: redox_daemon::Daemon, framebuffers: Vec<FrameBuffer>, spec: &[(
a: syscall::number::SYS_FEVENT,
b: *handle_id,
c: EVENT_READ.bits(),
d: count
d: count,
};
socket.write(&event_packet).expect("vesad: failed to write display event");
socket
.write(&event_packet)
.expect("vesad: failed to write display event");
}
} else {
handle.notified_read = false;
graphics/vesad/src/scheme.rs
+93 -63
View File
@@ -1,7 +1,9 @@
use std::collections::BTreeMap;
use std::{mem, ptr, slice, str};
use syscall::{Error, EventFlags, EBADF, EINVAL, ENOENT, O_NONBLOCK, Result, SchemeMut, PAGE_SIZE, MapFlags};
use syscall::{
Error, EventFlags, MapFlags, Result, SchemeMut, EBADF, EINVAL, ENOENT, O_NONBLOCK, PAGE_SIZE,
};
use crate::{framebuffer::FrameBuffer, screen::GraphicScreen};
@@ -22,7 +24,7 @@ pub struct Handle {
pub kind: HandleKind,
pub flags: usize,
pub events: EventFlags,
pub notified_read: bool
pub notified_read: bool,
}
pub struct DisplayScheme {
@@ -33,18 +35,15 @@ pub struct DisplayScheme {
next_id: usize,
pub handles: BTreeMap<usize, Handle>,
pub inputd_handle: inputd::Handle,
}
impl DisplayScheme {
pub fn new(mut framebuffers: Vec<FrameBuffer>, spec: &[()]) -> DisplayScheme {
let mut inputd_handle = inputd::Handle::new("vesa").unwrap();
let mut inputd_handle = inputd::Handle::new("vesa").unwrap();
let mut onscreens = Vec::new();
for fb in framebuffers.iter_mut() {
onscreens.push(unsafe {
fb.map().expect("vesad: failed to map framebuffer")
});
onscreens.push(unsafe { fb.map().expect("vesad: failed to map framebuffer") });
}
let mut vts = BTreeMap::<VtIndex, BTreeMap<ScreenIndex, GraphicScreen>>::new();
@@ -74,11 +73,13 @@ impl DisplayScheme {
if let HandleKind::Screen(vt_i, screen_i) = handle.kind {
if let Some(screens) = self.vts.get(&vt_i) {
if let Some(screen) = screens.get(&screen_i) {
screen.can_read().or(if handle.flags & O_NONBLOCK == O_NONBLOCK {
Some(0)
} else {
None
});
screen
.can_read()
.or(if handle.flags & O_NONBLOCK == O_NONBLOCK {
Some(0)
} else {
None
});
}
}
}
@@ -90,12 +91,19 @@ impl DisplayScheme {
fn resize(&mut self, width: usize, height: usize, stride: usize) {
//TODO: support resizing other outputs?
let fb_i = 0;
println!("Resizing framebuffer {} to {}, {} stride {}", fb_i, width, height, stride);
println!(
"Resizing framebuffer {} to {}, {} stride {}",
fb_i, width, height, stride
);
// Unmap old onscreen
unsafe {
let slice = mem::take(&mut self.onscreens[fb_i]);
libredox::call::munmap(slice.as_mut_ptr().cast(), (slice.len() * 4).next_multiple_of(PAGE_SIZE)).expect("vesad: failed to unmap framebuffer");
libredox::call::munmap(
slice.as_mut_ptr().cast(),
(slice.len() * 4).next_multiple_of(PAGE_SIZE),
)
.expect("vesad: failed to unmap framebuffer");
}
// Map new onscreen
@@ -104,15 +112,16 @@ impl DisplayScheme {
let onscreen_ptr = common::physmap(
self.framebuffers[fb_i].phys,
size * 4,
common::Prot { read: true, write: true },
common::Prot {
read: true,
write: true,
},
common::MemoryType::WriteCombining,
).expect("vesad: failed to map framebuffer") as *mut u32;
)
.expect("vesad: failed to map framebuffer") as *mut u32;
ptr::write_bytes(onscreen_ptr, 0, size);
slice::from_raw_parts_mut(
onscreen_ptr,
size
)
slice::from_raw_parts_mut(onscreen_ptr, size)
};
// Update size
@@ -139,34 +148,36 @@ impl SchemeMut for DisplayScheme {
if path_str == "handle" {
let id = self.next_id;
self.next_id += 1;
self.handles.insert(id, Handle {
kind: HandleKind::Input,
flags,
events: EventFlags::empty(),
notified_read: false
});
self.handles.insert(
id,
Handle {
kind: HandleKind::Input,
flags,
events: EventFlags::empty(),
notified_read: false,
},
);
return Ok(id);
}
let mut parts = path_str.split('/');
let mut vt_screen = parts.next().unwrap_or("").split('.');
let vt_i = VtIndex(
vt_screen.next().unwrap_or("").parse::<usize>().unwrap_or(1)
);
let screen_i = ScreenIndex(
vt_screen.next().unwrap_or("").parse::<usize>().unwrap_or(0)
);
let vt_i = VtIndex(vt_screen.next().unwrap_or("").parse::<usize>().unwrap_or(1));
let screen_i = ScreenIndex(vt_screen.next().unwrap_or("").parse::<usize>().unwrap_or(0));
if let Some(screens) = self.vts.get_mut(&vt_i) {
if screens.get_mut(&screen_i).is_some() {
let id = self.next_id;
self.next_id += 1;
self.handles.insert(id, Handle {
kind: HandleKind::Screen(vt_i, screen_i),
flags,
events: EventFlags::empty(),
notified_read: false
});
self.handles.insert(
id,
Handle {
kind: HandleKind::Screen(vt_i, screen_i),
flags,
events: EventFlags::empty(),
notified_read: false,
},
);
Ok(id)
} else {
@@ -182,7 +193,11 @@ impl SchemeMut for DisplayScheme {
return Err(Error::new(EINVAL));
}
let handle = self.handles.get(&id).map(|handle| handle.clone()).ok_or(Error::new(EBADF))?;
let handle = self
.handles
.get(&id)
.map(|handle| handle.clone())
.ok_or(Error::new(EBADF))?;
let new_id = self.next_id;
self.next_id += 1;
@@ -211,16 +226,24 @@ impl SchemeMut for DisplayScheme {
let path_str = match handle.kind {
HandleKind::Input => {
//TODO: allow inputs associated with other framebuffers?
format!("display:input/{}/{}", self.framebuffers[0].width, self.framebuffers[0].height)
},
HandleKind::Screen(vt_i, screen_i) => if let Some(screens) = self.vts.get(&vt_i) {
if let Some(screen) = screens.get(&screen_i) {
format!("display:{}.{}/{}/{}", vt_i.0, screen_i.0, screen.width, screen.height)
format!(
"display:input/{}/{}",
self.framebuffers[0].width, self.framebuffers[0].height
)
}
HandleKind::Screen(vt_i, screen_i) => {
if let Some(screens) = self.vts.get(&vt_i) {
if let Some(screen) = screens.get(&screen_i) {
format!(
"display:{}.{}/{}/{}",
vt_i.0, screen_i.0, screen.width, screen.height
)
} else {
return Err(Error::new(EBADF));
}
} else {
return Err(Error::new(EBADF));
}
} else {
return Err(Error::new(EBADF));
}
};
@@ -244,7 +267,7 @@ impl SchemeMut for DisplayScheme {
if vt_i == self.active {
screen.sync(
self.onscreens[screen_i.0],
self.framebuffers[screen_i.0].stride
self.framebuffers[screen_i.0].stride,
);
}
return Ok(0);
@@ -286,40 +309,47 @@ impl SchemeMut for DisplayScheme {
for (screen_i, screen) in screens.iter_mut() {
screen.redraw(
self.onscreens[screen_i.0],
self.framebuffers[screen_i.0].stride
self.framebuffers[screen_i.0].stride,
);
}
}
self.active = vt_i;
},
}
DisplayCommand::Resize { width, height, stride, .. } => {
DisplayCommand::Resize {
width,
height,
stride,
..
} => {
self.resize(width as usize, height as usize, stride as usize);
}
// Nothing to do for deactivate :)
DisplayCommand::Deactivate(_) => {},
DisplayCommand::Deactivate(_) => {}
}
Ok(buf.len())
},
}
HandleKind::Screen(vt_i, screen_i) => if let Some(screens) = self.vts.get_mut(&vt_i) {
if let Some(screen) = screens.get_mut(&screen_i) {
let count = screen.write(buf)?;
if vt_i == self.active {
screen.sync(
self.onscreens[screen_i.0],
self.framebuffers[screen_i.0].stride
);
HandleKind::Screen(vt_i, screen_i) => {
if let Some(screens) = self.vts.get_mut(&vt_i) {
if let Some(screen) = screens.get_mut(&screen_i) {
let count = screen.write(buf)?;
if vt_i == self.active {
screen.sync(
self.onscreens[screen_i.0],
self.framebuffers[screen_i.0].stride,
);
}
Ok(count)
} else {
Err(Error::new(EBADF))
}
Ok(count)
} else {
Err(Error::new(EBADF))
}
} else {
Err(Error::new(EBADF))
}
}
}
graphics/vesad/src/screen.rs
+26 -17
View File
@@ -1,6 +1,6 @@
use std::collections::VecDeque;
use std::convert::TryInto;
use std::{mem, slice, cmp, ptr};
use std::{cmp, mem, ptr, slice};
use orbclient::{Event, ResizeEvent};
use syscall::error::*;
@@ -55,13 +55,13 @@ impl GraphicScreen {
ptr::copy(
old_ptr as *const u8,
new_ptr as *mut u8,
cmp::min(width, self.width) * 4
cmp::min(width, self.width) * 4,
);
if width > self.width {
ptr::write_bytes(
new_ptr.offset(self.width as isize),
0,
width - self.width
width - self.width,
);
}
old_ptr = old_ptr.offset(self.width as isize);
@@ -86,18 +86,26 @@ impl GraphicScreen {
println!("Display is already {}, {}", width, height);
};
self.input.push_back(ResizeEvent {
width: width as u32,
height: height as u32,
}.to_event());
self.input.push_back(
ResizeEvent {
width: width as u32,
height: height as u32,
}
.to_event(),
);
}
pub fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
let mut i = 0;
let event_buf = unsafe { slice::from_raw_parts_mut(buf.as_mut_ptr() as *mut Event, buf.len()/mem::size_of::<Event>()) };
let event_buf = unsafe {
slice::from_raw_parts_mut(
buf.as_mut_ptr() as *mut Event,
buf.len() / mem::size_of::<Event>(),
)
};
while i < event_buf.len() && ! self.input.is_empty() {
while i < event_buf.len() && !self.input.is_empty() {
event_buf[i] = self.input.pop_front().unwrap();
i += 1;
}
@@ -117,7 +125,7 @@ impl GraphicScreen {
let sync_rects = unsafe {
slice::from_raw_parts(
buf.as_ptr() as *const SyncRect,
buf.len() / mem::size_of::<SyncRect>()
buf.len() / mem::size_of::<SyncRect>(),
)
};
@@ -148,23 +156,24 @@ impl GraphicScreen {
let mut rows = end_y - start_y;
while rows > 0 {
unsafe {
ptr::copy(
offscreen_ptr as *const u8,
onscreen_ptr as *mut u8,
len
);
ptr::copy(offscreen_ptr as *const u8, onscreen_ptr as *mut u8, len);
}
offscreen_ptr += self.width * 4;
onscreen_ptr += stride * 4;
rows -= 1;
};
}
}
}
pub fn redraw(&mut self, onscreen: &mut [u32], stride: usize) {
let width = self.width.try_into().unwrap();
let height = self.height.try_into().unwrap();
self.sync_rects.push(SyncRect { x: 0, y: 0, w: width, h: height });
self.sync_rects.push(SyncRect {
x: 0,
y: 0,
w: width,
h: height,
});
self.sync(onscreen, stride);
}
}
graphics/virtio-gpud/src/main.rs
+3 -1
View File
@@ -453,7 +453,9 @@ fn deamon(deamon: redox_daemon::Daemon) -> anyhow::Result<()> {
socket_file
.read(&mut packet)
.expect("virtio-gpud: failed to read disk scheme");
unsafe { scheme.handle(&mut packet); }
unsafe {
scheme.handle(&mut packet);
}
socket_file
.write(&packet)
.expect("virtio-gpud: failed to read disk scheme");
graphics/virtio-gpud/src/scheme.rs
+20 -8
View File
@@ -4,8 +4,8 @@ use std::collections::BTreeMap;
use std::sync::atomic::{AtomicBool, AtomicU32, AtomicUsize, Ordering};
use std::sync::Arc;
use inputd::Damage;
use common::{dma::Dma, sgl};
use inputd::Damage;
use syscall::{Error as SysError, MapFlags, SchemeMut, EAGAIN, EINVAL, PAGE_SIZE};
@@ -117,7 +117,8 @@ impl<'a> Display<'a> {
let fb_size = self.width as usize * self.height as usize * bpp / 8;
let mapped = self.mapped.get().unwrap();
self.map_screen_with(0, fb_size, mapped.as_ptr(), mapped.chunks()).await
self.map_screen_with(0, fb_size, mapped.as_ptr(), mapped.chunks())
.await
}
async fn map_screen(&self, offset: usize) -> Result<*mut u8, Error> {
@@ -135,7 +136,8 @@ impl<'a> Display<'a> {
let _ = self.mapped.set(mapped);
let mapped = self.mapped.get().unwrap();
self.map_screen_with(offset, fb_size, mapped.as_ptr(), mapped.chunks()).await
self.map_screen_with(offset, fb_size, mapped.as_ptr(), mapped.chunks())
.await
}
async fn map_screen_with(
@@ -167,7 +169,10 @@ impl<'a> Display<'a> {
};
}
let attach_request = Dma::new(AttachBacking::new(self.resource_id, mem_entries.len() as u32))?;
let attach_request = Dma::new(AttachBacking::new(
self.resource_id,
mem_entries.len() as u32,
))?;
let header = Dma::new(ControlHeader::default())?;
let command = ChainBuilder::new()
.chain(Buffer::new(&attach_request))
@@ -462,12 +467,19 @@ impl<'a> SchemeMut for Scheme<'a> {
fn close(&mut self, _id: usize) -> syscall::Result<usize> {
Ok(0)
}
fn mmap_prep(&mut self, id: usize, offset: u64, size: usize, flags: MapFlags) -> syscall::Result<usize> {
fn mmap_prep(
&mut self,
id: usize,
offset: u64,
size: usize,
flags: MapFlags,
) -> syscall::Result<usize> {
log::info!("KSMSG MMAP {} {:?} {} {}", id, flags, offset, size);
match self.handles.get(&id).ok_or(SysError::new(EINVAL))? {
Handle::Vt { display, .. } => {
Ok(futures::executor::block_on(display.map_screen(offset as usize)).unwrap() as usize)
}
Handle::Vt { display, .. } => Ok(futures::executor::block_on(
display.map_screen(offset as usize),
)
.unwrap() as usize),
_ => unreachable!(),
}
}