rust/kernel: add TCP CCA abstractions

This patch contains the abstractions that facilitate the implementation
of CCAs in Rust. They are split into two modules.

The `tcp` module contains the elements that are not specific to CCAs,
like the wrapper for the `struct tcp_sock`. It is intended to be
re-usable by abstractions for other parts of the TCP subsystem.

The `tcp::cong` module contains the `module_cca` macro that allows for
the convenient declaration of modules that implement a single CCA. It
mainly handles the registration and unregistration of the algorithms
with the rest of the kernel. The second important part it the
`Algorithm` trait, which represents the definition a single CCA. The
rest are wrappers around C structures that are specific to the CCA
use-case. For example, the `struct sock *` wrapper limits the operations
that CCAs can perform on the socket to those that are OK for them to do.

Author: Valentin Obst

net/ipv4/Kconfig

@@ -466,6 +466,23 @@ config INET_DIAG_DESTROY
 	  had been disconnected.
 	  If unsure, say N.
 
+config RUST_SOCK_ABSTRACTIONS
+	bool "INET: Rust sock abstractions"
+	depends on RUST
+	help
+	  Adds Rust abstractions for working with `struct sock`s.
+
+	  If unsure, say N.
+
+config RUST_TCP_ABSTRACTIONS
+	bool "TCP: Rust abstractions"
+	depends on RUST_SOCK_ABSTRACTIONS
+	help
+	  Adds support for writing kernel modules that integrate with TCP in
+	  Rust.
+
+	  If unsure, say N.
+
 menuconfig TCP_CONG_ADVANCED
 	bool "TCP: advanced congestion control"
 	help

rust/bindings/bindings_helper.h

@@ -17,6 +17,7 @@
 #include <linux/slab.h>
 #include <linux/wait.h>
 #include <linux/workqueue.h>
+#include <net/tcp.h>
 
 /* `bindgen` gets confused at certain things. */
 const size_t RUST_CONST_HELPER_ARCH_SLAB_MINALIGN = ARCH_SLAB_MINALIGN;

rust/helpers.c

@@ -31,6 +31,7 @@
 #include <linux/spinlock.h>
 #include <linux/wait.h>
 #include <linux/workqueue.h>
+#include <net/tcp.h>
 
 __noreturn void rust_helper_BUG(void)
 {
@@ -157,6 +158,42 @@ void rust_helper_init_work_with_key(struct work_struct *work, work_func_t func,
 }
 EXPORT_SYMBOL_GPL(rust_helper_init_work_with_key);
 
+bool rust_helper_tcp_in_slow_start(const struct tcp_sock *tp)
+{
+	return tcp_in_slow_start(tp);
+}
+EXPORT_SYMBOL_GPL(rust_helper_tcp_in_slow_start);
+
+bool rust_helper_tcp_is_cwnd_limited(const struct sock *sk)
+{
+	return tcp_is_cwnd_limited(sk);
+}
+EXPORT_SYMBOL_GPL(rust_helper_tcp_is_cwnd_limited);
+
+struct tcp_sock *rust_helper_tcp_sk(struct sock *sk)
+{
+	return tcp_sk(sk);
+}
+EXPORT_SYMBOL_GPL(rust_helper_tcp_sk);
+
+u32 rust_helper_tcp_snd_cwnd(const struct tcp_sock *tp)
+{
+	return tcp_snd_cwnd(tp);
+}
+EXPORT_SYMBOL_GPL(rust_helper_tcp_snd_cwnd);
+
+struct inet_connection_sock *rust_helper_inet_csk(const struct sock *sk)
+{
+	return inet_csk(sk);
+}
+EXPORT_SYMBOL_GPL(rust_helper_inet_csk);
+
+void *rust_helper_inet_csk_ca(struct sock *sk)
+{
+	return inet_csk_ca(sk);
+}
+EXPORT_SYMBOL_GPL(rust_helper_inet_csk_ca);
+
 /*
  * `bindgen` binds the C `size_t` type as the Rust `usize` type, so we can
  * use it in contexts where Rust expects a `usize` like slice (array) indices.

rust/kernel/lib.rs

@@ -13,6 +13,7 @@
 
 #![no_std]
 #![feature(allocator_api)]
+#![feature(associated_type_bounds)]
 #![feature(coerce_unsized)]
 #![feature(dispatch_from_dyn)]
 #![feature(new_uninit)]

rust/kernel/net.rs

@@ -4,3 +4,7 @@
 
 #[cfg(CONFIG_RUST_PHYLIB_ABSTRACTIONS)]
 pub mod phy;
+#[cfg(CONFIG_RUST_SOCK_ABSTRACTIONS)]
+pub mod sock;
+#[cfg(CONFIG_RUST_TCP_ABSTRACTIONS)]
+pub mod tcp;

rust/kernel/net/sock.rs

@@ -0,0 +1,170 @@
+//! Representation of a C `struct sock`.
+
+#[cfg(CONFIG_RUST_TCP_ABSTRACTIONS)]
+use crate::net::tcp::{self, InetConnectionSock, TcpSock};
+use crate::types::Opaque;
+use core::convert::TryFrom;
+use core::ptr::addr_of;
+
+/// Representation of a C `struct sock`.
+///
+/// Not intended to be used directly by modules. Abstractions should provide a
+/// safe interface to only those methods that are OK to use for the module.
+#[repr(transparent)]
+pub(crate) struct Sock {
+    sk: Opaque<bindings::sock>,
+}
+
+impl Sock {
+    /// Returns a raw pointer to the wrapped `struct sock`.
+    ///
+    /// It is up to the caller to use it correctly.
+    #[inline]
+    pub(crate) fn raw_sk_mut(&mut self) -> *mut bindings::sock {
+        self.sk.get()
+    }
+
+    /// Returns the sockets pacing rate in bytes per second.
+    #[inline]
+    pub(crate) fn sk_pacing_rate(&self) -> u64 {
+        // SAFETY: This field can always be read. It is a C unsigned long so we
+        // can always convert it to a u64 without loss.
+        // TODO: Make READ_ONCE once it is available.
+        unsafe { *addr_of!((*self.sk.get()).sk_pacing_rate) as u64 }
+    }
+
+    /// Returns the sockets pacing status.
+    #[inline]
+    pub(crate) fn sk_pacing_status(&self) -> Result<Pacing, ()> {
+        // SAFETY: This field can always be read.
+        unsafe { Pacing::try_from(*addr_of!((*self.sk.get()).sk_pacing_status)) }
+    }
+
+    /// Returns the sockets maximum GSO segment size to build.
+    #[inline]
+    pub(crate) fn sk_gso_max_size(&self) -> u32 {
+        // SAFETY: This field can always be read. It is an unsigned int and we
+        // are guaranteed that this will always fit into a u32.
+        unsafe { *addr_of!((*self.sk.get()).sk_gso_max_size) as u32 }
+    }
+
+    /// Returns the [`TcpSock`] that is containing the `Sock`.
+    ///
+    /// # Safety
+    ///
+    /// `sk` must be valid for `tcp_sk`.
+    #[inline]
+    #[cfg(CONFIG_RUST_TCP_ABSTRACTIONS)]
+    pub(crate) unsafe fn tcp_sk<'a>(&'a self) -> &'a TcpSock {
+        // SAFETY:
+        // - Downcasting via `tcp_sk` is OK by the functions precondition.
+        // - The cast is OK since `TcpSock` is transparent to `struct tcp_sock`.
+        unsafe { &*(bindings::tcp_sk(self.sk.get()) as *const TcpSock) }
+    }
+
+    /// Returns the [`TcpSock`] that is containing the `Sock`.
+    ///
+    /// # Safety
+    ///
+    /// `sk` must be valid for `tcp_sk`.
+    #[inline]
+    #[cfg(CONFIG_RUST_TCP_ABSTRACTIONS)]
+    pub(crate) unsafe fn tcp_sk_mut<'a>(&'a mut self) -> &'a mut TcpSock {
+        // SAFETY:
+        // - Downcasting via `tcp_sk` is OK by the functions precondition.
+        // - The cast is OK since `TcpSock` is transparent to `struct tcp_sock`.
+        unsafe { &mut *(bindings::tcp_sk(self.sk.get()) as *mut TcpSock) }
+    }
+
+    /// Returns the [private data] of the instance of the CCA used by this
+    /// socket.
+    ///
+    /// [private data]: tcp::cong::Algorithm::Data
+    ///
+    /// # Safety
+    ///
+    /// - `sk` must be valid for `inet_csk_ca`,
+    /// - `sk` must use the CCA `T`, the `init` CB of the CCA must have been
+    ///   called, the `release` CB of the CCA must not have been called.
+    #[inline]
+    #[cfg(CONFIG_RUST_TCP_ABSTRACTIONS)]
+    pub(crate) unsafe fn inet_csk_ca<'a, T: tcp::cong::Algorithm + ?Sized>(
+        &'a self,
+    ) -> &'a T::Data {
+        // SAFETY: By the function's preconditions, calling `inet_csk_ca` is OK
+        // and the returned pointer points to a valid instance of `T::Data`.
+        unsafe { &*(bindings::inet_csk_ca(self.sk.get()) as *const T::Data) }
+    }
+
+    /// Returns the [private data] of the instance of the CCA used by this
+    /// socket.
+    ///
+    /// [private data]: tcp::cong::Algorithm::Data
+    ///
+    /// # Safety
+    ///
+    /// - `sk` must be valid for `inet_csk_ca`,
+    /// - `sk` must use the CCA `T`, the `init` CB of the CCA must have been
+    ///   called, the `release` CB of the CCA must not have been called.
+    #[inline]
+    #[cfg(CONFIG_RUST_TCP_ABSTRACTIONS)]
+    pub(crate) unsafe fn inet_csk_ca_mut<'a, T: tcp::cong::Algorithm + ?Sized>(
+        &'a mut self,
+    ) -> &'a mut T::Data {
+        // SAFETY: By the function's preconditions, calling `inet_csk_ca` is OK
+        // and the returned pointer points to a valid instance of `T::Data`.
+        unsafe { &mut *(bindings::inet_csk_ca(self.sk.get()) as *mut T::Data) }
+    }
+
+    /// Returns the [`InetConnectionSock`] view of this socket.
+    ///
+    /// # Safety
+    ///
+    /// `sk` must be valid for `inet_csk`.
+    #[inline]
+    #[cfg(CONFIG_RUST_TCP_ABSTRACTIONS)]
+    pub(crate) unsafe fn inet_csk<'a>(&'a self) -> &'a InetConnectionSock {
+        // SAFETY:
+        // - Calling `inet_csk` is OK by the functions precondition.
+        // - The cast is OK since `InetConnectionSock` is transparent to
+        //   `struct inet_connection_sock`.
+        unsafe { &*(bindings::inet_csk(self.sk.get()) as *const InetConnectionSock) }
+    }
+
+    /// Tests if the connection's sending rate is limited by the cwnd.
+    ///
+    /// # Safety
+    ///
+    /// `sk` must be valid for `tcp_is_cwnd_limited`.
+    #[inline]
+    #[cfg(CONFIG_RUST_TCP_ABSTRACTIONS)]
+    pub(crate) unsafe fn tcp_is_cwnd_limited(&self) -> bool {
+        // SAFETY: Calling `tcp_is_cwnd_limited` is OK by the functions
+        // precondition.
+        unsafe { bindings::tcp_is_cwnd_limited(self.sk.get()) }
+    }
+}
+
+/// The socket's pacing status.
+#[repr(u32)]
+pub enum Pacing {
+    /// TODO
+    r#None = bindings::sk_pacing_SK_PACING_NONE,
+    /// TODO
+    Needed = bindings::sk_pacing_SK_PACING_NEEDED,
+    /// TODO
+    Fq = bindings::sk_pacing_SK_PACING_FQ,
+}
+
+impl TryFrom<u32> for Pacing {
+    type Error = ();
+
+    fn try_from(val: u32) -> Result<Self, Self::Error> {
+        match val {
+            x if x == Pacing::r#None as u32 => Ok(Pacing::r#None),
+            x if x == Pacing::Needed as u32 => Ok(Pacing::Needed),
+            x if x == Pacing::Fq as u32 => Ok(Pacing::Fq),
+            _ => Err(()),
+        }
+    }
+}