Skip to content

Commit 5d43f1f

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

14 files changed

+2203
-3
lines changed

Diff for: 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

Diff for: 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

Diff for: drivers/net/dummy_rs.rs

+241
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,241 @@
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+
//! The purpose of this driver is to provide a device to point a
9+
//! route through, but not to actually transmit packets.
10+
//!
11+
//! Why? If you have a machine whose only connection is an occasional
12+
//! PPP/SLIP/PLIP link, you can only connect to your own hostname
13+
//! when the link is up. Otherwise you have to use localhost.
14+
//! This isn't very consistent.
15+
//!
16+
//! One solution is to set up a dummy link using PPP/SLIP/PLIP,
17+
//! but this seems (to me) too much overhead for too little gain.
18+
//! This driver provides a small alternative. Thus you can do
19+
//!
20+
//! [when not running slip]
21+
//! ifconfig dummy slip.addr.ess.here up
22+
//! [to go to slip]
23+
//! ifconfig dummy down
24+
//! dip whatever
25+
//!
26+
//! This was written by looking at Donald Becker's skeleton driver
27+
//! and the loopback driver. I then threw away anything that didn't
28+
//! apply! Thanks to Alan Cox for the key clue on what to do with
29+
//! misguided packets.
30+
//!
31+
//! Finn Behrens, 30th April 20201
32+
//!
33+
//! rust rewrite of the C version from Nick Holloway, 27th May 1994
34+
//! see [dummy.c](./dummy.c)
35+
36+
#![no_std]
37+
#![feature(allocator_api, global_asm)]
38+
39+
use core::ops::Deref;
40+
41+
use kernel::net::device;
42+
use kernel::net::prelude::*;
43+
use kernel::net::rtnl;
44+
use kernel::Error;
45+
use kernel::{
46+
net::netlink::{NlAttrVec, NlExtAck},
47+
prelude::*,
48+
};
49+
50+
module! {
51+
type: RustNetDummy,
52+
name: b"dummy_rs",
53+
author: b"Rust for Linux Contributors",
54+
description: b"Rust dummy network driver",
55+
license: b"GPL v2",
56+
alias_rtnl_link: b"dummy_rs",
57+
params: {
58+
numdummies: usize {
59+
default: 0,
60+
permissions: 0,
61+
description: b"Number of dummy_rs pseudo devices",
62+
},
63+
},
64+
}
65+
66+
fn setup(dev: &mut NetDevice<DummyRsDev>) {
67+
dev.ether_setup();
68+
69+
dev.set_ops();
70+
71+
// Fill in device structure with ethernet-generic values.
72+
dev.add_flag(device::Iff::NOARP);
73+
dev.remove_flag(device::Iff::MULTICAST);
74+
75+
dev.add_private_flag(device::IffPriv::LIVE_ADDR_CHANGE);
76+
dev.add_private_flag(device::IffPriv::NO_QUEUE);
77+
78+
let mut feature = device::feature::NetIF::new();
79+
80+
feature += device::feature::NETIF_F_SG;
81+
feature += device::feature::NETIF_F_FRAGLIST;
82+
feature += device::feature::NETIF_F_GSO_SOFTWARE;
83+
feature += device::feature::NETIF_F_HW_CSUM;
84+
feature += device::feature::NETIF_F_HIGHDMA;
85+
feature += device::feature::NETIF_F_LLTX;
86+
feature += device::feature::NETIF_F_GSO_ENCAP_ALL;
87+
88+
dev.set_features(feature);
89+
dev.set_hw_features(feature);
90+
dev.set_hw_enc_features(feature);
91+
92+
dev.hw_addr_random();
93+
dev.set_mtu(0, 0);
94+
}
95+
96+
fn validate(tb: &NlAttrVec, _data: &NlAttrVec, _ext_ack: &NlExtAck) -> KernelResult<()> {
97+
if let Some(addr) = tb.get(kernel::bindings::IFLA_ADDRESS) {
98+
if addr.nla_len() != kernel::net::netlink::ETH_ALEN {
99+
return Err(Error::EINVAL);
100+
}
101+
if !addr.is_valid_ether_addr() {
102+
return Err(Error::EADDRNOTAVAIL);
103+
}
104+
}
105+
Ok(())
106+
}
107+
108+
rtnl_link_ops! {
109+
kind: b"dummy_rs",
110+
type: DummyRsDev,
111+
setup: setup,
112+
validate: validate,
113+
}
114+
115+
struct RustNetDummy {
116+
//dev: NetDevice<DummyRsDev>,
117+
}
118+
119+
impl KernelModule for RustNetDummy {
120+
fn init() -> KernelResult<Self> {
121+
let num = *numdummies.read();
122+
123+
unsafe { dummy_rs_link_ops.register() }?;
124+
125+
for _ in 0..(num) {
126+
let dev = NetDevice::new(
127+
DummyRsDev,
128+
kernel::cstr!("dummyrs%d"),
129+
kernel::net::device::NetNameAssingType::Enum,
130+
1,
131+
1,
132+
)?;
133+
dev.set_rtnl_ops(unsafe { &dummy_rs_link_ops });
134+
135+
if let Err(e) = dev.register() {
136+
pr_warn!("could not register: {}", e.to_kernel_errno());
137+
return Err(e);
138+
}
139+
}
140+
141+
Ok(RustNetDummy {
142+
//dev,
143+
})
144+
}
145+
}
146+
147+
impl Drop for RustNetDummy {
148+
fn drop(&mut self) {
149+
// TODO: remove unsafe somehow
150+
unsafe { dummy_rs_link_ops.unregister() };
151+
}
152+
}
153+
154+
struct DummyRsDev;
155+
156+
impl NetDeviceOps<Self> for DummyRsDev {
157+
kernel::declare_net_device_ops!(
158+
get_stats64,
159+
change_carrier,
160+
validate_addr,
161+
set_mac_addr,
162+
set_rx_mode
163+
);
164+
165+
fn init(dev: &mut NetDevice<Self>) -> KernelResult<()> {
166+
dev.set_new_pcpu_lstats()?;
167+
Ok(())
168+
}
169+
170+
fn uninit(dev: &mut NetDevice<Self>) {
171+
unsafe { dev.free_lstats() };
172+
}
173+
174+
fn start_xmit(skb: SkBuff, dev: &mut NetDevice<Self>) -> kernel::net::device::NetdevTX {
175+
let mut skb = skb;
176+
177+
dev.lstats_add(skb.len());
178+
179+
skb.tx_timestamp();
180+
drop(skb);
181+
182+
kernel::net::device::NetdevTX::TX_OK
183+
}
184+
185+
fn get_stats64(dev: &NetDevice<Self>, stats: &mut rtnl::RtnlLinkStats64) {
186+
stats.dev_read(dev);
187+
}
188+
189+
fn change_carrier(dev: &mut NetDevice<Self>, new_carrier: bool) -> KernelResult<()> {
190+
dev.carrier_set(new_carrier);
191+
192+
Ok(())
193+
}
194+
195+
fn validate_addr(dev: &NetDevice<Self>) -> KernelResult<()> {
196+
device::helpers::eth_validate_addr(dev)
197+
}
198+
199+
fn set_mac_addr(
200+
dev: &mut NetDevice<Self>,
201+
p: *mut kernel::c_types::c_void,
202+
) -> KernelResult<()> {
203+
device::helpers::eth_mac_addr(dev, p)
204+
}
205+
206+
// [Someting about faking multicast](https://elixir.bootlin.com/linux/v5.12-rc4/source/drivers/net/dummy.c#L48).
207+
fn set_rx_mode(_dev: &mut NetDevice<Self>) {}
208+
}
209+
210+
impl NetDeviceAdapter for DummyRsDev {
211+
type Inner = Self;
212+
213+
type Ops = Self;
214+
215+
type EthOps = Self;
216+
217+
fn setup(dev: &mut NetDevice<Self>) {
218+
setup(dev);
219+
}
220+
}
221+
222+
impl EthToolOps<Self> for DummyRsDev {
223+
kernel::declare_eth_tool_ops!(get_drvinfo, get_ts_info);
224+
225+
fn get_drvinfo(_dev: &NetDevice<Self>, info: &mut ethtool::EthtoolDrvinfo) {
226+
// TODO: how to do this more efficient without unsafe?
227+
// FIXME: !!
228+
let info: &kernel::bindings::ethtool_drvinfo = info.deref();
229+
unsafe {
230+
kernel::bindings::strlcpy(
231+
&(info.driver) as *const _ as *mut i8,
232+
b"dummy_rs\0" as *const _ as *mut i8,
233+
32,
234+
);
235+
}
236+
}
237+
238+
fn get_ts_info(dev: &NetDevice<Self>, info: &mut ethtool::EthToolTsInfo) -> KernelResult<()> {
239+
kernel::net::ethtool::helpers::ethtool_op_get_ts_info(dev, info)
240+
}
241+
}

Diff for: 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

Diff for: 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;

Diff for: 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+
}

0 commit comments

Comments
 (0)