1 use alloc::{ 2 collections::BTreeMap, 3 string::{String, ToString}, 4 sync::{Arc, Weak}, 5 }; 6 7 use crate::{ 8 filesystem::{ 9 devfs::{devfs_register, DevFS, DeviceINode}, 10 vfs::{file::FileMode, FilePrivateData, FileType, IndexNode, Metadata, ROOT_INODE}, 11 }, 12 kerror, 13 libs::{ 14 lib_ui::textui::{textui_putchar, FontColor}, 15 rwlock::RwLock, 16 }, 17 syscall::SystemError, 18 }; 19 20 use super::{TtyCore, TtyError, TtyFileFlag, TtyFilePrivateData}; 21 22 lazy_static! { 23 /// 所有TTY设备的B树。用于根据名字，找到Arc<TtyDevice> 24 /// TODO: 待设备驱动模型完善，具有类似功能的机制后，删掉这里 25 pub static ref TTY_DEVICES: RwLock<BTreeMap<String, Arc<TtyDevice>>> = RwLock::new(BTreeMap::new()); 26 } 27 28 /// @brief TTY设备 29 #[derive(Debug)] 30 pub struct TtyDevice { 31 /// TTY核心 32 core: TtyCore, 33 /// TTY所属的文件系统 34 fs: RwLock<Weak<DevFS>>, 35 /// TTY设备私有信息 36 private_data: RwLock<TtyDevicePrivateData>, 37 } 38 39 #[derive(Debug)] 40 struct TtyDevicePrivateData { 41 /// TTY设备名(如tty1) 42 name: String, 43 /// TTY设备文件的元数据 44 metadata: Metadata, 45 // TODO: 增加指向输出端口连接的设备的指针 46 } 47 48 impl TtyDevice { 49 pub fn new(name: &str) -> Arc<TtyDevice> { 50 let result = Arc::new(TtyDevice { 51 core: TtyCore::new(), 52 fs: RwLock::new(Weak::default()), 53 private_data: TtyDevicePrivateData::new(name), 54 }); 55 // 默认开启输入回显 56 result.core.enable_echo(); 57 return result; 58 } 59 60 /// @brief 判断文件私有信息是否为TTY文件的私有信息 61 #[inline] 62 fn verify_file_private_data<'a>( 63 &self, 64 private_data: &'a mut FilePrivateData, 65 ) -> Result<&'a mut TtyFilePrivateData, SystemError> { 66 if let FilePrivateData::Tty(t) = private_data { 67 return Ok(t); 68 } 69 return Err(SystemError::EIO); 70 } 71 72 /// @brief 获取TTY设备名 73 #[inline] 74 pub fn name(&self) -> String { 75 return self.private_data.read().name.clone(); 76 } 77 78 /// @brief 检查TTY文件的读写参数是否合法 79 #[inline] 80 pub fn check_rw_param(&self, len: usize, buf: &[u8]) -> Result<(), SystemError> { 81 if len > buf.len() { 82 return Err(SystemError::EINVAL); 83 } 84 return Ok(()); 85 } 86 87 /// @brief 向TTY的输入端口导入数据 88 pub fn input(&self, buf: &[u8]) -> Result<usize, SystemError> { 89 let r: Result<usize, TtyError> = self.core.input(buf, false); 90 if r.is_ok() { 91 return Ok(r.unwrap()); 92 } 93 94 let r = r.unwrap_err(); 95 match r { 96 TtyError::BufferFull(x) => return Ok(x), 97 TtyError::Closed => return Err(SystemError::ENODEV), 98 e => { 99 kerror!("tty error occurred while writing data to its input port, msg={e:?}"); 100 return Err(SystemError::EBUSY); 101 } 102 } 103 } 104 } 105 106 impl DeviceINode for TtyDevice { 107 fn set_fs(&self, fs: alloc::sync::Weak<crate::filesystem::devfs::DevFS>) { 108 *self.fs.write() = fs; 109 } 110 } 111 112 impl IndexNode for TtyDevice { 113 /// @brief 打开TTY设备 114 /// 115 /// @param data 文件私有信息 116 /// @param mode 打开模式 117 /// 118 /// TTY设备通过mode来确定这个文件到底是stdin/stdout/stderr 119 /// - mode的值为O_RDONLY时，表示这个文件是stdin 120 /// - mode的值为O_WRONLY时，表示这个文件是stdout 121 /// - mode的值为O_WRONLY | O_SYNC时，表示这个文件是stderr 122 fn open(&self, data: &mut FilePrivateData, mode: &FileMode) -> Result<(), SystemError> { 123 let mut p = TtyFilePrivateData::default(); 124 125 // 检查打开模式 126 let accmode = mode.accmode(); 127 if accmode == FileMode::O_RDONLY.accmode() { 128 p.flags.insert(TtyFileFlag::STDIN); 129 } else if accmode == FileMode::O_WRONLY.accmode() { 130 if mode.contains(FileMode::O_SYNC) { 131 p.flags.insert(TtyFileFlag::STDERR); 132 } else { 133 p.flags.insert(TtyFileFlag::STDOUT); 134 } 135 } else { 136 return Err(SystemError::EINVAL); 137 } 138 139 // 保存文件私有信息 140 *data = FilePrivateData::Tty(p); 141 return Ok(()); 142 } 143 144 fn read_at( 145 &self, 146 _offset: usize, 147 len: usize, 148 buf: &mut [u8], 149 data: &mut crate::filesystem::vfs::FilePrivateData, 150 ) -> Result<usize, SystemError> { 151 let _data: &mut TtyFilePrivateData = match self.verify_file_private_data(data) { 152 Ok(t) => t, 153 Err(e) => { 154 kerror!("Try to read tty device, but file private data type mismatch!"); 155 return Err(e); 156 } 157 }; 158 self.check_rw_param(len, buf)?; 159 160 // 读取stdin队列 161 let r: Result<usize, TtyError> = self.core.read_stdin(&mut buf[0..len], true); 162 if r.is_ok() { 163 return Ok(r.unwrap()); 164 } 165 166 match r.unwrap_err() { 167 TtyError::EOF(n) => { 168 return Ok(n); 169 } 170 171 x => { 172 kerror!("Error occurred when reading tty, msg={x:?}"); 173 return Err(SystemError::ECONNABORTED); 174 } 175 } 176 } 177 178 fn write_at( 179 &self, 180 _offset: usize, 181 len: usize, 182 buf: &[u8], 183 data: &mut crate::filesystem::vfs::FilePrivateData, 184 ) -> Result<usize, SystemError> { 185 let data: &mut TtyFilePrivateData = match self.verify_file_private_data(data) { 186 Ok(t) => t, 187 Err(e) => { 188 kerror!("Try to write tty device, but file private data type mismatch!"); 189 return Err(e); 190 } 191 }; 192 193 self.check_rw_param(len, buf)?; 194 195 // 根据当前文件是stdout还是stderr,选择不同的发送方式 196 let r: Result<usize, TtyError> = if data.flags.contains(TtyFileFlag::STDOUT) { 197 self.core.stdout(&buf[0..len], true) 198 } else if data.flags.contains(TtyFileFlag::STDERR) { 199 self.core.stderr(&buf[0..len], true) 200 } else { 201 return Err(SystemError::EPERM); 202 }; 203 204 if r.is_ok() { 205 self.sync().expect("Failed to sync tty device!"); 206 return Ok(r.unwrap()); 207 } 208 209 let r: TtyError = r.unwrap_err(); 210 kerror!("Error occurred when writing tty deivce. Error msg={r:?}"); 211 return Err(SystemError::EIO); 212 } 213 214 fn poll(&self) -> Result<crate::filesystem::vfs::PollStatus, SystemError> { 215 return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP); 216 } 217 218 fn fs(&self) -> Arc<dyn crate::filesystem::vfs::FileSystem> { 219 return self.fs.read().upgrade().unwrap(); 220 } 221 222 fn as_any_ref(&self) -> &dyn core::any::Any { 223 self 224 } 225 226 fn list(&self) -> Result<alloc::vec::Vec<alloc::string::String>, SystemError> { 227 return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP); 228 } 229 230 fn metadata(&self) -> Result<Metadata, SystemError> { 231 return Ok(self.private_data.read().metadata.clone()); 232 } 233 234 fn close(&self, _data: &mut FilePrivateData) -> Result<(), SystemError> { 235 return Ok(()); 236 } 237 238 fn sync(&self) -> Result<(), SystemError> { 239 // TODO: 引入IO重定向后，需要将输出重定向到对应的设备。 240 // 目前只是简单的输出到屏幕（为了实现的简便） 241 242 loop { 243 let mut buf = [0u8; 512]; 244 let r: Result<usize, TtyError> = self.core.output(&mut buf[0..511], false); 245 let len; 246 match r { 247 Ok(x) => { 248 len = x; 249 } 250 Err(TtyError::EOF(x)) | Err(TtyError::BufferEmpty(x)) => { 251 len = x; 252 } 253 _ => return Err(SystemError::EIO), 254 } 255 256 if len == 0 { 257 break; 258 } 259 // 输出到屏幕 260 261 for x in 0..len { 262 textui_putchar(buf[x] as char, FontColor::WHITE, FontColor::BLACK).ok(); 263 } 264 } 265 return Ok(()); 266 } 267 fn resize(&self, _len: usize) -> Result<(), SystemError> { 268 return Ok(()); 269 } 270 } 271 272 impl TtyDevicePrivateData { 273 pub fn new(name: &str) -> RwLock<Self> { 274 let mut metadata = Metadata::new(FileType::CharDevice, 0o755); 275 metadata.size = TtyCore::STDIN_BUF_SIZE as i64; 276 return RwLock::new(TtyDevicePrivateData { 277 name: name.to_string(), 278 metadata, 279 }); 280 } 281 } 282 283 /// @brief 导出到C的tty初始化函数 284 #[no_mangle] 285 pub extern "C" fn rs_tty_init() -> i32 { 286 let r = tty_init(); 287 if r.is_ok() { 288 return 0; 289 } else { 290 return r.unwrap_err().to_posix_errno(); 291 } 292 } 293 294 /// @brief 初始化TTY设备 295 pub fn tty_init() -> Result<(), SystemError> { 296 let tty: Arc<TtyDevice> = TtyDevice::new("tty0"); 297 let devfs_root_inode = ROOT_INODE().lookup("/dev"); 298 if devfs_root_inode.is_err() { 299 return Err(devfs_root_inode.unwrap_err()); 300 } 301 // 当前关闭键盘输入回显 302 // TODO: 完善Termios之后, 改为默认开启键盘输入回显. 303 tty.core.disable_echo(); 304 let guard = TTY_DEVICES.upgradeable_read(); 305 306 // 如果已经存在了这个设备 307 if guard.contains_key("tty0") { 308 return Err(SystemError::EEXIST); 309 } 310 311 let mut guard = guard.upgrade(); 312 313 guard.insert("tty0".to_string(), tty.clone()); 314 315 drop(guard); 316 317 let r = devfs_register(&tty.name(), tty); 318 if r.is_err() { 319 return Err(devfs_root_inode.unwrap_err()); 320 } 321 322 return Ok(()); 323 } 324