Skip to content

Commit 4163634

Browse files
kloenkkloenk
committed
Rust NetDevice and NetDeviceOperationsVtable struct
also adds drivers/net/dummy_rs.rs Signed-off-by: Finn Behrens <[email protected]>
1 parent 1825e2f commit 4163634

14 files changed

+2177
-3
lines changed

‎drivers/net/Kconfig

+16
Original file line numberDiff line numberDiff line change
@@ -72,6 +72,22 @@ config DUMMY
7272
To compile this driver as a module, choose M here: the module
7373
will be called dummy.
7474

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

‎drivers/net/Makefile

+1
Original file line numberDiff line numberDiff line change
@@ -10,6 +10,7 @@ obj-$(CONFIG_BONDING) += bonding/
1010
obj-$(CONFIG_IPVLAN) += ipvlan/
1111
obj-$(CONFIG_IPVTAP) += ipvlan/
1212
obj-$(CONFIG_DUMMY) += dummy.o
13+
obj-$(CONFIG_DUMMY_RS) += dummy_rs.o
1314
obj-$(CONFIG_WIREGUARD) += wireguard/
1415
obj-$(CONFIG_EQUALIZER) += eql.o
1516
obj-$(CONFIG_IFB) += ifb.o

‎drivers/net/dummy_rs.rs

+217
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,217 @@
1+
// SPDX-License-Identifier: GPL-2.0
2+
3+
//! Rust dummy network driver
4+
//!
5+
//! This is a demonstration of what a small driver looks like in Rust, based on drivers/net/dummy.c.
6+
//! This code is provided as a demonstration only, not as a proposal to mass-rewrite existing drivers in Rust
7+
8+
// TODO: copyright (see ./dummy.c)
9+
10+
#![no_std]
11+
#![feature(allocator_api, global_asm)]
12+
13+
use core::ops::Deref;
14+
15+
use kernel::net::device;
16+
use kernel::net::prelude::*;
17+
use kernel::net::rtnl;
18+
use kernel::Error;
19+
use kernel::{
20+
net::netlink::{NlAttrVec, NlExtAck},
21+
prelude::*,
22+
};
23+
24+
module! {
25+
type: RustNetDummy,
26+
name: b"dummy_rs",
27+
author: b"Rust for Linux Contributors",
28+
description: b"Rust dummy network driver",
29+
license: b"GPL v2",
30+
alias_rtnl_link: b"dummy_rs",
31+
params: {
32+
numdummies: usize {
33+
default: 0,
34+
permissions: 0,
35+
description: b"Number of dummy_rs pseudo devices",
36+
},
37+
},
38+
}
39+
40+
fn setup(dev: &mut NetDevice<DummyRsDev>) {
41+
dev.ether_setup();
42+
43+
dev.set_ops();
44+
45+
// Fill in device structure with ethernet-generic values.
46+
dev.add_flag(device::Iff::NOARP);
47+
dev.remove_flag(device::Iff::MULTICAST);
48+
49+
dev.add_private_flag(device::IffPriv::LIVE_ADDR_CHANGE);
50+
dev.add_private_flag(device::IffPriv::NO_QUEUE);
51+
52+
let mut feature = device::feature::NetIF::new();
53+
54+
//feature.add(device::feature::NETIF_F_SG);
55+
//feature.add(device::feature::NETIF_F_FRAGLIST_BIT as u64);
56+
feature += device::feature::NETIF_F_SG;
57+
feature += device::feature::NETIF_F_FRAGLIST;
58+
feature += device::feature::NETIF_F_GSO_SOFTWARE;
59+
feature += device::feature::NETIF_F_HW_CSUM;
60+
feature += device::feature::NETIF_F_HIGHDMA;
61+
feature += device::feature::NETIF_F_LLTX;
62+
feature += device::feature::NETIF_F_GSO_ENCAP_ALL;
63+
64+
dev.set_features(feature);
65+
dev.set_hw_features(feature);
66+
dev.set_hw_enc_features(feature);
67+
68+
dev.hw_addr_random();
69+
dev.set_mtu(0, 0);
70+
}
71+
72+
fn validate(tb: &NlAttrVec, _data: &NlAttrVec, _ext_ack: &NlExtAck) -> KernelResult<()> {
73+
if let Some(addr) = tb.get(kernel::bindings::IFLA_ADDRESS) {
74+
if addr.nla_len() != kernel::net::netlink::ETH_ALEN {
75+
return Err(Error::EINVAL);
76+
}
77+
if !addr.is_valid_ether_addr() {
78+
return Err(Error::EADDRNOTAVAIL);
79+
}
80+
}
81+
Ok(())
82+
}
83+
84+
rtnl_link_ops! {
85+
kind: b"dummy_rs",
86+
type: DummyRsDev,
87+
setup: setup,
88+
validate: validate,
89+
}
90+
91+
struct RustNetDummy {
92+
//dev: NetDevice<DummyRsDev>,
93+
}
94+
95+
impl KernelModule for RustNetDummy {
96+
fn init() -> KernelResult<Self> {
97+
let num = *numdummies.read();
98+
99+
unsafe { dummy_rs_link_ops.register() }?;
100+
101+
for _ in 0..(num) {
102+
let dev = NetDevice::new(
103+
DummyRsDev,
104+
kernel::cstr!("dummyrs%d"),
105+
kernel::net::device::NetNameAssingType::Enum,
106+
1,
107+
1,
108+
)?;
109+
dev.set_rtnl_ops(unsafe { &dummy_rs_link_ops });
110+
111+
if let Err(e) = dev.register() {
112+
pr_warn!("could not register: {}", e.to_kernel_errno());
113+
return Err(e);
114+
}
115+
}
116+
117+
Ok(RustNetDummy {
118+
//dev,
119+
})
120+
}
121+
}
122+
123+
impl Drop for RustNetDummy {
124+
fn drop(&mut self) {
125+
// TODO: remove unsafe somehow
126+
unsafe { dummy_rs_link_ops.unregister() };
127+
}
128+
}
129+
130+
struct DummyRsDev;
131+
132+
impl NetDeviceOps<Self> for DummyRsDev {
133+
kernel::declare_net_device_ops!(
134+
get_stats64,
135+
change_carrier,
136+
validate_addr,
137+
set_mac_addr,
138+
set_rx_mode
139+
);
140+
141+
fn init(dev: &mut NetDevice<Self>) -> KernelResult<()> {
142+
dev.set_new_pcpu_lstats()?;
143+
Ok(())
144+
}
145+
146+
fn uninit(dev: &mut NetDevice<Self>) {
147+
unsafe { dev.free_lstats() };
148+
}
149+
150+
fn start_xmit(skb: SkBuff, dev: &mut NetDevice<Self>) -> kernel::net::device::NetdevTX {
151+
let mut skb = skb;
152+
153+
dev.lstats_add(skb.len());
154+
155+
skb.tx_timestamp();
156+
drop(skb);
157+
158+
kernel::net::device::NetdevTX::TX_OK
159+
}
160+
161+
fn get_stats64(dev: &NetDevice<Self>, stats: &mut rtnl::RtnlLinkStats64) {
162+
stats.dev_read(dev);
163+
}
164+
165+
fn change_carrier(dev: &mut NetDevice<Self>, new_carrier: bool) -> KernelResult<()> {
166+
dev.carrier_set(new_carrier);
167+
168+
Ok(())
169+
}
170+
171+
fn validate_addr(dev: &NetDevice<Self>) -> KernelResult<()> {
172+
device::helpers::eth_validate_addr(dev)
173+
}
174+
175+
fn set_mac_addr(
176+
dev: &mut NetDevice<Self>,
177+
p: *mut kernel::c_types::c_void,
178+
) -> KernelResult<()> {
179+
device::helpers::eth_mac_addr(dev, p)
180+
}
181+
182+
// [Someting about faking multicast](https://elixir.bootlin.com/linux/v5.12-rc4/source/drivers/net/dummy.c#L48).
183+
fn set_rx_mode(_dev: &mut NetDevice<Self>) {}
184+
}
185+
186+
impl NetDeviceAdapter for DummyRsDev {
187+
type Inner = Self;
188+
189+
type Ops = Self;
190+
191+
type EthOps = Self;
192+
193+
fn setup(dev: &mut NetDevice<Self>) {
194+
setup(dev);
195+
}
196+
}
197+
198+
impl EthToolOps<Self> for DummyRsDev {
199+
kernel::declare_eth_tool_ops!(get_drvinfo, get_ts_info);
200+
201+
fn get_drvinfo(_dev: &NetDevice<Self>, info: &mut ethtool::EthtoolDrvinfo) {
202+
// TODO: how to do this more efficient without unsafe?
203+
// FIXME: !!
204+
let info: &kernel::bindings::ethtool_drvinfo = info.deref();
205+
unsafe {
206+
kernel::bindings::strlcpy(
207+
&(info.driver) as *const _ as *mut i8,
208+
b"dummy_rs\0" as *const _ as *mut i8,
209+
32,
210+
);
211+
}
212+
}
213+
214+
fn get_ts_info(dev: &NetDevice<Self>, info: &mut ethtool::EthToolTsInfo) -> KernelResult<()> {
215+
kernel::net::ethtool::helpers::ethtool_op_get_ts_info(dev, info)
216+
}
217+
}

‎rust/helpers.c

+32-1
Original file line numberDiff line numberDiff line change
@@ -7,6 +7,9 @@
77
#include <linux/gfp.h>
88
#include <linux/highmem.h>
99
#include <linux/uio.h>
10+
#include <linux/netdevice.h>
11+
#include <linux/etherdevice.h>
12+
#include <linux/rtnetlink.h>
1013

1114
void rust_helper_BUG(void)
1215
{
@@ -105,8 +108,36 @@ size_t rust_helper_copy_to_iter(const void *addr, size_t bytes, struct iov_iter
105108
}
106109
EXPORT_SYMBOL_GPL(rust_helper_copy_to_iter);
107110

108-
#if !defined(CONFIG_ARM)
111+
void *rust_helper_netdev_priv(struct net_device *dev)
112+
{
113+
return netdev_priv(dev);
114+
}
115+
EXPORT_SYMBOL_GPL(rust_helper_netdev_priv);
116+
117+
void rust_helper_eth_hw_addr_random(struct net_device *dev)
118+
{
119+
eth_hw_addr_random(dev);
120+
}
121+
EXPORT_SYMBOL_GPL(rust_helper_eth_hw_addr_random);
122+
123+
int rust_helper_net_device_set_new_lstats(struct net_device *dev)
124+
{
125+
dev->lstats = netdev_alloc_pcpu_stats(struct pcpu_lstats);
126+
if (!dev->lstats)
127+
return -ENOMEM;
128+
129+
return 0;
130+
}
131+
EXPORT_SYMBOL_GPL(rust_helper_net_device_set_new_lstats);
132+
133+
void rust_helper_dev_lstats_add(struct net_device *dev, unsigned int len)
134+
{
135+
dev_lstats_add(dev, len);
136+
}
137+
EXPORT_SYMBOL_GPL(rust_helper_dev_lstats_add);
138+
109139
// See https://github.com/rust-lang/rust-bindgen/issues/1671
140+
#if !defined(CONFIG_ARM)
110141
static_assert(__builtin_types_compatible_p(size_t, uintptr_t),
111142
"size_t must match uintptr_t, what architecture is this??");
112143
#endif

‎rust/kernel/bindings_helper.h

+8
Original file line numberDiff line numberDiff line change
@@ -2,6 +2,12 @@
22

33
#include <linux/cdev.h>
44
#include <linux/fs.h>
5+
#include <linux/netdevice.h>
6+
#include <linux/ethtool.h>
7+
#include <linux/etherdevice.h>
8+
#include <linux/netdev_features.h>
9+
#include <linux/rtnetlink.h>
10+
#include <net/rtnetlink.h>
511
#include <linux/module.h>
612
#include <linux/random.h>
713
#include <linux/slab.h>
@@ -17,3 +23,5 @@
1723
// `bindgen` gets confused at certain things
1824
const gfp_t BINDINGS_GFP_KERNEL = GFP_KERNEL;
1925
const gfp_t BINDINGS___GFP_ZERO = __GFP_ZERO;
26+
27+
const int BINDINGS_NLA_HDRLEN = NLA_HDRLEN;

‎rust/kernel/error.rs

+25-1
Original file line numberDiff line numberDiff line change
@@ -6,7 +6,7 @@
66
77
use crate::{bindings, c_types};
88
use alloc::{alloc::AllocError, collections::TryReserveError};
9-
use core::{num::TryFromIntError, str::Utf8Error};
9+
use core::{convert::TryFrom, num::TryFromIntError, str::Utf8Error};
1010

1111
/// Generic integer kernel error.
1212
///
@@ -48,6 +48,9 @@ impl Error {
4848
/// Interrupted system call.
4949
pub const EINTR: Self = Error(-(bindings::EINTR as i32));
5050

51+
/// Cannot assign requested address
52+
pub const EADDRNOTAVAIL: Self = Error(-(bindings::EADDRNOTAVAIL as i32));
53+
5154
/// Creates an [`Error`] from a kernel error code.
5255
pub fn from_kernel_errno(errno: c_types::c_int) -> Error {
5356
Error(errno)
@@ -104,3 +107,24 @@ impl From<AllocError> for Error {
104107
Error::ENOMEM
105108
}
106109
}
110+
111+
/// Used by the rtnl_link_ops macro to interface with C
112+
pub fn c_from_kernel_result<T>(r: KernelResult<T>) -> T
113+
where
114+
T: TryFrom<c_types::c_int>,
115+
T::Error: core::fmt::Debug,
116+
{
117+
match r {
118+
Ok(v) => v,
119+
Err(e) => T::try_from(e.to_kernel_errno()).unwrap(),
120+
}
121+
}
122+
123+
#[macro_export]
124+
macro_rules! c_from_kernel_result {
125+
($($tt:tt)*) => {{
126+
$crate::c_from_kernel_result((|| {
127+
$($tt)*
128+
})())
129+
}};
130+
}

‎rust/kernel/lib.rs

+2-1
Original file line numberDiff line numberDiff line change
@@ -42,6 +42,7 @@ pub mod chrdev;
4242
mod error;
4343
pub mod file_operations;
4444
pub mod miscdev;
45+
pub mod net;
4546
pub mod pages;
4647

4748
pub mod linked_list;
@@ -64,7 +65,7 @@ pub mod iov_iter;
6465
mod types;
6566
pub mod user_ptr;
6667

67-
pub use crate::error::{Error, KernelResult};
68+
pub use crate::error::{c_from_kernel_result, Error, KernelResult};
6869
pub use crate::types::{CStr, Mode};
6970

7071
/// Page size defined in terms of the `PAGE_SHIFT` macro from C.

0 commit comments

Comments
 (0)