nexoniarz/SchOS
nexoniarz/SchOS
Watch
1
0
Fork
You've already forked SchOS
 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity Actions

net: a network *class*, so the stack stops knowing what an e1000 is

Browse source 
The TCP/IP stack reached straight into the first driver anyone wrote.
net.c called e1000_present(), the lwIP glue was named netif_e1000.c and
called e1000_transmit(), and include/defs.h declared the driver's
internals to the whole kernel. The second NIC driver would therefore
have arrived with a near-identical copy of the glue file and a patch to
the protocol stack, which is the arrangement include/device.h was
written to prevent -- the e1000 even said so, with `.ops = 0, // no
class vtable yet; there is no net class`.

There is now. A driver publishes a struct netdev_ops -- transmit,
receive, mac, link_up -- and is finished: it never mentions lwIP, and
nothing above it learns its name. The display class was already this
shape; this is the same shape for networking, and the two now read the
same way in kernel/dev/device.c.

What that made possible immediately:

  - One netif per bound device instead of one per driver. lwIP's glue is
    netif_eth.c, it takes a struct device, and it holds up to NETIF_MAX
    interfaces. net.c attaches every network device it finds and starts
    DHCP on each, because which interface the network answers on is not
    ours to decide.
  - /proc/netif lists all of them, one block of fields each, with the
    interface name and the driver that claimed it.
  - The ARP self-test moved from the e1000 to the class. Nothing in it
    was chip-specific, and it is the first thing anyone will want to run
    against the next driver. Still `echo n > /proc/sysrq`.
  - Private headers live with their driver: e1000.h was in include/,
    where exactly one file could use it. The driver build now adds the
    driver's own directory to the include path.

The e1000 also drives more than one card. Its probe() refused the second
outright, because there was a single static instance -- so a machine
with two of them drove one and silently ignored the other. Instances are
an array now, and the instance is hung on dev->priv by a new optional
`attached` hook that the bus calls once the device exists. probe() runs
before device_add(), so there was previously nowhere to put it; that is
the whole reason the hook exists rather than a line inside probe.

QEMU gets an explicit NIC on every target (QEMU_NET). The default device
happens to be an e1000 on this machine type today, which is exactly the
sort of thing that stays true until a QEMU release changes it and the
network stops being exercised without anyone noticing.

Verified:
  - bootcheck -Net passes, 48 [ok], no failures -- including the moved
    self-test and two new checks that /proc/netif names both the
    interface and the driver behind it, which together say the stack
    went through the class rather than through a driver it was compiled
    to know.
  - Two NICs attached by hand (-device e1000 twice, second with its own
    MAC): eth0 and eth1 both attach, each reports its own MAC in
    /proc/netif, and each gets its own DHCP lease. Before this commit
    the same machine produced one interface.
  - make schfs-check still passes in full.

One trap worth recording: moving a header broke the build for anyone
with stale .d files -- make stopped with "No rule to make target
'include/e1000.h'". CFLAGS gains -MP, which emits a phony target per
header so a moved or deleted one can never wedge the build again.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
Nexoniarz 2026-08-15 16:42:34 +02:00
commit 20cc673a41
16 changed files with 729 additions and 367 deletions
Download patch file Download diff file Expand all files Collapse all files

159
kernel/dev/device.c
View file

@ -15,6 +15,7 @@
#include "param.h"
#include "device.h"
#include "display.h"
#include "netdev.h"
#include "theme.h"
#include "text.h"
@ -306,3 +307,161 @@ text_selftest(void)
display_present(0, 0, m.width, m.height);
cprintf("text: drew a specimen, \"%s\" measures %d px\n", msg, w);
}
// ---------------------------------------------------------------------------
// The network class. See include/netdev.h.
//
// Plural where the display class is singular: a machine with two NICs is
// ordinary, and "the network" is not a thing a stack can ask for the way a
// compositor asks for "the display". So this walks, and the caller decides
// what to do with each interface it finds.
struct device *
netdev_at(int i)
{
int seen = 0;
for (int k = 0; k < device_count(); k++) {
struct device *d = device_at(k);
if (!d || d->class != DEVCLASS_NET || !d->driver || !d->ops)
continue;
if (seen++ == i)
return d;
}
return 0;
}
int
netdev_count(void)
{
int n = 0;
while (netdev_at(n))
n++;
return n;
}
int
netdev_transmit(struct device *d, const void *frame, int len)
{
if (!d || !d->ops || !((struct netdev_ops *)d->ops)->transmit)
return -1;
return ((struct netdev_ops *)d->ops)->transmit(d, frame, len);
}
int
netdev_receive(struct device *d, void *out, int cap)
{
if (!d || !d->ops || !((struct netdev_ops *)d->ops)->receive)
return 0;
return ((struct netdev_ops *)d->ops)->receive(d, out, cap);
}
const unsigned char *
netdev_mac(struct device *d)
{
if (!d || !d->ops || !((struct netdev_ops *)d->ops)->mac)
return 0;
return ((struct netdev_ops *)d->ops)->mac(d);
}
int
netdev_link_up(struct device *d)
{
// A driver that cannot tell is treated as up. Reporting "down" for a link
// whose state is simply unknown would stop the stack on hardware that works.
if (!d || !d->ops || !((struct netdev_ops *)d->ops)->link_up)
return 1;
return ((struct netdev_ops *)d->ops)->link_up(d);
}
static void
put_be16(uint8 *p, uint16 v)
{
p[0] = (uint8)(v >> 8);
p[1] = (uint8)v;
}
// The ARP probe. Written for the e1000 when it was the only driver and there
// was no stack to test it with; it belongs here because it is the first thing
// anyone will want to run against the *next* driver, and none of it is
// specific to a chip.
//
// Under QEMU's user-mode networking the guest is 10.0.2.15 and the gateway is
// 10.0.2.2. SLIRP is silent until spoken to, which is why this has to transmit
// before it can expect to receive anything.
void
netdev_selftest(void)
{
struct device *d = netdev_at(0);
uint8 frame[42];
uint8 reply[2048];
if (!d) {
cprintf("netdev: no interface\n");
return;
}
const unsigned char *mac = netdev_mac(d);
if (!mac) {
cprintf("netdev: %s has no station address\n", d->name);
return;
}
static const uint8 me[4] = { 10, 0, 2, 15 }; // QEMU SLIRP guest address
static const uint8 them[4] = { 10, 0, 2, 2 }; // and its gateway
memset(frame, 0, sizeof(frame));
for (int i = 0; i < 6; i++)
frame[i] = 0xFF; // broadcast
for (int i = 0; i < 6; i++)
frame[6 + i] = mac[i];
put_be16(&frame[12], 0x0806); // ARP
put_be16(&frame[14], 1); // Ethernet
put_be16(&frame[16], 0x0800); // IPv4
frame[18] = 6; // hardware address length
frame[19] = 4; // protocol address length
put_be16(&frame[20], 1); // request
for (int i = 0; i < 6; i++)
frame[22 + i] = mac[i]; // sender hardware address
for (int i = 0; i < 4; i++)
frame[28 + i] = me[i]; // sender protocol address
// target hardware address stays zero -- that is what is being asked
for (int i = 0; i < 4; i++)
frame[38 + i] = them[i];
cprintf("netdev: %s asking who has %d.%d.%d.%d\n",
d->name, them[0], them[1], them[2], them[3]);
if (netdev_transmit(d, frame, sizeof(frame)) != 0) {
cprintf("netdev: %s transmit ring full\n", d->name);
return;
}
// Bounded poll. This runs from a sysrq write and there is nothing to sleep
// on that would be woken by a raw frame, so spinning briefly is honest.
//
// It will also swallow whatever else is on the wire, including the stack's
// own traffic if it is running -- which is why a non-ARP frame is reported
// rather than treated as a failure.
for (int spin = 0; spin < 20000000; spin++) {
int n = netdev_receive(d, reply, sizeof(reply));
if (n <= 0)
continue;
cprintf("netdev: %d bytes from %x:%x:%x:%x:%x:%x type %x\n",
n, reply[6], reply[7], reply[8], reply[9], reply[10], reply[11],
((uint32)reply[12] << 8) | reply[13]);
if (n >= 42 && reply[12] == 0x08 && reply[13] == 0x06 &&
reply[20] == 0 && reply[21] == 2) {
cprintf("netdev: ARP reply -- %d.%d.%d.%d is at %x:%x:%x:%x:%x:%x\n",
reply[28], reply[29], reply[30], reply[31],
reply[22], reply[23], reply[24], reply[25],
reply[26], reply[27]);
cprintf("netdev: %s self-test passed\n", d->name);
return;
}
}
cprintf("netdev: %s no reply\n", d->name);
}

5
kernel/dev/pci.c
View file

@ -386,6 +386,11 @@ pci_bind(const struct pci_driver *drv)
dev->product = d->device;
dev->b = d->bus; dev->s = d->slot; dev->f = d->func;
pci_describe(d, dev->desc, sizeof(dev->desc));
// Now, and only now, can a multi-instance driver say which of its
// own this device is: the object it would hang that on did not
// exist until the line above.
if (drv->attached)
drv->attached(d, dev);
}
}
break;

3
kernel/dev/procfs.c
View file

@ -21,6 +21,7 @@
#include "x86.h"
#include "device.h"
#include "display.h"
#include "netdev.h"
#include "param.h"
#include "memlayout.h"
#include "mmu.h"
@ -444,7 +445,7 @@ proc_sysrq_cmd(char cmd)
display_selftest();
break;
case 'n':
e1000_selftest();
netdev_selftest();
break;
case 't':
text_selftest();

227
kernel/drivers/net/e1000/e1000.c
View file

@ -1,10 +1,11 @@
// Intel 8254x gigabit Ethernet, written from Intel's public datasheet (317453).
//
// The first network device. There is no IP stack yet, so what this provides is
// the layer under one: a MAC address, a transmit path, and a receive ring that
// fills with frames. That is deliberately the right order -- an IP stack
// written before a driver has nothing to be tested against, and every bug in it
// looks like a driver bug.
// What it provides the rest of the system is a struct netdev_ops and nothing
// else: a station address, a transmit path and a receive ring. It does not
// know that lwIP exists, and lwIP does not know that it does -- see
// include/netdev.h for why that boundary is where it is. Adding a second NIC
// means writing another driver that fills in the same four function pointers,
// and touching no file outside its own directory.
//
// Bring-up follows the manual's initialisation sequence (section 14.3-14.5):
// reset, read the MAC out of EEPROM, clear the multicast table, set up the
@ -24,6 +25,7 @@
#include "memlayout.h"
#include "pci.h"
#include "device.h"
#include "netdev.h"
#include "dma.h"
#include "irq.h"
#include "e1000.h"
@ -42,10 +44,29 @@ struct e1000 {
int ready;
uint64 rx_packets, tx_packets, rx_dropped;
// Which PCI device this instance drives. Kept so that attached() can match
// the device the bus just published against the instance probe() set up --
// the two calls are separate, and nothing else connects them.
struct pci_dev *pdev;
struct spinlock lock;
};
static struct e1000 nic;
// More than one, because a machine really can have two of the same card and
// this driver used to refuse the second outright. Four is the same limit the
// stack puts on interfaces; each unused entry costs a few dozen bytes, and the
// rings behind a used one come from the DMA arena at probe time.
#define E1000_MAX_NICS 4
static struct e1000 nics[E1000_MAX_NICS];
// The instance behind a device, or 0. Every op goes through this rather than a
// file-static pointer, which is what makes two cards possible at all.
static struct e1000 *
nic_of(struct device *dev)
{
return dev ? (struct e1000 *)dev->priv : 0;
}
static inline uint32 rd(struct e1000 *e, int off) { return *(volatile uint32 *)(e->regs + off); }
static inline void wr(struct e1000 *e, int off, uint32 v) { *(volatile uint32 *)(e->regs + off) = v; }
@ -156,12 +177,13 @@ rings_setup(struct e1000 *e)
// Copies into the descriptor's own buffer rather than mapping the caller's.
// A zero-copy path wants the caller to guarantee the memory stays put and is
// physically contiguous, which nothing above this can promise yet.
int
e1000_transmit(const void *frame, int len)
//
static int
e1000_transmit(struct device *dev, const void *frame, int len)
{
struct e1000 *e = &nic;
struct e1000 *e = nic_of(dev);
if (!e->ready || len <= 0 || len > E1000_BUFSZ)
if (!e || !e->ready || len <= 0 || len > E1000_BUFSZ)
return -1;
acquire(&e->lock);
@ -190,12 +212,12 @@ e1000_transmit(const void *frame, int len)
// wakes a nonexistent protocol stack is harder to reason about than one that is
// asked. The interrupt handler below exists to keep the cause register clear
// and to count; when an IP stack arrives, this is where the hand-off changes.
int
e1000_receive(void *out, int cap)
static int
e1000_receive(struct device *dev, void *out, int cap)
{
struct e1000 *e = &nic;
struct e1000 *e = nic_of(dev);
if (!e->ready)
if (!e || !e->ready)
return 0;
acquire(&e->lock);
@ -231,37 +253,24 @@ e1000_intr(void *arg)
(void)cause;
}
int
e1000_info(char *buf, int cap)
{
struct e1000 *e = &nic;
int n = 0;
if (!e->ready)
return 0;
static const char hex[] = "0123456789abcdef";
n += 0;
for (int i = 0; i < 6 && n + 3 < cap; i++) {
buf[n++] = hex[e->mac[i] >> 4];
buf[n++] = hex[e->mac[i] & 0xF];
if (i < 5)
buf[n++] = ':';
}
if (n < cap) buf[n++] = '\n';
return n;
}
static int
e1000_probe(struct pci_dev *d)
{
struct e1000 *e = &nic;
struct e1000 *e = 0;
if (e->ready)
// A free slot, rather than "the one instance, if it is still free". The old
// spelling is why a machine with two of these cards drove only the first.
for (int i = 0; i < E1000_MAX_NICS; i++)
if (!nics[i].ready) {
e = &nics[i];
break;
}
if (!e)
return -1;
if (!d->bar[0].base)
return -1;
e->pdev = d;
initlock(&e->lock, "e1000");
pci_enable(d, 0x0006); // memory space + bus master
// ioremap rather than P2V: firmware may place a 64-bit BAR above the 4 GB the
@ -353,117 +362,45 @@ static const struct pci_match e1000_match[] = {
};
#undef M
static const unsigned char *
e1000_mac_op(struct device *dev)
{
struct e1000 *e = nic_of(dev);
return (e && e->ready) ? e->mac : 0;
}
static int
e1000_link_up(struct device *dev)
{
struct e1000 *e = nic_of(dev);
return e && e->ready && (rd(e, E1000_STATUS) & E1000_STATUS_LU) != 0;
}
// Hang the instance on the device the bus has just published. See the comment
// on `attached` in include/pci.h for why this cannot happen inside probe().
static void
e1000_attached(struct pci_dev *d, struct device *dev)
{
for (int i = 0; i < E1000_MAX_NICS; i++)
if (nics[i].ready && nics[i].pdev == d) {
dev->priv = &nics[i];
return;
}
}
// The whole of what the network stack sees of this driver.
static const struct netdev_ops e1000_netdev_ops = {
.transmit = e1000_transmit,
.receive = e1000_receive,
.mac = e1000_mac_op,
.link_up = e1000_link_up,
};
const struct pci_driver e1000_driver = {
.name = "e1000",
.devname = "eth",
.match = e1000_match,
.ops = 0, // no class vtable yet; there is no net class
.ops = &e1000_netdev_ops,
.probe = e1000_probe,
.attached = e1000_attached,
};
// --- self-test: does this thing actually move packets? ---------------------
//
// The transmit and receive paths were written together and neither had ever
// carried a frame. That is exactly the state in which a driver looks finished
// and is not: the rings are set up, the registers read back plausibly, and the
// first thing to discover otherwise would have been a protocol stack failing
// for reasons indistinguishable from its own bugs.
//
// So: build an ARP request by hand, send it, and wait for the reply. It proves
// the whole path at once -- descriptor format, DD handshake, tail bookkeeping,
// DMA addresses, the receive ring handback, and the MAC filter -- because an
// ARP reply is addressed to *us* and will not arrive if the filter is wrong.
//
// Under QEMU's user-mode networking the guest is 10.0.2.15 and the gateway is
// 10.0.2.2. SLIRP is silent until spoken to, which is why this has to transmit
// before it can expect to receive.
//
// `echo n > /proc/sysrq`.
static void
put_be16(uint8 *p, uint16 v)
{
p[0] = (uint8)(v >> 8);
p[1] = (uint8)v;
}
// Is there a NIC at all? Asked by netinit() before it starts a thread whose
// entire job would be to poll a device that is not there.
int
e1000_present(void)
{
return nic.ready;
}
const unsigned char *
e1000_mac(void)
{
return nic.mac;
}
void
e1000_selftest(void)
{
struct e1000 *e = &nic;
uint8 frame[42];
uint8 reply[E1000_BUFSZ];
if (!e->ready) {
cprintf("e1000: no device\n");
return;
}
static const uint8 me[4] = { 10, 0, 2, 15 }; // QEMU SLIRP guest address
static const uint8 them[4] = { 10, 0, 2, 2 }; // and its gateway
memset(frame, 0, sizeof(frame));
for (int i = 0; i < 6; i++)
frame[i] = 0xFF; // broadcast
for (int i = 0; i < 6; i++)
frame[6 + i] = e->mac[i];
put_be16(&frame[12], 0x0806); // ARP
put_be16(&frame[14], 1); // Ethernet
put_be16(&frame[16], 0x0800); // IPv4
frame[18] = 6; // hardware address length
frame[19] = 4; // protocol address length
put_be16(&frame[20], 1); // request
for (int i = 0; i < 6; i++)
frame[22 + i] = e->mac[i]; // sender hardware address
for (int i = 0; i < 4; i++)
frame[28 + i] = me[i]; // sender protocol address
// target hardware address stays zero -- that is what is being asked
for (int i = 0; i < 4; i++)
frame[38 + i] = them[i];
cprintf("e1000: asking who has %d.%d.%d.%d\n", them[0], them[1], them[2], them[3]);
if (e1000_transmit(frame, sizeof(frame)) != 0) {
cprintf("e1000: transmit ring full\n");
return;
}
// Bounded poll. There is no interrupt path to sleep on yet and this runs from
// a sysrq write, so spinning briefly is the honest way to wait.
for (int spin = 0; spin < 20000000; spin++) {
int n = e1000_receive(reply, sizeof(reply));
if (n <= 0)
continue;
cprintf("e1000: %d bytes from %x:%x:%x:%x:%x:%x type %x\n",
n, reply[6], reply[7], reply[8], reply[9], reply[10], reply[11],
((uint32)reply[12] << 8) | reply[13]);
if (n >= 42 && reply[12] == 0x08 && reply[13] == 0x06 &&
reply[20] == 0 && reply[21] == 2) {
cprintf("e1000: ARP reply -- %d.%d.%d.%d is at %x:%x:%x:%x:%x:%x\n",
reply[28], reply[29], reply[30], reply[31],
reply[22], reply[23], reply[24], reply[25],
reply[26], reply[27]);
cprintf("e1000: self-test passed, %d tx %d rx\n",
(int)e->tx_packets, (int)e->rx_packets);
return;
}
}
cprintf("e1000: no reply -- %d tx, %d rx\n",
(int)e->tx_packets, (int)e->rx_packets);
}

165
kernel/drivers/net/e1000/e1000.h Normal file
View file

@ -0,0 +1,165 @@
#pragma once
// Intel 8254x gigabit Ethernet — the register and descriptor layout.
//
// From Intel's public "PCI/PCI-X Family of Gigabit Ethernet Controllers
// Software Developer's Manual" (317453). A public document with no licence on
// what you write from it, which is why this is written rather than ported: see
// docs/licensing.md and docs/roadmap.md §1.
//
// QEMU's `-device e1000` is an 82540EM and implements enough of the manual to
// be worth targeting; it is also what the default `-net nic` gives you.
#define E1000_VENDOR 0x8086
// The 8254x family: PCI/PCI-X gigabit controllers that share the register map,
// descriptor format and EEPROM interface this driver implements.
//
// The device IDs are transcribed from FreeBSD's `sys/dev/e1000/e1000_hw.h`
// (Copyright (c) 2001-2020, Intel Corporation, BSD 3-clause -- verified to
// carry no advertising clause; see docs/licensing.md and NOTICE). They are
// data, not logic: the driver below is still written from Intel's manual
// 317453, and nothing of FreeBSD's implementation is used.
//
// This matters more than it looks. The driver bound exactly one device -- the
// 82540EM QEMU emulates -- which is fine for a virtual machine and useless on
// the sort of second-hand hardware a system like this actually gets run on.
// These are the cards in every desktop and server of that generation.
//
// Deliberately *not* included: the PCIe 8257x parts (82571-82574) and anything
// newer. They present a similar register map but differ in NVM access and
// initialisation, and claiming a device this driver has not been shown to
// initialise is worse than not claiming it -- the card binds, reports a MAC of
// nonsense, and nothing works for reasons that look nothing like the cause.
#define E1000_DEV_82540EM 0x100E
#define E1000_DEV_82540EM_LOM 0x1015
#define E1000_DEV_82540EP_LOM 0x1016
#define E1000_DEV_82540EP 0x1017
#define E1000_DEV_82540EP_LP 0x101E
#define E1000_DEV_82541EI 0x1013
#define E1000_DEV_82541EI_MOBILE 0x1018
#define E1000_DEV_82541ER_LOM 0x1014
#define E1000_DEV_82541ER 0x1078
#define E1000_DEV_82541GI 0x1076
#define E1000_DEV_82541GI_MOBILE 0x1077
#define E1000_DEV_82541GI_LF 0x107C
#define E1000_DEV_82544EI_FIBER 0x1009
#define E1000_DEV_82544GC_COPPER 0x100C
#define E1000_DEV_82544GC_LOM 0x100D
#define E1000_DEV_82545EM_COPPER 0x100F
#define E1000_DEV_82545EM_FIBER 0x1011
#define E1000_DEV_82545GM_COPPER 0x1026
#define E1000_DEV_82545GM_FIBER 0x1027
#define E1000_DEV_82545GM_SERDES 0x1028
#define E1000_DEV_82546EB_COPPER 0x1010
#define E1000_DEV_82546EB_FIBER 0x1012
#define E1000_DEV_82546EB_QUAD 0x101D
#define E1000_DEV_82546GB_COPPER 0x1079
#define E1000_DEV_82546GB_FIBER 0x107A
#define E1000_DEV_82546GB_SERDES 0x107B
#define E1000_DEV_82547EI 0x1019
// --- registers, byte offsets into BAR 0 ------------------------------------
#define E1000_CTRL 0x0000 // device control
#define E1000_STATUS 0x0008 // device status
#define E1000_EERD 0x0014 // EEPROM read
#define E1000_ICR 0x00C0 // interrupt cause read
#define E1000_IMS 0x00D0 // interrupt mask set
#define E1000_IMC 0x00D8 // interrupt mask clear
#define E1000_RCTL 0x0100 // receive control
#define E1000_TCTL 0x0400 // transmit control
#define E1000_TIPG 0x0410 // transmit inter-packet gap
#define E1000_RDBAL 0x2800 // receive descriptor base, low
#define E1000_RDBAH 0x2804 // receive descriptor base, high
#define E1000_RDLEN 0x2808 // receive descriptor length, in bytes
#define E1000_RDH 0x2810 // receive descriptor head
#define E1000_RDT 0x2818 // receive descriptor tail
#define E1000_TDBAL 0x3800
#define E1000_TDBAH 0x3804
#define E1000_TDLEN 0x3808
#define E1000_TDH 0x3810
#define E1000_TDT 0x3818
#define E1000_MTA 0x5200 // multicast table array, 128 entries
#define E1000_RAL 0x5400 // receive address low (the MAC filter)
#define E1000_RAH 0x5404 // receive address high
// CTRL
#define E1000_CTRL_RST (1 << 26)
#define E1000_CTRL_ASDE (1 << 5) // auto-speed detection
#define E1000_CTRL_SLU (1 << 6) // set link up
// STATUS
#define E1000_STATUS_LU (1 << 1) // link up
// EERD
#define E1000_EERD_START (1 << 0)
#define E1000_EERD_DONE (1 << 4)
#define E1000_EERD_ADDR_SHIFT 8
#define E1000_EERD_DATA_SHIFT 16
// RCTL
#define E1000_RCTL_EN (1 << 1) // receiver enable
#define E1000_RCTL_SBP (1 << 2) // store bad packets
#define E1000_RCTL_UPE (1 << 3) // unicast promiscuous
#define E1000_RCTL_MPE (1 << 4) // multicast promiscuous
#define E1000_RCTL_LBM_NONE (0 << 6)
#define E1000_RCTL_BAM (1 << 15) // accept broadcast
#define E1000_RCTL_SZ_2048 (0 << 16) // buffer size, with BSEX clear
#define E1000_RCTL_SECRC (1 << 26) // strip the Ethernet CRC
// TCTL
#define E1000_TCTL_EN (1 << 1)
#define E1000_TCTL_PSP (1 << 3) // pad short packets
#define E1000_TCTL_CT_SHIFT 4 // collision threshold
#define E1000_TCTL_COLD_SHIFT 12 // collision distance
// Transmit descriptor command bits
#define E1000_TXD_CMD_EOP (1 << 0) // end of packet
#define E1000_TXD_CMD_IFCS (1 << 1) // insert FCS/CRC
#define E1000_TXD_CMD_RS (1 << 3) // report status
#define E1000_TXD_STAT_DD (1 << 0) // descriptor done
// Receive descriptor status bits
#define E1000_RXD_STAT_DD (1 << 0)
#define E1000_RXD_STAT_EOP (1 << 1)
// Interrupt causes worth unmasking.
#define E1000_ICR_TXDW (1 << 0) // transmit descriptor written back
#define E1000_ICR_LSC (1 << 2) // link status change
#define E1000_ICR_RXDMT0 (1 << 4) // receive descriptor minimum threshold
#define E1000_ICR_RXT0 (1 << 7) // receiver timer
// --- descriptors -----------------------------------------------------------
//
// Both are 16 bytes and the hardware reads them by physical address, so the
// rings must be physically contiguous and 16-byte aligned.
struct e1000_tx_desc {
uint64 addr;
uint16 length;
uint8 cso; // checksum offset
uint8 cmd;
uint8 status;
uint8 css; // checksum start
uint16 special;
} __attribute__((packed));
struct e1000_rx_desc {
uint64 addr;
uint16 length;
uint16 checksum;
uint8 status;
uint8 errors;
uint16 special;
} __attribute__((packed));
// Ring sizes. The manual requires the descriptor ring length to be a multiple
// of 128 bytes, i.e. a multiple of 8 descriptors.
#define E1000_NTX 16
#define E1000_NRX 16
#define E1000_BUFSZ 2048

152
kernel/net/lwip/netif_e1000.c
View file

@ -1,152 +0,0 @@
// SPDX-License-Identifier: Apache-2.0
//
// The lwIP network interface backed by the e1000 driver.
//
// Two directions and almost nothing else: a linkoutput that flattens a pbuf
// chain into a frame and hands it to the driver, and a poll that takes frames
// off the driver and hands them up. Everything about IP, ARP and TCP lives in
// lwIP; everything about descriptors and registers lives in the driver; this
// file is the seam.
#include "types.h"
#include "defs.h"
#include "param.h"
#include "lwip/opt.h"
#include "lwip/netif.h"
#include "lwip/pbuf.h"
#include "lwip/etharp.h"
#include "lwip/ethip6.h"
#include "netif/ethernet.h"
#define ETH_MTU 1500
#define ETH_FRAMESZ 1518 // 1500 payload + 14 header + 4 FCS allowance
static struct netif e1000_netif;
// Frames in and out, for /proc/netif. Counted here rather than in the driver
// because this is the seam lwIP actually uses: a frame the driver received and
// this file dropped never reached the stack, and a counter kept one layer down
// would say otherwise. Only the network thread touches them, so no lock.
static uint64 rx_frames, tx_frames;
void
net_e1000_counts(uint64 *rx, uint64 *tx)
{
*rx = rx_frames;
*tx = tx_frames;
}
// One staging buffer, not one per call: a frame is 1518 bytes and the kernel
// stack is 4096 in total, so a local of this size on a path that is several
// frames deep is exactly the overflow the kstack canary exists to catch.
// Safe as a single static because every caller holds the lwIP lock.
static char txframe[ETH_FRAMESZ];
static char rxframe[ETH_FRAMESZ];
// Send one packet. lwIP hands over a pbuf chain; the driver wants one flat
// buffer, so this walks the chain into txframe.
static err_t
e1000_linkoutput(struct netif *netif, struct pbuf *p)
{
(void)netif;
if (p->tot_len > sizeof(txframe))
return ERR_IF;
u16_t off = 0;
for (struct pbuf *q = p; q != NULL; q = q->next) {
if (off + q->len > sizeof(txframe))
return ERR_IF;
memmove(txframe + off, q->payload, q->len);
off += q->len;
}
// A full transmit ring is congestion, not failure. Reporting ERR_IF would
// make lwIP drop the segment and wait for a retransmission timer; ERR_WOULDBLOCK
// lets it try again, which for TCP is the difference between a stall of
// milliseconds and one of seconds.
if (e1000_transmit(txframe, off) != 0)
return ERR_WOULDBLOCK;
tx_frames++;
return ERR_OK;
}
// Bring the interface up. Called once, by the network thread.
static err_t
e1000_netif_init(struct netif *netif)
{
const unsigned char *mac = e1000_mac();
netif->name[0] = 'e';
netif->name[1] = 'n';
netif->output = etharp_output; // IP -> ARP -> linkoutput
netif->linkoutput = e1000_linkoutput;
netif->mtu = ETH_MTU;
netif->hwaddr_len = 6;
for (int i = 0; i < 6; i++)
netif->hwaddr[i] = mac[i];
netif->flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP | NETIF_FLAG_LINK_UP;
return ERR_OK;
}
struct netif *
net_e1000_netif(void)
{
return &e1000_netif;
}
// Attach the interface with no address yet -- DHCP fills it in.
int
net_e1000_attach(void)
{
ip4_addr_t any;
IP4_ADDR(&any, 0, 0, 0, 0);
if (netif_add(&e1000_netif, &any, &any, &any, NULL,
e1000_netif_init, netif_input) == NULL)
return -1;
netif_set_default(&e1000_netif);
netif_set_up(&e1000_netif);
netif_set_link_up(&e1000_netif);
return 0;
}
// Take whatever the driver has and push it into lwIP. Returns how many frames
// moved, so the caller can tell a busy poll from an idle one.
//
// Bounded rather than draining: a receive loop with no limit starves everything
// else on a busy network, and the caller comes straight back anyway.
int
net_e1000_poll(void)
{
int moved = 0;
for (int i = 0; i < 32; i++) {
int len = e1000_receive(rxframe, sizeof(rxframe));
if (len <= 0)
break;
// PBUF_POOL, so this comes from lwIP's own pool rather than a heap it
// does not have. A null return means the pool is exhausted, which is a
// dropped packet -- entirely normal under load, and what the protocol
// above is designed to survive.
struct pbuf *p = pbuf_alloc(PBUF_RAW, (u16_t)len, PBUF_POOL);
if (p == NULL)
break;
pbuf_take(p, rxframe, (u16_t)len);
// netif->input is netif_input, set at netif_add: it dispatches on the
// Ethernet type. Ownership of the pbuf passes with the call, including
// when it fails, so there is nothing to free here.
if (e1000_netif.input(p, &e1000_netif) != ERR_OK)
pbuf_free(p);
rx_frames++;
moved++;
}
return moved;
}

215
kernel/net/lwip/netif_eth.c Normal file
View file

@ -0,0 +1,215 @@
// SPDX-License-Identifier: Apache-2.0
//
// lwIP network interfaces over the netdev class.
//
// The seam, and it is deliberately driver-agnostic: everything about IP, ARP
// and TCP lives in lwIP, everything about descriptors and registers lives in a
// driver, and this file knows only that a network device can transmit a frame,
// receive a frame and state its MAC address. It was `netif_e1000.c` and called
// `e1000_transmit` directly, which meant the second NIC driver would have
// arrived with a second near-identical copy of this file. See include/netdev.h.
//
// One netif per bound interface, up to NETIF_MAX. Two NICs is an ordinary
// machine -- a laptop with Ethernet and the virtual one QEMU adds is already
// two -- and the limit exists only because a fixed array is simpler than
// allocation for something enumerated once at boot.
#include "types.h"
#include "defs.h"
#include "param.h"
#include "device.h"
#include "netdev.h"
#include "lwip/opt.h"
#include "lwip/netif.h"
#include "lwip/pbuf.h"
#include "lwip/etharp.h"
#include "lwip/ethip6.h"
#include "netif/ethernet.h"
#define ETH_MTU 1500
#define ETH_FRAMESZ 1518 // 1500 payload + 14 header + 4 FCS allowance
struct eth_if {
struct netif netif;
struct device *dev;
// Frames in and out, for /proc/netif. Counted at this seam rather than in
// the driver on purpose: a frame the driver received and this file dropped
// never reached the stack, and a counter one layer down would say it did.
uint64 rx_frames, tx_frames;
int used;
};
static struct eth_if ifs[NETIF_MAX];
static int nifs;
// One staging buffer each, not one per call: a frame is 1518 bytes and the
// kernel stack is 4096 in total, so a local of this size on a path that is
// several frames deep is exactly the overflow the kstack canary exists to
// catch. Safe as a single static because every caller holds the lwIP lock --
// which is also why one pair serves every interface.
static char txframe[ETH_FRAMESZ];
static char rxframe[ETH_FRAMESZ];
// Send one packet. lwIP hands over a pbuf chain; a driver wants one flat
// buffer, so this walks the chain into txframe.
static err_t
eth_linkoutput(struct netif *netif, struct pbuf *p)
{
struct eth_if *e = netif->state;
if (p->tot_len > sizeof(txframe))
return ERR_IF;
u16_t off = 0;
for (struct pbuf *q = p; q != NULL; q = q->next) {
if (off + q->len > sizeof(txframe))
return ERR_IF;
memmove(txframe + off, q->payload, q->len);
off += q->len;
}
// A full transmit ring is congestion, not failure. Reporting ERR_IF would
// make lwIP drop the segment and wait for a retransmission timer;
// ERR_WOULDBLOCK lets it try again, which for TCP is the difference between
// a stall of milliseconds and one of seconds.
if (netdev_transmit(e->dev, txframe, off) != 0)
return ERR_WOULDBLOCK;
e->tx_frames++;
return ERR_OK;
}
// Bring one interface up. Called by netif_add, once per device.
static err_t
eth_netif_init(struct netif *netif)
{
struct eth_if *e = netif->state;
const unsigned char *mac = netdev_mac(e->dev);
netif->name[0] = 'e';
netif->name[1] = 'n';
netif->output = etharp_output; // IP -> ARP -> linkoutput
netif->linkoutput = eth_linkoutput;
netif->mtu = ETH_MTU;
netif->hwaddr_len = 6;
for (int i = 0; i < 6; i++)
netif->hwaddr[i] = mac ? mac[i] : 0;
netif->flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP | NETIF_FLAG_LINK_UP;
return ERR_OK;
}
// Attach one network device. Returns its interface index, or -1.
//
// No address: DHCP fills that in, and an interface that came up with a
// hardcoded one would be wrong on every network but the one it was written on.
int
net_eth_attach(struct device *dev)
{
ip4_addr_t any;
if (nifs >= NETIF_MAX || dev == 0)
return -1;
struct eth_if *e = &ifs[nifs];
e->dev = dev;
e->used = 1;
IP4_ADDR(&any, 0, 0, 0, 0);
if (netif_add(&e->netif, &any, &any, &any, e,
eth_netif_init, netif_input) == NULL) {
e->used = 0;
return -1;
}
// The first one is the default route. With one interface that is the only
// possible answer; with two it is a policy decision that belongs to a
// routing table this kernel does not have yet, and picking the first is at
// least a rule rather than an accident of enumeration order.
if (nifs == 0)
netif_set_default(&e->netif);
netif_set_up(&e->netif);
if (netdev_link_up(dev))
netif_set_link_up(&e->netif);
else
netif_set_link_down(&e->netif);
return nifs++;
}
int
net_eth_count(void)
{
return nifs;
}
struct netif *
net_eth_netif(int i)
{
if (i < 0 || i >= nifs)
return 0;
return &ifs[i].netif;
}
struct device *
net_eth_device(int i)
{
if (i < 0 || i >= nifs)
return 0;
return ifs[i].dev;
}
void
net_eth_counts(int i, uint64 *rx, uint64 *tx)
{
if (i < 0 || i >= nifs) {
*rx = *tx = 0;
return;
}
*rx = ifs[i].rx_frames;
*tx = ifs[i].tx_frames;
}
// Take whatever the drivers have and push it into lwIP. Returns how many
// frames moved across all interfaces, so the caller can tell a busy poll from
// an idle one.
//
// Bounded per interface rather than draining: a receive loop with no limit
// starves everything else on a busy network, and the caller comes straight
// back anyway.
int
net_eth_poll(void)
{
int moved = 0;
for (int k = 0; k < nifs; k++) {
struct eth_if *e = &ifs[k];
for (int i = 0; i < 32; i++) {
int len = netdev_receive(e->dev, rxframe, sizeof(rxframe));
if (len <= 0)
break;
// PBUF_POOL, so this comes from lwIP's own pool rather than a heap
// it does not have. A null return means the pool is exhausted,
// which is a dropped packet -- entirely normal under load, and what
// the protocol above is designed to survive.
struct pbuf *p = pbuf_alloc(PBUF_RAW, (u16_t)len, PBUF_POOL);
if (p == NULL)
break;
pbuf_take(p, rxframe, (u16_t)len);
// netif->input is netif_input, set at netif_add: it dispatches on
// the Ethernet type. Ownership of the pbuf passes with the call,
// including when it fails, so there is nothing to free here.
if (e->netif.input(p, &e->netif) != ERR_OK)
pbuf_free(p);
e->rx_frames++;
moved++;
}
}
return moved;
}

149
kernel/net/net.c
View file

@ -4,11 +4,15 @@
//
// lwIP with NO_SYS=1 has no threads of its own, so something has to feed it
// received frames and run its timers. That something is a kernel thread rather
// than the e1000 interrupt handler, and the reason is the lock: a call into
// than a driver's interrupt handler, and the reason is the lock: a call into
// lwIP can reach the driver, the driver can sleep, and an interrupt handler
// cannot. So the interrupt keeps doing what it always did -- clear the cause
// register -- and this thread polls.
//
// Nothing here names a driver. Interfaces come from the netdev class
// (include/netdev.h): every bound network device is attached, and a machine
// with two NICs gets two interfaces without a line changing in this file.
//
// Polling costs a wakeup every few milliseconds when the link is idle. The
// alternative, waking this thread from the interrupt, is a worthwhile change
// later; it is deliberately not the first version, because a receive path that
@ -20,6 +24,8 @@
#include "spinlock.h"
#include "sleeplock.h"
#include "proc.h"
#include "device.h"
#include "netdev.h"
#include "lwip/opt.h"
#include "lwip/init.h"
@ -66,42 +72,63 @@ net_thread(void)
lwip_sys_lock();
lwip_init();
if (net_e1000_attach() != 0) {
// Every bound network device becomes an interface. DHCP is started on each
// of them: which one answers is the network's business, not ours, and an
// interface left unconfigured because it happened to be second would be a
// rule nobody could see.
int attached = 0;
for (int i = 0; i < netdev_count(); i++) {
struct device *d = netdev_at(i);
int idx = net_eth_attach(d);
if (idx < 0)
continue;
dhcp_start(net_eth_netif(idx));
attached++;
cprintf("net: %s attached as interface %d\n", d->name, idx);
}
if (attached == 0) {
lwip_sys_unlock();
cprintf("net: no e1000; the network thread has nothing to drive\n");
cprintf("net: no network device; the thread has nothing to drive\n");
// Not a panic and not an exit: a kernel thread must never return, and
// a machine with no NIC is an ordinary machine.
for (;;)
wait_tick();
}
struct netif *nif = net_e1000_netif();
dhcp_start(nif);
lwip_sys_unlock();
cprintf("net: lwIP %d.%d.%d up, requesting an address\n",
LWIP_VERSION_MAJOR, LWIP_VERSION_MINOR, LWIP_VERSION_REVISION);
cprintf("net: lwIP %d.%d.%d up on %d interface%s, requesting an address\n",
LWIP_VERSION_MAJOR, LWIP_VERSION_MINOR, LWIP_VERSION_REVISION,
attached, attached == 1 ? "" : "s");
int announced = 0;
// One bit per interface, so a second one binding later is announced too.
int announced[NETIF_MAX] = { 0 };
for (;;) {
int moved;
lwip_sys_lock();
moved = net_e1000_poll();
moved = net_eth_poll();
sys_check_timeouts();
// Report the address once, when it first arrives. Anyone who has spent
// Report each address once, when it first arrives. Anyone who has spent
// an evening wondering whether the guest has an address at all wants
// this on the console rather than in a file they have to know about.
if (!announced && !ip4_addr_isany_val(*netif_ip4_addr(nif))) {
for (int i = 0; i < attached; i++) {
struct netif *nif = net_eth_netif(i);
if (announced[i] || ip4_addr_isany_val(*netif_ip4_addr(nif)))
continue;
const ip4_addr_t *a = netif_ip4_addr(nif);
const ip4_addr_t *m = netif_ip4_netmask(nif);
const ip4_addr_t *gw = netif_ip4_gw(nif);
cprintf("net: %d.%d.%d.%d/%d.%d.%d.%d via %d.%d.%d.%d\n",
cprintf("net: %s %d.%d.%d.%d/%d.%d.%d.%d via %d.%d.%d.%d\n",
net_eth_device(i)->name,
ip4_addr1(a), ip4_addr2(a), ip4_addr3(a), ip4_addr4(a),
ip4_addr1(m), ip4_addr2(m), ip4_addr3(m), ip4_addr4(m),
ip4_addr1(gw), ip4_addr2(gw), ip4_addr3(gw), ip4_addr4(gw));
announced = 1;
announced[i] = 1;
net_bound = 1;
}
lwip_sys_unlock();
@ -183,65 +210,83 @@ put_field(char *out, const char *name)
return n;
}
// One block of fields per interface, separated by a blank line. A reader that
// can parse one can parse any number, which is the whole reason it is not a
// single flat list of values: with two NICs a flat list has no way to say which
// address belongs to which.
int
net_info(char *buf, int cap)
{
int len = 0;
if (cap < 512)
// Room for the largest block, so the loop below never needs a bounds check
// in the middle of writing one.
if (cap < 256 * (NETIF_MAX + 1))
return 0;
if (!net_started) {
if (!net_started || net_eth_count() == 0) {
len += put_field(buf + len, "state");
len += put_str(buf + len, e1000_present() ? "down\n" : "no interface\n");
len += put_str(buf + len, netdev_count() ? "down\n" : "no interface\n");
return len;
}
struct netif *nif = net_e1000_netif();
for (int i = 0; i < net_eth_count(); i++) {
struct netif *nif = net_eth_netif(i);
struct device *dev = net_eth_device(i);
lwip_sys_lock();
if (i)
buf[len++] = '\n';
len += put_field(buf + len, "interface");
buf[len++] = nif->name[0];
buf[len++] = nif->name[1];
len += put_u(buf + len, nif->num);
buf[len++] = '\n';
lwip_sys_lock();
len += put_field(buf + len, "mac");
len += put_mac(buf + len, nif->hwaddr);
buf[len++] = '\n';
len += put_field(buf + len, "interface");
len += put_str(buf + len, dev->name);
buf[len++] = '\n';
len += put_field(buf + len, "state");
len += put_str(buf + len, net_bound ? "up\n" : "no address\n");
len += put_field(buf + len, "driver");
len += put_str(buf + len, dev->driver ? dev->driver : "-");
buf[len++] = '\n';
len += put_field(buf + len, "address");
len += put_ip4(buf + len, netif_ip4_addr(nif));
buf[len++] = '\n';
len += put_field(buf + len, "mac");
len += put_mac(buf + len, nif->hwaddr);
buf[len++] = '\n';
len += put_field(buf + len, "netmask");
len += put_ip4(buf + len, netif_ip4_netmask(nif));
buf[len++] = '\n';
// Per interface, not per system: with two NICs one can be configured
// while the other is still asking.
len += put_field(buf + len, "state");
len += put_str(buf + len,
ip4_addr_isany_val(*netif_ip4_addr(nif)) ? "no address\n"
: "up\n");
len += put_field(buf + len, "gateway");
len += put_ip4(buf + len, netif_ip4_gw(nif));
buf[len++] = '\n';
len += put_field(buf + len, "address");
len += put_ip4(buf + len, netif_ip4_addr(nif));
buf[len++] = '\n';
len += put_field(buf + len, "mtu");
len += put_u(buf + len, nif->mtu);
buf[len++] = '\n';
len += put_field(buf + len, "netmask");
len += put_ip4(buf + len, netif_ip4_netmask(nif));
buf[len++] = '\n';
lwip_sys_unlock();
len += put_field(buf + len, "gateway");
len += put_ip4(buf + len, netif_ip4_gw(nif));
buf[len++] = '\n';
uint64 rx, tx;
net_e1000_counts(&rx, &tx);
len += put_field(buf + len, "mtu");
len += put_u(buf + len, nif->mtu);
buf[len++] = '\n';
len += put_field(buf + len, "rx_frames");
len += put_u(buf + len, rx);
buf[len++] = '\n';
lwip_sys_unlock();
len += put_field(buf + len, "tx_frames");
len += put_u(buf + len, tx);
buf[len++] = '\n';
uint64 rx, tx;
net_eth_counts(i, &rx, &tx);
len += put_field(buf + len, "rx_frames");
len += put_u(buf + len, rx);
buf[len++] = '\n';
len += put_field(buf + len, "tx_frames");
len += put_u(buf + len, tx);
buf[len++] = '\n';
}
return len;
}
@ -258,9 +303,9 @@ netinit(void)
// depends on that reasoning holding forever is not worth the two lines
// saved.
inet_init();
if (!e1000_present()) {
// Silent: a machine without an e1000 is not misconfigured, and this
// runs on every boot.
if (netdev_count() == 0) {
// Silent: a machine with no network device is not misconfigured, and
// this runs on every boot.
return;
}
net_started = 1;