mod.rs 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402
  1. use core::intrinsics::unlikely;
  2. use alloc::string::String;
  3. use thingbuf::mpsc::{
  4. self,
  5. errors::{TryRecvError, TrySendError},
  6. };
  7. use crate::libs::rwlock::RwLock;
  8. pub mod init;
  9. pub mod serial;
  10. pub mod tty_device;
  11. pub mod tty_driver;
  12. bitflags! {
  13. pub struct TtyCoreState: u32{
  14. /// 在读取stdin缓冲区时,由于队列为空,有读者被阻塞
  15. const BLOCK_AT_STDIN_READ = (1 << 0);
  16. /// 开启输入回显。
  17. const ECHO_ON = (1 << 1);
  18. }
  19. #[derive(Default)]
  20. pub struct TtyFileFlag:u32{
  21. /// 当前文件是stdin文件
  22. const STDIN = (1 << 0);
  23. /// 当前文件是stdout文件
  24. const STDOUT = (1 << 1);
  25. /// 当前文件是stderr文件
  26. const STDERR = (1 << 2);
  27. }
  28. }
  29. /// @brief tty文件的私有信息
  30. #[derive(Debug, Default, Clone)]
  31. pub struct TtyFilePrivateData {
  32. flags: TtyFileFlag,
  33. }
  34. /// @brief tty设备的核心功能结构体。在此结构体的基础上,衍生出TTY/PTY/PTS等
  35. ///
  36. /// 每个TTY Core有5个端口:
  37. /// - stdin:连接到一个活动进程的stdin文件描述符
  38. /// - stdout:连接到多个进程的stdout文件描述符
  39. /// - stderr:连接到多个进程的stdout文件描述符
  40. /// - 输入端口:向tty设备输入数据的接口。输入到该接口的数据,将被导向stdin接口。
  41. /// 如果开启了回显,那么,数据也将同时被导向输出端
  42. /// - 输出端口:tty设备对外输出数据的端口。从stdout、stderr输入的数据,将会被导向此端口。
  43. /// 此端口可以连接到屏幕、文件、或者是另一个tty core的输入端口。如果开启了
  44. /// 输入数据回显,那么,输入端口的数据,将会被同时导向此端口,以及stdin端口
  45. #[derive(Debug)]
  46. struct TtyCore {
  47. /// stdin的mpsc队列输入输出端
  48. stdin_rx: mpsc::Receiver<u8>,
  49. stdin_tx: mpsc::Sender<u8>,
  50. /// 输出的mpsc队列输入输出端
  51. output_rx: mpsc::Receiver<u8>,
  52. output_tx: mpsc::Sender<u8>,
  53. /// tty核心的状态
  54. state: RwLock<TtyCoreState>,
  55. }
  56. #[derive(Debug)]
  57. #[allow(dead_code)]
  58. pub enum TtyError {
  59. /// 缓冲区满,返回成功传送的字节数
  60. BufferFull(usize),
  61. /// 缓冲区空,返回成功传送的字节数
  62. BufferEmpty(usize),
  63. /// 设备已经被关闭
  64. Closed,
  65. /// End of file(已经读取的字符数,包含eof)
  66. EOF(usize),
  67. Unknown(String),
  68. }
  69. impl TtyCore {
  70. // 各个缓冲区的大小
  71. pub const STDIN_BUF_SIZE: usize = 4096;
  72. pub const OUTPUT_BUF_SIZE: usize = 4096;
  73. /// @brief 创建一个TTY核心组件
  74. pub fn new() -> TtyCore {
  75. let (stdin_tx, stdin_rx) = mpsc::channel::<u8>(Self::STDIN_BUF_SIZE);
  76. let (output_tx, output_rx) = mpsc::channel::<u8>(Self::OUTPUT_BUF_SIZE);
  77. let state: RwLock<TtyCoreState> = RwLock::new(TtyCoreState { bits: 0 });
  78. return TtyCore {
  79. stdin_rx,
  80. stdin_tx,
  81. output_rx,
  82. output_tx,
  83. state,
  84. };
  85. }
  86. /// @brief 向tty的输入端口输入数据
  87. ///
  88. /// @param buf 输入数据
  89. ///
  90. /// @param block 是否允许阻塞
  91. ///
  92. /// @return Ok(成功传送的字节数)
  93. /// @return Err(TtyError) 内部错误信息
  94. pub fn input(&self, buf: &[u8], block: bool) -> Result<usize, TtyError> {
  95. // TODO: 在这里考虑增加对信号发送的处理
  96. let val = self.write_stdin(buf, block)?;
  97. // 如果开启了输入回显,那么就写一份到输出缓冲区
  98. if self.echo_enabled() {
  99. self.write_output(&buf[0..val], true)?;
  100. }
  101. return Ok(val);
  102. }
  103. /// @brief 从tty的输出端口读出数据
  104. ///
  105. /// @param buf 输出缓冲区
  106. ///
  107. /// @return Ok(成功传送的字节数)
  108. /// @return Err(TtyError) 内部错误信息
  109. #[inline]
  110. pub fn output(&self, buf: &mut [u8], block: bool) -> Result<usize, TtyError> {
  111. return self.read_output(buf, block);
  112. }
  113. /// @brief tty的stdout接口
  114. ///
  115. /// @param buf 输入缓冲区
  116. ///
  117. /// @return Ok(成功传送的字节数)
  118. /// @return Err(TtyError) 内部错误信息
  119. #[inline]
  120. pub fn stdout(&self, buf: &[u8], block: bool) -> Result<usize, TtyError> {
  121. return self.write_output(buf, block);
  122. }
  123. /// @brief tty的stderr接口
  124. ///
  125. /// @param buf 输入缓冲区
  126. ///
  127. /// @return Ok(成功传送的字节数)
  128. /// @return Err(TtyError) 内部错误信息
  129. #[inline]
  130. pub fn stderr(&self, buf: &[u8], block: bool) -> Result<usize, TtyError> {
  131. return self.write_output(buf, block);
  132. }
  133. /// @brief 读取TTY的stdin缓冲区
  134. ///
  135. /// @param buf 读取到的位置
  136. /// @param block 是否阻塞读
  137. ///
  138. /// @return Ok(成功读取的字节数)
  139. /// @return Err(TtyError) 内部错误信息
  140. pub fn read_stdin(&self, buf: &mut [u8], block: bool) -> Result<usize, TtyError> {
  141. // TODO: 增加对EOF的处理
  142. let mut cnt = 0;
  143. while cnt < buf.len() {
  144. let val: Result<mpsc::RecvRef<u8>, TryRecvError> = self.stdin_rx.try_recv_ref();
  145. if let Err(err) = val {
  146. match err {
  147. TryRecvError::Closed => return Err(TtyError::Closed),
  148. TryRecvError::Empty => {
  149. if block {
  150. continue;
  151. } else {
  152. return Ok(cnt);
  153. }
  154. }
  155. _ => return Err(TtyError::Unknown(format!("{err:?}"))),
  156. }
  157. } else {
  158. let x = *val.unwrap();
  159. buf[cnt] = x;
  160. cnt += 1;
  161. if unlikely(self.stdin_should_return(x)) {
  162. return Ok(cnt);
  163. }
  164. }
  165. }
  166. return Ok(cnt);
  167. }
  168. fn stdin_should_return(&self, c: u8) -> bool {
  169. // 如果是换行符或者是ctrl+d,那么就应该返回
  170. return c == b'\n' || c == 4;
  171. }
  172. /// @brief 向stdin缓冲区内写入数据
  173. ///
  174. /// @param buf 输入缓冲区
  175. ///
  176. /// @param block 当缓冲区满的时候,是否阻塞
  177. ///
  178. /// @return Ok(成功传送的字节数)
  179. /// @return Err(BufferFull(成功传送的字节数)) 缓冲区满,成功传送的字节数
  180. /// @return Err(TtyError) 内部错误信息
  181. fn write_stdin(&self, buf: &[u8], block: bool) -> Result<usize, TtyError> {
  182. let mut cnt = 0;
  183. while cnt < buf.len() {
  184. let r: Result<mpsc::SendRef<u8>, TrySendError> = self.stdin_tx.try_send_ref();
  185. if let Err(e) = r {
  186. match e {
  187. TrySendError::Closed(_) => return Err(TtyError::Closed),
  188. TrySendError::Full(_) => {
  189. if block {
  190. continue;
  191. } else {
  192. return Err(TtyError::BufferFull(cnt));
  193. }
  194. }
  195. _ => return Err(TtyError::Unknown(format!("{e:?}"))),
  196. }
  197. } else {
  198. *r.unwrap() = buf[cnt];
  199. cnt += 1;
  200. }
  201. }
  202. return Ok(cnt);
  203. }
  204. /// @brief 读取TTY的output缓冲区
  205. ///
  206. /// @param buf 读取到的位置
  207. /// @param block 是否阻塞读
  208. ///
  209. /// @return Ok(成功读取的字节数)
  210. /// @return Err(TtyError) 内部错误信息
  211. fn read_output(&self, buf: &mut [u8], block: bool) -> Result<usize, TtyError> {
  212. let mut cnt = 0;
  213. while cnt < buf.len() {
  214. let val: Result<mpsc::RecvRef<u8>, TryRecvError> = self.output_rx.try_recv_ref();
  215. if let Err(err) = val {
  216. match err {
  217. TryRecvError::Closed => return Err(TtyError::Closed),
  218. TryRecvError::Empty => {
  219. if block {
  220. continue;
  221. } else {
  222. return Ok(cnt);
  223. }
  224. }
  225. _ => return Err(TtyError::Unknown(format!("{err:?}"))),
  226. }
  227. } else {
  228. buf[cnt] = *val.unwrap();
  229. cnt += 1;
  230. }
  231. }
  232. return Ok(cnt);
  233. }
  234. /// @brief 向output缓冲区内写入数据
  235. ///
  236. /// @param buf 输入缓冲区
  237. ///
  238. /// @param block 当缓冲区满的时候,是否阻塞
  239. ///
  240. /// @return Ok(成功传送的字节数)
  241. /// @return Err(BufferFull(成功传送的字节数)) 缓冲区满,成功传送的字节数
  242. /// @return Err(TtyError) 内部错误信息
  243. fn write_output(&self, buf: &[u8], block: bool) -> Result<usize, TtyError> {
  244. let mut cnt = 0;
  245. while cnt < buf.len() {
  246. let r: Result<mpsc::SendRef<u8>, TrySendError> = self.output_tx.try_send_ref();
  247. if let Err(e) = r {
  248. match e {
  249. TrySendError::Closed(_) => return Err(TtyError::Closed),
  250. TrySendError::Full(_) => {
  251. if block {
  252. continue;
  253. } else {
  254. return Err(TtyError::BufferFull(cnt));
  255. }
  256. }
  257. _ => return Err(TtyError::Unknown(format!("{e:?}"))),
  258. }
  259. } else {
  260. *r.unwrap() = buf[cnt];
  261. cnt += 1;
  262. }
  263. }
  264. return Ok(cnt);
  265. }
  266. /// @brief 开启tty输入回显(也就是将输入数据传送一份到输出缓冲区)
  267. #[inline]
  268. pub fn enable_echo(&self) {
  269. self.state.write().set(TtyCoreState::ECHO_ON, true);
  270. }
  271. /// @brief 关闭输入回显
  272. #[inline]
  273. #[allow(dead_code)]
  274. pub fn disable_echo(&self) {
  275. self.state.write().set(TtyCoreState::ECHO_ON, false);
  276. }
  277. /// @brief 判断当前tty核心,是否开启了输入回显
  278. ///
  279. /// @return true 开启了输入回显
  280. ///
  281. /// @return false 未开启输入回显
  282. #[inline]
  283. #[allow(dead_code)]
  284. pub fn echo_enabled(&self) -> bool {
  285. return self.state.read().contains(TtyCoreState::ECHO_ON);
  286. }
  287. }
  288. // ======= 以下代码考虑了“缓冲区满,然后睡眠,当缓冲区有空位就唤醒”的逻辑。
  289. // 但是由于在开发过程中的调整,并且由于数据结构发生变化,因此暂时不实现上述优化,因此先注释。
  290. //
  291. // @brief 读取TTY的stdin缓冲区
  292. //
  293. // @param buf 读取到的位置
  294. // @param block 是否阻塞读
  295. //
  296. // @return Ok(成功读取的字节数)
  297. // @return Err(TtyError) 内部错误信息
  298. // pub fn read_stdin(&mut self, buf: &mut [u8], block: bool) -> Result<usize, TtyError> {
  299. // let mut cnt = 0;
  300. // loop{
  301. // if cnt == buf.len(){
  302. // break;
  303. // }
  304. // let val:Option<u8> = self.stdin_queue.dequeue();
  305. // // 如果没读到
  306. // if val.is_none() {
  307. // // 如果阻塞读
  308. // if block {
  309. // let state_guard: RwLockUpgradableGuard<TtyCoreState> =
  310. // self.state.upgradeable_read();
  311. // // 判断是否有进程正在stdin上睡眠,如果有,则忙等读
  312. // // 理论上,这种情况应该不存在,因为stdin是单读者的
  313. // if state_guard.contains(TtyCoreState::BLOCK_AT_STDIN_READ) {
  314. // kwarn!("Read stdin: Process {} want to read its' stdin, but previous process {} is sleeping on the stdin.", current_pcb().pid, self.stdin_waiter.read().as_ref().unwrap().pid);
  315. // drop(state_guard);
  316. // Self::ringbuf_spin_dequeue(&mut buf[cnt], &mut self.stdin_queue);
  317. // cnt += 1;
  318. // } else {
  319. // // 正常情况,阻塞读,将当前进程休眠
  320. // let mut state_guard: RwLockWriteGuard<TtyCoreState> = state_guard.upgrade();
  321. // let mut stdin_waiter_guard: RwLockWriteGuard<
  322. // Option<&mut process_control_block>,
  323. // > = self.stdin_waiter.write();
  324. // // 由于输入数据到stdin的时候,必须先获得state guard的读锁。而这里我们已经获取了state的写锁。
  325. // // 因此可以保证,此时没有新的数据会进入stdin_queue. 因此再次尝试读取stdin_queue
  326. // let val:Option<u8> = self.stdin_queue.dequeue();
  327. // // 读到数据,不用睡眠
  328. // if val.is_some(){
  329. // buf[cnt] = val.unwrap();
  330. // cnt += 1;
  331. // continue;
  332. // }
  333. // // 没读到数据,准备睡眠
  334. // // 设置等待标志位
  335. // state_guard.set(TtyCoreState::BLOCK_AT_STDIN_READ, true);
  336. // // 将当前进程标记为被其他机制管理
  337. // unsafe {
  338. // current_pcb().mark_sleep_interruptible();
  339. // }
  340. // *stdin_waiter_guard = Some(current_pcb());
  341. // drop(stdin_waiter_guard);
  342. // drop(state_guard);
  343. // sched();
  344. // continue;
  345. // }
  346. // } else {
  347. // // 非阻塞读,没读到就直接返回了
  348. // return Ok(cnt);
  349. // }
  350. // }else{
  351. // buf[cnt] = val.unwrap();
  352. // cnt += 1;
  353. // }
  354. // }
  355. // return Ok(cnt);
  356. // }
  357. // fn write_stdin(&self)
  358. // /// @brief 非休眠的,自旋地读队列,直到有元素被读出来
  359. // fn ringbuf_spin_dequeue(dst: &mut u8, queue: &mut AllocRingBuffer<u8>) {
  360. // loop {
  361. // if let Some(val) = queue.dequeue() {
  362. // *dst = val;
  363. // return;
  364. // }
  365. // }
  366. // }