[starnix][nanohub] Integrate with serial device

Bug: 394110973
Change-Id: I6a6717cdd849c6d982eab13976a69a77950774e4
Reviewed-on: https://fuchsia-review.googlesource.com/c/fuchsia/+/1232026
Reviewed-by: Adam Barth <[email protected]>
Commit-Queue: Duncan Millard <[email protected]>

Author: Duncan Millard

src/starnix/kernel/device/registry.rs

@@ -391,7 +391,7 @@ impl DeviceRegistry {
     /// registrations with these device numbers, use this function instead to register the device.
     ///
     /// Note: We do not currently allocate from this entire range because we have mistakenly
-    /// hardcoded some device registrations from the dynamic range. Once we fix these regirations
+    /// hardcoded some device registrations from the dynamic range. Once we fix these registrations
     /// to be dynamic, we should expand to using the full dynamic range.
     ///
     /// See `register_device` for an explanation of the parameters.

src/starnix/kernel/device/serial.rs

@@ -38,8 +38,15 @@ impl ForwardTask {
             let _result = move || -> Result<(), Error> {
                 let waiter = Waiter::new();
                 loop {
+                    // Register edge triggered waiter for POLLOUT on terminal main side
+                    // This is waiting for the terminal to flag it can receive data
                     terminal.main_wait_async(&waiter, FdEvents::POLLOUT, EventHandler::None);
-                    waiter.wait(locked, current_task)?;
+
+                    // Only await the event if it is not already asserted
+                    if !terminal.main_query_events().contains(FdEvents::POLLOUT) {
+                        waiter.wait(locked, current_task)?;
+                    }
+
                     let data = serial_proxy
                         .read(zx::MonotonicInstant::INFINITE)?
                         .map_err(|e: i32| from_status_like_fdio!(zx::Status::from_raw(e)))?;
@@ -56,8 +63,15 @@ impl ForwardTask {
             let _result = move || -> Result<(), Error> {
                 let waiter = Waiter::new();
                 loop {
+                    // Register edge triggered waiter for POLLIN on terminal main side
+                    // This is waiting for the terminal to flag it has data to send
                     terminal.main_wait_async(&waiter, FdEvents::POLLIN, EventHandler::None);
-                    waiter.wait(locked, current_task)?;
+
+                    // Only await the event if it is not already asserted
+                    if !terminal.main_query_events().contains(FdEvents::POLLIN) {
+                        waiter.wait(locked, current_task)?;
+                    }
+
                     let size = terminal.read().get_available_read_size(true);
                     let mut buffer = VecOutputBuffer::new(size);
                     terminal.main_read(locked, &mut buffer)?;
@@ -87,7 +101,6 @@ impl SerialDevice {
     ///
     /// To register the device, call `register_serial_device`.
     pub fn new(
-        _locked: &mut Locked<'_, Unlocked>,
         current_task: &CurrentTask,
         serial_device: ClientEnd<fserial::DeviceMarker>,
     ) -> Result<Arc<Self>, Errno> {

src/starnix/kernel/meta/starnix_kernel.cml

@@ -60,6 +60,12 @@
             path: "/dev/class/gpu",
             availability: "optional",
         },
+        {
+            directory: "dev-serial",
+            rights: [ "r*" ],
+            path: "/dev/class/serial",
+            availability: "optional",
+        },
         {
             // This service replaces the directory capability above.
             service: "fuchsia.gpu.magma.Service",

src/starnix/modules/nanohub/BUILD.gn

@@ -28,12 +28,18 @@ rustc_library("nanohub") {
   ]
 
   deps = [
+    "//sdk/fidl/fuchsia.hardware.serial:fuchsia.hardware.serial_rust",
     "//sdk/fidl/fuchsia.hardware.sockettunnel:fuchsia.hardware.sockettunnel_rust",
     "//sdk/rust/zx",
+    "//src/lib/fdio/rust:fdio",
+    "//src/lib/fidl/rust/fidl",
     "//src/lib/fuchsia-component",
+    "//src/lib/fuchsia-fs",
     "//src/starnix/kernel:starnix_core",
+    "//src/starnix/kernel:starnix_logging",
     "//src/starnix/lib/starnix_sync",
     "//src/starnix/lib/starnix_syscalls",
     "//src/starnix/lib/starnix_uapi",
+    "//third_party/rust_crates:futures",
   ]
 }

src/starnix/modules/nanohub/nanohub.rs

@@ -2,14 +2,23 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+use std::ops::DerefMut;
+use std::sync::Arc;
+
 use crate::nanohub_comms_directory::NanohubCommsDirectory;
 use crate::socket_tunnel_file::register_socket_tunnel_device;
+use fidl_fuchsia_hardware_serial as fserial;
+use futures::TryStreamExt;
+use starnix_core::device::serial::SerialDevice;
 use starnix_core::fs::sysfs::DeviceDirectory;
-use starnix_core::task::CurrentTask;
+use starnix_core::task::{CurrentTask, Kernel};
 use starnix_core::vfs::{BytesFile, FsString, StaticDirectoryBuilder};
-use starnix_sync::{FileOpsCore, LockBefore, Locked};
+use starnix_logging::{log_error, log_info};
+use starnix_sync::{Locked, Unlocked};
 use starnix_uapi::mode;
 
+const SERIAL_DIRECTORY: &str = "/dev/class/serial";
+
 /// Function to be invoked by ProcDirectory while constructing /proc/device-tree
 pub fn nanohub_procfs_builder(
     builder: &'_ mut StaticDirectoryBuilder<'_>,
@@ -25,10 +34,7 @@ pub fn nanohub_procfs_builder(
     });
 }
 
-pub fn nanohub_device_init<L>(locked: &mut Locked<'_, L>, current_task: &CurrentTask)
-where
-    L: LockBefore<FileOpsCore>,
-{
+pub fn nanohub_device_init(locked: &mut Locked<'_, Unlocked>, current_task: &CurrentTask) {
     struct Descriptor {
         socket_label: FsString,
         dev_node_name: FsString,
@@ -100,4 +106,105 @@ where
         "nanohub".into(),
         NanohubCommsDirectory::new,
     );
+
+    // Spawn future to bind and configure serial device
+    current_task.kernel().kthreads.spawn_future({
+        let kernel = current_task.kernel().clone();
+        async move { register_serial_device(kernel).await }
+    });
+}
+
+async fn register_serial_device(kernel: Arc<Kernel>) {
+    let current_task = kernel.kthreads.system_task();
+
+    // TODO Move this to expect once test support is enabled
+    let dir =
+        match fuchsia_fs::directory::open_in_namespace(SERIAL_DIRECTORY, fuchsia_fs::PERM_READABLE)
+        {
+            Ok(dir) => dir,
+            Err(e) => {
+                log_error!("Failed to open serial directory: {:}", e);
+                return;
+            }
+        };
+
+    let mut watcher = match fuchsia_fs::directory::Watcher::new(&dir).await {
+        Ok(watcher) => watcher,
+        Err(e) => {
+            log_info!("Failed to create directory watcher for serial device: {:}", e);
+            return;
+        }
+    };
+
+    loop {
+        match watcher.try_next().await {
+            Ok(Some(watch_msg)) => {
+                let filename = watch_msg
+                    .filename
+                    .as_path()
+                    .to_str()
+                    .expect("Failed to convert watch_msg to str");
+                if filename == "." {
+                    continue;
+                }
+                if watch_msg.event == fuchsia_fs::directory::WatchEvent::ADD_FILE
+                    || watch_msg.event == fuchsia_fs::directory::WatchEvent::EXISTING
+                {
+                    let instance_path = format!("{}/{}", SERIAL_DIRECTORY, filename);
+                    let (client_channel, server_channel) = zx::Channel::create();
+                    if let Err(_) = fdio::service_connect(&instance_path, server_channel) {
+                        continue;
+                    }
+
+                    // `fuchsia.hardware.serial` exposes a `DeviceProxy` type used for binding with
+                    // a `Device` type. This should not be confused with the `DeviceProxy` generated
+                    // by FIDL
+                    let device_proxy = fserial::DeviceProxy_SynchronousProxy::new(client_channel);
+                    let (serial_proxy, server_end) =
+                        fidl::endpoints::create_sync_proxy::<fserial::DeviceMarker>();
+
+                    // Instruct the serial driver to bind the connection to the underlying device
+                    if let Err(_) = device_proxy.get_channel(server_end) {
+                        continue;
+                    }
+
+                    // Fetch the device class to see if this is the correct instance
+                    let device_class = match serial_proxy.get_class(zx::MonotonicInstant::INFINITE)
+                    {
+                        Ok(class) => class,
+                        Err(_) => continue,
+                    };
+
+                    if device_class == fserial::Class::Mcu {
+                        let serial_device =
+                            SerialDevice::new(current_task, serial_proxy.into_channel().into())
+                                .expect("Can create SerialDevice wrapper");
+
+                        // TODO This will register with an incorrect device number. We should be
+                        // dynamically registering a major device and this should be minor device 1
+                        // of that major device.
+                        let registry = &current_task.kernel().device_registry;
+                        registry
+                            .register_dyn_device(
+                                current_task.kernel().kthreads.unlocked_for_async().deref_mut(),
+                                current_task,
+                                "ttyHS1".into(),
+                                registry.objects.tty_class(),
+                                DeviceDirectory::new,
+                                serial_device,
+                            )
+                            .expect("Can register serial device");
+                        break;
+                    }
+                }
+            }
+            Ok(None) => {
+                break;
+            }
+            Err(e) => {
+                log_error!("Serial driver stream ended with error: {:}", e);
+                break;
+            }
+        }
+    }
 }

src/starnix/runner/meta/starnix_runner.cml

@@ -151,6 +151,11 @@
             from: "parent",
             to: [ "#kernels" ],
         },
+        {
+            directory: "dev-serial",
+            from: "parent",
+            to: [ "#kernels" ],
+        },
         {
             // This service replaces the directory capability above.
             service: "fuchsia.gpu.magma.Service",

src/starnix/runner/meta/starnix_runner.core_shard.cml

@@ -143,6 +143,13 @@
             to: [ "#starnix_runner" ],
             subdir: "gpu",
         },
+        {
+            directory: "dev-class",
+            from: "parent",
+            as: "dev-serial",
+            to: [ "#starnix_runner" ],
+            subdir: "serial",
+        },
         {
             // This service replaces the directory capability above.
             service: "fuchsia.gpu.magma.Service",