rust/net: add sock, tcp_sock and icsk wrappers

Signed-off-by: Valentin Obst <[email protected]>

Author: Valentin Obst

net/ipv4/Kconfig

@@ -466,6 +466,22 @@ 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 Rust kernel modules that integrate with TCP.
+
+	  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,36 @@ 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);
+
 /*
  * `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/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,143 @@
+// SPDX-License-Identifier: GPL-2.0-only
+
+//! Representation of a C `struct sock`.
+//!
+//! C header: [`include/net/sock.h`](srctree/include/net/sock.h)
+
+#[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 operations that are OK to use for the module.
+///
+/// # Invariants
+///
+/// Referencing a `sock` using this struct asserts that you are in
+/// a context where all safe methods defined on this struct are indeed safe to
+/// call.
+#[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 {
+        // NOTE: C uses READ_ONCE for this field, thus `read_volatile`.
+        // SAFETY: The struct invariant ensures that we may access
+        // this field without additional synchronization. It is a C unsigned
+        // long so we can always convert it to a u64 without loss.
+        unsafe { addr_of!((*self.sk.get()).sk_pacing_rate).read_volatile() as u64 }
+    }
+
+    /// Returns the sockets pacing status.
+    #[inline]
+    pub(crate) fn sk_pacing_status(&self) -> Result<Pacing, ()> {
+        // SAFETY: The struct invariant ensures that we may access
+        // this field without additional synchronization.
+        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: The struct invariant ensures that we may access
+        // this field without additional synchronization. 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 [`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)]
+#[allow(missing_docs)]
+pub enum Pacing {
+    r#None = bindings::sk_pacing_SK_PACING_NONE,
+    Needed = bindings::sk_pacing_SK_PACING_NEEDED,
+    Fq = bindings::sk_pacing_SK_PACING_FQ,
+}
+
+// TODO: Replace with automatically generated code by bindgen when it becomes
+// possible.
+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(()),
+        }
+    }
+}

rust/kernel/net/tcp.rs

@@ -0,0 +1,128 @@
+// SPDX-License-Identifier: GPL-2.0-only
+
+//! Transmission Control Protocol (TCP).
+
+use crate::time;
+use crate::types::Opaque;
+use core::{num, ptr};
+
+/// Representation of a `struct inet_connection_sock`.
+///
+/// # Invariants
+///
+/// Referencing a `inet_connection_sock` using this struct asserts that you are
+/// in a context where all safe methods defined on this struct are indeed safe
+/// to call.
+///
+/// C header: [`include/net/inet_connection_sock.h`](srctree/include/net/inet_connection_sock.h)
+#[repr(transparent)]
+pub struct InetConnectionSock {
+    icsk: Opaque<bindings::inet_connection_sock>,
+}
+
+/// Representation of a `struct tcp_sock`.
+///
+/// # Invariants
+///
+/// Referencing a `tcp_sock` using this struct asserts that you are in
+/// a context where all safe methods defined on this struct are indeed safe to
+/// call.
+///
+/// C header: [`include/linux/tcp.h`](srctree/include/linux/tcp.h)
+#[repr(transparent)]
+pub struct TcpSock {
+    tp: Opaque<bindings::tcp_sock>,
+}
+
+impl TcpSock {
+    /// Returns true iff `snd_cwnd < snd_ssthresh`.
+    #[inline]
+    pub fn in_slow_start(&self) -> bool {
+        // SAFETY: The struct invariant ensures that we may call this function
+        // without additional synchronization.
+        unsafe { bindings::tcp_in_slow_start(self.tp.get()) }
+    }
+
+    /// Performs the standard slow start increment of cwnd.
+    ///
+    /// If this causes the socket to exit slow start, any leftover ACKs are
+    /// returned.
+    #[inline]
+    pub fn slow_start(&mut self, acked: u32) -> u32 {
+        // SAFETY: The struct invariant ensures that we may call this function
+        // without additional synchronization.
+        unsafe { bindings::tcp_slow_start(self.tp.get(), acked) }
+    }
+
+    /// Performs the standard increase of cwnd during congestion avoidance.
+    ///
+    /// The increase per ACK is upper bounded by `1 / w`.
+    #[inline]
+    pub fn cong_avoid_ai(&mut self, w: num::NonZeroU32, acked: u32) {
+        // SAFETY: The struct invariant ensures that we may call this function
+        // without additional synchronization.
+        unsafe { bindings::tcp_cong_avoid_ai(self.tp.get(), w.get(), acked) };
+    }
+
+    /// Returns the connection's current cwnd.
+    #[inline]
+    pub fn snd_cwnd(&self) -> u32 {
+        // SAFETY: The struct invariant ensures that we may call this function
+        // without additional synchronization.
+        unsafe { bindings::tcp_snd_cwnd(self.tp.get()) }
+    }
+
+    /// Returns the connection's current ssthresh.
+    #[inline]
+    pub fn snd_ssthresh(&self) -> u32 {
+        // SAFETY: The struct invariant ensures that we may access
+        // this field without additional synchronization.
+        unsafe { *ptr::addr_of!((*self.tp.get()).snd_ssthresh) }
+    }
+
+    /// Returns the sequence number of the next byte that will be sent.
+    #[inline]
+    pub fn snd_nxt(&self) -> u32 {
+        // SAFETY: The struct invariant ensures that we may access
+        // this field without additional synchronization.
+        unsafe { *ptr::addr_of!((*self.tp.get()).snd_nxt) }
+    }
+
+    /// Returns the sequence number of the first unacknowledged byte.
+    #[inline]
+    pub fn snd_una(&self) -> u32 {
+        // SAFETY: The struct invariant ensures that we may access
+        // this field without additional synchronization.
+        unsafe { *ptr::addr_of!((*self.tp.get()).snd_una) }
+    }
+
+    /// Returns the time when the last packet was received or sent.
+    #[inline]
+    pub fn tcp_mstamp(&self) -> time::Usecs {
+        // SAFETY: The struct invariant ensures that we may access
+        // this field without additional synchronization.
+        unsafe { *ptr::addr_of!((*self.tp.get()).tcp_mstamp) }
+    }
+
+    /// Sets the connection's ssthresh.
+    #[inline]
+    pub fn set_snd_ssthresh(&mut self, new: u32) {
+        // SAFETY: The struct invariant ensures that we may access
+        // this field without additional synchronization.
+        unsafe { *ptr::addr_of_mut!((*self.tp.get()).snd_ssthresh) = new };
+    }
+
+    /// Returns the timestamp of the last send data packet in 32bit Jiffies.
+    #[inline]
+    pub fn lsndtime(&self) -> time::Jiffies32 {
+        // SAFETY: The struct invariant ensures that we may access
+        // this field without additional synchronization.
+        unsafe { *ptr::addr_of!((*self.tp.get()).lsndtime) as time::Jiffies32 }
+    }
+}
+
+/// Tests if `sqn_1` comes after `sqn_2`.
+#[inline]
+pub fn after(sqn_1: u32, sqn_2: u32) -> bool {
+    (sqn_2.wrapping_sub(sqn_1) as i32) < 0
+}