net: sharded PCB hash table, kill TCP_DEMUX (Phase 6b)

Replace the single-lock PcbTable + shadow TcpDemuxTable with a unified
sharded design: 16 independently-locked TcpShard instances for
established connections (SYN_SENT, SYN_RECV, DATA, TIME_WAIT) plus a
separate ListenerTable for LISTEN sockets.

Architecture:
- TCP_SHARDS: [IrqMutex<TcpShard>; 16], each with 8 PCB + 8 buffer slots
- TCP_LISTENERS: IrqMutex<ListenerTable> with 16 slots, linear scan
- FNV-1a hash on the full 4-tuple selects the shard; O(8) scan within
- ConnId encodes (shard, slot) or (listener, slot) in a u32
- All locks at LOCK_LEVEL_RESOURCE; never hold two simultaneously
- input() locks one shard for established, falls back to listener table
  for SYNs, then locks the child's shard to install — three sequential
  lock acquisitions, never nested

Deleted: TcpDemuxTable, TcpDemuxBucket, TcpEstablishedEntry,
TcpListenerEntry, TCP_DEMUX, TCP_DEMUX_BUCKETS_TABLE, tcp_demux_hash,
and all register/unregister/lookup calls in socket.rs and ipv4.rs
(~300 lines removed from listener.rs, ~35 from ipv4.rs, ~25 from
socket.rs). The sharded table is the single source of truth.

Zero unsafe blocks throughout.

Author: Lon60

net/src/ipv4.rs

@@ -208,40 +208,6 @@ fn dispatch_tcp(src_ip: [u8; 4], dst_ip: [u8; 4], pkt: &PacketBuf, checksum_rx:
     let payload = &ip_payload[hdr_len..];
     let now_ms = slopos_utils::clock::uptime_ms();
 
-    // Demux table pre-lookup for debug/fast-path validation.
-    // The demux table provides O(n) lookup by 4-tuple (established) or
-    // 2-tuple (listener). The actual state machine processing still goes
-    // through tcp_input() which uses TcpConnectionTable internally.
-    {
-        use super::tcp::listener::TCP_DEMUX;
-        use super::types::{Ipv4Addr, Port};
-
-        let demux = TCP_DEMUX.lock();
-        let local_ip = Ipv4Addr(dst_ip);
-        let local_port = Port(hdr.dst_port);
-        let remote_ip = Ipv4Addr(src_ip);
-        let remote_port = Port(hdr.src_port);
-
-        if let Some(conn_id) =
-            demux.lookup_established(local_ip, local_port, remote_ip, remote_port)
-        {
-            klog_debug!(
-                "tcp demux: established conn_id={} for {}:{} -> {}:{}",
-                conn_id,
-                src_ip[0],
-                src_ip[1],
-                hdr.src_port,
-                hdr.dst_port
-            );
-        } else if let Some(sock_idx) = demux.lookup_listener(local_ip, local_port) {
-            klog_debug!(
-                "tcp demux: listener sock_idx={} for port {}",
-                sock_idx,
-                hdr.dst_port
-            );
-        }
-    }
-
     let actions = tcp::input(src_ip, dst_ip, &hdr, options, payload, now_ms);
 
     for seg in actions.segments() {

net/src/socket.rs

@@ -894,25 +894,14 @@ pub fn socket_notify_tcp_activity(actions: &tcp::Actions) {
     if let Some(conn_id) = actions.conn_id {
         socket_notify_tcp_idx_waiters(conn_id);
 
-        // When a connection transitions to Established, register it
-        // in the TCP demux table for fast 4-tuple lookup.
+        // Wire completed 3WHS into the listener's accept queue.
+        // The child PCB inherits the parent listener's socket_id at
+        // install time, so we read it directly instead of looking up
+        // the old TCP_DEMUX table.
         if actions.notify.contains(tcp::SocketNotify::NEW_ESTABLISHED) {
-            if let Some(tuple) = tcp::with_pcb(conn_id, |pcb| pcb.tuple) {
-                let _ = tcp_listener::TCP_DEMUX.lock().register_established(
-                    Ipv4Addr(tuple.local_ip),
-                    Port(tuple.local_port),
-                    Ipv4Addr(tuple.remote_ip),
-                    Port(tuple.remote_port),
-                    conn_id.0,
-                );
-
-                // Wire completed 3WHS into the listener's accept queue.
-                // Read the PCB metadata to build the AcceptedConn — this
-                // is the ACK leg, not the SYN leg, so actions.accepted is
-                // not populated.
-                let listener_sock_idx = tcp_listener::TCP_DEMUX
-                    .lock()
-                    .lookup_listener(Ipv4Addr(tuple.local_ip), Port(tuple.local_port));
+            if let Some(_tuple) = tcp::with_pcb(conn_id, |pcb| pcb.tuple) {
+                let listener_sock_idx =
+                    tcp::with_pcb(conn_id, |pcb| pcb.socket_id.map(|s| s.0)).flatten();
                 if let Some(listener_idx) = listener_sock_idx {
                     let accepted_meta = tcp::with_pcb(conn_id, |pcb| {
                         let tcp::PcbState::Data(d) = &pcb.state else {
@@ -1409,12 +1398,8 @@ pub fn socket_listen(sock_idx: u32, backlog: u32) -> i32 {
             }
             sock.state = SocketState::Listening;
 
-            // Register listener in TCP demux table.
-            let _ = tcp_listener::TCP_DEMUX
-                .lock()
-                .register_listener(local.ip, local.port, sock_idx);
-
             // Set bidirectional link on the connection.
+            // (Listener is already registered in TCP_LISTENERS by tcp::listen.)
             tcp::set_socket_idx(tcp_idx, Some(tcp::SocketId(sock_idx)));
 
             0
@@ -2126,7 +2111,7 @@ pub fn socket_recv(sock_idx: u32, buf: *mut u8, len: usize) -> i64 {
 }
 
 pub fn socket_close(sock_idx: u32) -> i32 {
-    let (tcp_idx, udp_unbind, icmp_unbind, recv_hint, send_hint, accept_hint, was_listener) = {
+    let (tcp_idx, udp_unbind, icmp_unbind, recv_hint, send_hint, accept_hint, _was_listener) = {
         let mut table = NEW_SOCKET_TABLE.lock();
         let Some(sock) = table.get_mut(sock_idx as usize) else {
             return errno_i32(ERRNO_ENOTSOCK);
@@ -2173,15 +2158,9 @@ pub fn socket_close(sock_idx: u32) -> i32 {
         )
     };
 
-    // Unregister from TCP demux table.
-    if was_listener {
-        tcp_listener::TCP_DEMUX.lock().unregister_listener(sock_idx);
-    }
+    // Release the TCP connection (if any).  The sharded table handles
+    // cleanup internally via release(); no separate demux unregister needed.
     if let Some(tcp_idx) = tcp_idx {
-        tcp_listener::TCP_DEMUX
-            .lock()
-            .unregister_established(tcp_idx.0);
-        // Clear the bidirectional link.
         tcp::set_socket_idx(tcp_idx, None);
     }
 

net/src/tcp/actions.rs

@@ -148,8 +148,8 @@ bitflags! {
         /// can return 0 from `recv()` once buffered data is drained.
         const PEER_CLOSED     = 1 << 4;
         /// The connection just completed its 3-way handshake.  Signals
-        /// the glue layer to register the child in `tcp::listener::TCP_DEMUX`
-        /// for fast 4-tuple lookup on subsequent segments.
+        /// the glue layer to allocate a buffer and wire the child into
+        /// the listener's accept queue.
         const NEW_ESTABLISHED = 1 << 5;
     }
 }