DragonOS-Community/DragonOS
4
1
Fork 0
mirror of https://github.com/DragonOS-Community/DragonOS.git synced 2025-06-18 12:16:31 +00:00
Code Issues Releases Wiki Activity

fix(net): TCP Resources and add syscall print, change to use latest smoltcp (#1032)

Browse Source 
* change to smoltcp

* add syscall, fix wront accept-listen logic

* add version and resource close
This commit is contained in:
Samuel Dai
2024-11-07 14:38:31 +08:00
committed by GitHub
parent 055c1448e3
commit ff13f9f622
12 changed files with 569 additions and 133 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
kernel/Cargo.toml
View File

@ -48,7 +48,7 @@ linkme = "=0.3.27"
num = { version = "=0.4.0", default-features = false }
num-derive = "=0.3"
num-traits = { git = "https://git.mirrors.dragonos.org.cn/DragonOS-Community/num-traits.git", rev="1597c1c", default-features = false }
smoltcp = { version = "=0.11.0", default-features = false, features = ["log", "alloc", "socket-raw", "socket-udp", "socket-tcp", "socket-icmp", "socket-dhcpv4", "socket-dns", "proto-ipv4", "proto-ipv6"]}
smoltcp = { git = "https://git.mirrors.dragonos.org.cn/DragonOS-Community/smoltcp.git", rev = "3e61c909fd540d05575068d16dc4574e196499ed", default-features = false, features = ["log", "alloc", "socket-raw", "socket-udp", "socket-tcp", "socket-icmp", "socket-dhcpv4", "socket-dns", "proto-ipv4", "proto-ipv6"]}
system_error = { path = "crates/system_error" }
uefi = { version = "=0.26.0", features = ["alloc"] }
uefi-raw = "=0.5.0"

75
kernel/src/arch/x86_64/syscall/mod.rs
View File

@ -1,7 +1,7 @@
use crate::{
arch::{
ipc::signal::X86_64SignalArch,
syscall::nr::{SYS_ARCH_PRCTL, SYS_RT_SIGRETURN},
syscall::nr::{SysCall, SYS_ARCH_PRCTL, SYS_RT_SIGRETURN},
CurrentIrqArch,
},
exception::InterruptArch,
@ -11,7 +11,6 @@ use crate::{
process::ProcessManager,
syscall::{Syscall, SYS_SCHED},
};
use log::debug;
use system_error::SystemError;
use super::{
@ -53,7 +52,7 @@ macro_rules! syscall_return {
if $show {
let pid = ProcessManager::current_pcb().pid();
debug!("syscall return:pid={:?},ret= {:?}\n", pid, ret as isize);
log::debug!("[SYS] [Pid: {:?}] [Retn: {:?}]", pid, ret as i64);
}
unsafe {
@ -63,6 +62,24 @@ macro_rules! syscall_return {
}};
}
macro_rules! normal_syscall_return {
($val:expr, $regs:expr, $show:expr) => {{
let ret = $val;
if $show {
let pid = ProcessManager::current_pcb().pid();
log::debug!("[SYS] [Pid: {:?}] [Retn: {:?}]", pid, ret);
}
$regs.rax = ret.unwrap_or_else(|e| e.to_posix_errno() as usize) as u64;
unsafe {
CurrentIrqArch::interrupt_disable();
}
return;
}};
}
#[no_mangle]
pub extern "sysv64" fn syscall_handler(frame: &mut TrapFrame) {
let syscall_num = frame.rax as usize;
@ -87,15 +104,37 @@ pub extern "sysv64" fn syscall_handler(frame: &mut TrapFrame) {
];
mfence();
let pid = ProcessManager::current_pcb().pid();
let show = false;
// let show = if syscall_num != SYS_SCHED && pid.data() >= 7 {
// true
// } else {
// false
// };
let mut show = (syscall_num != SYS_SCHED) && (pid.data() >= 7);
// let mut show = true;
if show {
debug!("syscall: pid: {:?}, num={:?}\n", pid, syscall_num);
let to_print = SysCall::try_from(syscall_num);
if let Ok(to_print) = to_print {
use SysCall::*;
match to_print {
SYS_ACCEPT | SYS_ACCEPT4 | SYS_BIND | SYS_CONNECT | SYS_SHUTDOWN | SYS_LISTEN => {
// show &= false;
}
SYS_RECVFROM | SYS_SENDTO | SYS_SENDMSG | SYS_RECVMSG => {
show &= false;
}
SYS_SOCKET | SYS_GETSOCKNAME | SYS_GETPEERNAME | SYS_SOCKETPAIR | SYS_SETSOCKOPT
| SYS_GETSOCKOPT => {
show &= false;
}
SYS_OPEN | SYS_OPENAT | SYS_CREAT | SYS_CLOSE => {
show &= false;
}
SYS_READ | SYS_WRITE | SYS_READV | SYS_WRITEV | SYS_PREAD64 | SYS_PWRITE64
| SYS_PREADV | SYS_PWRITEV | SYS_PREADV2 => {
show &= false;
}
_ => {
show &= false;
}
}
if show {
log::debug!("[SYS] [Pid: {:?}] [Call: {:?}]", pid, to_print);
}
}
// Arch specific syscall
@ -108,21 +147,11 @@ pub extern "sysv64" fn syscall_handler(frame: &mut TrapFrame) {
);
}
SYS_ARCH_PRCTL => {
syscall_return!(
Syscall::arch_prctl(args[0], args[1])
.unwrap_or_else(|e| e.to_posix_errno() as usize),
frame,
show
);
normal_syscall_return!(Syscall::arch_prctl(args[0], args[1]), frame, show);
}
_ => {}
}
syscall_return!(
Syscall::handle(syscall_num, &args, frame).unwrap_or_else(|e| e.to_posix_errno() as usize)
as u64,
frame,
show
);
normal_syscall_return!(Syscall::handle(syscall_num, &args, frame), frame, show);
}
/// 系统调用初始化

378
kernel/src/arch/x86_64/syscall/nr.rs
View File

@ -355,3 +355,381 @@ pub const SYS_WAIT4: usize = 61;
pub const SYS_WAITID: usize = 247;
pub const SYS_WRITE: usize = 1;
pub const SYS_WRITEV: usize = 20;
use num_traits::{FromPrimitive, ToPrimitive};
use system_error::SystemError;
#[allow(non_camel_case_types)]
#[derive(Debug, Clone, Copy, FromPrimitive, ToPrimitive, PartialEq, Eq)]
pub enum SysCall {
SYS__SYSCTL = 156,
SYS_ACCEPT = 43,
SYS_ACCEPT4 = 288,
SYS_ACCESS = 21,
SYS_ACCT = 163,
SYS_ADD_KEY = 248,
SYS_ADJTIMEX = 159,
SYS_AFS_SYSCALL = 183,
SYS_ALARM = 37,
SYS_ARCH_PRCTL = 158,
SYS_BIND = 49,
SYS_BPF = 321,
SYS_BRK = 12,
SYS_CAPGET = 125,
SYS_CAPSET = 126,
SYS_CHDIR = 80,
SYS_CHMOD = 90,
SYS_CHOWN = 92,
SYS_CHROOT = 161,
SYS_CLOCK_ADJTIME = 305,
SYS_CLOCK_GETRES = 229,
SYS_CLOCK_GETTIME = 228,
SYS_CLOCK_NANOSLEEP = 230,
SYS_CLOCK_SETTIME = 227,
SYS_CLONE = 56,
SYS_CLONE3 = 435,
SYS_CLOSE = 3,
SYS_CLOSE_RANGE = 436,
SYS_CONNECT = 42,
SYS_COPY_FILE_RANGE = 326,
SYS_CREAT = 85,
SYS_CREATE_MODULE = 174,
SYS_DELETE_MODULE = 176,
SYS_DUP = 32,
SYS_DUP2 = 33,
SYS_DUP3 = 292,
SYS_EPOLL_CREATE = 213,
SYS_EPOLL_CREATE1 = 291,
SYS_EPOLL_CTL = 233,
SYS_EPOLL_CTL_OLD = 214,
SYS_EPOLL_PWAIT = 281,
SYS_EPOLL_PWAIT2 = 441,
SYS_EPOLL_WAIT = 232,
SYS_EPOLL_WAIT_OLD = 215,
SYS_EVENTFD = 284,
SYS_EVENTFD2 = 290,
SYS_EXECVE = 59,
SYS_EXECVEAT = 322,
SYS_EXIT = 60,
SYS_EXIT_GROUP = 231,
SYS_FACCESSAT = 269,
SYS_FACCESSAT2 = 439,
SYS_FADVISE64 = 221,
SYS_FALLOCATE = 285,
SYS_FANOTIFY_INIT = 300,
SYS_FANOTIFY_MARK = 301,
SYS_FCHDIR = 81,
SYS_FCHMOD = 91,
SYS_FCHMODAT = 268,
SYS_FCHOWN = 93,
SYS_FCHOWNAT = 260,
SYS_FCNTL = 72,
SYS_FDATASYNC = 75,
SYS_FGETXATTR = 193,
SYS_FINIT_MODULE = 313,
SYS_FLISTXATTR = 196,
SYS_FLOCK = 73,
SYS_FORK = 57,
SYS_FREMOVEXATTR = 199,
SYS_FSCONFIG = 431,
SYS_FSETXATTR = 190,
SYS_FSMOUNT = 432,
SYS_FSOPEN = 430,
SYS_FSPICK = 433,
SYS_FSTAT = 5,
SYS_FSTATFS = 138,
SYS_FSYNC = 74,
SYS_FTRUNCATE = 77,
SYS_FUTEX = 202,
SYS_FUTIMESAT = 261,
SYS_GET_KERNEL_SYMS = 177,
SYS_GET_MEMPOLICY = 239,
SYS_GET_ROBUST_LIST = 274,
SYS_GET_THREAD_AREA = 211,
SYS_GETCPU = 309,
SYS_GETCWD = 79,
SYS_GETDENTS = 78,
SYS_GETDENTS64 = 217,
SYS_GETEGID = 108,
SYS_GETEUID = 107,
SYS_GETGID = 104,
SYS_GETGROUPS = 115,
SYS_GETITIMER = 36,
SYS_GETPEERNAME = 52,
SYS_GETPGID = 121,
SYS_GETPGRP = 111,
SYS_GETPID = 39,
SYS_GETPMSG = 181,
SYS_GETPPID = 110,
SYS_GETPRIORITY = 140,
SYS_GETRANDOM = 318,
SYS_GETRESGID = 120,
SYS_GETRESUID = 118,
SYS_GETRLIMIT = 97,
SYS_GETRUSAGE = 98,
SYS_GETSID = 124,
SYS_GETSOCKNAME = 51,
SYS_GETSOCKOPT = 55,
SYS_GETTID = 186,
SYS_GETTIMEOFDAY = 96,
SYS_GETUID = 102,
SYS_GETXATTR = 191,
SYS_INIT_MODULE = 175,
SYS_INOTIFY_ADD_WATCH = 254,
SYS_INOTIFY_INIT = 253,
SYS_INOTIFY_INIT1 = 294,
SYS_INOTIFY_RM_WATCH = 255,
SYS_IO_CANCEL = 210,
SYS_IO_DESTROY = 207,
SYS_IO_GETEVENTS = 208,
SYS_IO_PGETEVENTS = 333,
SYS_IO_SETUP = 206,
SYS_IO_SUBMIT = 209,
SYS_IO_URING_ENTER = 426,
SYS_IO_URING_REGISTER = 427,
SYS_IO_URING_SETUP = 425,
SYS_IOCTL = 16,
SYS_IOPERM = 173,
SYS_IOPL = 172,
SYS_IOPRIO_GET = 252,
SYS_IOPRIO_SET = 251,
SYS_KCMP = 312,
SYS_KEXEC_FILE_LOAD = 320,
SYS_KEXEC_LOAD = 246,
SYS_KEYCTL = 250,
SYS_KILL = 62,
SYS_LCHOWN = 94,
SYS_LGETXATTR = 192,
SYS_LINK = 86,
SYS_LINKAT = 265,
SYS_LISTEN = 50,
SYS_LISTXATTR = 194,
SYS_LLISTXATTR = 195,
SYS_LOOKUP_DCOOKIE = 212,
SYS_LREMOVEXATTR = 198,
SYS_LSEEK = 8,
SYS_LSETXATTR = 189,
SYS_LSTAT = 6,
SYS_MADVISE = 28,
SYS_MBIND = 237,
SYS_MEMBARRIER = 324,
SYS_MEMFD_CREATE = 319,
SYS_MIGRATE_PAGES = 256,
SYS_MINCORE = 27,
SYS_MKDIR = 83,
SYS_MKDIRAT = 258,
SYS_MKNOD = 133,
SYS_MKNODAT = 259,
SYS_MLOCK = 149,
SYS_MLOCK2 = 325,
SYS_MLOCKALL = 151,
SYS_MMAP = 9,
SYS_MODIFY_LDT = 154,
SYS_MOUNT = 165,
SYS_MOUNT_SETATTR = 442,
SYS_MOVE_MOUNT = 429,
SYS_MOVE_PAGES = 279,
SYS_MPROTECT = 10,
SYS_MQ_GETSETATTR = 245,
SYS_MQ_NOTIFY = 244,
SYS_MQ_OPEN = 240,
SYS_MQ_TIMEDRECEIVE = 243,
SYS_MQ_TIMEDSEND = 242,
SYS_MQ_UNLINK = 241,
SYS_MREMAP = 25,
SYS_MSGCTL = 71,
SYS_MSGGET = 68,
SYS_MSGRCV = 70,
SYS_MSGSND = 69,
SYS_MSYNC = 26,
SYS_MUNLOCK = 150,
SYS_MUNLOCKALL = 152,
SYS_MUNMAP = 11,
SYS_NAME_TO_HANDLE_AT = 303,
SYS_NANOSLEEP = 35,
SYS_NEWFSTATAT = 262,
SYS_NFSSERVCTL = 180,
SYS_OPEN = 2,
SYS_OPEN_BY_HANDLE_AT = 304,
SYS_OPEN_TREE = 428,
SYS_OPENAT = 257,
SYS_OPENAT2 = 437,
SYS_PAUSE = 34,
SYS_PERF_EVENT_OPEN = 298,
SYS_PERSONALITY = 135,
SYS_PIDFD_GETFD = 438,
SYS_PIDFD_OPEN = 434,
SYS_PIDFD_SEND_SIGNAL = 424,
SYS_PIPE = 22,
SYS_PIPE2 = 293,
SYS_PIVOT_ROOT = 155,
SYS_PKEY_ALLOC = 330,
SYS_PKEY_FREE = 331,
SYS_PKEY_MPROTECT = 329,
SYS_POLL = 7,
SYS_PPOLL = 271,
SYS_PRCTL = 157,
SYS_PREAD64 = 17,
SYS_PREADV = 295,
SYS_PREADV2 = 327,
SYS_PRLIMIT64 = 302,
SYS_PROCESS_MADVISE = 440,
SYS_PROCESS_VM_READV = 310,
SYS_PROCESS_VM_WRITEV = 311,
SYS_PSELECT6 = 270,
SYS_PTRACE = 101,
SYS_PUTPMSG = 182,
SYS_PWRITE64 = 18,
SYS_PWRITEV = 296,
SYS_PWRITEV2 = 328,
SYS_QUERY_MODULE = 178,
SYS_QUOTACTL = 179,
SYS_READ = 0,
SYS_READAHEAD = 187,
SYS_READLINK = 89,
SYS_READLINKAT = 267,
SYS_READV = 19,
SYS_REBOOT = 169,
SYS_RECVFROM = 45,
SYS_RECVMMSG = 299,
SYS_RECVMSG = 47,
SYS_REMAP_FILE_PAGES = 216,
SYS_REMOVEXATTR = 197,
SYS_RENAME = 82,
SYS_RENAMEAT = 264,
SYS_RENAMEAT2 = 316,
SYS_REQUEST_KEY = 249,
SYS_RESTART_SYSCALL = 219,
SYS_RMDIR = 84,
SYS_RSEQ = 334,
SYS_RT_SIGACTION = 13,
SYS_RT_SIGPENDING = 127,
SYS_RT_SIGPROCMASK = 14,
SYS_RT_SIGQUEUEINFO = 129,
SYS_RT_SIGRETURN = 15,
SYS_RT_SIGSUSPEND = 130,
SYS_RT_SIGTIMEDWAIT = 128,
SYS_RT_TGSIGQUEUEINFO = 297,
SYS_SCHED_GET_PRIORITY_MAX = 146,
SYS_SCHED_GET_PRIORITY_MIN = 147,
SYS_SCHED_GETAFFINITY = 204,
SYS_SCHED_GETATTR = 315,
SYS_SCHED_GETPARAM = 143,
SYS_SCHED_GETSCHEDULER = 145,
SYS_SCHED_RR_GET_INTERVAL = 148,
SYS_SCHED_SETAFFINITY = 203,
SYS_SCHED_SETATTR = 314,
SYS_SCHED_SETPARAM = 142,
SYS_SCHED_SETSCHEDULER = 144,
SYS_SCHED_YIELD = 24,
SYS_SECCOMP = 317,
SYS_SECURITY = 185,
SYS_SELECT = 23,
SYS_SEMCTL = 66,
SYS_SEMGET = 64,
SYS_SEMOP = 65,
SYS_SEMTIMEDOP = 220,
SYS_SENDFILE = 40,
SYS_SENDMMSG = 307,
SYS_SENDMSG = 46,
SYS_SENDTO = 44,
SYS_SET_MEMPOLICY = 238,
SYS_SET_ROBUST_LIST = 273,
SYS_SET_THREAD_AREA = 205,
SYS_SET_TID_ADDRESS = 218,
SYS_SETDOMAINNAME = 171,
SYS_SETFSGID = 123,
SYS_SETFSUID = 122,
SYS_SETGID = 106,
SYS_SETGROUPS = 116,
SYS_SETHOSTNAME = 170,
SYS_SETITIMER = 38,
SYS_SETNS = 308,
SYS_SETPGID = 109,
SYS_SETPRIORITY = 141,
SYS_SETREGID = 114,
SYS_SETRESGID = 119,
SYS_SETRESUID = 117,
SYS_SETREUID = 113,
SYS_SETRLIMIT = 160,
SYS_SETSID = 112,
SYS_SETSOCKOPT = 54,
SYS_SETTIMEOFDAY = 164,
SYS_SETUID = 105,
SYS_SETXATTR = 188,
SYS_SHMAT = 30,
SYS_SHMCTL = 31,
SYS_SHMDT = 67,
SYS_SHMGET = 29,
SYS_SHUTDOWN = 48,
SYS_SIGALTSTACK = 131,
SYS_SIGNALFD = 282,
SYS_SIGNALFD4 = 289,
SYS_SOCKET = 41,
SYS_SOCKETPAIR = 53,
SYS_SPLICE = 275,
SYS_STAT = 4,
SYS_STATFS = 137,
SYS_STATX = 332,
SYS_SWAPOFF = 168,
SYS_SWAPON = 167,
SYS_SYMLINK = 88,
SYS_SYMLINKAT = 266,
SYS_SYNC = 162,
SYS_SYNC_FILE_RANGE = 277,
SYS_SYNCFS = 306,
SYS_SYSFS = 139,
SYS_SYSINFO = 99,
SYS_SYSLOG = 103,
SYS_TEE = 276,
SYS_TGKILL = 234,
SYS_TIME = 201,
SYS_TIMER_CREATE = 222,
SYS_TIMER_DELETE = 226,
SYS_TIMER_GETOVERRUN = 225,
SYS_TIMER_GETTIME = 224,
SYS_TIMER_SETTIME = 223,
SYS_TIMERFD_CREATE = 283,
SYS_TIMERFD_GETTIME = 287,
SYS_TIMERFD_SETTIME = 286,
SYS_TIMES = 100,
SYS_TKILL = 200,
SYS_TRUNCATE = 76,
SYS_TUXCALL = 184,
SYS_UMASK = 95,
SYS_UMOUNT2 = 166,
SYS_UNAME = 63,
SYS_UNLINK = 87,
SYS_UNLINKAT = 263,
SYS_UNSHARE = 272,
SYS_USELIB = 134,
SYS_USERFAULTFD = 323,
SYS_USTAT = 136,
SYS_UTIME = 132,
SYS_UTIMENSAT = 280,
SYS_UTIMES = 235,
SYS_VFORK = 58,
SYS_VHANGUP = 153,
SYS_VMSPLICE = 278,
SYS_VSERVER = 236,
SYS_WAIT4 = 61,
SYS_WAITID = 247,
SYS_WRITE = 1,
SYS_WRITEV = 20,
}
impl TryFrom<usize> for SysCall {
type Error = SystemError;
fn try_from(value: usize) -> Result<Self, Self::Error> {
match <Self as FromPrimitive>::from_usize(value) {
Some(p) => Ok(p),
None => Err(SystemError::EINVAL),
}
}
}
impl From<SysCall> for usize {
fn from(value: SysCall) -> Self {
<SysCall as ToPrimitive>::to_usize(&value).unwrap()
}
}

6
kernel/src/driver/net/e1000e/e1000e_driver.rs
View File

@ -96,11 +96,11 @@ pub struct InnerE1000EInterface {
}
impl phy::RxToken for E1000ERxToken {
fn consume<R, F>(mut self, f: F) -> R
fn consume<R, F>(self, f: F) -> R
where
F: FnOnce(&mut [u8]) -> R,
F: FnOnce(&[u8]) -> R,
{
let result = f(self.0.as_mut_slice());
let result = f(self.0.as_slice());
self.0.free_buffer();
return result;
}

35
kernel/src/driver/net/loopback.rs
View File

@ -50,11 +50,11 @@ impl phy::RxToken for LoopbackRxToken {
///
/// ## 返回值
/// 返回函数 `f` 在 `self.buffer` 上的调用结果。
fn consume<R, F>(mut self, f: F) -> R
fn consume<R, F>(self, f: F) -> R
where
F: FnOnce(&mut [u8]) -> R,
F: FnOnce(&[u8]) -> R
{
f(self.buffer.as_mut_slice())
f(self.buffer.as_slice())
}
}
@ -277,20 +277,41 @@ impl LoopbackInterface {
/// 返回一个 `Arc<Self>`，即一个指向新创建的 `LoopbackInterface` 实例的智能指针。
pub fn new(mut driver: LoopbackDriver) -> Arc<Self> {
let iface_id = generate_iface_id();
let mut iface_config = smoltcp::iface::Config::new(HardwareAddress::Ethernet(
smoltcp::wire::EthernetAddress([0x00, 0x00, 0x00, 0x00, 0x00, 0x00]),
));
let hardware_addr = HardwareAddress::Ethernet(smoltcp::wire::EthernetAddress([
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
]));
let mut iface_config = smoltcp::iface::Config::new(hardware_addr);
iface_config.random_seed = rand() as u64;
let mut iface =
smoltcp::iface::Interface::new(iface_config, &mut driver, Instant::now().into());
iface.set_any_ip(true);
let addr = IpAddress::v4(127, 0, 0, 1);
let cidr = IpCidr::new(addr, 8);
//设置网卡地址为127.0.0.1
iface.update_ip_addrs(|ip_addrs| {
ip_addrs
.push(IpCidr::new(IpAddress::v4(127, 0, 0, 1), 8))
.push(cidr)
.expect("Push ipCidr failed: full");
});
iface.routes_mut().update(|routes_map| {
routes_map
.push(smoltcp::iface::Route {
cidr,
via_router: addr,
preferred_until: None,
expires_at: None,
})
.expect("Add default ipv4 route failed: full");
});
Arc::new(LoopbackInterface {
driver: LoopbackDriverWapper(UnsafeCell::new(driver)),
common: IfaceCommon::new(iface_id, false, iface),

26
kernel/src/driver/net/mod.rs
View File

@ -209,19 +209,21 @@ impl IfaceCommon {
let mut interface = self.smol_iface.lock_irqsave();
let (has_events, poll_at) = {
let mut has_events = false;
let mut poll_at;
loop {
has_events |= interface.poll(timestamp, device, &mut sockets);
poll_at = interface.poll_at(timestamp, &sockets);
let Some(instant) = poll_at else {
break;
};
if instant > timestamp {
break;
(
matches!(
interface.poll(timestamp, device, &mut sockets),
smoltcp::iface::PollResult::SocketStateChanged
),
loop {
let poll_at = interface.poll_at(timestamp, &sockets);
let Some(instant) = poll_at else {
break poll_at;
};
if instant > timestamp {
break poll_at;
}
}
}
(has_events, poll_at)
)
};
// drop sockets here to avoid deadlock

6
kernel/src/driver/net/virtio_net.rs
View File

@ -585,11 +585,11 @@ impl phy::TxToken for VirtioNetToken {
impl phy::RxToken for VirtioNetToken {
fn consume<R, F>(self, f: F) -> R
where
F: FnOnce(&mut [u8]) -> R,
F: FnOnce(&[u8]) -> R,
{
// 为了线程安全，这里需要对VirtioNet进行加【写锁】，以保证对设备的互斥访问。
let mut rx_buf = self.rx_buffer.unwrap();
let result = f(rx_buf.packet_mut());
let rx_buf = self.rx_buffer.unwrap();
let result = f(rx_buf.packet());
self.driver
.inner
.lock()

41
kernel/src/net/posix.rs
View File

@ -122,29 +122,29 @@ impl SockAddr {
let addr_in: SockAddrIn = addr.addr_in;
use smoltcp::wire;
let ip: wire::IpAddress = wire::IpAddress::from(wire::Ipv4Address::from_bytes(
&u32::from_be(addr_in.sin_addr).to_be_bytes()[..],
let ip: wire::IpAddress = wire::IpAddress::from(wire::Ipv4Address::from_bits(
u32::from_be(addr_in.sin_addr),
));
let port = u16::from_be(addr_in.sin_port);
return Ok(Endpoint::Ip(wire::IpEndpoint::new(ip, port)));
}
AddressFamily::INet6 => {
if len < addr.len()? {
log::error!("len < addr.len()");
return Err(SystemError::EINVAL);
}
log::debug!("INet6");
let addr_in: SockAddrIn = addr.addr_in;
// AddressFamily::INet6 => {
// if len < addr.len()? {
// log::error!("len < addr.len()");
// return Err(SystemError::EINVAL);
// }
// log::debug!("INet6");
// let addr_in: SockAddrIn = addr.addr_in;
use smoltcp::wire;
let ip: wire::IpAddress = wire::IpAddress::from(wire::Ipv6Address::from_bytes(
&u32::from_be(addr_in.sin_addr).to_be_bytes()[..],
));
let port = u16::from_be(addr_in.sin_port);
// use smoltcp::wire;
// let ip: wire::IpAddress = wire::IpAddress::from(wire::Ipv6Address::from_bits(
// u128::from_be(addr_in.sin_addr),
// ));
// let port = u16::from_be(addr_in.sin_port);
return Ok(Endpoint::Ip(wire::IpEndpoint::new(ip, port)));
}
// return Ok(Endpoint::Ip(wire::IpEndpoint::new(ip, port)));
// }
AddressFamily::Unix => {
let addr_un: SockAddrUn = addr.addr_un;
@ -232,12 +232,7 @@ impl SockAddr {
};
return Ok(Endpoint::Unixpath((inode.metadata()?.inode_id, path)));
}
AddressFamily::Packet => {
// TODO: support packet socket
log::warn!("not support address family {:?}", addr.family);
return Err(SystemError::EINVAL);
}
},
_ => {
log::warn!("not support address family {:?}", addr.family);
return Err(SystemError::EINVAL);
@ -312,7 +307,7 @@ impl From<Endpoint> for SockAddr {
let addr_in = SockAddrIn {
sin_family: AddressFamily::INet as u16,
sin_port: ip_endpoint.port.to_be(),
sin_addr: u32::from_be_bytes(ipv4_addr.0).to_be(),
sin_addr: ipv4_addr.to_bits(),
sin_zero: [0; 8],
};

22
kernel/src/net/socket/inet/common/mod.rs
View File

@ -41,40 +41,24 @@ impl BoundInner {
T: smoltcp::socket::AnySocket<'static>,
{
if address.is_unspecified() {
// let inner = Vec::new();
// for (_, iface) in *NET_DEVICES.read_irqsave() {
// let handle = iface.sockets().lock_no_preempt().add(socket);
// iface
// }
// 强绑VirtualIO
// log::debug!("Not bind to any iface, bind to virtIO");
let ifaces: Vec<Arc<dyn Iface>> = NET_DEVICES
let iface = NET_DEVICES
.read_irqsave()
.iter()
.filter_map(|(_, v)| {
.find_map(|(_, v)| {
if v.common().is_default_iface() {
Some(v.clone())
} else {
None
}
})
.collect();
.expect("No default interface");
// let iface = NET_DEVICES
// .read_irqsave()
// .get(&0)
// .expect("??bind without virtIO, serious?")
// .clone();
let iface = ifaces[0].clone();
let handle = iface.sockets().lock_no_preempt().add(socket);
return Ok(Self { handle, iface });
} else {
let iface = get_iface_to_bind(address).ok_or(ENODEV)?;
let handle = iface.sockets().lock_no_preempt().add(socket);
// log::debug!("Bind to iface: {}", iface.iface_name());
// return Ok(Self { inner: vec![(handle, iface)] });
return Ok(Self { handle, iface });
}
}

72
kernel/src/net/socket/inet/stream/inner.rs
View File

@ -31,13 +31,13 @@ where
#[derive(Debug)]
pub enum Init {
Unbound((Box<smoltcp::socket::tcp::Socket<'static>>, bool)),
Unbound((Box<smoltcp::socket::tcp::Socket<'static>>, smoltcp::wire::IpVersion)),
Bound((socket::inet::BoundInner, smoltcp::wire::IpEndpoint)),
}
impl Init {
pub(super) fn new(v4: bool) -> Self {
Init::Unbound((Box::new(new_smoltcp_socket()), v4))
pub(super) fn new(ver: smoltcp::wire::IpVersion) -> Self {
Init::Unbound((Box::new(new_smoltcp_socket()), ver))
}
/// 传入一个已经绑定的socket
@ -75,14 +75,14 @@ impl Init {
remote_endpoint: smoltcp::wire::IpEndpoint,
) -> Result<(socket::inet::BoundInner, smoltcp::wire::IpEndpoint), (Self, SystemError)> {
match self {
Init::Unbound((socket, v4)) => {
Init::Unbound((socket, ver)) => {
let (bound, address) =
socket::inet::BoundInner::bind_ephemeral(*socket, remote_endpoint.addr)
.map_err(|err| (Self::new(v4), err))?;
.map_err(|err| (Self::new(ver), err))?;
let bound_port = bound
.port_manager()
.bind_ephemeral_port(Types::Tcp)
.map_err(|err| (Self::new(v4), err))?;
.map_err(|err| (Self::new(ver), err))?;
let endpoint = smoltcp::wire::IpEndpoint::new(address, bound_port);
Ok((bound, endpoint))
}
@ -129,14 +129,16 @@ impl Init {
} else {
smoltcp::wire::IpListenEndpoint::from(local)
};
// log::debug!("listen at {:?}", listen_addr);
log::debug!("listen at {:?}", listen_addr);
let mut inners = Vec::new();
if let Err(err) = || -> Result<(), SystemError> {
for _ in 0..(backlog - 1) {
// -1 because the first one is already bound
let new_listen = socket::inet::BoundInner::bind(
new_listen_smoltcp_socket(listen_addr),
&local.addr,
listen_addr.addr.as_ref().unwrap_or(
&smoltcp::wire::IpAddress::from(smoltcp::wire::Ipv4Address::UNSPECIFIED)
),
)?;
inners.push(new_listen);
}
@ -155,8 +157,19 @@ impl Init {
return Ok(Listening {
inners,
connect: AtomicUsize::new(0),
listen_addr,
});
}
pub(super) fn close(&self) {
match self {
Init::Unbound(_) => {}
Init::Bound((inner, endpoint)) => {
inner.port_manager().unbind_port(Types::Tcp, endpoint.port);
inner.with_mut::<smoltcp::socket::tcp::Socket, _, _>(|socket| socket.close());
}
}
}
}
#[derive(Debug, Default, Clone, Copy)]
@ -245,6 +258,7 @@ impl Connecting {
pub struct Listening {
inners: Vec<socket::inet::BoundInner>,
connect: AtomicUsize,
listen_addr: smoltcp::wire::IpListenEndpoint,
}
impl Listening {
@ -258,23 +272,20 @@ impl Listening {
return Err(EAGAIN_OR_EWOULDBLOCK);
}
let (local_endpoint, remote_endpoint) = connected
let remote_endpoint = connected
.with::<smoltcp::socket::tcp::Socket, _, _>(|socket| {
(
socket
.local_endpoint()
.expect("A Connected Tcp With No Local Endpoint"),
socket
.remote_endpoint()
.expect("A Connected Tcp With No Remote Endpoint"),
)
socket
.remote_endpoint()
.expect("A Connected Tcp With No Remote Endpoint")
});
// log::debug!("local at {:?}", local_endpoint);
let mut new_listen = socket::inet::BoundInner::bind(
new_listen_smoltcp_socket(local_endpoint),
&local_endpoint.addr,
new_listen_smoltcp_socket(self.listen_addr),
self.listen_addr.addr.as_ref().unwrap_or(
&smoltcp::wire::IpAddress::from(smoltcp::wire::Ipv4Address::UNSPECIFIED),
),
)?;
// swap the connected socket with the new_listen socket
@ -307,14 +318,21 @@ impl Listening {
}
pub fn get_name(&self) -> smoltcp::wire::IpEndpoint {
self.inners[0].with::<smoltcp::socket::tcp::Socket, _, _>(|socket| {
if let Some(name) = socket.local_endpoint() {
return name;
} else {
// TODO: IPV6
return UNSPECIFIED_LOCAL_ENDPOINT_V4;
}
})
smoltcp::wire::IpEndpoint::new(self.listen_addr.addr.unwrap_or(
smoltcp::wire::IpAddress::from(smoltcp::wire::Ipv4Address::UNSPECIFIED),
), self.listen_addr.port)
}
pub fn close(&self) {
log::debug!("Close Listening Socket");
let port = self.get_name().port;
for inner in self.inners.iter() {
inner.with_mut::<smoltcp::socket::tcp::Socket, _, _>(|socket| socket.close());
}
self.inners[0]
.iface()
.port_manager()
.unbind_port(Types::Tcp, port);
}
}

26
kernel/src/net/socket/inet/stream/mod.rs
View File

@ -2,7 +2,7 @@ use alloc::sync::{Arc, Weak};
use core::sync::atomic::{AtomicBool, AtomicUsize};
use system_error::SystemError::{self, *};
use crate::libs::rwlock::RwLock;
use crate::{arch::init, libs::rwlock::RwLock};
use crate::net::event_poll::EPollEventType;
use crate::net::net_core::poll_ifaces;
use crate::net::socket::*;
@ -29,9 +29,9 @@ pub struct TcpSocket {
}
impl TcpSocket {
pub fn new(nonblock: bool, v4: bool) -> Arc<Self> {
pub fn new(nonblock: bool, ver: smoltcp::wire::IpVersion) -> Arc<Self> {
Arc::new_cyclic(|me| Self {
inner: RwLock::new(Some(Inner::Init(Init::new(v4)))),
inner: RwLock::new(Some(Inner::Init(Init::new(ver)))),
shutdown: Shutdown::new(),
nonblock: AtomicBool::new(nonblock),
wait_queue: WaitQueue::default(),
@ -234,12 +234,11 @@ impl Socket for TcpSocket {
fn get_name(&self) -> Result<Endpoint, SystemError> {
match self.inner.read().as_ref().expect("Tcp Inner is None") {
Inner::Init(Init::Unbound((_, v4))) => {
if *v4 {
Ok(Endpoint::Ip(UNSPECIFIED_LOCAL_ENDPOINT_V4))
} else {
Ok(Endpoint::Ip(UNSPECIFIED_LOCAL_ENDPOINT_V6))
}
Inner::Init(Init::Unbound((_, ver))) => {
Ok(Endpoint::Ip( match ver {
smoltcp::wire::IpVersion::Ipv4 => UNSPECIFIED_LOCAL_ENDPOINT_V4,
smoltcp::wire::IpVersion::Ipv6 => UNSPECIFIED_LOCAL_ENDPOINT_V6,
}))
}
Inner::Init(Init::Bound((_, local))) => Ok(Endpoint::Ip(*local)),
Inner::Connecting(connecting) => Ok(Endpoint::Ip(connecting.get_name())),
@ -324,7 +323,14 @@ impl Socket for TcpSocket {
es.release();
Ok(())
}
_ => Ok(()),
Inner::Listening(ls) => {
ls.close();
Ok(())
}
Inner::Init(init) => {
init.close();
Ok(())
},
})
.unwrap_or(Ok(()))
}

13
kernel/src/net/socket/inet/syscall.rs
View File

@ -8,7 +8,7 @@ use inet::{TcpSocket, UdpSocket};
use crate::net::socket::*;
fn create_inet_socket(
v4: bool,
version: smoltcp::wire::IpVersion,
socket_type: PSOCK,
protocol: smoltcp::wire::IpProtocol,
) -> Result<Arc<dyn Socket>, SystemError> {
@ -26,7 +26,7 @@ fn create_inet_socket(
},
PSOCK::Stream => match protocol {
HopByHop | Tcp => {
return Ok(TcpSocket::new(false, v4));
return Ok(TcpSocket::new(false, version));
}
_ => {
return Err(EPROTONOSUPPORT);
@ -44,8 +44,11 @@ fn create_inet_socket(
pub struct Inet;
impl family::Family for Inet {
fn socket(stype: PSOCK, protocol: u32) -> Result<Arc<Inode>, SystemError> {
let socket =
create_inet_socket(true, stype, smoltcp::wire::IpProtocol::from(protocol as u8))?;
let socket = create_inet_socket(
smoltcp::wire::IpVersion::Ipv4,
stype,
smoltcp::wire::IpProtocol::from(protocol as u8)
)?;
Ok(Inode::new(socket))
}
}
@ -54,7 +57,7 @@ pub struct Inet6;
impl family::Family for Inet6 {
fn socket(stype: PSOCK, protocol: u32) -> Result<Arc<Inode>, SystemError> {
let socket = create_inet_socket(
false,
smoltcp::wire::IpVersion::Ipv6,
stype,
smoltcp::wire::IpProtocol::from(protocol as u8),
)?;