lkml.org 
[lkml]   [2023]   [Aug]   [17]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
Patch in this message
/
From
Date
SubjectRe: [RFC PATCH 0/7] Rust Socket abstractions
On Mon, 14 Aug 2023 at 23:36, Andrew Lunn <andrew@lunn.ch> wrote:
>
> > > There is a long standing tradition in Linux, you don't get a new API
> > > merged without a user.
> >
> > Sorry for not being clear on that.
> >
> > These abstractions are meant to be used by modules: having them, modules
> > can start using the kernel network functionalities through a first, high level
> > interface.
> >
> > Since there is currently no network support in Rust, this patch series
> > represents a first step to provide access to networking to modules.
> > Sockets are just the highest layer of the network stack: the goal would be
> > to port structures deeper in the network stack, to give modules more
> > access to the network api. However, you need to start somewhere.
> >
> > >
> > > There is not too much use of in kernel sockets. Network file systems
> > > like NFS, and SMB are one. These need to be careful with memory usage,
> > > you could be busy writing blocks out because the system is low on
> > > memory and trying to free some up, and asking for more memory might
> > > not work. Sending kernel log messages to a server. But that needs
> > > care because of the different contexts it can be used in. Without
> > > knowing what it will be used for, it is hard for us the point the
> > > special considerations which need to be made.
> > >
> > > So please also let us see the code using this API.
> > >
> > > Andrew
> >
> > The lack of these abstractions was noticed in the context of a research
> > of the usability of Rust for the development of consensus algorithms using UDP.
>
> O.K, so what are the use cases for consensus algorithms using UDP
> within the kernel? Where is this code? Ideally you should post it for
> merging alongside the rust API to sockets its needs. We can then
> review both together, just as we would if somebody were submitting a
> new API in C along with its user.
>
> Andrew

Hello Andrew,
in the last few days, I had the opportunity to discuss with some people from
the RustForLinux community.

I apologize for not being clear: the goal of these APIs was to give some
network support to, in particular, out-of-tree modules; they were not meant to
be used by a specific module that was planned to get upstreamed as well.
The idea behind this patch is that, as of now, Rust is not a viable option for
any OOT module that requires even the highest-level network support.

I am wondering whether the `net` subsystem is interested in reviewing, giving
feedback and eventually accepting code that is currently OOT-only.

Also, it would be interesting if you could provide us any module or
functionality you are planning to get in-tree which might use this interface;
it could be useful in order to understand the applicability of these
abstractions and find a concrete in-kernel use-case.

I included in the email a couple of sample OOT modules that showcase the
functionalities of the socket API; they will be attached as an actual patch if
there will be a v2.

Thank you for your time,
Michele


From 4c966f6ff3acd3b7c27f7a558648722b227d45a7 Mon Sep 17 00:00:00 2001
From: Michele Dalle Rive <dallerivemichele@gmail.com>
Date: Thu, 17 Aug 2023 15:51:47 +0200
Subject: [PATCH] rust: net: add OOT sample modules.

Add two sample modules that showcase some functionalities of the Rust
socket API.

Signed-off-by: Michele Dalle Rive <dallerivemichele@gmail.com>
---
samples/rust/rust_socket.rs | 45 +++++++++++++++++++++++++++++++++
samples/rust/rust_tcp_server.rs | 34 +++++++++++++++++++++++++
2 files changed, 79 insertions(+)
create mode 100644 samples/rust/rust_socket.rs
create mode 100644 samples/rust/rust_tcp_server.rs

diff --git a/samples/rust/rust_socket.rs b/samples/rust/rust_socket.rs
new file mode 100644
index 000000000000..fc1ed8536e57
--- /dev/null
+++ b/samples/rust/rust_socket.rs
@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: GPL-2.0
+
+//! Rust minimal sample.
+
+use core::str::FromStr;
+use kernel::prelude::*;
+use kernel::net::socket::*;
+use kernel::net::ip::IpProtocol;
+use kernel::net::addr::{SocketAddr};
+use kernel::net::AddressFamily;
+use kernel::flag_set;
+
+module! {
+ type: RustSocket,
+ name: "rust_socket",
+ author: "Rust for Linux Contributors",
+ description: "Rust sockets support sample",
+ license: "GPL",
+}
+
+struct RustSocket {}
+
+impl kernel::Module for RustSocket {
+ fn init(_module: &'static ThisModule) -> Result<Self> {
+ let sock = Socket::new(AddressFamily::Inet,
SockType::Datagram, IpProtocol::Udp)?;
+ let addr = "0.0.0.0:8000";
+ sock.bind(SocketAddr::from_str(addr)?)?;
+
+ sock.set_option::<opts::sock::ReuseAddr>(true)?;
+
+ assert_eq!(sock.sockname()?, SocketAddr::from_str(addr)?);
+
+ let mut buf = [0; 1024];
+ while let Ok((bytes, msghdr)) = sock.receive_msg(&mut buf,
flag_set!()) {
+ if bytes == 0 {
+ break;
+ }
+ pr_info!("Received {} bytes from {}", bytes,
msghdr.address().unwrap());
+ if msghdr.flags().contains(flags::MessageFlag::Trunc) {
+ pr_info!("The message was truncated");
+ }
+ }
+ Ok(Self{})
+ }
+}
\ No newline at end of file
diff --git a/samples/rust/rust_tcp_server.rs b/samples/rust/rust_tcp_server.rs
new file mode 100644
index 000000000000..987c4c752d2b
--- /dev/null
+++ b/samples/rust/rust_tcp_server.rs
@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: GPL-2.0
+
+//! Rust echo server sample.
+
+use core::str::FromStr;
+use kernel::prelude::*;
+use kernel::net::tcp::TcpListener;
+use kernel::net::addr::SocketAddr;
+use kernel::flag_set;
+
+module! {
+ type: RustTcpServer,
+ name: "rust_tcp_server",
+ author: "Rust for Linux Contributors",
+ license: "GPL",
+}
+
+struct RustTcpServer {}
+
+impl kernel::Module for RustTcpServer {
+ fn init(_module: &'static ThisModule) -> Result<Self> {
+ let listener =
TcpListener::new(SocketAddr::from_str("0.0.0.0:8000")?)?;
+ while let Ok(stream) = listener.accept() {
+ let mut buf = [0; 1024];
+ while let Ok(size) = stream.receive(&mut buf, flag_set!()) {
+ if size == 0 {
+ break;
+ }
+ stream.send(&buf[..size], flag_set!())?;
+ }
+ }
+ Ok(Self {})
+ }
+}
--
2.41.0
\
 
 \ /
  Last update: 2023-08-17 16:54    [W:0.147 / U:0.040 seconds]
©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site