loop

type Config struct {
	// Group is the group's name, for the start line and State.
	Group string
	// Value is the group's LoopValue.
	Value corenet.LoopValue
	// MaxConns is LimitsValue.MaxConns: past it a connection is accepted and
	// closed at once. Zero sets no ceiling.
	MaxConns int
	// IdleTimeout closes a connection with no traffic for that long, its
	// output sent. Zero sets none.
	IdleTimeout time.Duration
	// ReadTimeout is the group's read bound. TCP_DEFER_ACCEPT, once opted into,
	// takes it in whole seconds, rounded up. Zero sets none, and the option is
	// not set.
	ReadTimeout time.Duration
	// KeepAlive is the idle time before the first keepalive probe of an
	// accepted socket, and the interval between probes: zero is 15 s, the
	// standard library's, and negative sets no keepalive.
	KeepAlive time.Duration
	// UserTimeout is TCP_USER_TIMEOUT, the time sent output may stay
	// unacknowledged before the kernel closes the connection with an error,
	// rounded up to whole milliseconds. Zero sets none.
	UserTimeout time.Duration
	// Handler is the group's loop handler.
	Handler corenet.LoopHandler
	// Busy reports whether a connection of a lane waits on its worker (the
	// chain's LoopOffloader.Pending, R3): the drain keeps it open, eviction
	// passes it by. Nil when nothing offloads.
	Busy func(lane int, ref corenet.LoopConnRef) bool
	// Listeners are the sockets to accept on.
	Listeners []Listener
	// Log receives the one start line; nil is standard error.
	Log io.Writer
	// Disabled are the capabilities the operator switched off: never probed,
	// never used, reported "disabled" (ADR 0189).
	Disabled []corenet.Capability
	// DisabledBy says how they were switched off in State; empty is
	// KITSUNIUM_NET_DISABLE.
	DisabledBy string
	// LoopsSource is where Value.Loops came from, for State, when server
	// resolved it already: LoopsAuto read as GOMAXPROCS is "auto". Empty lets
	// the group say it itself.
	LoopsSource string
	// Memory is the soft-memory-limit derivation server read (memlimit.Derive):
	// its Allowance, when one was found, sizes a slab budget LoopValue leaves
	// at zero (#809). The zero value derives nothing.
	Memory coreproc.MemoryLimitValue
	// contains filtered or unexported fields
}

type Group struct {
	// contains filtered or unexported fields
}

type Listener struct {
	// FD is the duplicated descriptor, close-on-exec.
	FD int
	// Loop is one more than the index of the only loop that accepts on it — a
	// SO_REUSEPORT shard (#856) —, zero when every loop of the group does.
	Loop int
}

type PacketConfig struct {
	// Group is the group's name.
	Group string
	// FD is the UDP socket's duplicated descriptor, close-on-exec.
	FD int
	// Lane is the lane's index, PacketLoopIO.Loop's answer.
	Lane int
	// Ceiling is the group's MaxPacketSize: a datagram past it is counted in
	// Counters.Oversized and never handed on.
	Ceiling int
	// Handler is the group's datagram loop handler.
	Handler corenet.PacketLoopHandler
	// Counters are where the lane counts what State reports.
	Counters PacketCountersValue
	// OnGSOOff is called once, on the lane's thread, when the device refuses a
	// UDP_SEGMENT send with EIO and the lane sends one datagram a message from
	// then on. Nil calls nothing.
	OnGSOOff func()
}

type PacketCountersValue struct {
	// Total counts the datagrams received.
	Total *atomic.Uint64
	// Oversized counts the datagrams past the ceiling, dropped.
	Oversized *atomic.Uint64
	// Truncated counts the messages the kernel cut, dropped.
	Truncated *atomic.Uint64
	// ReplyFailures counts the queued replies the kernel refused.
	ReplyFailures *atomic.Uint64
	// GSOOversized counts the UDP_SEGMENT sends refused with EMSGSIZE.
	GSOOversized *atomic.Uint64
	// KernelDrops adds the growth of the socket's SO_RXQ_OVFL count.
	KernelDrops *atomic.Uint64
}

type PacketLane interface {
	// Handover drains the socket before its successor reads it (ADR 0192 §D4):
	// the lane stops its receive, serves what the socket queued to EAGAIN,
	// sends the replies, switches UDP GRO off and stops; Done is closed then.
	Handover()
	// Stop stops the lane now, its queued datagrams left in the socket, and
	// waits until its thread has returned.
	Stop()
	// Done is closed once the lane's thread has returned.
	Done() <-chan struct{}
}