Rust NetDevice and NetDeviceOperationsVtable struct

also adds drivers/net/dummy_rs.rs

Signed-off-by: Finn Behrens <[email protected]>

Author: kloenk

Diff for: drivers/net/Kconfig

@@ -72,6 +72,22 @@ config DUMMY
 	  To compile this driver as a module, choose M here: the module
 	  will be called dummy.
 
+config DUMMY_RS
+	tristate "Dummy net driver support"
+    depends on HAS_RUST
+	help
+	  This is essentially a bit-bucket device (i.e. traffic you send to
+	  this device is consigned into oblivion) with a configurable IP
+	  address. It is most commonly used in order to make your currently
+	  inactive SLIP address seem like a real address for local programs.
+	  If you use SLIP or PPP, you might want to say Y here. It won't
+	  enlarge your kernel. What a deal. Read about it in the Network
+	  Administrator's Guide, available from
+	  <http://www.tldp.org/docs.html#guide>.
+
+	  To compile this driver as a module, choose M here: the module
+	  will be called dummy_rs.
+
 config WIREGUARD
 	tristate "WireGuard secure network tunnel"
 	depends on NET && INET

Diff for: drivers/net/Makefile

@@ -10,6 +10,7 @@ obj-$(CONFIG_BONDING) += bonding/
 obj-$(CONFIG_IPVLAN) += ipvlan/
 obj-$(CONFIG_IPVTAP) += ipvlan/
 obj-$(CONFIG_DUMMY) += dummy.o
+obj-$(CONFIG_DUMMY_RS) += dummy_rs.o
 obj-$(CONFIG_WIREGUARD) += wireguard/
 obj-$(CONFIG_EQUALIZER) += eql.o
 obj-$(CONFIG_IFB) += ifb.o

Diff for: drivers/net/dummy_rs.rs

@@ -0,0 +1,228 @@
+// SPDX-License-Identifier: GPL-2.0
+
+//! Rust dummy network driver
+//! 
+//! This is a demonstration of what a small driver looks like in Rust, based on drivers/net/dummy.c.
+//! This code is provided as a demonstration only, not as a proposal to mass-rewrite existing drivers in Rust
+
+// TODO: copyright (see ./dummy.c)
+
+
+#![no_std]
+#![feature(allocator_api, global_asm)]
+
+use core::ops::Deref;
+
+use kernel::{net::netlink::{NlAttrVec, NlExtAck}, prelude::*};
+use kernel::net::prelude::*;
+use kernel::net::device;
+use kernel::net::rtnl;
+use kernel::Error;
+
+module! {
+    type: RustNetDummy,
+    name: b"dummy_rs",
+    author: b"Rust for Linux Contributors",
+    description: b"Rust dummy network driver",
+    license: b"GPL v2",
+    alias: b"rtnl-link-dummy_rs",
+    params: {
+        numdummies: usize {
+            default: 0,
+            permissions: 0o644,
+            description: b"Number of dummy_rs pseudo devices",
+        },
+    },
+}
+
+fn setup(dev: &mut NetDevice<DummyRsDev>) {
+    pr_info!("called rtnl_setup");
+    dev.ether_setup();
+
+    // Fill in device structure with ethernet-generic values.
+    dev.add_flag(device::Iff::NOARP);
+    dev.remove_flag(device::Iff::MULTICAST);
+
+    dev.add_private_flag(device::IffPriv::LIVE_ADDR_CHANGE);
+    dev.add_private_flag(device::IffPriv::NO_QUEUE);
+
+    let mut feature = device::feature::NetIF::new();
+
+    //feature.add(device::feature::NETIF_F_SG);
+    //feature.add(device::feature::NETIF_F_FRAGLIST_BIT as u64);
+    feature += device::feature::NETIF_F_SG;
+    feature += device::feature::NETIF_F_FRAGLIST;
+    feature += device::feature::NETIF_F_GSO_SOFTWARE;
+    feature += device::feature::NETIF_F_HW_CSUM;
+    feature += device::feature::NETIF_F_HIGHDMA;
+    feature += device::feature::NETIF_F_LLTX;
+    feature += device::feature::NETIF_F_GSO_ENCAP_ALL;
+
+    dev.set_features(feature);
+    dev.set_hw_features(feature);
+    dev.set_hw_enc_features(feature);
+
+    dev.hw_addr_random();
+    dev.set_mtu(0, 0);
+}
+
+fn validate(tb: &NlAttrVec, data: &NlAttrVec, ext_ack: &NlExtAck) -> KernelResult<()> {
+    pr_info!("validate nlattr");
+    if let Some(addr) = tb.get(kernel::bindings::IFLA_ADDRESS) {
+        if addr.nla_len() != kernel::net::netlink::ETH_ALEN {
+            return Err(Error::EINVAL);
+        }
+        if !addr.is_valid_ether_addr() {
+            return Err(Error::EADDRNOTAVAIL);
+        }
+    } else {
+        pr_info!("no IFLA_ADDRESS in nlattr");
+    }
+    pr_info!("valid nlattr");
+    Ok(())
+}
+
+rtnl_link_ops! {
+    kind: b"dummy_rs",
+    type: DummyRsDev,
+    setup: setup,
+    validate: validate,
+}
+
+struct RustNetDummy {
+    dev: NetDevice<DummyRsDev>,
+}
+
+
+impl KernelModule for RustNetDummy {
+    fn init() -> KernelResult<Self> {
+        {
+            let lock =THIS_MODULE.kernel_param_lock();
+            pr_info!("Rust Network Dummy with {} pseudo devices\n", numdummies.read(&lock));
+        }
+
+        unsafe { dummy_rs_rtnl_link_ops.register() }?;
+
+        let mut dev = NetDevice::new(DummyRsDev, kernel::cstr!("dummyrs%d"), kernel::net::device::NetNameAssingType::Enum, 1, 1)?;
+        dev.set_rtnl_ops( unsafe { &dummy_rs_rtnl_link_ops });
+
+        if let Err(e) = dev.register() {
+            pr_warn!("could not register: {}", e.to_kernel_errno());
+            return Err(e);
+        }
+        pr_info!("device registered");
+
+        Ok(RustNetDummy {
+            dev,
+        })
+    }
+}
+
+impl Drop for RustNetDummy {
+    fn drop(&mut self) {
+        pr_info!("remove rust net dummy");
+
+
+        unsafe {
+            //let ptr = &dummy_rs_rtnl_link_ops as *const _ as *mut kernel::bindings::rtnl_link_ops;
+            pr_info!("rtnl: {:#?}", &dummy_rs_rtnl_link_ops.0);
+            let ptr = &dummy_rs_rtnl_link_ops.get_ptr();
+            pr_info!("rtnl_link_ops_ptr: {:?}", ptr);
+        }
+        // TODO rtnl_link_unregister
+        // TODO: remove unsafe somehow
+        unsafe { dummy_rs_rtnl_link_ops.unregister() };
+    }
+}
+
+
+struct DummyRsDev;
+
+impl NetDeviceOps<Self> for DummyRsDev {
+    kernel::declare_net_device_ops!(
+        get_stats64,
+        change_carrier,
+        validate_addr,
+        set_mac_addr,
+        set_rx_mode
+    );
+
+    fn init(dev: &mut NetDevice<Self>) -> KernelResult<()> {
+        dev.set_new_pcpu_lstats()?;
+        Ok(())
+    }
+
+    fn uninit(dev: &mut NetDevice<Self>) {
+        unsafe { dev.free_lstats() };
+    }
+
+    fn start_xmit(skb: SkBuff, dev: &mut NetDevice<Self>) -> kernel::net::device::NetdevTX {
+        let mut skb = skb;
+
+        // TODO: dev_lstatt_add(dev, skb->len)
+        dev.lstats_add(skb.len());
+
+        skb.tx_timestamp();
+        drop(skb);
+
+        pr_info!("start_xmit called");
+
+        kernel::net::device::NetdevTX::TX_OK
+    }
+
+    fn get_stats64(dev: &NetDevice<Self>, stats: &mut rtnl::RtnlLinkStats64) {
+        pr_info!("get stats64");
+        stats.dev_read(dev);
+    }
+
+    fn change_carrier(dev: &mut NetDevice<Self>, new_carrier: bool) -> KernelResult<()> {
+        dev.carrier_set(new_carrier);
+
+        Ok(())
+    }
+
+    fn validate_addr(dev: &NetDevice<Self>) -> KernelResult<()> {
+        pr_info!("eth_validate_addr");
+        device::helpers::eth_validate_addr(dev)
+    }
+
+    fn set_mac_addr(dev: &mut NetDevice<Self>, p: *mut kernel::c_types::c_void) -> KernelResult<()> {
+        device::helpers::eth_mac_addr(dev, p)
+    }
+
+    // Someting about faking multicast
+    fn set_rx_mode(dev: &mut NetDevice<Self>) {
+         pr_info!("set_rx_mode");
+    }
+}
+
+impl NetDeviceAdapter for DummyRsDev {
+    type Inner = Self;
+
+    type Ops = Self;
+
+    type EthOps = Self;
+
+    fn setup(dev: &mut NetDevice<Self>) {
+        pr_info!("called netdev_setup");
+        setup(dev);
+        //dev.set_rtnl_ops( unsafe { &dummy_rs_rtnl_link_ops });
+    }
+}
+
+impl EthToolOps<Self> for DummyRsDev {
+    kernel::declare_eth_tool_ops!(get_drvinfo, get_ts_info);
+
+    fn get_drvinfo(_dev: &NetDevice<Self>, info: &mut ethtool::EthtoolDrvinfo) {
+        // TODO: how to do this more efficient without unsafe?
+        // FIXME: !!
+        let info: &kernel::bindings::ethtool_drvinfo = info.deref();
+        unsafe {
+            kernel::bindings::strlcpy(&(info.driver) as *const _ as *mut i8, b"dummy_rs\0" as *const _ as *mut i8, 32);
+        }
+    }
+
+    fn get_ts_info(dev: &NetDevice<Self>, info: &mut ethtool::EthToolTsInfo) -> KernelResult<()> {
+        kernel::net::ethtool::helpers::ethtool_op_get_ts_info(dev, info)
+    }
+}

Diff for: rust/helpers.c

@@ -7,6 +7,9 @@
 #include <linux/gfp.h>
 #include <linux/highmem.h>
 #include <linux/uio.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/rtnetlink.h>
 
 void rust_helper_BUG(void)
 {
@@ -105,8 +108,36 @@ size_t rust_helper_copy_to_iter(const void *addr, size_t bytes, struct iov_iter
 }
 EXPORT_SYMBOL_GPL(rust_helper_copy_to_iter);
 
-#if !defined(CONFIG_ARM)
+void *rust_helper_netdev_priv(struct net_device *dev)
+{
+	return netdev_priv(dev);
+}
+EXPORT_SYMBOL_GPL(rust_helper_netdev_priv);
+
+void rust_helper_eth_hw_addr_random(struct net_device *dev)
+{
+	eth_hw_addr_random(dev);
+}
+EXPORT_SYMBOL_GPL(rust_helper_eth_hw_addr_random);
+
+int rust_helper_net_device_set_new_lstats(struct net_device *dev)
+{
+	dev->lstats = netdev_alloc_pcpu_stats(struct pcpu_lstats);
+	if (!dev->lstats)
+		return -ENOMEM;
+
+	return 0;
+}
+EXPORT_SYMBOL_GPL(rust_helper_net_device_set_new_lstats);
+
+void rust_helper_dev_lstats_add(struct net_device *dev, unsigned int len)
+{
+	dev_lstats_add(dev, len);
+}
+EXPORT_SYMBOL_GPL(rust_helper_dev_lstats_add);
+
 // See https://github.com/rust-lang/rust-bindgen/issues/1671
+#if !defined(CONFIG_ARM)
 static_assert(__builtin_types_compatible_p(size_t, uintptr_t),
 	"size_t must match uintptr_t, what architecture is this??");
 #endif

Diff for: rust/kernel/bindings_helper.h

@@ -2,6 +2,12 @@
 
 #include <linux/cdev.h>
 #include <linux/fs.h>
+#include <linux/netdevice.h>
+#include <linux/ethtool.h>
+#include <linux/etherdevice.h>
+#include <linux/netdev_features.h>
+#include <linux/rtnetlink.h>
+#include <net/rtnetlink.h>
 #include <linux/module.h>
 #include <linux/random.h>
 #include <linux/slab.h>
@@ -17,3 +23,5 @@
 // `bindgen` gets confused at certain things
 const gfp_t BINDINGS_GFP_KERNEL = GFP_KERNEL;
 const gfp_t BINDINGS___GFP_ZERO = __GFP_ZERO;
+
+const int BINDINGS_NLA_HDRLEN = NLA_HDRLEN;

Diff for: rust/kernel/error.rs

@@ -6,7 +6,7 @@
 
 use crate::{bindings, c_types};
 use alloc::{alloc::AllocError, collections::TryReserveError};
-use core::{num::TryFromIntError, str::Utf8Error};
+use core::{convert::TryFrom, num::TryFromIntError, str::Utf8Error};
 
 /// Generic integer kernel error.
 ///
@@ -48,6 +48,9 @@ impl Error {
     /// Interrupted system call.
     pub const EINTR: Self = Error(-(bindings::EINTR as i32));
 
+    /// Cannot assign requested address
+    pub const EADDRNOTAVAIL: Self = Error(-(bindings::EADDRNOTAVAIL as i32));
+
     /// Creates an [`Error`] from a kernel error code.
     pub fn from_kernel_errno(errno: c_types::c_int) -> Error {
         Error(errno)
@@ -104,3 +107,24 @@ impl From<AllocError> for Error {
         Error::ENOMEM
     }
 }
+
+/// Used by the rtnl_link_ops macro to interface with C
+pub fn c_from_kernel_result<T>(r: KernelResult<T>) -> T
+where
+    T: TryFrom<c_types::c_int>,
+    T::Error: core::fmt::Debug,
+{
+    match r {
+        Ok(v) => v,
+        Err(e) => T::try_from(e.to_kernel_errno()).unwrap(),
+    }
+}
+
+#[macro_export]
+macro_rules! c_from_kernel_result {
+    ($($tt:tt)*) => {{
+        $crate::c_from_kernel_result((|| {
+            $($tt)*
+        })())
+    }};
+}

Diff for: rust/kernel/lib.rs

@@ -41,6 +41,7 @@ pub mod c_types;
 pub mod chrdev;
 mod error;
 pub mod file_operations;
+pub mod net;
 pub mod miscdev;
 pub mod pages;
 
@@ -64,7 +65,7 @@ pub mod iov_iter;
 mod types;
 pub mod user_ptr;
 
-pub use crate::error::{Error, KernelResult};
+pub use crate::error::{Error, KernelResult, c_from_kernel_result};
 pub use crate::types::{CStr, Mode};
 
 /// Page size defined in terms of the `PAGE_SHIFT` macro from C.