Remove alxd

It hasn't been in a functional state for years.

Cargo.lock

@@ -80,19 +80,6 @@ dependencies = [
  "memchr 2.7.6",
 ]
 
-[[package]]
-name = "alxd"
-version = "0.1.0"
-dependencies = [
- "bitflags 2.10.0",
- "common",
- "daemon",
- "libredox",
- "redox-scheme",
- "redox_event",
- "redox_syscall 0.7.0",
-]
-
 [[package]]
 name = "amlserde"
 version = "0.0.1"

Cargo.toml

@@ -44,7 +44,6 @@ members = [
     "drivers/input/ps2d",
     "drivers/input/usbhidd",
 
-    "drivers/net/alxd",
     "drivers/net/driver-network",
     "drivers/net/e1000d",
     "drivers/net/ixgbed",

drivers/net/alxd/Cargo.toml

@@ -1,14 +0,0 @@
-[package]
-name = "alxd"
-version = "0.1.0"
-edition = "2018"
-
-[dependencies]
-bitflags = "2"
-redox_event.workspace = true
-redox_syscall.workspace = true
-
-common = { path = "../../common" }
-daemon = { path = "../../../daemon" }
-libredox.workspace = true
-redox-scheme.workspace = true

drivers/net/alxd/src/main.rs

@@ -1,149 +0,0 @@
-#![feature(macro_metavar_expr_concat)]
-#![allow(dead_code)]
-#![allow(non_upper_case_globals)]
-#![allow(unused_parens)]
-
-extern crate event;
-extern crate syscall;
-
-use std::fs::File;
-use std::io::{Read, Write};
-use std::os::fd::AsRawFd;
-use std::{env, iter};
-
-use event::{user_data, EventQueue};
-use redox_scheme::scheme::register_sync_scheme;
-use redox_scheme::wrappers::ReadinessBased;
-use redox_scheme::Socket;
-use std::cell::RefCell;
-
-pub mod device;
-
-fn main() {
-    common::init();
-    daemon::Daemon::new(daemon);
-}
-
-fn daemon(daemon: daemon::Daemon) -> ! {
-    let mut args = env::args().skip(1);
-
-    let mut name = args.next().expect("alxd: no name provided");
-    name.push_str("_alx");
-
-    let bar_str = args.next().expect("alxd: no address provided");
-    let bar = usize::from_str_radix(&bar_str, 16).expect("alxd: failed to parse address");
-
-    let irq_str = args.next().expect("alxd: no irq provided");
-    let irq = irq_str.parse::<u8>().expect("alxd: failed to parse irq");
-
-    println!(" + ALX {} on: {:X}, IRQ: {}\n", name, bar, irq);
-
-    let socket = Socket::nonblock().expect("alxd: failed to create socket");
-    let mut readiness_based = ReadinessBased::new(&socket, 16);
-
-    let mut irq_file =
-        File::open(format!("/scheme/irq/{}", irq)).expect("alxd: failed to open IRQ file");
-
-    let address = unsafe {
-        common::physmap(
-            bar,
-            128 * 1024,
-            common::Prot::RW,
-            common::MemoryType::Uncacheable,
-        )
-        .expect("alxd: failed to map address") as usize
-    };
-    {
-        let device = RefCell::new({
-            let mut device =
-                unsafe { device::Alx::new(address).expect("alxd: failed to allocate device") };
-            register_sync_scheme(&socket, "network", &mut device)
-                .expect("alxd: failed to register network scheme to namespace");
-            device
-        });
-
-        daemon.ready();
-
-        user_data! {
-            enum Source {
-                Irq,
-                Scheme,
-            }
-        }
-
-        let event_queue = EventQueue::<Source>::new().expect("alxd: failed to create event queue");
-        event_queue
-            .subscribe(
-                irq_file.as_raw_fd() as usize,
-                Source::Irq,
-                event::EventFlags::READ,
-            )
-            .unwrap();
-        event_queue
-            .subscribe(
-                socket.inner().raw(),
-                Source::Scheme,
-                event::EventFlags::READ,
-            )
-            .unwrap();
-
-        libredox::call::setrens(0, 0).expect("alxd: failed to enter null namespace");
-
-        for event in iter::once(Source::Scheme)
-            .chain(event_queue.map(|e| e.expect("alxd: failed to get next event").user_data))
-        {
-            match event {
-                Source::Irq => {
-                    let mut irq = [0; 8];
-                    irq_file.read(&mut irq).unwrap();
-                    if !unsafe { device.borrow_mut().intr_legacy() } {
-                        continue;
-                    }
-                    irq_file.write(&mut irq).unwrap();
-
-                    readiness_based
-                        .poll_all_requests(|| device.borrow_mut())
-                        .expect("alxd: failed to poll requests");
-                    if !readiness_based
-                        .write_responses()
-                        .expect("alxd: failed to write to socket")
-                    {
-                        break;
-                    }
-
-                    /* TODO: Currently a no-op
-                    let next_read = device.next_read();
-                    if next_read > 0 {
-                        return Ok(Some(next_read));
-                    }
-                    */
-                }
-
-                Source::Scheme => {
-                    if !readiness_based
-                        .read_requests()
-                        .expect("alxd: failed to read from socket")
-                    {
-                        break;
-                    }
-                    readiness_based.process_requests(|| device.borrow_mut());
-                    if !readiness_based
-                        .write_responses()
-                        .expect("alxd: failed to write to socket")
-                    {
-                        break;
-                    }
-
-                    // TODO
-                    /*
-                    let next_read = device.next_read();
-                    if next_read > 0 {
-                        return Ok(Some(next_read));
-                    }
-                    */
-                }
-            }
-        }
-    }
-    std::process::exit(0);
-}