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

graphics/vesad: Remove support for reading resize events

Browse Source 
Nobody actually listens for them from vesad itself anyway. Instead they
listen for them from inputd.
This commit is contained in:
bjorn3
2024-12-22 17:07:24 +01:00
parent a09d0fb761
commit a88f2c4b53
3 changed files with 31 additions and 171 deletions
Download Patch File Download Diff File Expand all files Collapse all files
graphics/vesad/src/main.rs
+9 -59
View File
@@ -3,12 +3,11 @@ extern crate orbclient;
extern crate syscall;
use event::{user_data, EventQueue};
use libredox::errno::{EAGAIN, EINTR};
use redox_scheme::{RequestKind, Response, SignalBehavior, Socket, V2};
use libredox::errno::EAGAIN;
use redox_scheme::{RequestKind, SignalBehavior, Socket, V2};
use std::env;
use std::fs::File;
use std::os::fd::AsRawFd;
use syscall::EVENT_READ;
use crate::{framebuffer::FrameBuffer, scheme::DisplayScheme};
@@ -118,7 +117,6 @@ fn inner(daemon: redox_daemon::Daemon, framebuffers: Vec<FrameBuffer>, spec: &[(
inputd_control_handle.activate_vt(1).unwrap();
let mut blocked = Vec::new();
let all = [Source::Input, Source::Scheme];
for event in all
.into_iter()
@@ -148,66 +146,18 @@ fn inner(daemon: redox_daemon::Daemon, framebuffers: Vec<FrameBuffer>, spec: &[(
match request.kind() {
RequestKind::Call(call_request) => {
if let Some(resp) = call_request.handle_scheme_block_mut(&mut scheme) {
socket
.write_response(resp, SignalBehavior::Restart)
.expect("vesad: failed to write display scheme");
} else {
blocked.push(call_request);
}
}
RequestKind::Cancellation(cancellation_request) => {
if let Some(i) = blocked.iter().position(|req| {
req.request().request_id() == cancellation_request.id
}) {
let blocked_req = blocked.remove(i);
let resp =
Response::new(&blocked_req, Err(syscall::Error::new(EINTR)));
socket
.write_response(resp, SignalBehavior::Restart)
.expect("vesad: failed to write display scheme");
}
socket
.write_response(
call_request.handle_scheme_mut(&mut scheme),
SignalBehavior::Restart,
)
.expect("vesad: failed to write display scheme");
}
RequestKind::Cancellation(_cancellation_request) => {}
RequestKind::MsyncMsg | RequestKind::MunmapMsg | RequestKind::MmapMsg => {
unreachable!()
}
}
// If there are blocked readers, try to handle them.
{
let mut i = 0;
while i < blocked.len() {
if let Some(resp) = blocked[i].handle_scheme_block_mut(&mut scheme) {
socket
.write_response(resp, SignalBehavior::Restart)
.expect("vesad: failed to write display scheme");
blocked.remove(i);
} else {
i += 1;
}
}
}
for (handle_id, handle) in scheme.handles.iter_mut() {
if handle.notified_read || !handle.events.contains(EVENT_READ) {
continue;
}
let can_read = scheme
.vts
.get(&handle.vt)
.and_then(|screens| screens.get(&handle.screen))
.map_or(false, |screen| screen.can_read());
if can_read {
handle.notified_read = true;
socket
.post_fevent(*handle_id, EVENT_READ.bits())
.expect("vesad: failed to write display event");
} else {
handle.notified_read = false;
}
}
}
}
}
graphics/vesad/src/scheme.rs
+22 -77
View File
@@ -2,8 +2,8 @@ use std::collections::BTreeMap;
use std::str;
use inputd::{VtEvent, VtEventKind};
use redox_scheme::SchemeBlockMut;
use syscall::{Error, EventFlags, MapFlags, Result, EBADF, EINVAL, ENOENT, O_NONBLOCK};
use redox_scheme::SchemeMut;
use syscall::{Error, MapFlags, Result, EBADF, EINVAL, ENOENT};
use crate::{framebuffer::FrameBuffer, screen::GraphicScreen};
@@ -17,10 +17,6 @@ pub struct ScreenIndex(usize);
pub struct Handle {
pub vt: VtIndex,
pub screen: ScreenIndex,
pub flags: usize,
pub events: EventFlags,
pub notified_read: bool,
}
pub struct DisplayScheme {
@@ -109,14 +105,8 @@ impl DisplayScheme {
}
}
impl SchemeBlockMut for DisplayScheme {
fn open(
&mut self,
path_str: &str,
flags: usize,
_uid: u32,
_gid: u32,
) -> Result<Option<usize>> {
impl SchemeMut for DisplayScheme {
fn open(&mut self, path_str: &str, _flags: usize, _uid: u32, _gid: u32) -> Result<usize> {
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));
@@ -131,14 +121,10 @@ impl SchemeBlockMut for DisplayScheme {
Handle {
vt: vt_i,
screen: screen_i,
flags,
events: EventFlags::empty(),
notified_read: false,
},
);
Ok(Some(id))
Ok(id)
} else {
Err(Error::new(ENOENT))
}
@@ -147,7 +133,7 @@ impl SchemeBlockMut for DisplayScheme {
}
}
fn dup(&mut self, id: usize, buf: &[u8]) -> Result<Option<usize>> {
fn dup(&mut self, id: usize, buf: &[u8]) -> Result<usize> {
if !buf.is_empty() {
return Err(Error::new(EINVAL));
}
@@ -163,22 +149,10 @@ impl SchemeBlockMut for DisplayScheme {
self.handles.insert(new_id, handle.clone());
Ok(Some(new_id))
Ok(new_id)
}
fn fevent(
&mut self,
id: usize,
flags: syscall::EventFlags,
) -> Result<Option<syscall::EventFlags>> {
let handle = self.handles.get_mut(&id).ok_or(Error::new(EBADF))?;
handle.notified_read = false;
handle.events = flags;
Ok(Some(syscall::EventFlags::empty()))
}
fn fpath(&mut self, id: usize, buf: &mut [u8]) -> Result<Option<usize>> {
fn fpath(&mut self, id: usize, buf: &mut [u8]) -> Result<usize> {
let handle = self.handles.get(&id).ok_or(Error::new(EBADF))?;
let path_str = {
@@ -204,10 +178,10 @@ impl SchemeBlockMut for DisplayScheme {
i += 1;
}
Ok(Some(i))
Ok(i)
}
fn fsync(&mut self, id: usize) -> Result<Option<usize>> {
fn fsync(&mut self, id: usize) -> Result<usize> {
let handle = self.handles.get(&id).ok_or(Error::new(EBADF))?;
if let Some(screens) = self.vts.get_mut(&handle.vt) {
@@ -215,7 +189,7 @@ impl SchemeBlockMut for DisplayScheme {
if handle.vt == self.active {
screen.redraw(&mut self.framebuffers[handle.screen.0]);
}
return Ok(Some(0));
return Ok(0);
}
}
@@ -225,47 +199,24 @@ impl SchemeBlockMut for DisplayScheme {
fn read(
&mut self,
id: usize,
buf: &mut [u8],
_buf: &mut [u8],
_offset: u64,
_fcntl_flags: u32,
) -> Result<Option<usize>> {
let handle = self.handles.get(&id).ok_or(Error::new(EBADF))?;
) -> Result<usize> {
let _handle = self.handles.get(&id).ok_or(Error::new(EBADF))?;
if let Some(screens) = self.vts.get_mut(&handle.vt) {
if let Some(screen) = screens.get_mut(&handle.screen) {
let nread = screen.read(buf)?;
if nread != 0 {
return Ok(Some(nread));
} else {
if handle.flags & O_NONBLOCK == O_NONBLOCK {
return Ok(Some(0));
} else {
return Ok(None);
}
}
}
}
Err(Error::new(EBADF))
Err(Error::new(EINVAL))
}
fn write(
&mut self,
id: usize,
buf: &[u8],
_offset: u64,
_fcntl_flags: u32,
) -> Result<Option<usize>> {
fn write(&mut self, id: usize, buf: &[u8], _offset: u64, _fcntl_flags: u32) -> Result<usize> {
let handle = self.handles.get(&id).ok_or(Error::new(EBADF))?;
if let Some(screens) = self.vts.get_mut(&handle.vt) {
if let Some(screen) = screens.get_mut(&handle.screen) {
if handle.vt == self.active {
screen
.write(buf, Some(&mut self.framebuffers[handle.screen.0]))
.map(|count| Some(count))
screen.write(buf, Some(&mut self.framebuffers[handle.screen.0]))
} else {
screen.write(buf, None).map(|count| Some(count))
screen.write(buf, None)
}
} else {
Err(Error::new(EBADF))
@@ -275,23 +226,17 @@ impl SchemeBlockMut for DisplayScheme {
}
}
fn close(&mut self, id: usize) -> Result<Option<usize>> {
fn close(&mut self, id: usize) -> Result<usize> {
self.handles.remove(&id).ok_or(Error::new(EBADF))?;
Ok(Some(0))
Ok(0)
}
fn mmap_prep(
&mut self,
id: usize,
off: u64,
size: usize,
_flags: MapFlags,
) -> Result<Option<usize>> {
fn mmap_prep(&mut self, id: usize, off: u64, size: usize, _flags: MapFlags) -> Result<usize> {
let handle = self.handles.get(&id).ok_or(Error::new(EBADF))?;
if let Some(screens) = self.vts.get(&handle.vt) {
if let Some(screen) = screens.get(&handle.screen) {
if off as usize + size <= screen.offscreen.len() * 4 {
return Ok(Some(screen.offscreen.as_ptr() as usize + off as usize));
return Ok(screen.offscreen.as_ptr() as usize + off as usize);
} else {
return Err(Error::new(EINVAL));
}
graphics/vesad/src/screen.rs
-35
View File
@@ -1,9 +1,7 @@
use std::collections::VecDeque;
use std::convert::TryInto;
use std::{cmp, mem, ptr, slice};
use inputd::Damage;
use orbclient::{Event, ResizeEvent};
use syscall::error::*;
use crate::display::OffscreenBuffer;
@@ -13,7 +11,6 @@ pub struct GraphicScreen {
pub width: usize,
pub height: usize,
pub offscreen: OffscreenBuffer,
pub input: VecDeque<Event>,
}
impl GraphicScreen {
@@ -22,7 +19,6 @@ impl GraphicScreen {
width,
height,
offscreen: OffscreenBuffer::new(width * height),
input: VecDeque::new(),
}
}
}
@@ -71,36 +67,6 @@ impl GraphicScreen {
} else {
println!("Display is already {}, {}", width, height);
};
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>(),
)
};
while i < event_buf.len() && !self.input.is_empty() {
event_buf[i] = self.input.pop_front().unwrap();
i += 1;
}
Ok(i * mem::size_of::<Event>())
}
pub fn can_read(&self) -> bool {
!self.input.is_empty()
}
pub fn write(&mut self, buf: &[u8], framebuffer: Option<&mut FrameBuffer>) -> Result<usize> {
@@ -117,7 +83,6 @@ impl GraphicScreen {
Ok(sync_rects.len() * mem::size_of::<Damage>())
}
pub fn sync(&mut self, framebuffer: &mut FrameBuffer, sync_rects: &[Damage]) {
for sync_rect in sync_rects {
let sync_rect = sync_rect.clip(