vasilito
b9874d0941
Add redbear-usb-storage-check in-guest binary that validates USB mass storage read and write I/O: discovers /scheme/disk/ devices, writes a test pattern to sector 2048, reads it back, verifies match, restores original content. Updates test-usb-storage-qemu.sh with write-proof verification step. Includes all accumulated Red Bear OS work: kernel patches, relibc patches, driver infrastructure, DRM/GPU, KDE recipes, firmware, validation tooling, build system hardening, and documentation.
488 lines
18 KiB
Rust
488 lines
18 KiB
Rust
use inputd::ProducerHandle;
|
|
use log::{error, warn};
|
|
use orbclient::{ButtonEvent, KeyEvent, MouseEvent, MouseRelativeEvent, ScrollEvent};
|
|
use std::{
|
|
convert::TryInto,
|
|
fs::File,
|
|
io::{Read, Write},
|
|
time::Duration,
|
|
};
|
|
use syscall::TimeSpec;
|
|
|
|
use crate::controller::Ps2;
|
|
use crate::mouse::{MouseResult, MouseState};
|
|
use crate::vm;
|
|
|
|
bitflags! {
|
|
pub struct MousePacketFlags: u8 {
|
|
const LEFT_BUTTON = 1;
|
|
const RIGHT_BUTTON = 1 << 1;
|
|
const MIDDLE_BUTTON = 1 << 2;
|
|
const ALWAYS_ON = 1 << 3;
|
|
const X_SIGN = 1 << 4;
|
|
const Y_SIGN = 1 << 5;
|
|
const X_OVERFLOW = 1 << 6;
|
|
const Y_OVERFLOW = 1 << 7;
|
|
}
|
|
}
|
|
|
|
fn timespec_from_duration(duration: Duration) -> TimeSpec {
|
|
TimeSpec {
|
|
tv_sec: duration.as_secs().try_into().unwrap(),
|
|
tv_nsec: duration.subsec_nanos().try_into().unwrap(),
|
|
}
|
|
}
|
|
|
|
fn duration_from_timespec(timespec: TimeSpec) -> Duration {
|
|
Duration::new(
|
|
timespec.tv_sec.try_into().unwrap(),
|
|
timespec.tv_nsec.try_into().unwrap(),
|
|
)
|
|
}
|
|
|
|
pub struct Ps2d {
|
|
ps2: Ps2,
|
|
vmmouse: bool,
|
|
vmmouse_relative: bool,
|
|
input: ProducerHandle,
|
|
time_file: File,
|
|
extended: bool,
|
|
mouse_x: i32,
|
|
mouse_y: i32,
|
|
mouse_left: bool,
|
|
mouse_middle: bool,
|
|
mouse_right: bool,
|
|
mouse_state: MouseState,
|
|
mouse_timeout: Option<TimeSpec>,
|
|
packets: [u8; 4],
|
|
packet_i: usize,
|
|
}
|
|
|
|
impl Ps2d {
|
|
pub fn new(input: ProducerHandle, time_file: File) -> Self {
|
|
let mut ps2 = Ps2::new();
|
|
ps2.init().expect("failed to initialize");
|
|
|
|
// FIXME add an option for orbital to disable this when an app captures the mouse.
|
|
let vmmouse_relative = false;
|
|
let vmmouse = vm::enable(vmmouse_relative);
|
|
|
|
// TODO: QEMU hack, maybe do this when Init timed out?
|
|
if vmmouse {
|
|
// 3 = MouseId::Intellimouse1
|
|
MouseState::Bat.handle(3, &mut ps2);
|
|
}
|
|
|
|
let mut this = Ps2d {
|
|
ps2,
|
|
vmmouse,
|
|
vmmouse_relative,
|
|
input,
|
|
time_file,
|
|
extended: false,
|
|
mouse_x: 0,
|
|
mouse_y: 0,
|
|
mouse_left: false,
|
|
mouse_middle: false,
|
|
mouse_right: false,
|
|
mouse_state: MouseState::Init,
|
|
mouse_timeout: None,
|
|
packets: [0; 4],
|
|
packet_i: 0,
|
|
};
|
|
|
|
if !this.vmmouse {
|
|
// This triggers initializing the mouse
|
|
this.handle_mouse(None);
|
|
}
|
|
|
|
this
|
|
}
|
|
|
|
pub fn irq(&mut self) {
|
|
while let Some((keyboard, data)) = self.ps2.next() {
|
|
self.handle(keyboard, data);
|
|
}
|
|
}
|
|
|
|
pub fn time_event(&mut self) {
|
|
let mut time = TimeSpec::default();
|
|
match self.time_file.read(&mut time) {
|
|
Ok(_count) => {}
|
|
Err(err) => {
|
|
log::error!("failed to read time file: {}", err);
|
|
return;
|
|
}
|
|
}
|
|
if let Some(mouse_timeout) = self.mouse_timeout {
|
|
if time.tv_sec > mouse_timeout.tv_sec
|
|
|| (time.tv_sec == mouse_timeout.tv_sec && time.tv_nsec >= mouse_timeout.tv_nsec)
|
|
{
|
|
self.handle_mouse(None);
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn handle(&mut self, keyboard: bool, data: u8) {
|
|
if keyboard {
|
|
if data == 0xE0 {
|
|
self.extended = true;
|
|
} else {
|
|
let (ps2_scancode, pressed) = if data >= 0x80 {
|
|
(data - 0x80, false)
|
|
} else {
|
|
(data, true)
|
|
};
|
|
|
|
let scancode = if self.extended {
|
|
self.extended = false;
|
|
match ps2_scancode {
|
|
0x1C => orbclient::K_NUM_ENTER,
|
|
0x1D => orbclient::K_RIGHT_CTRL,
|
|
0x20 => orbclient::K_VOLUME_TOGGLE,
|
|
0x22 => orbclient::K_MEDIA_PLAY_PAUSE,
|
|
0x24 => orbclient::K_MEDIA_STOP,
|
|
0x10 => orbclient::K_MEDIA_REWIND,
|
|
0x19 => orbclient::K_MEDIA_FAST_FORWARD,
|
|
0x2E => orbclient::K_VOLUME_DOWN,
|
|
0x30 => orbclient::K_VOLUME_UP,
|
|
0x35 => orbclient::K_NUM_SLASH,
|
|
0x38 => orbclient::K_ALT_GR,
|
|
0x47 => orbclient::K_HOME,
|
|
0x48 => orbclient::K_UP,
|
|
0x49 => orbclient::K_PGUP,
|
|
0x4B => orbclient::K_LEFT,
|
|
0x4D => orbclient::K_RIGHT,
|
|
0x4F => orbclient::K_END,
|
|
0x50 => orbclient::K_DOWN,
|
|
0x51 => orbclient::K_PGDN,
|
|
0x52 => orbclient::K_INS,
|
|
0x53 => orbclient::K_DEL,
|
|
0x5B => orbclient::K_LEFT_SUPER,
|
|
0x5C => orbclient::K_RIGHT_SUPER,
|
|
0x5D => orbclient::K_APP,
|
|
0x5E => orbclient::K_POWER,
|
|
0x5F => orbclient::K_SLEEP,
|
|
/* 0x80 to 0xFF used for press/release detection */
|
|
_ => {
|
|
if pressed {
|
|
warn!("unknown extended scancode {:02X}", ps2_scancode);
|
|
}
|
|
0
|
|
}
|
|
}
|
|
} else {
|
|
match ps2_scancode {
|
|
/* 0x00 unused */
|
|
0x01 => orbclient::K_ESC,
|
|
0x02 => orbclient::K_1,
|
|
0x03 => orbclient::K_2,
|
|
0x04 => orbclient::K_3,
|
|
0x05 => orbclient::K_4,
|
|
0x06 => orbclient::K_5,
|
|
0x07 => orbclient::K_6,
|
|
0x08 => orbclient::K_7,
|
|
0x09 => orbclient::K_8,
|
|
0x0A => orbclient::K_9,
|
|
0x0B => orbclient::K_0,
|
|
0x0C => orbclient::K_MINUS,
|
|
0x0D => orbclient::K_EQUALS,
|
|
0x0E => orbclient::K_BKSP,
|
|
0x0F => orbclient::K_TAB,
|
|
0x10 => orbclient::K_Q,
|
|
0x11 => orbclient::K_W,
|
|
0x12 => orbclient::K_E,
|
|
0x13 => orbclient::K_R,
|
|
0x14 => orbclient::K_T,
|
|
0x15 => orbclient::K_Y,
|
|
0x16 => orbclient::K_U,
|
|
0x17 => orbclient::K_I,
|
|
0x18 => orbclient::K_O,
|
|
0x19 => orbclient::K_P,
|
|
0x1A => orbclient::K_BRACE_OPEN,
|
|
0x1B => orbclient::K_BRACE_CLOSE,
|
|
0x1C => orbclient::K_ENTER,
|
|
0x1D => orbclient::K_CTRL,
|
|
0x1E => orbclient::K_A,
|
|
0x1F => orbclient::K_S,
|
|
0x20 => orbclient::K_D,
|
|
0x21 => orbclient::K_F,
|
|
0x22 => orbclient::K_G,
|
|
0x23 => orbclient::K_H,
|
|
0x24 => orbclient::K_J,
|
|
0x25 => orbclient::K_K,
|
|
0x26 => orbclient::K_L,
|
|
0x27 => orbclient::K_SEMICOLON,
|
|
0x28 => orbclient::K_QUOTE,
|
|
0x29 => orbclient::K_TICK,
|
|
0x2A => orbclient::K_LEFT_SHIFT,
|
|
0x2B => orbclient::K_BACKSLASH,
|
|
0x2C => orbclient::K_Z,
|
|
0x2D => orbclient::K_X,
|
|
0x2E => orbclient::K_C,
|
|
0x2F => orbclient::K_V,
|
|
0x30 => orbclient::K_B,
|
|
0x31 => orbclient::K_N,
|
|
0x32 => orbclient::K_M,
|
|
0x33 => orbclient::K_COMMA,
|
|
0x34 => orbclient::K_PERIOD,
|
|
0x35 => orbclient::K_SLASH,
|
|
0x36 => orbclient::K_RIGHT_SHIFT,
|
|
0x37 => orbclient::K_NUM_ASTERISK,
|
|
0x38 => orbclient::K_ALT,
|
|
0x39 => orbclient::K_SPACE,
|
|
0x3A => orbclient::K_CAPS,
|
|
0x3B => orbclient::K_F1,
|
|
0x3C => orbclient::K_F2,
|
|
0x3D => orbclient::K_F3,
|
|
0x3E => orbclient::K_F4,
|
|
0x3F => orbclient::K_F5,
|
|
0x40 => orbclient::K_F6,
|
|
0x41 => orbclient::K_F7,
|
|
0x42 => orbclient::K_F8,
|
|
0x43 => orbclient::K_F9,
|
|
0x44 => orbclient::K_F10,
|
|
0x45 => orbclient::K_NUM,
|
|
0x46 => orbclient::K_SCROLL,
|
|
0x47 => orbclient::K_NUM_7,
|
|
0x48 => orbclient::K_NUM_8,
|
|
0x49 => orbclient::K_NUM_9,
|
|
0x4A => orbclient::K_NUM_MINUS,
|
|
0x4B => orbclient::K_NUM_4,
|
|
0x4C => orbclient::K_NUM_5,
|
|
0x4D => orbclient::K_NUM_6,
|
|
0x4E => orbclient::K_NUM_PLUS,
|
|
0x4F => orbclient::K_NUM_1,
|
|
0x50 => orbclient::K_NUM_2,
|
|
0x51 => orbclient::K_NUM_3,
|
|
0x52 => orbclient::K_NUM_0,
|
|
0x53 => orbclient::K_NUM_PERIOD,
|
|
/* 0x54 to 0x55 unused */
|
|
0x56 => 0x56, // UK Backslash
|
|
0x57 => orbclient::K_F11,
|
|
0x58 => orbclient::K_F12,
|
|
/* 0x59 to 0x7F unused */
|
|
/* 0x80 to 0xFF used for press/release detection */
|
|
_ => {
|
|
if pressed {
|
|
warn!("unknown scancode {:02X}", ps2_scancode);
|
|
}
|
|
0
|
|
}
|
|
}
|
|
};
|
|
|
|
if scancode != 0 {
|
|
self.input
|
|
.write_event(
|
|
KeyEvent {
|
|
character: '\0',
|
|
scancode,
|
|
pressed,
|
|
}
|
|
.to_event(),
|
|
)
|
|
.expect("failed to write key event");
|
|
}
|
|
}
|
|
} else if self.vmmouse {
|
|
for _i in 0..256 {
|
|
let (status, _, _, _) = unsafe { vm::cmd(vm::ABSPOINTER_STATUS, 0) };
|
|
//TODO if ((status & VMMOUSE_ERROR) == VMMOUSE_ERROR)
|
|
|
|
let queue_length = status & 0xffff;
|
|
if queue_length == 0 {
|
|
break;
|
|
}
|
|
|
|
if queue_length % 4 != 0 {
|
|
error!("queue length not a multiple of 4: {}", queue_length);
|
|
break;
|
|
}
|
|
|
|
let (status, dx, dy, dz) = unsafe { vm::cmd(vm::ABSPOINTER_DATA, 4) };
|
|
|
|
if self.vmmouse_relative {
|
|
if dx != 0 || dy != 0 {
|
|
self.input
|
|
.write_event(
|
|
MouseRelativeEvent {
|
|
dx: dx as i32,
|
|
dy: dy as i32,
|
|
}
|
|
.to_event(),
|
|
)
|
|
.expect("ps2d: failed to write mouse event");
|
|
}
|
|
} else {
|
|
let x = dx as i32;
|
|
let y = dy as i32;
|
|
if x != self.mouse_x || y != self.mouse_y {
|
|
self.mouse_x = x;
|
|
self.mouse_y = y;
|
|
self.input
|
|
.write_event(MouseEvent { x, y }.to_event())
|
|
.expect("ps2d: failed to write mouse event");
|
|
}
|
|
};
|
|
|
|
if dz != 0 {
|
|
self.input
|
|
.write_event(
|
|
ScrollEvent {
|
|
x: 0,
|
|
y: -(dz as i32),
|
|
}
|
|
.to_event(),
|
|
)
|
|
.expect("ps2d: failed to write scroll event");
|
|
}
|
|
|
|
let left = status & vm::LEFT_BUTTON == vm::LEFT_BUTTON;
|
|
let middle = status & vm::MIDDLE_BUTTON == vm::MIDDLE_BUTTON;
|
|
let right = status & vm::RIGHT_BUTTON == vm::RIGHT_BUTTON;
|
|
if left != self.mouse_left
|
|
|| middle != self.mouse_middle
|
|
|| right != self.mouse_right
|
|
{
|
|
self.mouse_left = left;
|
|
self.mouse_middle = middle;
|
|
self.mouse_right = right;
|
|
self.input
|
|
.write_event(
|
|
ButtonEvent {
|
|
left,
|
|
middle,
|
|
right,
|
|
}
|
|
.to_event(),
|
|
)
|
|
.expect("ps2d: failed to write button event");
|
|
}
|
|
}
|
|
} else {
|
|
self.handle_mouse(Some(data));
|
|
}
|
|
}
|
|
|
|
pub fn handle_mouse(&mut self, data_opt: Option<u8>) {
|
|
// log::trace!(
|
|
// "handle_mouse state {:?} data {:?}",
|
|
// self.mouse_state,
|
|
// data_opt
|
|
// );
|
|
let mouse_res = match data_opt {
|
|
Some(data) => self.mouse_state.handle(data, &mut self.ps2),
|
|
None => self.mouse_state.handle_timeout(&mut self.ps2),
|
|
};
|
|
self.mouse_timeout = None;
|
|
let (packet_data, extra_packet) = match mouse_res {
|
|
MouseResult::None => {
|
|
return;
|
|
}
|
|
MouseResult::Packet(packet_data, extra_packet) => (packet_data, extra_packet),
|
|
MouseResult::Timeout(duration) => {
|
|
// Read current time
|
|
let mut time = TimeSpec::default();
|
|
match self.time_file.read(&mut time) {
|
|
Ok(_count) => {}
|
|
Err(err) => {
|
|
log::error!("failed to read time file: {}", err);
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Add duration to time
|
|
time = timespec_from_duration(duration_from_timespec(time) + duration);
|
|
|
|
// Write next time
|
|
match self.time_file.write(&time) {
|
|
Ok(_count) => {}
|
|
Err(err) => {
|
|
log::error!("failed to write time file: {}", err);
|
|
}
|
|
}
|
|
|
|
self.mouse_timeout = Some(time);
|
|
return;
|
|
}
|
|
};
|
|
|
|
self.packets[self.packet_i] = packet_data;
|
|
self.packet_i += 1;
|
|
|
|
let flags = MousePacketFlags::from_bits_truncate(self.packets[0]);
|
|
if !flags.contains(MousePacketFlags::ALWAYS_ON) {
|
|
error!("mouse misalign {:X}", self.packets[0]);
|
|
|
|
self.packets = [0; 4];
|
|
self.packet_i = 0;
|
|
} else if self.packet_i >= self.packets.len() || (!extra_packet && self.packet_i >= 3) {
|
|
if !flags.contains(MousePacketFlags::X_OVERFLOW)
|
|
&& !flags.contains(MousePacketFlags::Y_OVERFLOW)
|
|
{
|
|
let mut dx = self.packets[1] as i32;
|
|
if flags.contains(MousePacketFlags::X_SIGN) {
|
|
dx -= 0x100;
|
|
}
|
|
|
|
let mut dy = -(self.packets[2] as i32);
|
|
if flags.contains(MousePacketFlags::Y_SIGN) {
|
|
dy += 0x100;
|
|
}
|
|
|
|
let mut dz = 0;
|
|
if extra_packet {
|
|
let mut scroll = (self.packets[3] & 0xF) as i8;
|
|
if scroll & (1 << 3) == 1 << 3 {
|
|
scroll -= 16;
|
|
}
|
|
dz = -scroll as i32;
|
|
}
|
|
|
|
if dx != 0 || dy != 0 {
|
|
self.input
|
|
.write_event(MouseRelativeEvent { dx, dy }.to_event())
|
|
.expect("ps2d: failed to write mouse event");
|
|
}
|
|
|
|
if dz != 0 {
|
|
self.input
|
|
.write_event(ScrollEvent { x: 0, y: dz }.to_event())
|
|
.expect("ps2d: failed to write scroll event");
|
|
}
|
|
|
|
let left = flags.contains(MousePacketFlags::LEFT_BUTTON);
|
|
let middle = flags.contains(MousePacketFlags::MIDDLE_BUTTON);
|
|
let right = flags.contains(MousePacketFlags::RIGHT_BUTTON);
|
|
if left != self.mouse_left
|
|
|| middle != self.mouse_middle
|
|
|| right != self.mouse_right
|
|
{
|
|
self.mouse_left = left;
|
|
self.mouse_middle = middle;
|
|
self.mouse_right = right;
|
|
self.input
|
|
.write_event(
|
|
ButtonEvent {
|
|
left,
|
|
middle,
|
|
right,
|
|
}
|
|
.to_event(),
|
|
)
|
|
.expect("ps2d: failed to write button event");
|
|
}
|
|
} else {
|
|
warn!(
|
|
"overflow {:X} {:X} {:X} {:X}",
|
|
self.packets[0], self.packets[1], self.packets[2], self.packets[3]
|
|
);
|
|
}
|
|
|
|
self.packets = [0; 4];
|
|
self.packet_i = 0;
|
|
}
|
|
}
|
|
}
|