Removed newlib exclusion for network features

src/executor/mod.rs

@@ -22,23 +22,21 @@ use smoltcp::time::Instant;
 use crate::arch::core_local::*;
 #[cfg(all(
 	any(feature = "tcp", feature = "udp"),
-	not(feature = "pci"),
-	not(feature = "newlib")
+	not(feature = "pci")
 ))]
 use crate::drivers::mmio::get_network_driver;
-#[cfg(all(any(feature = "tcp", feature = "udp"), not(feature = "newlib")))]
+#[cfg(all(any(feature = "tcp", feature = "udp")))]
 use crate::drivers::net::NetworkDriver;
 #[cfg(all(
 	any(feature = "tcp", feature = "udp"),
-	feature = "pci",
-	not(feature = "newlib")
+	feature = "pci"
 ))]
 use crate::drivers::pci::get_network_driver;
-#[cfg(all(any(feature = "tcp", feature = "udp"), not(feature = "newlib")))]
+#[cfg(all(any(feature = "tcp", feature = "udp")))]
 use crate::executor::network::network_delay;
 use crate::executor::task::AsyncTask;
 use crate::fd::IoError;
-#[cfg(all(any(feature = "tcp", feature = "udp"), not(feature = "newlib")))]
+#[cfg(all(any(feature = "tcp", feature = "udp")))]
 use crate::scheduler::PerCoreSchedulerExt;
 use crate::synch::futex::*;
 
@@ -97,7 +95,7 @@ where
 }
 
 pub fn init() {
-	#[cfg(all(any(feature = "tcp", feature = "udp"), not(feature = "newlib")))]
+	#[cfg(all(any(feature = "tcp", feature = "udp")))]
 	crate::executor::network::init();
 }
 

src/fd/mod.rs

@@ -7,15 +7,15 @@ use core::time::Duration;
 
 use async_trait::async_trait;
 use dyn_clone::DynClone;
-#[cfg(all(any(feature = "tcp", feature = "udp"), not(feature = "newlib")))]
+#[cfg(all(any(feature = "tcp", feature = "udp")))]
 use smoltcp::wire::{IpEndpoint, IpListenEndpoint};
 
 use crate::arch::kernel::core_local::core_scheduler;
 use crate::executor::{block_on, poll_on};
 use crate::fs::{DirectoryEntry, FileAttr, SeekWhence};
 
 mod eventfd;
-#[cfg(all(any(feature = "tcp", feature = "udp"), not(feature = "newlib")))]
+#[cfg(all(any(feature = "tcp", feature = "udp")))]
 pub(crate) mod socket;
 pub(crate) mod stdio;
 
@@ -207,56 +207,56 @@ pub(crate) trait ObjectInterface: Sync + Send + core::fmt::Debug + DynClone {
 	}
 
 	/// `accept` a connection on a socket
-	#[cfg(all(any(feature = "tcp", feature = "udp"), not(feature = "newlib")))]
+	#[cfg(all(any(feature = "tcp", feature = "udp")))]
 	fn accept(&self) -> Result<IpEndpoint, IoError> {
 		Err(IoError::EINVAL)
 	}
 
 	/// initiate a connection on a socket
-	#[cfg(all(any(feature = "tcp", feature = "udp"), not(feature = "newlib")))]
+	#[cfg(all(any(feature = "tcp", feature = "udp")))]
 	fn connect(&self, _endpoint: IpEndpoint) -> Result<(), IoError> {
 		Err(IoError::EINVAL)
 	}
 
 	/// `bind` a name to a socket
-	#[cfg(all(any(feature = "tcp", feature = "udp"), not(feature = "newlib")))]
+	#[cfg(all(any(feature = "tcp", feature = "udp")))]
 	fn bind(&self, _name: IpListenEndpoint) -> Result<(), IoError> {
 		Err(IoError::EINVAL)
 	}
 
 	/// `listen` for connections on a socket
-	#[cfg(all(any(feature = "tcp", feature = "udp"), not(feature = "newlib")))]
+	#[cfg(all(any(feature = "tcp", feature = "udp")))]
 	fn listen(&self, _backlog: i32) -> Result<(), IoError> {
 		Err(IoError::EINVAL)
 	}
 
 	/// `setsockopt` sets options on sockets
-	#[cfg(all(any(feature = "tcp", feature = "udp"), not(feature = "newlib")))]
+	#[cfg(all(any(feature = "tcp", feature = "udp")))]
 	fn setsockopt(&self, _opt: SocketOption, _optval: bool) -> Result<(), IoError> {
 		Err(IoError::EINVAL)
 	}
 
 	/// `getsockopt` gets options on sockets
-	#[cfg(all(any(feature = "tcp", feature = "udp"), not(feature = "newlib")))]
+	#[cfg(all(any(feature = "tcp", feature = "udp")))]
 	fn getsockopt(&self, _opt: SocketOption) -> Result<bool, IoError> {
 		Err(IoError::EINVAL)
 	}
 
 	/// `getsockname` gets socket name
-	#[cfg(all(any(feature = "tcp", feature = "udp"), not(feature = "newlib")))]
+	#[cfg(all(any(feature = "tcp", feature = "udp")))]
 	fn getsockname(&self) -> Option<IpEndpoint> {
 		None
 	}
 
 	/// `getpeername` get address of connected peer
-	#[cfg(all(any(feature = "tcp", feature = "udp"), not(feature = "newlib")))]
+	#[cfg(all(any(feature = "tcp", feature = "udp")))]
 	#[allow(dead_code)]
 	fn getpeername(&self) -> Option<IpEndpoint> {
 		None
 	}
 
 	/// receive a message from a socket
-	#[cfg(all(any(feature = "tcp", feature = "udp"), not(feature = "newlib")))]
+	#[cfg(all(any(feature = "tcp", feature = "udp")))]
 	fn recvfrom(&self, _buffer: &mut [u8]) -> Result<(usize, IpEndpoint), IoError> {
 		Err(IoError::ENOSYS)
 	}
@@ -268,13 +268,13 @@ pub(crate) trait ObjectInterface: Sync + Send + core::fmt::Debug + DynClone {
 	/// If a peer address has been prespecified, either the message shall
 	/// be sent to the address specified by dest_addr (overriding the pre-specified peer
 	/// address).
-	#[cfg(all(any(feature = "tcp", feature = "udp"), not(feature = "newlib")))]
+	#[cfg(all(any(feature = "tcp", feature = "udp")))]
 	fn sendto(&self, _buffer: &[u8], _endpoint: IpEndpoint) -> Result<usize, IoError> {
 		Err(IoError::ENOSYS)
 	}
 
 	/// shut down part of a full-duplex connection
-	#[cfg(all(any(feature = "tcp", feature = "udp"), not(feature = "newlib")))]
+	#[cfg(all(any(feature = "tcp", feature = "udp")))]
 	fn shutdown(&self, _how: i32) -> Result<(), IoError> {
 		Err(IoError::ENOSYS)
 	}

src/lib.rs

@@ -130,20 +130,9 @@ extern "C" fn initd(_arg: usize) {
 		fn runtime_entry(argc: i32, argv: *const *const u8, env: *const *const u8) -> !;
 		#[cfg(all(not(test), any(feature = "nostd", feature = "common-os")))]
 		fn main(argc: i32, argv: *const *const u8, env: *const *const u8);
-		#[cfg(feature = "newlib")]
-		fn init_lwip();
-		#[cfg(feature = "newlib")]
-		fn init_rtl8139_netif(freq: u32) -> i32;
 	}
 
 	if !env::is_uhyve() {
-		// initialize LwIP library for newlib-based applications
-		#[cfg(feature = "newlib")]
-		unsafe {
-			init_lwip();
-			init_rtl8139_netif(processor::get_frequency() as u32);
-		}
-
 		info!("Hermit is running on common system!");
 	} else {
 		info!("Hermit is running on uhyve!");

src/scheduler/mod.rs

@@ -442,18 +442,6 @@ impl PerCoreScheduler {
 		})
 	}
 
-	#[cfg(feature = "newlib")]
-	#[inline]
-	pub fn set_lwip_errno(&self, errno: i32) {
-		without_interrupts(|| self.current_task.borrow_mut().lwip_errno = errno);
-	}
-
-	#[cfg(feature = "newlib")]
-	#[inline]
-	pub fn get_lwip_errno(&self) -> i32 {
-		without_interrupts(|| self.current_task.borrow().lwip_errno)
-	}
-
 	#[inline]
 	pub fn get_current_task_id(&self) -> TaskId {
 		without_interrupts(|| self.current_task.borrow().id)

src/scheduler/task.rs

@@ -399,9 +399,6 @@ pub(crate) struct Task {
 	// Physical address of the 1st level page table
 	#[cfg(all(target_arch = "x86_64", feature = "common-os"))]
 	pub root_page_table: usize,
-	/// lwIP error code for this task
-	#[cfg(feature = "newlib")]
-	pub lwip_errno: i32,
 }
 
 pub(crate) trait TaskFrame {
@@ -437,8 +434,6 @@ impl Task {
 			tls: None,
 			#[cfg(all(target_arch = "x86_64", feature = "common-os"))]
 			root_page_table: arch::create_new_root_page_table(),
-			#[cfg(feature = "newlib")]
-			lwip_errno: 0,
 		}
 	}
 
@@ -507,8 +502,6 @@ impl Task {
 			tls: None,
 			#[cfg(all(target_arch = "x86_64", feature = "common-os"))]
 			root_page_table: *crate::scheduler::BOOT_ROOT_PAGE_TABLE.get().unwrap(),
-			#[cfg(feature = "newlib")]
-			lwip_errno: 0,
 		}
 	}
 }

src/syscalls/interfaces/uhyve.rs

@@ -10,20 +10,11 @@ use crate::arch;
 use crate::arch::mm::{paging, PhysAddr, VirtAddr};
 use crate::syscalls::interfaces::SyscallInterface;
 #[cfg(feature = "newlib")]
-use crate::syscalls::lwip::sys_lwip_get_errno;
-#[cfg(feature = "newlib")]
-use crate::syscalls::{LWIP_FD_BIT, LWIP_LOCK};
 
 const UHYVE_PORT_EXIT: u16 = 0x540;
 const UHYVE_PORT_CMDSIZE: u16 = 0x740;
 const UHYVE_PORT_CMDVAL: u16 = 0x780;
 
-#[cfg(feature = "newlib")]
-extern "C" {
-	fn lwip_write(fd: i32, buf: *const u8, len: usize) -> i32;
-	fn lwip_read(fd: i32, buf: *mut u8, len: usize) -> i32;
-}
-
 /// forward a request to the hypervisor uhyve
 #[inline]
 #[cfg(target_arch = "x86_64")]

src/syscalls/mod.rs

@@ -35,12 +35,11 @@ mod entropy;
 mod futex;
 mod interfaces;
 #[cfg(feature = "newlib")]
-mod lwip;
 mod processor;
 #[cfg(feature = "newlib")]
 mod recmutex;
 mod semaphore;
-#[cfg(all(any(feature = "tcp", feature = "udp"), not(feature = "newlib")))]
+#[cfg(all(any(feature = "tcp", feature = "udp")))]
 pub mod socket;
 mod spinlock;
 mod system;
@@ -49,12 +48,6 @@ pub(crate) mod table;
 mod tasks;
 mod timer;
 
-#[cfg(feature = "newlib")]
-const LWIP_FD_BIT: i32 = 1 << 30;
-
-#[cfg(feature = "newlib")]
-pub(crate) static LWIP_LOCK: InterruptTicketMutex<()> = InterruptTicketMutex::new(());
-
 pub(crate) static SYS: Lazy<&'static dyn SyscallInterface> = Lazy::new(|| {
 	if env::is_uhyve() {
 		&self::interfaces::Uhyve

src/syscalls/socket.rs

@@ -5,7 +5,7 @@ use core::ffi::{c_char, c_void};
 use core::mem::size_of;
 use core::ops::DerefMut;
 
-#[cfg(all(any(feature = "tcp", feature = "udp"), not(feature = "newlib")))]
+#[cfg(all(any(feature = "tcp", feature = "udp")))]
 use smoltcp::wire::{IpAddress, IpEndpoint, IpListenEndpoint};
 
 use crate::errno::*;
@@ -102,7 +102,7 @@ pub struct sockaddr_in {
 	pub sin_zero: [c_char; 8],
 }
 
-#[cfg(all(any(feature = "tcp", feature = "udp"), not(feature = "newlib")))]
+#[cfg(all(any(feature = "tcp", feature = "udp")))]
 impl From<sockaddr_in> for IpListenEndpoint {
 	fn from(addr: sockaddr_in) -> IpListenEndpoint {
 		let port = u16::from_be(addr.sin_port);
@@ -118,7 +118,7 @@ impl From<sockaddr_in> for IpListenEndpoint {
 	}
 }
 
-#[cfg(all(any(feature = "tcp", feature = "udp"), not(feature = "newlib")))]
+#[cfg(all(any(feature = "tcp", feature = "udp")))]
 impl From<sockaddr_in> for IpEndpoint {
 	fn from(addr: sockaddr_in) -> IpEndpoint {
 		let port = u16::from_be(addr.sin_port);
@@ -129,7 +129,7 @@ impl From<sockaddr_in> for IpEndpoint {
 	}
 }
 
-#[cfg(all(any(feature = "tcp", feature = "udp"), not(feature = "newlib")))]
+#[cfg(all(any(feature = "tcp", feature = "udp")))]
 impl From<IpEndpoint> for sockaddr_in {
 	fn from(endpoint: IpEndpoint) -> Self {
 		match endpoint.addr {
@@ -162,7 +162,7 @@ pub struct sockaddr_in6 {
 	pub sin6_scope_id: u32,
 }
 
-#[cfg(all(any(feature = "tcp", feature = "udp"), not(feature = "newlib")))]
+#[cfg(all(any(feature = "tcp", feature = "udp")))]
 impl From<sockaddr_in6> for IpListenEndpoint {
 	fn from(addr: sockaddr_in6) -> IpListenEndpoint {
 		let port = u16::from_be(addr.sin6_port);
@@ -184,7 +184,7 @@ impl From<sockaddr_in6> for IpListenEndpoint {
 	}
 }
 
-#[cfg(all(any(feature = "tcp", feature = "udp"), not(feature = "newlib")))]
+#[cfg(all(any(feature = "tcp", feature = "udp")))]
 impl From<sockaddr_in6> for IpEndpoint {
 	fn from(addr: sockaddr_in6) -> IpEndpoint {
 		let port = u16::from_be(addr.sin6_port);
@@ -202,7 +202,7 @@ impl From<sockaddr_in6> for IpEndpoint {
 	}
 }
 
-#[cfg(all(any(feature = "tcp", feature = "udp"), not(feature = "newlib")))]
+#[cfg(all(any(feature = "tcp", feature = "udp")))]
 impl From<IpEndpoint> for sockaddr_in6 {
 	fn from(endpoint: IpEndpoint) -> Self {
 		match endpoint.addr {

xtask/src/build.rs

@@ -114,12 +114,6 @@ impl Build {
 			"__bss_start",
 			"mcount",
 			"runtime_entry",
-			// lwIP functions (C runtime)
-			"init_lwip",
-			"lwip_read",
-			"lwip_write",
-			// lwIP rtl8139 driver
-			"init_rtl8139_netif",
 			"irq_install_handler",
 			"virt_to_phys",
 			"eoi",