unslop, improve the tio interface

overlay/batch/multi_coalesce_test.go

@@ -1,17 +1,33 @@
 package batch
 
 import (
+	"bytes"
+	"io"
 	"testing"
 
 	"github.com/slackhq/nebula/test"
 )
 
+// newTestMultiCoalescer builds a batcher over w and asserts it really is
+// multi-lane. NewMultiCoalescer collapses to a bare Passthrough when w can
+// offload neither protocol, and a test that meant to exercise a lane would
+// otherwise pass vacuously.
+func newTestMultiCoalescer(tb testing.TB, w io.Writer) *MultiCoalescer {
+	tb.Helper()
+	b := NewMultiCoalescer(w, test.NewLogger())
+	m, ok := b.(*MultiCoalescer)
+	if !ok {
+		tb.Fatalf("want a *MultiCoalescer, got %T", b)
+	}
+	return m
+}
+
 // TestMultiCoalescerRoutesByProto confirms TCP/UDP/other land in the right
 // lane: TCP and UDP get coalesced when their lanes are enabled, anything
 // else (ICMP here) falls through to plain Write.
 func TestMultiCoalescerRoutesByProto(t *testing.T) {
 	w := &fakeTunWriter{gsoEnabled: true}
-	m := NewMultiCoalescer(w, test.NewLogger(), true, true)
+	m := newTestMultiCoalescer(t, w)
 
 	tcpPay := make([]byte, 1200)
 	udpPay := make([]byte, 1200)
@@ -48,12 +64,15 @@ func TestMultiCoalescerRoutesByProto(t *testing.T) {
 	}
 }
 
-// TestMultiCoalescerDisabledUDPFallsThrough verifies that when the UDP lane
-// is disabled (e.g. kernel doesn't support USO), UDP packets still reach
-// the kernel via the passthrough lane rather than being lost.
-func TestMultiCoalescerDisabledUDPFallsThrough(t *testing.T) {
-	w := &fakeTunWriter{gsoEnabled: true}
-	m := NewMultiCoalescer(w, test.NewLogger(), true, false) // TSO on, USO off
+// TestMultiCoalescerNoUSOFallsThrough verifies that on a queue without USO
+// (older kernel: TSO but no GSO_UDP_L4) the UDP lane never comes up and UDP
+// packets still reach the kernel via passthrough rather than being lost.
+func TestMultiCoalescerNoUSOFallsThrough(t *testing.T) {
+	w := &fakeTunWriter{gsoEnabled: true, noUSO: true}
+	m := newTestMultiCoalescer(t, w)
+	if m.udp != nil {
+		t.Fatal("UDP lane must not come up without USO")
+	}
 
 	if err := m.Commit(buildUDPv4(1000, 53, make([]byte, 800))); err != nil {
 		t.Fatal(err)
@@ -72,10 +91,53 @@ func TestMultiCoalescerDisabledUDPFallsThrough(t *testing.T) {
 	}
 }
 
-// TestMultiCoalescerDisabledTCPFallsThrough mirrors the TSO=off case.
-func TestMultiCoalescerDisabledTCPFallsThrough(t *testing.T) {
-	w := &fakeTunWriter{gsoEnabled: true}
-	m := NewMultiCoalescer(w, test.NewLogger(), false, true) // TSO off, USO on
+// TestMultiCoalescerNoOffloadsIsPassthrough covers a queue that can't offload
+// anything. Both lane constructors refuse, so there's nothing left to
+// dispatch between and NewMultiCoalescer hands back the passthrough lane
+// itself — no wrapper, no per-packet protocol demux, and every packet reaches
+// the kernel in arrival order. This is the case Interface.activate used to
+// special-case with a bare Passthrough.
+func TestMultiCoalescerNoOffloadsIsPassthrough(t *testing.T) {
+	w := &fakeTunWriter{gsoEnabled: false}
+	m := NewMultiCoalescer(w, test.NewLogger())
+
+	if _, ok := m.(*Passthrough); !ok {
+		t.Fatalf("want a bare *Passthrough when neither offload is available, got %T", m)
+	}
+	pkts := [][]byte{
+		buildTCPv4(1000, tcpAck, make([]byte, 1200)),
+		buildUDPv4(1000, 53, make([]byte, 800)),
+		buildTCPv4(2200, tcpAck, make([]byte, 1200)),
+	}
+	for _, p := range pkts {
+		if err := m.Commit(p); err != nil {
+			t.Fatal(err)
+		}
+	}
+	if err := m.Flush(); err != nil {
+		t.Fatal(err)
+	}
+	if len(w.gsoWrites) != 0 {
+		t.Errorf("no GSO writes possible, got %d", len(w.gsoWrites))
+	}
+	if len(w.writes) != len(pkts) {
+		t.Fatalf("want %d plain writes, got %d", len(pkts), len(w.writes))
+	}
+	// One lane for everything means arrival order survives end to end.
+	for i, want := range pkts {
+		if !bytes.Equal(w.writes[i], want) {
+			t.Errorf("write %d out of order or corrupt", i)
+		}
+	}
+}
+
+// TestMultiCoalescerNoTSOFallsThrough mirrors the no-TSO case.
+func TestMultiCoalescerNoTSOFallsThrough(t *testing.T) {
+	w := &fakeTunWriter{gsoEnabled: true, noTSO: true}
+	m := newTestMultiCoalescer(t, w)
+	if m.tcp != nil {
+		t.Fatal("TCP lane must not come up without TSO")
+	}
 
 	pay := make([]byte, 1200)
 	if err := m.Commit(buildTCPv4(1000, tcpAck, pay)); err != nil {