mirror of https://github.com/containers/podman.git
114 lines
3.2 KiB
Go
114 lines
3.2 KiB
Go
//go:build linux
|
|
|
|
package specgen
|
|
|
|
import (
|
|
"fmt"
|
|
|
|
spec "github.com/opencontainers/runtime-spec/specs-go"
|
|
"golang.org/x/sys/unix"
|
|
)
|
|
|
|
// statBlkDev returns path's major and minor, or an error, if path is not a block device.
|
|
func statBlkDev(path string) (int64, int64, error) {
|
|
var stat unix.Stat_t
|
|
|
|
if err := unix.Stat(path, &stat); err != nil {
|
|
return 0, 0, fmt.Errorf("could not parse device %s: %w", path, err)
|
|
}
|
|
if stat.Mode&unix.S_IFMT != unix.S_IFBLK {
|
|
return 0, 0, fmt.Errorf("%s: not a block device", path)
|
|
}
|
|
rdev := uint64(stat.Rdev) //nolint:unconvert // Some architectures have different type.
|
|
return int64(unix.Major(rdev)), int64(unix.Minor(rdev)), nil
|
|
}
|
|
|
|
// fillThrottleDev fills in dev.Major and dev.Minor fields based on path to a block device.
|
|
func fillThrottleDev(path string, dev *spec.LinuxThrottleDevice) error {
|
|
major, minor, err := statBlkDev(path)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
dev.Major, dev.Minor = major, minor
|
|
|
|
return nil
|
|
}
|
|
|
|
// FinishThrottleDevices takes the temporary representation of the throttle
|
|
// devices in the specgen, fills in major and minor numbers, and amends the
|
|
// specgen with the specified devices. It returns an error if any device
|
|
// specified doesn't exist or is not a block device.
|
|
func FinishThrottleDevices(s *SpecGenerator) error {
|
|
if len(s.ThrottleReadBpsDevice)+len(s.ThrottleWriteBpsDevice)+len(s.ThrottleReadIOPSDevice)+len(s.ThrottleWriteIOPSDevice) == 0 {
|
|
return nil
|
|
}
|
|
|
|
if s.ResourceLimits == nil {
|
|
s.ResourceLimits = &spec.LinuxResources{}
|
|
}
|
|
if s.ResourceLimits.BlockIO == nil {
|
|
s.ResourceLimits.BlockIO = &spec.LinuxBlockIO{}
|
|
}
|
|
|
|
for k, v := range s.ThrottleReadBpsDevice {
|
|
if err := fillThrottleDev(k, &v); err != nil {
|
|
return err
|
|
}
|
|
s.ResourceLimits.BlockIO.ThrottleReadBpsDevice = append(s.ResourceLimits.BlockIO.ThrottleReadBpsDevice, v)
|
|
}
|
|
|
|
for k, v := range s.ThrottleWriteBpsDevice {
|
|
if err := fillThrottleDev(k, &v); err != nil {
|
|
return err
|
|
}
|
|
s.ResourceLimits.BlockIO.ThrottleWriteBpsDevice = append(s.ResourceLimits.BlockIO.ThrottleWriteBpsDevice, v)
|
|
}
|
|
|
|
for k, v := range s.ThrottleReadIOPSDevice {
|
|
if err := fillThrottleDev(k, &v); err != nil {
|
|
return err
|
|
}
|
|
s.ResourceLimits.BlockIO.ThrottleReadIOPSDevice = append(s.ResourceLimits.BlockIO.ThrottleReadIOPSDevice, v)
|
|
}
|
|
|
|
for k, v := range s.ThrottleWriteIOPSDevice {
|
|
if err := fillThrottleDev(k, &v); err != nil {
|
|
return err
|
|
}
|
|
s.ResourceLimits.BlockIO.ThrottleWriteIOPSDevice = append(s.ResourceLimits.BlockIO.ThrottleWriteIOPSDevice, v)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func WeightDevices(specgen *SpecGenerator) error {
|
|
if len(specgen.WeightDevice) == 0 {
|
|
return nil
|
|
}
|
|
|
|
if specgen.ResourceLimits == nil {
|
|
specgen.ResourceLimits = &spec.LinuxResources{}
|
|
}
|
|
if specgen.ResourceLimits.BlockIO == nil {
|
|
specgen.ResourceLimits.BlockIO = &spec.LinuxBlockIO{}
|
|
}
|
|
|
|
for k, v := range specgen.WeightDevice {
|
|
major, minor, err := statBlkDev(k)
|
|
if err != nil {
|
|
return fmt.Errorf("bad --blkio-weight-device: %w", err)
|
|
}
|
|
specgen.ResourceLimits.BlockIO.WeightDevice = append(specgen.ResourceLimits.BlockIO.WeightDevice,
|
|
spec.LinuxWeightDevice{
|
|
LinuxBlockIODevice: spec.LinuxBlockIODevice{
|
|
Major: major,
|
|
Minor: minor,
|
|
},
|
|
Weight: v.Weight,
|
|
})
|
|
}
|
|
|
|
return nil
|
|
}
|