1 use crate::arch::rand::rand;
2 use crate::driver::base::class::Class;
3 use crate::driver::base::device::bus::Bus;
4 use crate::driver::base::device::driver::Driver;
5 use crate::driver::base::device::{Device, DeviceCommonData, DeviceType, IdTable};
6 use crate::driver::base::kobject::{
7 KObjType, KObject, KObjectCommonData, KObjectState, LockedKObjectState,
8 };
9 use crate::driver::base::kset::KSet;
10 use crate::filesystem::kernfs::KernFSInode;
11 use crate::init::initcall::INITCALL_DEVICE;
12 use crate::libs::rwlock::{RwLockReadGuard, RwLockWriteGuard};
13 use crate::libs::spinlock::{SpinLock, SpinLockGuard};
14 use crate::net::{generate_iface_id, NET_DEVICES};
15 use crate::time::Instant;
16 use alloc::collections::VecDeque;
17 use alloc::fmt::Debug;
18 use alloc::string::{String, ToString};
19 use alloc::sync::{Arc, Weak};
20 use alloc::vec::Vec;
21 use core::cell::UnsafeCell;
22 use core::ops::{Deref, DerefMut};
23 use smoltcp::wire::HardwareAddress;
24 use smoltcp::{
25 phy::{self},
26 wire::{IpAddress, IpCidr},
27 };
28 use system_error::SystemError;
29 use unified_init::macros::unified_init;
30
31 use super::{register_netdevice, NetDeivceState, NetDevice, NetDeviceCommonData, Operstate};
32
33 const DEVICE_NAME: &str = "loopback";
34
35 /// ## 环回接收令牌
36 /// 用于储存lo网卡接收到的数据
37 pub struct LoopbackRxToken {
38 buffer: Vec<u8>,
39 }
40
41 impl phy::RxToken for LoopbackRxToken {
42 /// ## 实现Rxtoken的consume函数
43 /// 接受一个函数 `f`，并在 `self.buffer` 上调用它。
44 ///
45 /// ## 参数
46 /// - mut self ：一个可变的 `LoopbackRxToken` 实例。
47 /// - f ：接受一个可变的 u8 切片，并返回类型 `R` 的结果。
48 ///
49 /// ## 返回值
50 /// 返回函数 `f` 在 `self.buffer` 上的调用结果。
consume<R, F>(mut self, f: F) -> R where F: FnOnce(&mut [u8]) -> R,51 fn consume<R, F>(mut self, f: F) -> R
52 where
53 F: FnOnce(&mut [u8]) -> R,
54 {
55 f(self.buffer.as_mut_slice())
56 }
57 }
58
59 /// ## 环回发送令牌
60 /// 返回驱动用于操作lo设备
61 pub struct LoopbackTxToken {
62 driver: LoopbackDriver,
63 }
64
65 impl phy::TxToken for LoopbackTxToken {
66 /// ## 实现TxToken的consume函数
67 /// 向lo的队列推入待发送的数据报，实现环回
68 ///
69 /// ## 参数
70 /// - self
71 /// - len：数据包的长度
72 /// - f：接受一个可变的 u8 切片，并返回类型 `R` 的结果。
73 ///
74 /// ## 返回值
75 /// 返回f对数据包操纵的结果
consume<R, F>(self, len: usize, f: F) -> R where F: FnOnce(&mut [u8]) -> R,76 fn consume<R, F>(self, len: usize, f: F) -> R
77 where
78 F: FnOnce(&mut [u8]) -> R,
79 {
80 let mut buffer = vec![0; len];
81 let result = f(buffer.as_mut_slice());
82 let mut device = self.driver.inner.lock();
83 device.loopback_transmit(buffer);
84 result
85 }
86 }
87
88 /// ## Loopback设备
89 /// 成员是一个队列，用来存放接受到的数据包。
90 /// 当使用lo发送数据包时，不会把数据包传到link层，而是直接发送到该队列，实现环回。
91 pub struct Loopback {
92 //回环设备的缓冲区,接受的数据包会存放在这里，发送的数据包也会发送到这里，实现环回
93 queue: VecDeque<Vec<u8>>,
94 }
95
96 impl Loopback {
97 /// ## Loopback创建函数
98 /// 创建lo设备
new() -> Self99 pub fn new() -> Self {
100 let queue = VecDeque::new();
101 Loopback { queue }
102 }
103 /// ## Loopback处理接受到的数据包函数
104 /// Loopback接受到数据后会调用这个函数来弹出接收的数据，返回给协议栈
105 ///
106 /// ## 参数
107 /// - &mut self ：自身可变引用
108 ///
109 /// ## 返回值
110 /// - queue的头部数据包
loopback_receive(&mut self) -> Vec<u8>111 pub fn loopback_receive(&mut self) -> Vec<u8> {
112 let buffer = self.queue.pop_front();
113 match buffer {
114 Some(buffer) => {
115 //debug!("lo receive:{:?}", buffer);
116 return buffer;
117 }
118 None => {
119 return Vec::new();
120 }
121 }
122 }
123 /// ## Loopback发送数据包的函数
124 /// Loopback发送数据包给自己的接收队列，实现环回
125 ///
126 /// ## 参数
127 /// - &mut self：自身可变引用
128 /// - buffer：需要发送的数据包
loopback_transmit(&mut self, buffer: Vec<u8>)129 pub fn loopback_transmit(&mut self, buffer: Vec<u8>) {
130 //debug!("lo transmit!");
131 self.queue.push_back(buffer)
132 }
133 }
134
135 /// ## driver的包裹器
136 /// 为实现获得不可变引用的Interface的内部可变性，故为Driver提供UnsafeCell包裹器
137 ///
138 /// 参考virtio_net.rs
139 struct LoopbackDriverWapper(UnsafeCell<LoopbackDriver>);
140 unsafe impl Send for LoopbackDriverWapper {}
141 unsafe impl Sync for LoopbackDriverWapper {}
142
143 /// ## deref 方法返回一个指向 `LoopbackDriver` 的引用。
144 impl Deref for LoopbackDriverWapper {
145 type Target = LoopbackDriver;
deref(&self) -> &Self::Target146 fn deref(&self) -> &Self::Target {
147 unsafe { &*self.0.get() }
148 }
149 }
150 /// ## `deref_mut` 方法返回一个指向可变 `LoopbackDriver` 的引用。
151 impl DerefMut for LoopbackDriverWapper {
deref_mut(&mut self) -> &mut Self::Target152 fn deref_mut(&mut self) -> &mut Self::Target {
153 unsafe { &mut *self.0.get() }
154 }
155 }
156
157 impl LoopbackDriverWapper {
158 /// ## force_get_mut返回一个指向可变 `LoopbackDriver` 的引用。
159 #[allow(clippy::mut_from_ref)]
160 #[allow(clippy::mut_from_ref)]
force_get_mut(&self) -> &mut LoopbackDriver161 fn force_get_mut(&self) -> &mut LoopbackDriver {
162 unsafe { &mut *self.0.get() }
163 }
164 }
165
166 /// ## Loopback驱动
167 /// 负责操作Loopback设备实现基本的网卡功能
168 pub struct LoopbackDriver {
169 pub inner: Arc<SpinLock<Loopback>>,
170 }
171
172 impl LoopbackDriver {
173 /// ## LoopbackDriver创建函数
new() -> Self174 pub fn new() -> Self {
175 let inner = Arc::new(SpinLock::new(Loopback::new()));
176 LoopbackDriver { inner }
177 }
178 }
179
180 impl Clone for LoopbackDriver {
clone(&self) -> Self181 fn clone(&self) -> Self {
182 LoopbackDriver {
183 inner: self.inner.clone(),
184 }
185 }
186 }
187
188 impl phy::Device for LoopbackDriver {
189 type RxToken<'a>
190 = LoopbackRxToken
191 where
192 Self: 'a;
193 type TxToken<'a>
194 = LoopbackTxToken
195 where
196 Self: 'a;
197 /// ## 返回设备的物理层特性。
198 /// lo设备的最大传输单元为65535，最大突发大小为1，传输介质默认为Ethernet
capabilities(&self) -> phy::DeviceCapabilities199 fn capabilities(&self) -> phy::DeviceCapabilities {
200 let mut result = phy::DeviceCapabilities::default();
201 result.max_transmission_unit = 65535;
202 result.max_burst_size = Some(1);
203 result.medium = smoltcp::phy::Medium::Ethernet;
204 return result;
205 }
206 /// ## Loopback驱动处理接受数据事件
207 /// 驱动调用Loopback的receive函数，处理buffer封装成（rx，tx）返回给上层
208 ///
209 /// ## 参数
210 /// - `&mut self` ：自身可变引用
211 /// - `_timestamp`
212 ///
213 /// ## 返回值
214 /// - None: 如果接收队列为空，返回 `None`，以通知上层没有可以接收的包
215 /// - Option::Some((rx, tx))：如果接收队列不为空，返回 `Some`，其中包含一个接收令牌 `rx` 和一个发送令牌 `tx`
receive( &mut self, _timestamp: smoltcp::time::Instant, ) -> Option<(Self::RxToken<'_>, Self::TxToken<'_>)>216 fn receive(
217 &mut self,
218 _timestamp: smoltcp::time::Instant,
219 ) -> Option<(Self::RxToken<'_>, Self::TxToken<'_>)> {
220 let buffer = self.inner.lock().loopback_receive();
221 //receive队列为为空，返回NONE值以通知上层没有可以receive的包
222 if buffer.is_empty() {
223 return Option::None;
224 }
225 let rx = LoopbackRxToken { buffer };
226 let tx = LoopbackTxToken {
227 driver: self.clone(),
228 };
229 return Option::Some((rx, tx));
230 }
231 /// ## Loopback驱动处理发送数据包事件
232 /// Loopback驱动在需要发送数据时会调用这个函数来获取一个发送令牌。
233 ///
234 /// ## 参数
235 /// - `&mut self` ：自身可变引用
236 /// - `_timestamp`
237 ///
238 /// ## 返回值
239 /// - 返回一个 `Some`，其中包含一个发送令牌，该令牌包含一个对自身的克隆引用
transmit(&mut self, _timestamp: smoltcp::time::Instant) -> Option<Self::TxToken<'_>>240 fn transmit(&mut self, _timestamp: smoltcp::time::Instant) -> Option<Self::TxToken<'_>> {
241 Some(LoopbackTxToken {
242 driver: self.clone(),
243 })
244 }
245 }
246
247 /// ## LoopbackInterface结构
248 /// 封装驱动包裹器和iface，设置接口名称
249 #[cast_to([sync] NetDevice)]
250 #[cast_to([sync] Device)]
251 pub struct LoopbackInterface {
252 driver: LoopbackDriverWapper,
253 iface_id: usize,
254 iface: SpinLock<smoltcp::iface::Interface>,
255 name: String,
256 inner: SpinLock<InnerLoopbackInterface>,
257 locked_kobj_state: LockedKObjectState,
258 }
259
260 #[derive(Debug)]
261 pub struct InnerLoopbackInterface {
262 netdevice_common: NetDeviceCommonData,
263 device_common: DeviceCommonData,
264 kobj_common: KObjectCommonData,
265 }
266
267 impl LoopbackInterface {
268 /// ## `new` 是一个公共函数，用于创建一个新的 `LoopbackInterface` 实例。
269 /// 生成一个新的接口 ID。创建一个新的接口配置，设置其硬件地址和随机种子，使用接口配置和驱动器创建一个新的 `smoltcp::iface::Interface` 实例。
270 /// 设置接口的 IP 地址为 127.0.0.1。
271 /// 创建一个新的 `LoopbackDriverWapper` 实例，包装驱动器。
272 /// 创建一个新的 `LoopbackInterface` 实例，包含驱动器、接口 ID、接口和名称，并将其封装在一个 `Arc` 中。
273 /// ## 参数
274 /// - `driver`：一个 `LoopbackDriver` 实例，用于驱动网络环回操作。
275 ///
276 /// ## 返回值
277 /// 返回一个 `Arc<Self>`，即一个指向新创建的 `LoopbackInterface` 实例的智能指针。
new(mut driver: LoopbackDriver) -> Arc<Self>278 pub fn new(mut driver: LoopbackDriver) -> Arc<Self> {
279 let iface_id = generate_iface_id();
280 let mut iface_config = smoltcp::iface::Config::new(HardwareAddress::Ethernet(
281 smoltcp::wire::EthernetAddress([0x02, 0x00, 0x00, 0x00, 0x00, 0x01]),
282 ));
283 iface_config.random_seed = rand() as u64;
284
285 let mut iface =
286 smoltcp::iface::Interface::new(iface_config, &mut driver, Instant::now().into());
287 //设置网卡地址为127.0.0.1
288 iface.update_ip_addrs(|ip_addrs| {
289 ip_addrs
290 .push(IpCidr::new(IpAddress::v4(127, 0, 0, 1), 8))
291 .unwrap();
292 });
293 let driver = LoopbackDriverWapper(UnsafeCell::new(driver));
294 Arc::new(LoopbackInterface {
295 driver,
296 iface_id,
297 iface: SpinLock::new(iface),
298 name: "lo".to_string(),
299 inner: SpinLock::new(InnerLoopbackInterface {
300 netdevice_common: NetDeviceCommonData::default(),
301 device_common: DeviceCommonData::default(),
302 kobj_common: KObjectCommonData::default(),
303 }),
304 locked_kobj_state: LockedKObjectState::default(),
305 })
306 }
307
inner(&self) -> SpinLockGuard<InnerLoopbackInterface>308 fn inner(&self) -> SpinLockGuard<InnerLoopbackInterface> {
309 return self.inner.lock();
310 }
311 }
312
313 impl Debug for LoopbackInterface {
fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result314 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
315 f.debug_struct("LoopbackInterface")
316 .field("iface_id", &self.iface_id)
317 .field("iface", &"smtoltcp::iface::Interface")
318 .field("name", &self.name)
319 .finish()
320 }
321 }
322
323 impl KObject for LoopbackInterface {
as_any_ref(&self) -> &dyn core::any::Any324 fn as_any_ref(&self) -> &dyn core::any::Any {
325 self
326 }
327
set_inode(&self, inode: Option<Arc<KernFSInode>>)328 fn set_inode(&self, inode: Option<Arc<KernFSInode>>) {
329 self.inner().kobj_common.kern_inode = inode;
330 }
331
inode(&self) -> Option<Arc<KernFSInode>>332 fn inode(&self) -> Option<Arc<KernFSInode>> {
333 self.inner().kobj_common.kern_inode.clone()
334 }
335
parent(&self) -> Option<Weak<dyn KObject>>336 fn parent(&self) -> Option<Weak<dyn KObject>> {
337 self.inner().kobj_common.parent.clone()
338 }
339
set_parent(&self, parent: Option<Weak<dyn KObject>>)340 fn set_parent(&self, parent: Option<Weak<dyn KObject>>) {
341 self.inner().kobj_common.parent = parent;
342 }
343
kset(&self) -> Option<Arc<KSet>>344 fn kset(&self) -> Option<Arc<KSet>> {
345 self.inner().kobj_common.kset.clone()
346 }
347
set_kset(&self, kset: Option<Arc<KSet>>)348 fn set_kset(&self, kset: Option<Arc<KSet>>) {
349 self.inner().kobj_common.kset = kset;
350 }
351
kobj_type(&self) -> Option<&'static dyn KObjType>352 fn kobj_type(&self) -> Option<&'static dyn KObjType> {
353 self.inner().kobj_common.kobj_type
354 }
355
name(&self) -> String356 fn name(&self) -> String {
357 self.name.clone()
358 }
359
set_name(&self, _name: String)360 fn set_name(&self, _name: String) {
361 // do nothing
362 }
363
kobj_state(&self) -> RwLockReadGuard<KObjectState>364 fn kobj_state(&self) -> RwLockReadGuard<KObjectState> {
365 self.locked_kobj_state.read()
366 }
367
kobj_state_mut(&self) -> RwLockWriteGuard<KObjectState>368 fn kobj_state_mut(&self) -> RwLockWriteGuard<KObjectState> {
369 self.locked_kobj_state.write()
370 }
371
set_kobj_state(&self, state: KObjectState)372 fn set_kobj_state(&self, state: KObjectState) {
373 *self.locked_kobj_state.write() = state;
374 }
375
set_kobj_type(&self, ktype: Option<&'static dyn KObjType>)376 fn set_kobj_type(&self, ktype: Option<&'static dyn KObjType>) {
377 self.inner().kobj_common.kobj_type = ktype;
378 }
379 }
380
381 impl Device for LoopbackInterface {
dev_type(&self) -> DeviceType382 fn dev_type(&self) -> DeviceType {
383 DeviceType::Net
384 }
385
id_table(&self) -> IdTable386 fn id_table(&self) -> IdTable {
387 IdTable::new(DEVICE_NAME.to_string(), None)
388 }
389
bus(&self) -> Option<Weak<dyn Bus>>390 fn bus(&self) -> Option<Weak<dyn Bus>> {
391 self.inner().device_common.bus.clone()
392 }
393
set_bus(&self, bus: Option<Weak<dyn Bus>>)394 fn set_bus(&self, bus: Option<Weak<dyn Bus>>) {
395 self.inner().device_common.bus = bus;
396 }
397
class(&self) -> Option<Arc<dyn Class>>398 fn class(&self) -> Option<Arc<dyn Class>> {
399 let mut guard = self.inner();
400 let r = guard.device_common.class.clone()?.upgrade();
401 if r.is_none() {
402 guard.device_common.class = None;
403 }
404
405 return r;
406 }
407
set_class(&self, class: Option<Weak<dyn Class>>)408 fn set_class(&self, class: Option<Weak<dyn Class>>) {
409 self.inner().device_common.class = class;
410 }
411
driver(&self) -> Option<Arc<dyn Driver>>412 fn driver(&self) -> Option<Arc<dyn Driver>> {
413 let r = self.inner().device_common.driver.clone()?.upgrade();
414 if r.is_none() {
415 self.inner().device_common.driver = None;
416 }
417
418 return r;
419 }
420
set_driver(&self, driver: Option<Weak<dyn Driver>>)421 fn set_driver(&self, driver: Option<Weak<dyn Driver>>) {
422 self.inner().device_common.driver = driver;
423 }
424
is_dead(&self) -> bool425 fn is_dead(&self) -> bool {
426 false
427 }
428
can_match(&self) -> bool429 fn can_match(&self) -> bool {
430 self.inner().device_common.can_match
431 }
432
set_can_match(&self, can_match: bool)433 fn set_can_match(&self, can_match: bool) {
434 self.inner().device_common.can_match = can_match;
435 }
436
state_synced(&self) -> bool437 fn state_synced(&self) -> bool {
438 true
439 }
440
dev_parent(&self) -> Option<Weak<dyn Device>>441 fn dev_parent(&self) -> Option<Weak<dyn Device>> {
442 self.inner().device_common.get_parent_weak_or_clear()
443 }
444
set_dev_parent(&self, parent: Option<Weak<dyn Device>>)445 fn set_dev_parent(&self, parent: Option<Weak<dyn Device>>) {
446 self.inner().device_common.parent = parent;
447 }
448 }
449
450 impl NetDevice for LoopbackInterface {
451 /// 由于lo网卡设备不是实际的物理设备，其mac地址需要手动设置为一个默认值，这里默认为00:00:00:00:00
mac(&self) -> smoltcp::wire::EthernetAddress452 fn mac(&self) -> smoltcp::wire::EthernetAddress {
453 let mac = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00];
454 smoltcp::wire::EthernetAddress(mac)
455 }
456
457 #[inline]
nic_id(&self) -> usize458 fn nic_id(&self) -> usize {
459 self.iface_id
460 }
461
462 #[inline]
iface_name(&self) -> String463 fn iface_name(&self) -> String {
464 self.name.clone()
465 }
466 /// ## `update_ip_addrs` 用于更新接口的 IP 地址。
467 ///
468 /// ## 参数
469 /// - `&self` ：自身引用
470 /// - `ip_addrs` ：一个包含 `smoltcp::wire::IpCidr` 的切片，表示要设置的 IP 地址和子网掩码
471 ///
472 /// ## 返回值
473 /// - 如果 `ip_addrs` 的长度不为 1，返回 `Err(SystemError::EINVAL)`，表示输入参数无效
474 /// - 如果更新成功，返回 `Ok(())`
update_ip_addrs( &self, ip_addrs: &[smoltcp::wire::IpCidr], ) -> Result<(), system_error::SystemError>475 fn update_ip_addrs(
476 &self,
477 ip_addrs: &[smoltcp::wire::IpCidr],
478 ) -> Result<(), system_error::SystemError> {
479 if ip_addrs.len() != 1 {
480 return Err(SystemError::EINVAL);
481 }
482
483 self.iface.lock().update_ip_addrs(|addrs| {
484 let dest = addrs.iter_mut().next();
485
486 if let Some(dest) = dest {
487 *dest = ip_addrs[0];
488 } else {
489 addrs.push(ip_addrs[0]).expect("Push ipCidr failed: full");
490 }
491 });
492 return Ok(());
493 }
494 /// ## `poll` 用于轮询接口的状态。
495 ///
496 /// ## 参数
497 /// - `&self` ：自身引用
498 /// - `sockets` ：一个可变引用到 `smoltcp::iface::SocketSet`，表示要轮询的套接字集
499 ///
500 /// ## 返回值
501 /// - 如果轮询成功，返回 `Ok(())`
502 /// - 如果轮询失败，返回 `Err(SystemError::EAGAIN_OR_EWOULDBLOCK)`，表示需要再次尝试或者操作会阻塞
poll(&self, sockets: &mut smoltcp::iface::SocketSet) -> Result<(), SystemError>503 fn poll(&self, sockets: &mut smoltcp::iface::SocketSet) -> Result<(), SystemError> {
504 let timestamp: smoltcp::time::Instant = Instant::now().into();
505 let mut guard = self.iface.lock();
506 let poll_res = guard.poll(timestamp, self.driver.force_get_mut(), sockets);
507 if poll_res {
508 return Ok(());
509 }
510 return Err(SystemError::EAGAIN_OR_EWOULDBLOCK);
511 }
512
513 #[inline(always)]
inner_iface(&self) -> &SpinLock<smoltcp::iface::Interface>514 fn inner_iface(&self) -> &SpinLock<smoltcp::iface::Interface> {
515 return &self.iface;
516 }
517
addr_assign_type(&self) -> u8518 fn addr_assign_type(&self) -> u8 {
519 return self.inner().netdevice_common.addr_assign_type;
520 }
521
net_device_type(&self) -> u16522 fn net_device_type(&self) -> u16 {
523 self.inner().netdevice_common.net_device_type = 24; // 环回设备
524 return self.inner().netdevice_common.net_device_type;
525 }
526
net_state(&self) -> NetDeivceState527 fn net_state(&self) -> NetDeivceState {
528 return self.inner().netdevice_common.state;
529 }
530
set_net_state(&self, state: NetDeivceState)531 fn set_net_state(&self, state: NetDeivceState) {
532 self.inner().netdevice_common.state |= state;
533 }
534
operstate(&self) -> Operstate535 fn operstate(&self) -> Operstate {
536 return self.inner().netdevice_common.operstate;
537 }
538
set_operstate(&self, state: Operstate)539 fn set_operstate(&self, state: Operstate) {
540 self.inner().netdevice_common.operstate = state;
541 }
542 }
543
loopback_probe()544 pub fn loopback_probe() {
545 loopback_driver_init();
546 }
547 /// ## lo网卡设备初始化函数
548 /// 创建驱动和iface，初始化一个lo网卡，添加到全局NET_DEVICES中
loopback_driver_init()549 pub fn loopback_driver_init() {
550 let driver = LoopbackDriver::new();
551 let iface = LoopbackInterface::new(driver);
552 // 标识网络设备已经启动
553 iface.set_net_state(NetDeivceState::__LINK_STATE_START);
554
555 NET_DEVICES
556 .write_irqsave()
557 .insert(iface.iface_id, iface.clone());
558
559 register_netdevice(iface.clone()).expect("register lo device failed");
560 }
561
562 /// ## lo网卡设备的注册函数
563 #[unified_init(INITCALL_DEVICE)]
loopback_init() -> Result<(), SystemError>564 pub fn loopback_init() -> Result<(), SystemError> {
565 loopback_probe();
566 return Ok(());
567 }
568