linux

Documentation

Overview

Package linux implements the Linux specific datapath implementation

Index

• Variables
• func CheckRequirements(log *slog.Logger) error
• func NewDatapath(p DatapathParams) datapath.Datapath
• func NewNodeHandler(log *slog.Logger, tunnelConfig dpTunnel.Config, nodeMap nodemap.MapV2, ...) (datapath.NodeHandler, datapath.NodeIDHandler, datapath.NodeNeighbors)
• func NodeDeviceNameWithDefaultRoute() (string, error)
• func NodeEnsureLocalRoutingRule() error
• type DatapathConfiguration
• type DatapathParams
• type DeviceManager
  • func (dm *DeviceManager) Detect(k8sEnabled bool) ([]string, error)
• type DevicesConfig
  • func (c DevicesConfig) Flags(flags *pflag.FlagSet)
• type NeighLink
• type NextHop

Variables

var DevicesControllerCell = cell.Module(
	"devices-controller",
	"Synchronizes the device and route tables with the kernel",

	cell.ProvidePrivate(
		tables.NewDeviceTable,
		tables.NewRouteTable,
	),
	cell.Invoke(
		statedb.RegisterTable[*tables.Device],
		statedb.RegisterTable[*tables.Route],
	),

	cell.Provide(
		newDevicesController,
		newDeviceManager,
	),
	cell.Config(DevicesConfig{}),

	cell.Invoke(func(*devicesController) {}),
)

DevicesControllerCell registers a controller that subscribes to network devices and routes via netlink and populates the devices and routes devices.

Functions

func CheckRequirements

func CheckRequirements(log *slog.Logger) error

CheckRequirements checks that minimum kernel requirements are met for configuring the BPF datapath.

func NewDatapath

func NewDatapath(p DatapathParams) datapath.Datapath

NewDatapath creates a new Linux datapath

func NewNodeHandler

func NewNodeHandler(
	log *slog.Logger,
	tunnelConfig dpTunnel.Config,
	nodeMap nodemap.MapV2,
	nodeManager manager.NodeManager,
) (datapath.NodeHandler, datapath.NodeIDHandler, datapath.NodeNeighbors)

NewNodeHandler returns a new node handler to handle node events and implement the implications in the Linux datapath

func NodeDeviceNameWithDefaultRoute

func NodeDeviceNameWithDefaultRoute() (string, error)

NodeDeviceNameWithDefaultRoute returns the node's device name which handles the default route in the current namespace

func NodeEnsureLocalRoutingRule

func NodeEnsureLocalRoutingRule() error

NodeEnsureLocalRoutingRule moves the kernel's default '0: from all lookup local' ip rule up to priority 100 to create space for Cilium to install rules with a lower pref (meaning a higher priority).

Cilium's 'new' rule is always installed before removing the default one with pref 0 to avoid breaking local packet delivery.

Types

type DatapathConfiguration

type DatapathConfiguration struct {
	// HostDevice is the name of the device to be used to access the host.
	HostDevice string

	// TunnelDevice is the name of the tunnel device (if any).
	TunnelDevice string
}

DatapathConfiguration is the static configuration of the datapath. The configuration cannot change throughout the lifetime of a datapath object.

type DatapathParams

type DatapathParams struct {
	ConfigWriter   datapath.ConfigWriter
	RuleManager    datapath.IptablesManager
	WGAgent        datapath.WireguardAgent
	NodeMap        nodemap.MapV2
	BWManager      datapath.BandwidthManager
	NodeAddressing datapath.NodeAddressing
	MTU            datapath.MTUConfiguration
	Loader         datapath.Loader
	NodeManager    manager.NodeManager
	DB             *statedb.DB
	Devices        statedb.Table[*tables.Device]
	Orchestrator   datapath.Orchestrator
	NodeHandler    datapath.NodeHandler
	NodeIDHandler  datapath.NodeIDHandler
	NodeNeighbors  datapath.NodeNeighbors
}

type DeviceManager

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

DeviceManager is a temporary compatibility bridge to keep DeviceManager uses as is and reuse its tests against DevicesController and the devices table.

This will be refactored away in follow-up PRs that convert code over to the devices table. The DirectRoutingDevice and IPv6MCastDevice would computed from the devices table as necessary.

func (*DeviceManager) Detect

func (dm *DeviceManager) Detect(k8sEnabled bool) ([]string, error)

type DevicesConfig

type DevicesConfig struct {
	// Devices is the user-specified devices to use. This can be
	// either concrete devices ("eth0,eth1"), or a wildcard "eth+".
	// If empty the devices are auto-detected according to rules defined
	// by isSelectedDevice().
	Devices []string
	// ForceDeviceDetection forces the auto-detection of devices,
	// even if user-specific devices are explicitly listed.
	ForceDeviceDetection bool
}

func (DevicesConfig) Flags

func (c DevicesConfig) Flags(flags *pflag.FlagSet)

type NeighLink

type NeighLink struct {
	Name string `json:"link-name"`
}

NeighLink contains the details of a NeighLink

type NextHop

type NextHop struct {
	Name  string
	IP    net.IP
	IsNew bool
}