starnix_core/device/
serial.rs

1// Copyright 2025 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5use crate::device::kobject::DeviceMetadata;
6use crate::device::terminal::{Terminal, TtyState};
7use crate::device::{DeviceMode, DeviceOps};
8use crate::fs::devpts::{TtyFile, new_pts_fs_with_state};
9use crate::task::dynamic_thread_spawner::SpawnRequestBuilder;
10use crate::task::{CurrentTask, EventHandler, Kernel, Waiter};
11use crate::vfs::{FileOps, FsString, NamespaceNode, VecInputBuffer, VecOutputBuffer};
12use anyhow::Error;
13use fidl::endpoints::ClientEnd;
14use fidl_fuchsia_hardware_serial as fserial;
15use starnix_sync::{FileOpsCore, Locked, Unlocked};
16use starnix_uapi::device_type::{DeviceType, TTY_MAJOR};
17use starnix_uapi::errors::Errno;
18use starnix_uapi::from_status_like_fdio;
19use starnix_uapi::open_flags::OpenFlags;
20use starnix_uapi::vfs::FdEvents;
21use std::sync::Arc;
22
23struct ForwardTask {
24    terminal: Arc<Terminal>,
25    serial_proxy: Arc<fserial::DeviceSynchronousProxy>,
26}
27
28impl ForwardTask {
29    fn new(terminal: Arc<Terminal>, serial_proxy: Arc<fserial::DeviceSynchronousProxy>) -> Self {
30        terminal.main_open();
31        Self { terminal, serial_proxy }
32    }
33
34    fn spawn_reader(&self, kernel: &Kernel) {
35        let terminal = self.terminal.clone();
36        let serial_proxy = self.serial_proxy.clone();
37        let closure = move |locked: &mut Locked<Unlocked>, current_task: &CurrentTask| {
38            let _result = move || -> Result<(), Error> {
39                let waiter = Waiter::new();
40                loop {
41                    // Register edge triggered waiter for POLLOUT on terminal main side
42                    // This is waiting for the terminal to flag it can receive data
43                    terminal.main_wait_async(&waiter, FdEvents::POLLOUT, EventHandler::None);
44
45                    // Only await the event if it is not already asserted
46                    if !terminal.main_query_events().contains(FdEvents::POLLOUT) {
47                        waiter.wait(locked, current_task)?;
48                    }
49
50                    let data = serial_proxy
51                        .read(zx::MonotonicInstant::INFINITE)?
52                        .map_err(|e: i32| from_status_like_fdio!(zx::Status::from_raw(e)))?;
53                    terminal.main_write(locked, &mut VecInputBuffer::from(data))?;
54                }
55            }();
56        };
57        let req = SpawnRequestBuilder::new()
58            .with_debug_name("serial-reader")
59            .with_sync_closure(closure)
60            .build();
61        kernel.kthreads.spawner().spawn_from_request(req);
62    }
63
64    fn spawn_writer(&self, kernel: &Kernel) {
65        let terminal = self.terminal.clone();
66        let serial_proxy = self.serial_proxy.clone();
67        let closure = move |locked: &mut Locked<Unlocked>, current_task: &CurrentTask| {
68            let _result = move || -> Result<(), Error> {
69                let waiter = Waiter::new();
70                loop {
71                    // Register edge triggered waiter for POLLIN on terminal main side
72                    // This is waiting for the terminal to flag it has data to send
73                    terminal.main_wait_async(&waiter, FdEvents::POLLIN, EventHandler::None);
74
75                    // Only await the event if it is not already asserted
76                    if !terminal.main_query_events().contains(FdEvents::POLLIN) {
77                        waiter.wait(locked, current_task)?;
78                    }
79
80                    let size = terminal.read().get_available_read_size(true);
81                    let mut buffer = VecOutputBuffer::new(size);
82                    terminal.main_read(locked, &mut buffer)?;
83                    serial_proxy
84                        .write(buffer.data(), zx::MonotonicInstant::INFINITE)?
85                        .map_err(|e: i32| from_status_like_fdio!(zx::Status::from_raw(e)))?;
86                }
87            }();
88        };
89        let req = SpawnRequestBuilder::new()
90            .with_debug_name("serial-writer")
91            .with_sync_closure(closure)
92            .build();
93        kernel.kthreads.spawner().spawn_from_request(req);
94    }
95}
96
97impl Drop for ForwardTask {
98    fn drop(&mut self) {
99        self.terminal.main_close();
100        // TODO: How do we terminate the spawned threads?
101    }
102}
103
104pub struct SerialDevice {
105    terminal: Arc<Terminal>,
106    _forward_task: ForwardTask,
107}
108
109impl SerialDevice {
110    /// Create a serial device attached to the given fuchsia.hardware.serial endpoint.
111    ///
112    /// To register the device, call `register_serial_device`.
113    pub fn new(
114        locked: &mut Locked<Unlocked>,
115        current_task: &CurrentTask,
116        serial_device: ClientEnd<fserial::DeviceMarker>,
117    ) -> Result<Arc<Self>, Errno> {
118        let kernel = current_task.kernel();
119
120        let state = Arc::new(TtyState::default());
121        let fs = new_pts_fs_with_state(locked, kernel, Default::default(), state.clone())?;
122        let terminal = state.get_next_terminal(fs.root().clone(), current_task.current_fscred())?;
123
124        let serial_proxy = Arc::new(serial_device.into_sync_proxy());
125        let forward_task = ForwardTask::new(terminal.clone(), serial_proxy);
126        forward_task.spawn_reader(kernel);
127        forward_task.spawn_writer(kernel);
128
129        Ok(Arc::new(Self { terminal, _forward_task: forward_task }))
130    }
131}
132
133impl DeviceOps for Arc<SerialDevice> {
134    fn open(
135        &self,
136        _locked: &mut Locked<FileOpsCore>,
137        _current_task: &CurrentTask,
138        _id: DeviceType,
139        _node: &NamespaceNode,
140        _flags: OpenFlags,
141    ) -> Result<Box<dyn FileOps>, Errno> {
142        Ok(Box::new(TtyFile::new(self.terminal.clone())))
143    }
144}
145
146/// Register the given serial device.
147///
148/// The `index` should be the numerical value associated with the device. For example, if you want
149/// to register /dev/ttyS<n>, then `index` should be `n`.
150pub fn register_serial_device(
151    locked: &mut Locked<Unlocked>,
152    system_task: &CurrentTask,
153    index: u32,
154    serial_device: Arc<SerialDevice>,
155) -> Result<(), Errno> {
156    // See https://www.kernel.org/doc/Documentation/admin-guide/devices.txt
157    //  64 = /dev/ttyS0    First UART serial port
158    const SERIAL_MINOR_BASE: u32 = 64;
159
160    let name = FsString::from(format!("ttyS{}", index));
161
162    let kernel = system_task.kernel();
163    let registry = &kernel.device_registry;
164    registry.register_device(
165        locked,
166        system_task,
167        name.as_ref(),
168        DeviceMetadata::new(
169            name.clone(),
170            DeviceType::new(TTY_MAJOR, SERIAL_MINOR_BASE + index),
171            DeviceMode::Char,
172        ),
173        registry.objects.tty_class(),
174        serial_device,
175    )?;
176    Ok(())
177}
starnix_core/device/serial.rs

starnix_core/device/
serial.rs
