config

Documentation

Index

• Constants
• Variables
• func GetHostPath(devInfo DeviceInfo, vhostUserStoreEnabled bool, vhostUserStorePath string) (string, error)
• func GetVhostUserNodeStat(devNodePath string, devNodeStat *unix.Stat_t) (err error)
• func SetLogger(logger *logrus.Entry)
• type BlockDrive
• type DeviceInfo
  • func PmemDeviceInfo(source, destination string) (*DeviceInfo, error)
• type DeviceState
• type DeviceType
• type PCIePort
  • func (p PCIePort) Invalid() bool
  • func (p PCIePort) String() string
  • func (p PCIePort) Valid() bool
• type PCIePortBusPrefix
  • func (p PCIePortBusPrefix) String() string
• type PCIePortMapping
• type RNGDev
• type VFIODev
• type VFIODeviceType
• type VFIOModeType
  • func (m *VFIOModeType) VFIOSetMode(modeName string) error
• type VhostUserDeviceAttrs

Constants

const (
	// DeviceVFIO is the VFIO device type
	DeviceVFIO DeviceType = "vfio"

	// DeviceBlock is the block device type
	DeviceBlock DeviceType = "block"

	// DeviceGeneric is a generic device type
	DeviceGeneric DeviceType = "generic"

	//VhostUserSCSI - SCSI based vhost-user type
	VhostUserSCSI = "vhost-user-scsi-pci"

	//VhostUserNet - net based vhost-user type
	VhostUserNet = "virtio-net-pci"

	//VhostUserBlk represents a block vhostuser device type
	VhostUserBlk = "vhost-user-blk-pci"

	//VhostUserFS represents a virtio-fs vhostuser device type
	VhostUserFS = "vhost-user-fs-pci"
)

const (
	// VirtioMmio means use virtio-mmio for mmio based drives
	VirtioMmio = "virtio-mmio"

	// VirtioBlock means use virtio-blk for hotplugging drives
	VirtioBlock = "virtio-blk"

	// VirtioBlockCCW means use virtio-blk-ccw for hotplugging drives
	VirtioBlockCCW = "virtio-blk-ccw"

	// VirtioSCSI means use virtio-scsi for hotplugging drives
	VirtioSCSI = "virtio-scsi"

	// Nvdimm means use nvdimm for hotplugging drives
	Nvdimm = "nvdimm"
)

const (
	// AIOThreads is the pthread asynchronous I/O implementation.
	AIOThreads = "threads"

	// AIONative is the native Linux AIO implementation
	AIONative = "native"

	// AIOUring is the Linux io_uring I/O implementation
	AIOIOUring = "io_uring"
)

const (
	// Virtio9P means use virtio-9p for the shared file system
	Virtio9P = "virtio-9p"

	// VirtioFS means use virtio-fs for the shared file system
	VirtioFS = "virtio-fs"

	// VirtioFSNydus means use nydus for the shared file system
	VirtioFSNydus = "virtio-fs-nydus"

	// NoSharedFS means *no* shared file system solution will be used
	// and files will be copied into the guest system.
	//
	// WARNING: This should be carefully used, and only used in very few
	// specific cases, as any update to the mount will *NOT* be reflected
	// during the lifecycle of the pod, causing issues with rotation of
	// secrets, certs, or configurations via kubernetes objects like
	// configMaps or secrets, as those will be copied into the guest at
	// *pod* *creation* *time*.
	NoSharedFS = "none"
)

const (
	// Define the string key for DriverOptions in DeviceInfo struct
	FsTypeOpt      = "fstype"
	BlockDriverOpt = "block-driver"

	VhostUserReconnectTimeOutOpt = "vhost-user-reconnect-timeout"
)

const (
	// The OCI spec requires the major-minor number to be provided for a
	// device. We have chosen the below major numbers to represent
	// vhost-user devices.
	VhostUserBlkMajor  = 241
	VhostUserSCSIMajor = 242
)

const (
	// RootPort attach VFIO devices to a root-port
	RootPort PCIePort = "root-port"
	// SwitchPort attach VFIO devices to a switch-port
	SwitchPort = "switch-port"
	// BridgePort is the default
	BridgePort = "bridge-port"
	// NoPort is for disabling VFIO hotplug/coldplug
	NoPort = "no-port"
	// InvalidPort is for invalid port
	InvalidPort = "invalid-port"
)

const (

	// The timeout for reconnecting on non-server sockets when the remote end
	// goes away.
	// qemu will delay this many seconds and then attempt to reconnect.  Zero
	// disables reconnecting, and is the default.
	DefaultVhostUserReconnectTimeOut = 0
)

Variables

var GetHostPathFunc = GetHostPath

GetHostPathFunc is function pointer used to mock GetHostPath in tests.

var GetVhostUserNodeStatFunc = GetVhostUserNodeStat

GetVhostUserNodeStatFunc is function pointer used to mock GetVhostUserNodeStat in tests. Through this functon, user can get device type information.

var (
	// Each of this structures keeps track of the devices attached to the
	// different types of PCI ports. We can deduces the Bus number from it
	// and eliminate duplicates being assigned.
	PCIeDevices = map[PCIePort]PCIePortMapping{}
)

var PCIePortPrefixMapping = map[PCIePort]PCIePortBusPrefix{
	RootPort:   PCIeRootPortPrefix,
	SwitchPort: PCIeSwitchhDownstreamPortPrefix,
	BridgePort: PCIBridgePortPrefix,
}

var SysBusPciDevicesPath = "/sys/bus/pci/devices"

SysBusPciDevicesPath is static string of /sys/bus/pci/devices

var SysDevPrefix = "/sys/dev"

SysDevPrefix is static string of /sys/dev

var SysIOMMUGroupPath = "/sys/kernel/iommu_groups"

SysIOMMUGroupPath is static string of /sys/kernel/iommu_groups

Functions

func GetHostPath

func GetHostPath(devInfo DeviceInfo, vhostUserStoreEnabled bool, vhostUserStorePath string) (string, error)

GetHostPath is used to fetch the host path for the device. The path passed in the spec refers to the path that should appear inside the container. We need to find the actual device path on the host based on the major-minor numbers of the device.

func GetVhostUserNodeStat

func GetVhostUserNodeStat(devNodePath string, devNodeStat *unix.Stat_t) (err error)

func SetLogger

func SetLogger(logger *logrus.Entry)

SetLogger sets up a logger for this pkg

Types

type BlockDrive

type BlockDrive struct {
	// File is the path to the disk-image/device which will be used with this drive
	File string

	// Format of the drive
	Format string

	// ID is used to identify this drive in the hypervisor options.
	ID string

	// MmioAddr is used to identify the slot at which the drive is attached (order?).
	MmioAddr string

	// SCSI Address of the block device, in case the device is attached using SCSI driver
	// SCSI address is in the format SCSI-Id:LUN
	SCSIAddr string

	// NvdimmID is the nvdimm id inside the VM
	NvdimmID string

	// VirtPath at which the device appears inside the VM, outside of the container mount namespace
	VirtPath string

	// DevNo identifies the css bus id for virtio-blk-ccw
	DevNo string

	// PCIPath is the PCI path used to identify the slot at which the drive is attached.
	PCIPath vcTypes.PciPath

	// Index assigned to the drive. In case of virtio-scsi, this is used as SCSI LUN index
	Index int

	// ShareRW enables multiple qemu instances to share the File
	ShareRW bool

	// ReadOnly sets the device file readonly
	ReadOnly bool

	// Pmem enables persistent memory. Use File as backing file
	// for a nvdimm device in the guest
	Pmem bool

	// This block device is for swap
	Swap bool
}

BlockDrive represents a block storage drive which may be used in case the storage driver has an underlying block storage device.

type DeviceInfo

type DeviceInfo struct {
	// DriverOptions is specific options for each device driver
	// for example, for BlockDevice, we can set DriverOptions["block-driver"]="virtio-blk"
	DriverOptions map[string]string

	// Hostpath is device path on host
	HostPath string

	// ContainerPath is device path inside container
	ContainerPath string `json:"-"`

	// Type of device: c, b, u or p
	// c , u - character(unbuffered)
	// p - FIFO
	// b - block(buffered) special file
	// More info in mknod(1).
	DevType string

	// ID for the device that is passed to the hypervisor.
	ID string

	// Major, minor numbers for device.
	Major int64
	Minor int64

	// FileMode permission bits for the device.
	FileMode os.FileMode

	// id of the device owner.
	UID uint32

	// id of the device group.
	GID uint32

	// Pmem enabled persistent memory. Use HostPath as backing file
	// for a nvdimm device in the guest.
	Pmem bool

	// If applicable, should this device be considered RO
	ReadOnly bool

	// ColdPlug specifies whether the device must be cold plugged (true)
	// or hot plugged (false).
	ColdPlug bool

	// Specifies the PCIe port type to which the device is attached
	Port PCIePort
}

DeviceInfo is an embedded type that contains device data common to all types of devices.

func PmemDeviceInfo

func PmemDeviceInfo(source, destination string) (*DeviceInfo, error)

PmemDeviceInfo returns a DeviceInfo if a loop device is mounted on source, and the backing file of the loop device has the PFN signature.

type DeviceState

type DeviceState struct {
	// DriverOptions is specific options for each device driver
	// for example, for BlockDevice, we can set DriverOptions["block-driver"]="virtio-blk"
	DriverOptions map[string]string

	// VhostUserDeviceAttrs is specific for vhost-user device driver
	VhostUserDev *VhostUserDeviceAttrs `json:",omitempty"`

	// BlockDrive is specific for block device driver
	BlockDrive *BlockDrive `json:",omitempty"`

	ID string

	// Type is used to specify driver type
	// Refs: pkg/device/config/config.go:DeviceType
	Type string

	// Type of device: c, b, u or p
	// c , u - character(unbuffered)
	// p - FIFO
	// b - block(buffered) special file
	// More info in mknod(1).
	DevType string

	// VFIODev is specific VFIO device driver
	VFIODevs []*VFIODev `json:",omitempty"`

	RefCount    uint
	AttachCount uint

	// Major, minor numbers for device.
	Major int64
	Minor int64

	// ColdPlug specifies whether the device must be cold plugged (true)
	// or hot plugged (false).
	ColdPlug bool
}

DeviceState is a structure which represents host devices plugged to a hypervisor, one Device can be shared among containers in POD Refs: pkg/device/drivers/generic.go:GenericDevice

type DeviceType

type DeviceType string

DeviceType indicates device type

type PCIePort

type PCIePort string

PCIePort distinguish only between root and switch port

func (PCIePort) Invalid

func (p PCIePort) Invalid() bool

func (PCIePort) String

func (p PCIePort) String() string

func (PCIePort) Valid

func (p PCIePort) Valid() bool

type PCIePortBusPrefix

type PCIePortBusPrefix string

PCIePortBusPrefix gives us the correct bus nameing dependeing on the port used to hot(cold)-plug the device

const (
	PCIeRootPortPrefix              PCIePortBusPrefix = "rp"
	PCIeSwitchPortPrefix            PCIePortBusPrefix = "sw"
	PCIeSwitchUpstreamPortPrefix    PCIePortBusPrefix = "swup"
	PCIeSwitchhDownstreamPortPrefix PCIePortBusPrefix = "swdp"
	PCIBridgePortPrefix             PCIePortBusPrefix = "bp"
)

func (PCIePortBusPrefix) String

func (p PCIePortBusPrefix) String() string

type PCIePortMapping

type PCIePortMapping map[string]bool

type RNGDev

type RNGDev struct {
	// ID is used to identify the device in the hypervisor options.
	ID string
	// Filename is the file to use as entropy source.
	Filename string
}

RNGDev represents a random number generator device

type VFIODev

type VFIODev struct {
	// ID is used to identify this drive in the hypervisor options.
	ID string

	// BDF (Bus:Device.Function) of the PCI address
	BDF string

	// sysfsdev of VFIO mediated device
	SysfsDev string

	// VendorID specifies vendor id
	VendorID string

	// DeviceID specifies device id
	DeviceID string

	// PCI Class Code
	Class string

	// Bus of VFIO PCIe device
	Bus string

	// Guest PCI path of device
	GuestPciPath vcTypes.PciPath

	// Type of VFIO device
	Type VFIODeviceType

	// IsPCIe specifies device is PCIe or PCI
	IsPCIe bool

	// APDevices are the Adjunct Processor devices assigned to the mdev
	APDevices []string

	// Rank identifies a device in a IOMMU group
	Rank int

	// Port is the PCIe port type to which the device is attached
	Port PCIePort
}

VFIODev represents a VFIO PCI device used for hotplugging

type VFIODeviceType

type VFIODeviceType uint32

VFIODeviceType indicates VFIO device type

const (
	// VFIODeviceErrorType is the error type of VFIO device
	VFIODeviceErrorType VFIODeviceType = iota

	// VFIOPCIDeviceNormalType is a normal VFIO PCI device type
	VFIOPCIDeviceNormalType

	// VFIOPCIDeviceMediatedType is a VFIO PCI mediated device type
	VFIOPCIDeviceMediatedType

	// VFIOAPDeviceMediatedType is a VFIO AP mediated device type
	VFIOAPDeviceMediatedType
)

type VFIOModeType

type VFIOModeType uint32

VFIOMode indicates e behaviour mode for handling devices in the VM

const (
	// VFIOModeVFIO specifies OCI compliant behaviour: VFIO
	// devices specified to Kata appear as VFIO devices within the
	// container
	VFIOModeVFIO VFIOModeType = iota

	// VFIOModeGuestKernel specifies Kata-specific behaviour
	// useful in certain cases: VFIO devices specified to Kata are
	// bound to whatever driver in the VM will take them.  This
	// requires specialized containers expecting this behaviour to
	// locate and use the devices
	VFIOModeGuestKernel
)

func (*VFIOModeType) VFIOSetMode

func (m *VFIOModeType) VFIOSetMode(modeName string) error

type VhostUserDeviceAttrs

type VhostUserDeviceAttrs struct {
	DevID      string
	SocketPath string
	// MacAddress is only meaningful for vhost user net device
	MacAddress string

	// These are only meaningful for vhost user fs devices
	Tag string

	Cache string

	Type DeviceType

	// PCIPath is the PCI path used to identify the slot at which
	// the drive is attached.  It is only meaningful for vhost
	// user block devices
	PCIPath vcTypes.PciPath

	// Block index of the device if assigned
	Index int

	CacheSize uint32

	QueueSize uint32

	// Reconnect timeout for socket of vhost user block device
	ReconnectTime uint32
}

VhostUserDeviceAttrs represents data shared by most vhost-user devices