opencontainers/runc
1
0
Fork 0
mirror of https://github.com/opencontainers/runc.git synced 2025-08-07 01:22:38 +03:00
Code Activity

Move the cgroups setting into a Resources struct

Browse Source 
This allows us to distinguish cases where a container
needs to just join the paths or also additionally
set cgroups settings. This will help in implementing
cgroupsPath support in the spec.

Signed-off-by: Mrunal Patel <mrunalp@gmail.com>
This commit is contained in:
Mrunal Patel
2015-12-14 19:26:29 -05:00
parent 11f8fdca33
commit 55a49f2110
26 changed files with 168 additions and 159 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
libcontainer/cgroups/fs/apply_raw.go
View File

@@ -137,7 +137,7 @@ func (m *Manager) Apply(pid int) (err error) {
m.Paths = paths m.Paths = paths
if paths["cpu"] != "" { if paths["cpu"] != "" {
if err := CheckCpushares(paths["cpu"], c.CpuShares); err != nil { if err := CheckCpushares(paths["cpu"], c.Resources.CpuShares); err != nil {
return err return err
} }
} }
@@ -202,15 +202,15 @@ func (m *Manager) Freeze(state configs.FreezerState) error {
if err != nil { if err != nil {
return err return err
} }
prevState := m.Cgroups.Freezer prevState := m.Cgroups.Resources.Freezer
m.Cgroups.Freezer = state m.Cgroups.Resources.Freezer = state
freezer, err := subsystems.Get("freezer") freezer, err := subsystems.Get("freezer")
if err != nil { if err != nil {
return err return err
} }
err = freezer.Set(dir, m.Cgroups) err = freezer.Set(dir, m.Cgroups)
if err != nil { if err != nil {
m.Cgroups.Freezer = prevState m.Cgroups.Resources.Freezer = prevState
return err return err
} }
return nil return nil

18
libcontainer/cgroups/fs/blkio.go
View File

@@ -35,18 +35,18 @@ func (s *BlkioGroup) Apply(d *cgroupData) error {
} }
func (s *BlkioGroup) Set(path string, cgroup *configs.Cgroup) error { func (s *BlkioGroup) Set(path string, cgroup *configs.Cgroup) error {
if cgroup.BlkioWeight != 0 { if cgroup.Resources.BlkioWeight != 0 {
if err := writeFile(path, "blkio.weight", strconv.FormatUint(uint64(cgroup.BlkioWeight), 10)); err != nil { if err := writeFile(path, "blkio.weight", strconv.FormatUint(uint64(cgroup.Resources.BlkioWeight), 10)); err != nil {
return err return err
} }
} }
if cgroup.BlkioLeafWeight != 0 { if cgroup.Resources.BlkioLeafWeight != 0 {
if err := writeFile(path, "blkio.leaf_weight", strconv.FormatUint(uint64(cgroup.BlkioLeafWeight), 10)); err != nil { if err := writeFile(path, "blkio.leaf_weight", strconv.FormatUint(uint64(cgroup.Resources.BlkioLeafWeight), 10)); err != nil {
return err return err
} }
} }
for _, wd := range cgroup.BlkioWeightDevice { for _, wd := range cgroup.Resources.BlkioWeightDevice {
if err := writeFile(path, "blkio.weight_device", wd.WeightString()); err != nil { if err := writeFile(path, "blkio.weight_device", wd.WeightString()); err != nil {
return err return err
} }
@@ -54,22 +54,22 @@ func (s *BlkioGroup) Set(path string, cgroup *configs.Cgroup) error {
return err return err
} }
} }
for _, td := range cgroup.BlkioThrottleReadBpsDevice { for _, td := range cgroup.Resources.BlkioThrottleReadBpsDevice {
if err := writeFile(path, "blkio.throttle.read_bps_device", td.String()); err != nil { if err := writeFile(path, "blkio.throttle.read_bps_device", td.String()); err != nil {
return err return err
} }
} }
for _, td := range cgroup.BlkioThrottleWriteBpsDevice { for _, td := range cgroup.Resources.BlkioThrottleWriteBpsDevice {
if err := writeFile(path, "blkio.throttle.write_bps_device", td.String()); err != nil { if err := writeFile(path, "blkio.throttle.write_bps_device", td.String()); err != nil {
return err return err
} }
} }
for _, td := range cgroup.BlkioThrottleReadIOPSDevice { for _, td := range cgroup.Resources.BlkioThrottleReadIOPSDevice {
if err := writeFile(path, "blkio.throttle.read_iops_device", td.String()); err != nil { if err := writeFile(path, "blkio.throttle.read_iops_device", td.String()); err != nil {
return err return err
} }
} }
for _, td := range cgroup.BlkioThrottleWriteIOPSDevice { for _, td := range cgroup.Resources.BlkioThrottleWriteIOPSDevice {
if err := writeFile(path, "blkio.throttle.write_iops_device", td.String()); err != nil { if err := writeFile(path, "blkio.throttle.write_iops_device", td.String()); err != nil {
return err return err
} }

14
libcontainer/cgroups/fs/blkio_test.go
View File

@@ -89,7 +89,7 @@ func TestBlkioSetWeight(t *testing.T) {
"blkio.weight": strconv.Itoa(weightBefore), "blkio.weight": strconv.Itoa(weightBefore),
}) })
helper.CgroupData.config.BlkioWeight = weightAfter helper.CgroupData.config.Resources.BlkioWeight = weightAfter
blkio := &BlkioGroup{} blkio := &BlkioGroup{}
if err := blkio.Set(helper.CgroupPath, helper.CgroupData.config); err != nil { if err := blkio.Set(helper.CgroupPath, helper.CgroupData.config); err != nil {
t.Fatal(err) t.Fatal(err)
@@ -120,7 +120,7 @@ func TestBlkioSetWeightDevice(t *testing.T) {
"blkio.weight_device": weightDeviceBefore, "blkio.weight_device": weightDeviceBefore,
}) })
helper.CgroupData.config.BlkioWeightDevice = []*configs.WeightDevice{wd} helper.CgroupData.config.Resources.BlkioWeightDevice = []*configs.WeightDevice{wd}
blkio := &BlkioGroup{} blkio := &BlkioGroup{}
if err := blkio.Set(helper.CgroupPath, helper.CgroupData.config); err != nil { if err := blkio.Set(helper.CgroupPath, helper.CgroupData.config); err != nil {
t.Fatal(err) t.Fatal(err)
@@ -157,7 +157,7 @@ func TestBlkioSetMultipleWeightDevice(t *testing.T) {
"blkio.weight_device": weightDeviceBefore, "blkio.weight_device": weightDeviceBefore,
}) })
helper.CgroupData.config.BlkioWeightDevice = []*configs.WeightDevice{wd1, wd2} helper.CgroupData.config.Resources.BlkioWeightDevice = []*configs.WeightDevice{wd1, wd2}
blkio := &BlkioGroup{} blkio := &BlkioGroup{}
if err := blkio.Set(helper.CgroupPath, helper.CgroupData.config); err != nil { if err := blkio.Set(helper.CgroupPath, helper.CgroupData.config); err != nil {
t.Fatal(err) t.Fatal(err)
@@ -529,7 +529,7 @@ func TestBlkioSetThrottleReadBpsDevice(t *testing.T) {
"blkio.throttle.read_bps_device": throttleBefore, "blkio.throttle.read_bps_device": throttleBefore,
}) })
helper.CgroupData.config.BlkioThrottleReadBpsDevice = []*configs.ThrottleDevice{td} helper.CgroupData.config.Resources.BlkioThrottleReadBpsDevice = []*configs.ThrottleDevice{td}
blkio := &BlkioGroup{} blkio := &BlkioGroup{}
if err := blkio.Set(helper.CgroupPath, helper.CgroupData.config); err != nil { if err := blkio.Set(helper.CgroupPath, helper.CgroupData.config); err != nil {
t.Fatal(err) t.Fatal(err)
@@ -559,7 +559,7 @@ func TestBlkioSetThrottleWriteBpsDevice(t *testing.T) {
"blkio.throttle.write_bps_device": throttleBefore, "blkio.throttle.write_bps_device": throttleBefore,
}) })
helper.CgroupData.config.BlkioThrottleWriteBpsDevice = []*configs.ThrottleDevice{td} helper.CgroupData.config.Resources.BlkioThrottleWriteBpsDevice = []*configs.ThrottleDevice{td}
blkio := &BlkioGroup{} blkio := &BlkioGroup{}
if err := blkio.Set(helper.CgroupPath, helper.CgroupData.config); err != nil { if err := blkio.Set(helper.CgroupPath, helper.CgroupData.config); err != nil {
t.Fatal(err) t.Fatal(err)
@@ -589,7 +589,7 @@ func TestBlkioSetThrottleReadIOpsDevice(t *testing.T) {
"blkio.throttle.read_iops_device": throttleBefore, "blkio.throttle.read_iops_device": throttleBefore,
}) })
helper.CgroupData.config.BlkioThrottleReadIOPSDevice = []*configs.ThrottleDevice{td} helper.CgroupData.config.Resources.BlkioThrottleReadIOPSDevice = []*configs.ThrottleDevice{td}
blkio := &BlkioGroup{} blkio := &BlkioGroup{}
if err := blkio.Set(helper.CgroupPath, helper.CgroupData.config); err != nil { if err := blkio.Set(helper.CgroupPath, helper.CgroupData.config); err != nil {
t.Fatal(err) t.Fatal(err)
@@ -619,7 +619,7 @@ func TestBlkioSetThrottleWriteIOpsDevice(t *testing.T) {
"blkio.throttle.write_iops_device": throttleBefore, "blkio.throttle.write_iops_device": throttleBefore,
}) })
helper.CgroupData.config.BlkioThrottleWriteIOPSDevice = []*configs.ThrottleDevice{td} helper.CgroupData.config.Resources.BlkioThrottleWriteIOPSDevice = []*configs.ThrottleDevice{td}
blkio := &BlkioGroup{} blkio := &BlkioGroup{}
if err := blkio.Set(helper.CgroupPath, helper.CgroupData.config); err != nil { if err := blkio.Set(helper.CgroupPath, helper.CgroupData.config); err != nil {
t.Fatal(err) t.Fatal(err)

20
libcontainer/cgroups/fs/cpu.go
View File

@@ -35,28 +35,28 @@ func (s *CpuGroup) Apply(d *cgroupData) error {
} }
func (s *CpuGroup) Set(path string, cgroup *configs.Cgroup) error { func (s *CpuGroup) Set(path string, cgroup *configs.Cgroup) error {
if cgroup.CpuShares != 0 { if cgroup.Resources.CpuShares != 0 {
if err := writeFile(path, "cpu.shares", strconv.FormatInt(cgroup.CpuShares, 10)); err != nil { if err := writeFile(path, "cpu.shares", strconv.FormatInt(cgroup.Resources.CpuShares, 10)); err != nil {
return err return err
} }
} }
if cgroup.CpuPeriod != 0 { if cgroup.Resources.CpuPeriod != 0 {
if err := writeFile(path, "cpu.cfs_period_us", strconv.FormatInt(cgroup.CpuPeriod, 10)); err != nil { if err := writeFile(path, "cpu.cfs_period_us", strconv.FormatInt(cgroup.Resources.CpuPeriod, 10)); err != nil {
return err return err
} }
} }
if cgroup.CpuQuota != 0 { if cgroup.Resources.CpuQuota != 0 {
if err := writeFile(path, "cpu.cfs_quota_us", strconv.FormatInt(cgroup.CpuQuota, 10)); err != nil { if err := writeFile(path, "cpu.cfs_quota_us", strconv.FormatInt(cgroup.Resources.CpuQuota, 10)); err != nil {
return err return err
} }
} }
if cgroup.CpuRtPeriod != 0 { if cgroup.Resources.CpuRtPeriod != 0 {
if err := writeFile(path, "cpu.rt_period_us", strconv.FormatInt(cgroup.CpuRtPeriod, 10)); err != nil { if err := writeFile(path, "cpu.rt_period_us", strconv.FormatInt(cgroup.Resources.CpuRtPeriod, 10)); err != nil {
return err return err
} }
} }
if cgroup.CpuRtRuntime != 0 { if cgroup.Resources.CpuRtRuntime != 0 {
if err := writeFile(path, "cpu.rt_runtime_us", strconv.FormatInt(cgroup.CpuRtRuntime, 10)); err != nil { if err := writeFile(path, "cpu.rt_runtime_us", strconv.FormatInt(cgroup.Resources.CpuRtRuntime, 10)); err != nil {
return err return err
} }
} }

10
libcontainer/cgroups/fs/cpu_test.go
View File

@@ -23,7 +23,7 @@ func TestCpuSetShares(t *testing.T) {
"cpu.shares": strconv.Itoa(sharesBefore), "cpu.shares": strconv.Itoa(sharesBefore),
}) })
helper.CgroupData.config.CpuShares = sharesAfter helper.CgroupData.config.Resources.CpuShares = sharesAfter
cpu := &CpuGroup{} cpu := &CpuGroup{}
if err := cpu.Set(helper.CgroupPath, helper.CgroupData.config); err != nil { if err := cpu.Set(helper.CgroupPath, helper.CgroupData.config); err != nil {
t.Fatal(err) t.Fatal(err)
@@ -61,10 +61,10 @@ func TestCpuSetBandWidth(t *testing.T) {
"cpu.rt_period_us": strconv.Itoa(rtPeriodBefore), "cpu.rt_period_us": strconv.Itoa(rtPeriodBefore),
}) })
helper.CgroupData.config.CpuQuota = quotaAfter helper.CgroupData.config.Resources.CpuQuota = quotaAfter
helper.CgroupData.config.CpuPeriod = periodAfter helper.CgroupData.config.Resources.CpuPeriod = periodAfter
helper.CgroupData.config.CpuRtRuntime = rtRuntimeAfter helper.CgroupData.config.Resources.CpuRtRuntime = rtRuntimeAfter
helper.CgroupData.config.CpuRtPeriod = rtPeriodAfter helper.CgroupData.config.Resources.CpuRtPeriod = rtPeriodAfter
cpu := &CpuGroup{} cpu := &CpuGroup{}
if err := cpu.Set(helper.CgroupPath, helper.CgroupData.config); err != nil { if err := cpu.Set(helper.CgroupPath, helper.CgroupData.config); err != nil {
t.Fatal(err) t.Fatal(err)

8
libcontainer/cgroups/fs/cpuset.go
View File

@@ -29,13 +29,13 @@ func (s *CpusetGroup) Apply(d *cgroupData) error {
} }
func (s *CpusetGroup) Set(path string, cgroup *configs.Cgroup) error { func (s *CpusetGroup) Set(path string, cgroup *configs.Cgroup) error {
if cgroup.CpusetCpus != "" { if cgroup.Resources.CpusetCpus != "" {
if err := writeFile(path, "cpuset.cpus", cgroup.CpusetCpus); err != nil { if err := writeFile(path, "cpuset.cpus", cgroup.Resources.CpusetCpus); err != nil {
return err return err
} }
} }
if cgroup.CpusetMems != "" { if cgroup.Resources.CpusetMems != "" {
if err := writeFile(path, "cpuset.mems", cgroup.CpusetMems); err != nil { if err := writeFile(path, "cpuset.mems", cgroup.Resources.CpusetMems); err != nil {
return err return err
} }
} }

4
libcontainer/cgroups/fs/cpuset_test.go
View File

@@ -19,7 +19,7 @@ func TestCpusetSetCpus(t *testing.T) {
"cpuset.cpus": cpusBefore, "cpuset.cpus": cpusBefore,
}) })
helper.CgroupData.config.CpusetCpus = cpusAfter helper.CgroupData.config.Resources.CpusetCpus = cpusAfter
cpuset := &CpusetGroup{} cpuset := &CpusetGroup{}
if err := cpuset.Set(helper.CgroupPath, helper.CgroupData.config); err != nil { if err := cpuset.Set(helper.CgroupPath, helper.CgroupData.config); err != nil {
t.Fatal(err) t.Fatal(err)
@@ -48,7 +48,7 @@ func TestCpusetSetMems(t *testing.T) {
"cpuset.mems": memsBefore, "cpuset.mems": memsBefore,
}) })
helper.CgroupData.config.CpusetMems = memsAfter helper.CgroupData.config.Resources.CpusetMems = memsAfter
cpuset := &CpusetGroup{} cpuset := &CpusetGroup{}
if err := cpuset.Set(helper.CgroupPath, helper.CgroupData.config); err != nil { if err := cpuset.Set(helper.CgroupPath, helper.CgroupData.config); err != nil {
t.Fatal(err) t.Fatal(err)

6
libcontainer/cgroups/fs/devices.go
View File

@@ -30,12 +30,12 @@ func (s *DevicesGroup) Apply(d *cgroupData) error {
} }
func (s *DevicesGroup) Set(path string, cgroup *configs.Cgroup) error { func (s *DevicesGroup) Set(path string, cgroup *configs.Cgroup) error {
if !cgroup.AllowAllDevices { if !cgroup.Resources.AllowAllDevices {
if err := writeFile(path, "devices.deny", "a"); err != nil { if err := writeFile(path, "devices.deny", "a"); err != nil {
return err return err
} }
for _, dev := range cgroup.AllowedDevices { for _, dev := range cgroup.Resources.AllowedDevices {
if err := writeFile(path, "devices.allow", dev.CgroupString()); err != nil { if err := writeFile(path, "devices.allow", dev.CgroupString()); err != nil {
return err return err
} }
@@ -47,7 +47,7 @@ func (s *DevicesGroup) Set(path string, cgroup *configs.Cgroup) error {
return err return err
} }
for _, dev := range cgroup.DeniedDevices { for _, dev := range cgroup.Resources.DeniedDevices {
if err := writeFile(path, "devices.deny", dev.CgroupString()); err != nil { if err := writeFile(path, "devices.deny", dev.CgroupString()); err != nil {
return err return err
} }

8
libcontainer/cgroups/fs/devices_test.go
View File

@@ -41,8 +41,8 @@ func TestDevicesSetAllow(t *testing.T) {
"devices.deny": "a", "devices.deny": "a",
}) })
helper.CgroupData.config.AllowAllDevices = false helper.CgroupData.config.Resources.AllowAllDevices = false
helper.CgroupData.config.AllowedDevices = allowedDevices helper.CgroupData.config.Resources.AllowedDevices = allowedDevices
devices := &DevicesGroup{} devices := &DevicesGroup{}
if err := devices.Set(helper.CgroupPath, helper.CgroupData.config); err != nil { if err := devices.Set(helper.CgroupPath, helper.CgroupData.config); err != nil {
t.Fatal(err) t.Fatal(err)
@@ -66,8 +66,8 @@ func TestDevicesSetDeny(t *testing.T) {
"devices.allow": "a", "devices.allow": "a",
}) })
helper.CgroupData.config.AllowAllDevices = true helper.CgroupData.config.Resources.AllowAllDevices = true
helper.CgroupData.config.DeniedDevices = deniedDevices helper.CgroupData.config.Resources.DeniedDevices = deniedDevices
devices := &DevicesGroup{} devices := &DevicesGroup{}
if err := devices.Set(helper.CgroupPath, helper.CgroupData.config); err != nil { if err := devices.Set(helper.CgroupPath, helper.CgroupData.config); err != nil {
t.Fatal(err) t.Fatal(err)

8
libcontainer/cgroups/fs/freezer.go
View File

@@ -32,9 +32,9 @@ func (s *FreezerGroup) Apply(d *cgroupData) error {
} }
func (s *FreezerGroup) Set(path string, cgroup *configs.Cgroup) error { func (s *FreezerGroup) Set(path string, cgroup *configs.Cgroup) error {
switch cgroup.Freezer { switch cgroup.Resources.Freezer {
case configs.Frozen, configs.Thawed: case configs.Frozen, configs.Thawed:
if err := writeFile(path, "freezer.state", string(cgroup.Freezer)); err != nil { if err := writeFile(path, "freezer.state", string(cgroup.Resources.Freezer)); err != nil {
return err return err
} }
@@ -43,7 +43,7 @@ func (s *FreezerGroup) Set(path string, cgroup *configs.Cgroup) error {
if err != nil { if err != nil {
return err return err
} }
if strings.TrimSpace(state) == string(cgroup.Freezer) { if strings.TrimSpace(state) == string(cgroup.Resources.Freezer) {
break break
} }
time.Sleep(1 * time.Millisecond) time.Sleep(1 * time.Millisecond)
@@ -51,7 +51,7 @@ func (s *FreezerGroup) Set(path string, cgroup *configs.Cgroup) error {
case configs.Undefined: case configs.Undefined:
return nil return nil
default: default:
return fmt.Errorf("Invalid argument '%s' to freezer.state", string(cgroup.Freezer)) return fmt.Errorf("Invalid argument '%s' to freezer.state", string(cgroup.Resources.Freezer))
} }
return nil return nil

4
libcontainer/cgroups/fs/freezer_test.go
View File

@@ -16,7 +16,7 @@ func TestFreezerSetState(t *testing.T) {
"freezer.state": string(configs.Frozen), "freezer.state": string(configs.Frozen),
}) })
helper.CgroupData.config.Freezer = configs.Thawed helper.CgroupData.config.Resources.Freezer = configs.Thawed
freezer := &FreezerGroup{} freezer := &FreezerGroup{}
if err := freezer.Set(helper.CgroupPath, helper.CgroupData.config); err != nil { if err := freezer.Set(helper.CgroupPath, helper.CgroupData.config); err != nil {
t.Fatal(err) t.Fatal(err)
@@ -39,7 +39,7 @@ func TestFreezerSetInvalidState(t *testing.T) {
invalidArg configs.FreezerState = "Invalid" invalidArg configs.FreezerState = "Invalid"
) )
helper.CgroupData.config.Freezer = invalidArg helper.CgroupData.config.Resources.Freezer = invalidArg
freezer := &FreezerGroup{} freezer := &FreezerGroup{}
if err := freezer.Set(helper.CgroupPath, helper.CgroupData.config); err == nil { if err := freezer.Set(helper.CgroupPath, helper.CgroupData.config); err == nil {
t.Fatal("Failed to return invalid argument error") t.Fatal("Failed to return invalid argument error")

2
libcontainer/cgroups/fs/hugetlb.go
View File

@@ -32,7 +32,7 @@ func (s *HugetlbGroup) Apply(d *cgroupData) error {
} }
func (s *HugetlbGroup) Set(path string, cgroup *configs.Cgroup) error { func (s *HugetlbGroup) Set(path string, cgroup *configs.Cgroup) error {
for _, hugetlb := range cgroup.HugetlbLimit { for _, hugetlb := range cgroup.Resources.HugetlbLimit {
if err := writeFile(path, strings.Join([]string{"hugetlb", hugetlb.Pagesize, "limit_in_bytes"}, "."), strconv.FormatUint(hugetlb.Limit, 10)); err != nil { if err := writeFile(path, strings.Join([]string{"hugetlb", hugetlb.Pagesize, "limit_in_bytes"}, "."), strconv.FormatUint(hugetlb.Limit, 10)); err != nil {
return err return err
} }

2
libcontainer/cgroups/fs/hugetlb_test.go
View File

@@ -40,7 +40,7 @@ func TestHugetlbSetHugetlb(t *testing.T) {
} }
for _, pageSize := range HugePageSizes { for _, pageSize := range HugePageSizes {
helper.CgroupData.config.HugetlbLimit = []*configs.HugepageLimit{ helper.CgroupData.config.Resources.HugetlbLimit = []*configs.HugepageLimit{
{ {
Pagesize: pageSize, Pagesize: pageSize,
Limit: hugetlbAfter, Limit: hugetlbAfter,

38
libcontainer/cgroups/fs/memory.go
View File

@@ -55,40 +55,40 @@ func (s *MemoryGroup) Apply(d *cgroupData) (err error) {
} }
func (s *MemoryGroup) Set(path string, cgroup *configs.Cgroup) error { func (s *MemoryGroup) Set(path string, cgroup *configs.Cgroup) error {
if cgroup.Memory != 0 { if cgroup.Resources.Memory != 0 {
if err := writeFile(path, "memory.limit_in_bytes", strconv.FormatInt(cgroup.Memory, 10)); err != nil { if err := writeFile(path, "memory.limit_in_bytes", strconv.FormatInt(cgroup.Resources.Memory, 10)); err != nil {
return err return err
} }
} }
if cgroup.MemoryReservation != 0 { if cgroup.Resources.MemoryReservation != 0 {
if err := writeFile(path, "memory.soft_limit_in_bytes", strconv.FormatInt(cgroup.MemoryReservation, 10)); err != nil { if err := writeFile(path, "memory.soft_limit_in_bytes", strconv.FormatInt(cgroup.Resources.MemoryReservation, 10)); err != nil {
return err return err
} }
} }
if cgroup.MemorySwap > 0 { if cgroup.Resources.MemorySwap > 0 {
if err := writeFile(path, "memory.memsw.limit_in_bytes", strconv.FormatInt(cgroup.MemorySwap, 10)); err != nil { if err := writeFile(path, "memory.memsw.limit_in_bytes", strconv.FormatInt(cgroup.Resources.MemorySwap, 10)); err != nil {
return err return err
} }
} }
if cgroup.KernelMemory > 0 { if cgroup.Resources.KernelMemory > 0 {
if err := writeFile(path, "memory.kmem.limit_in_bytes", strconv.FormatInt(cgroup.KernelMemory, 10)); err != nil { if err := writeFile(path, "memory.kmem.limit_in_bytes", strconv.FormatInt(cgroup.Resources.KernelMemory, 10)); err != nil {
return err return err
} }
} }
if cgroup.OomKillDisable { if cgroup.Resources.OomKillDisable {
if err := writeFile(path, "memory.oom_control", "1"); err != nil { if err := writeFile(path, "memory.oom_control", "1"); err != nil {
return err return err
} }
} }
if cgroup.MemorySwappiness >= 0 && cgroup.MemorySwappiness <= 100 { if cgroup.Resources.MemorySwappiness >= 0 && cgroup.Resources.MemorySwappiness <= 100 {
if err := writeFile(path, "memory.swappiness", strconv.FormatInt(cgroup.MemorySwappiness, 10)); err != nil { if err := writeFile(path, "memory.swappiness", strconv.FormatInt(cgroup.Resources.MemorySwappiness, 10)); err != nil {
return err return err
} }
} else if cgroup.MemorySwappiness == -1 { } else if cgroup.Resources.MemorySwappiness == -1 {
return nil return nil
} else { } else {
return fmt.Errorf("invalid value:%d. valid memory swappiness range is 0-100", cgroup.MemorySwappiness) return fmt.Errorf("invalid value:%d. valid memory swappiness range is 0-100", cgroup.Resources.MemorySwappiness)
} }
return nil return nil
@@ -139,12 +139,12 @@ func (s *MemoryGroup) GetStats(path string, stats *cgroups.Stats) error {
} }
func memoryAssigned(cgroup *configs.Cgroup) bool { func memoryAssigned(cgroup *configs.Cgroup) bool {
return cgroup.Memory != 0 || return cgroup.Resources.Memory != 0 ||
cgroup.MemoryReservation != 0 || cgroup.Resources.MemoryReservation != 0 ||
cgroup.MemorySwap > 0 || cgroup.Resources.MemorySwap > 0 ||
cgroup.KernelMemory > 0 || cgroup.Resources.KernelMemory > 0 ||
cgroup.OomKillDisable || cgroup.Resources.OomKillDisable ||
cgroup.MemorySwappiness != -1 cgroup.Resources.MemorySwappiness != -1
} }
func getMemoryData(path, name string) (cgroups.MemoryData, error) { func getMemoryData(path, name string) (cgroups.MemoryData, error) {

10
libcontainer/cgroups/fs/memory_test.go
View File

@@ -33,8 +33,8 @@ func TestMemorySetMemory(t *testing.T) {
"memory.soft_limit_in_bytes": strconv.Itoa(reservationBefore), "memory.soft_limit_in_bytes": strconv.Itoa(reservationBefore),
}) })
helper.CgroupData.config.Memory = memoryAfter helper.CgroupData.config.Resources.Memory = memoryAfter
helper.CgroupData.config.MemoryReservation = reservationAfter helper.CgroupData.config.Resources.MemoryReservation = reservationAfter
memory := &MemoryGroup{} memory := &MemoryGroup{}
if err := memory.Set(helper.CgroupPath, helper.CgroupData.config); err != nil { if err := memory.Set(helper.CgroupPath, helper.CgroupData.config); err != nil {
t.Fatal(err) t.Fatal(err)
@@ -70,7 +70,7 @@ func TestMemorySetMemoryswap(t *testing.T) {
"memory.memsw.limit_in_bytes": strconv.Itoa(memoryswapBefore), "memory.memsw.limit_in_bytes": strconv.Itoa(memoryswapBefore),
}) })
helper.CgroupData.config.MemorySwap = memoryswapAfter helper.CgroupData.config.Resources.MemorySwap = memoryswapAfter
memory := &MemoryGroup{} memory := &MemoryGroup{}
if err := memory.Set(helper.CgroupPath, helper.CgroupData.config); err != nil { if err := memory.Set(helper.CgroupPath, helper.CgroupData.config); err != nil {
t.Fatal(err) t.Fatal(err)
@@ -98,7 +98,7 @@ func TestMemorySetKernelMemory(t *testing.T) {
"memory.kmem.limit_in_bytes": strconv.Itoa(kernelMemoryBefore), "memory.kmem.limit_in_bytes": strconv.Itoa(kernelMemoryBefore),
}) })
helper.CgroupData.config.KernelMemory = kernelMemoryAfter helper.CgroupData.config.Resources.KernelMemory = kernelMemoryAfter
memory := &MemoryGroup{} memory := &MemoryGroup{}
if err := memory.Set(helper.CgroupPath, helper.CgroupData.config); err != nil { if err := memory.Set(helper.CgroupPath, helper.CgroupData.config); err != nil {
t.Fatal(err) t.Fatal(err)
@@ -126,7 +126,7 @@ func TestMemorySetMemorySwappinessDefault(t *testing.T) {
"memory.swappiness": strconv.Itoa(swappinessBefore), "memory.swappiness": strconv.Itoa(swappinessBefore),
}) })
helper.CgroupData.config.Memory = swappinessAfter helper.CgroupData.config.Resources.Memory = swappinessAfter
memory := &MemoryGroup{} memory := &MemoryGroup{}
if err := memory.Set(helper.CgroupPath, helper.CgroupData.config); err != nil { if err := memory.Set(helper.CgroupPath, helper.CgroupData.config); err != nil {
t.Fatal(err) t.Fatal(err)

4
libcontainer/cgroups/fs/net_cls.go
View File

@@ -28,8 +28,8 @@ func (s *NetClsGroup) Apply(d *cgroupData) error {
} }
func (s *NetClsGroup) Set(path string, cgroup *configs.Cgroup) error { func (s *NetClsGroup) Set(path string, cgroup *configs.Cgroup) error {
if cgroup.NetClsClassid != "" { if cgroup.Resources.NetClsClassid != "" {
if err := writeFile(path, "net_cls.classid", cgroup.NetClsClassid); err != nil { if err := writeFile(path, "net_cls.classid", cgroup.Resources.NetClsClassid); err != nil {
return err return err
} }
} }

2
libcontainer/cgroups/fs/net_cls_test.go
View File

@@ -19,7 +19,7 @@ func TestNetClsSetClassid(t *testing.T) {
"net_cls.classid": classidBefore, "net_cls.classid": classidBefore,
}) })
helper.CgroupData.config.NetClsClassid = classidAfter helper.CgroupData.config.Resources.NetClsClassid = classidAfter
netcls := &NetClsGroup{} netcls := &NetClsGroup{}
if err := netcls.Set(helper.CgroupPath, helper.CgroupData.config); err != nil { if err := netcls.Set(helper.CgroupPath, helper.CgroupData.config); err != nil {
t.Fatal(err) t.Fatal(err)

2
libcontainer/cgroups/fs/net_prio.go
View File

@@ -28,7 +28,7 @@ func (s *NetPrioGroup) Apply(d *cgroupData) error {
} }
func (s *NetPrioGroup) Set(path string, cgroup *configs.Cgroup) error { func (s *NetPrioGroup) Set(path string, cgroup *configs.Cgroup) error {
for _, prioMap := range cgroup.NetPrioIfpriomap { for _, prioMap := range cgroup.Resources.NetPrioIfpriomap {
if err := writeFile(path, "net_prio.ifpriomap", prioMap.CgroupString()); err != nil { if err := writeFile(path, "net_prio.ifpriomap", prioMap.CgroupString()); err != nil {
return err return err
} }

2
libcontainer/cgroups/fs/net_prio_test.go
View File

@@ -22,7 +22,7 @@ func TestNetPrioSetIfPrio(t *testing.T) {
helper := NewCgroupTestUtil("net_prio", t) helper := NewCgroupTestUtil("net_prio", t)
defer helper.cleanup() defer helper.cleanup()
helper.CgroupData.config.NetPrioIfpriomap = prioMap helper.CgroupData.config.Resources.NetPrioIfpriomap = prioMap
netPrio := &NetPrioGroup{} netPrio := &NetPrioGroup{}
if err := netPrio.Set(helper.CgroupPath, helper.CgroupData.config); err != nil { if err := netPrio.Set(helper.CgroupPath, helper.CgroupData.config); err != nil {
t.Fatal(err) t.Fatal(err)

1
libcontainer/cgroups/fs/util_test.go
View File

@@ -33,6 +33,7 @@ func NewCgroupTestUtil(subsystem string, t *testing.T) *cgroupTestUtil {
d := &cgroupData{ d := &cgroupData{
config: &configs.Cgroup{}, config: &configs.Cgroup{},
} }
d.config.Resources = &configs.Resources{}
tempDir, err := ioutil.TempDir("", "cgroup_test") tempDir, err := ioutil.TempDir("", "cgroup_test")
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)

74
libcontainer/cgroups/systemd/apply_systemd.go
View File

@@ -189,26 +189,26 @@ func (m *Manager) Apply(pid int) error {
newProp("DefaultDependencies", false)) newProp("DefaultDependencies", false))
} }
if c.Memory != 0 { if c.Resources.Memory != 0 {
properties = append(properties, properties = append(properties,
newProp("MemoryLimit", uint64(c.Memory))) newProp("MemoryLimit", uint64(c.Resources.Memory)))
} }
if c.CpuShares != 0 { if c.Resources.CpuShares != 0 {
properties = append(properties, properties = append(properties,
newProp("CPUShares", uint64(c.CpuShares))) newProp("CPUShares", uint64(c.Resources.CpuShares)))
} }
if c.BlkioWeight != 0 { if c.Resources.BlkioWeight != 0 {
properties = append(properties, properties = append(properties,
newProp("BlockIOWeight", uint64(c.BlkioWeight))) newProp("BlockIOWeight", uint64(c.Resources.BlkioWeight)))
} }
// We need to set kernel memory before processes join cgroup because // We need to set kernel memory before processes join cgroup because
// kmem.limit_in_bytes can only be set when the cgroup is empty. // kmem.limit_in_bytes can only be set when the cgroup is empty.
// And swap memory limit needs to be set after memory limit, only // And swap memory limit needs to be set after memory limit, only
// memory limit is handled by systemd, so it's kind of ugly here. // memory limit is handled by systemd, so it's kind of ugly here.
if c.KernelMemory > 0 { if c.Resources.KernelMemory > 0 {
if err := setKernelMemory(c); err != nil { if err := setKernelMemory(c); err != nil {
return err return err
} }
@@ -279,7 +279,7 @@ func (m *Manager) Apply(pid int) error {
m.Paths = paths m.Paths = paths
if paths["cpu"] != "" { if paths["cpu"] != "" {
if err := fs.CheckCpushares(paths["cpu"], c.CpuShares); err != nil { if err := fs.CheckCpushares(paths["cpu"], c.Resources.CpuShares); err != nil {
return err return err
} }
} }
@@ -334,23 +334,23 @@ func joinCpu(c *configs.Cgroup, pid int) error {
if err != nil && !cgroups.IsNotFound(err) { if err != nil && !cgroups.IsNotFound(err) {
return err return err
} }
if c.CpuQuota != 0 { if c.Resources.CpuQuota != 0 {
if err = writeFile(path, "cpu.cfs_quota_us", strconv.FormatInt(c.CpuQuota, 10)); err != nil { if err = writeFile(path, "cpu.cfs_quota_us", strconv.FormatInt(c.Resources.CpuQuota, 10)); err != nil {
return err return err
} }
} }
if c.CpuPeriod != 0 { if c.Resources.CpuPeriod != 0 {
if err = writeFile(path, "cpu.cfs_period_us", strconv.FormatInt(c.CpuPeriod, 10)); err != nil { if err = writeFile(path, "cpu.cfs_period_us", strconv.FormatInt(c.Resources.CpuPeriod, 10)); err != nil {
return err return err
} }
} }
if c.CpuRtPeriod != 0 { if c.Resources.CpuRtPeriod != 0 {
if err = writeFile(path, "cpu.rt_period_us", strconv.FormatInt(c.CpuRtPeriod, 10)); err != nil { if err = writeFile(path, "cpu.rt_period_us", strconv.FormatInt(c.Resources.CpuRtPeriod, 10)); err != nil {
return err return err
} }
} }
if c.CpuRtRuntime != 0 { if c.Resources.CpuRtRuntime != 0 {
if err = writeFile(path, "cpu.rt_runtime_us", strconv.FormatInt(c.CpuRtRuntime, 10)); err != nil { if err = writeFile(path, "cpu.rt_runtime_us", strconv.FormatInt(c.Resources.CpuRtRuntime, 10)); err != nil {
return err return err
} }
} }
@@ -418,15 +418,15 @@ func (m *Manager) Freeze(state configs.FreezerState) error {
if err != nil { if err != nil {
return err return err
} }
prevState := m.Cgroups.Freezer prevState := m.Cgroups.Resources.Freezer
m.Cgroups.Freezer = state m.Cgroups.Resources.Freezer = state
freezer, err := subsystems.Get("freezer") freezer, err := subsystems.Get("freezer")
if err != nil { if err != nil {
return err return err
} }
err = freezer.Set(path, m.Cgroups) err = freezer.Set(path, m.Cgroups)
if err != nil { if err != nil {
m.Cgroups.Freezer = prevState m.Cgroups.Resources.Freezer = prevState
return err return err
} }
return nil return nil
@@ -510,8 +510,8 @@ func setKernelMemory(c *configs.Cgroup) error {
return err return err
} }
if c.KernelMemory > 0 { if c.Resources.KernelMemory > 0 {
err = writeFile(path, "memory.kmem.limit_in_bytes", strconv.FormatInt(c.KernelMemory, 10)) err = writeFile(path, "memory.kmem.limit_in_bytes", strconv.FormatInt(c.Resources.KernelMemory, 10))
if err != nil { if err != nil {
return err return err
} }
@@ -527,33 +527,33 @@ func joinMemory(c *configs.Cgroup, pid int) error {
} }
// -1 disables memoryswap // -1 disables memoryswap
if c.MemorySwap > 0 { if c.Resources.MemorySwap > 0 {
err = writeFile(path, "memory.memsw.limit_in_bytes", strconv.FormatInt(c.MemorySwap, 10)) err = writeFile(path, "memory.memsw.limit_in_bytes", strconv.FormatInt(c.Resources.MemorySwap, 10))
if err != nil { if err != nil {
return err return err
} }
} }
if c.MemoryReservation > 0 { if c.Resources.MemoryReservation > 0 {
err = writeFile(path, "memory.soft_limit_in_bytes", strconv.FormatInt(c.MemoryReservation, 10)) err = writeFile(path, "memory.soft_limit_in_bytes", strconv.FormatInt(c.Resources.MemoryReservation, 10))
if err != nil { if err != nil {
return err return err
} }
} }
if c.OomKillDisable { if c.Resources.OomKillDisable {
if err := writeFile(path, "memory.oom_control", "1"); err != nil { if err := writeFile(path, "memory.oom_control", "1"); err != nil {
return err return err
} }
} }
if c.MemorySwappiness >= 0 && c.MemorySwappiness <= 100 { if c.Resources.MemorySwappiness >= 0 && c.Resources.MemorySwappiness <= 100 {
err = writeFile(path, "memory.swappiness", strconv.FormatInt(c.MemorySwappiness, 10)) err = writeFile(path, "memory.swappiness", strconv.FormatInt(c.Resources.MemorySwappiness, 10))
if err != nil { if err != nil {
return err return err
} }
} else if c.MemorySwappiness == -1 { } else if c.Resources.MemorySwappiness == -1 {
return nil return nil
} else { } else {
return fmt.Errorf("invalid value:%d. valid memory swappiness range is 0-100", c.MemorySwappiness) return fmt.Errorf("invalid value:%d. valid memory swappiness range is 0-100", c.Resources.MemorySwappiness)
} }
return nil return nil
@@ -582,12 +582,12 @@ func joinBlkio(c *configs.Cgroup, pid int) error {
return err return err
} }
// systemd doesn't directly support this in the dbus properties // systemd doesn't directly support this in the dbus properties
if c.BlkioLeafWeight != 0 { if c.Resources.BlkioLeafWeight != 0 {
if err := writeFile(path, "blkio.leaf_weight", strconv.FormatUint(uint64(c.BlkioLeafWeight), 10)); err != nil { if err := writeFile(path, "blkio.leaf_weight", strconv.FormatUint(uint64(c.Resources.BlkioLeafWeight), 10)); err != nil {
return err return err
} }
} }
for _, wd := range c.BlkioWeightDevice { for _, wd := range c.Resources.BlkioWeightDevice {
if err := writeFile(path, "blkio.weight_device", wd.WeightString()); err != nil { if err := writeFile(path, "blkio.weight_device", wd.WeightString()); err != nil {
return err return err
} }
@@ -595,22 +595,22 @@ func joinBlkio(c *configs.Cgroup, pid int) error {
return err return err
} }
} }
for _, td := range c.BlkioThrottleReadBpsDevice { for _, td := range c.Resources.BlkioThrottleReadBpsDevice {
if err := writeFile(path, "blkio.throttle.read_bps_device", td.String()); err != nil { if err := writeFile(path, "blkio.throttle.read_bps_device", td.String()); err != nil {
return err return err
} }
} }
for _, td := range c.BlkioThrottleWriteBpsDevice { for _, td := range c.Resources.BlkioThrottleWriteBpsDevice {
if err := writeFile(path, "blkio.throttle.write_bps_device", td.String()); err != nil { if err := writeFile(path, "blkio.throttle.write_bps_device", td.String()); err != nil {
return err return err
} }
} }
for _, td := range c.BlkioThrottleReadIOPSDevice { for _, td := range c.Resources.BlkioThrottleReadIOPSDevice {
if err := writeFile(path, "blkio.throttle.read_iops_device", td.String()); err != nil { if err := writeFile(path, "blkio.throttle.read_iops_device", td.String()); err != nil {
return err return err
} }
} }
for _, td := range c.BlkioThrottleWriteIOPSDevice { for _, td := range c.Resources.BlkioThrottleWriteIOPSDevice {
if err := writeFile(path, "blkio.throttle.write_iops_device", td.String()); err != nil { if err := writeFile(path, "blkio.throttle.write_iops_device", td.String()); err != nil {
return err return err
} }

11
libcontainer/configs/cgroup_unix.go
View File

@@ -16,6 +16,14 @@ type Cgroup struct {
// name of parent cgroup or slice // name of parent cgroup or slice
Parent string `json:"parent"` Parent string `json:"parent"`
// ScopePrefix decribes prefix for the scope name
ScopePrefix string `json:"scope_prefix"`
// Resources contains various cgroups settings to apply
Resources *Resources `json:"resources"`
}
type Resources struct {
// If this is true allow access to any kind of device within the container. If false, allow access only to devices explicitly listed in the allowed_devices list. // If this is true allow access to any kind of device within the container. If false, allow access only to devices explicitly listed in the allowed_devices list.
AllowAllDevices bool `json:"allow_all_devices"` AllowAllDevices bool `json:"allow_all_devices"`
@@ -83,9 +91,6 @@ type Cgroup struct {
// Hugetlb limit (in bytes) // Hugetlb limit (in bytes)
HugetlbLimit []*HugepageLimit `json:"hugetlb_limit"` HugetlbLimit []*HugepageLimit `json:"hugetlb_limit"`
// ScopePrefix decribes prefix for the scope name
ScopePrefix string `json:"scope_prefix"`
// Whether to disable OOM Killer // Whether to disable OOM Killer
OomKillDisable bool `json:"oom_kill_disable"` OomKillDisable bool `json:"oom_kill_disable"`

2
libcontainer/container_linux.go
View File

@@ -985,7 +985,7 @@ func (c *linuxContainer) currentStatus() (Status, error) {
} }
return 0, newSystemError(err) return 0, newSystemError(err)
} }
if c.config.Cgroups != nil && c.config.Cgroups.Freezer == configs.Frozen { if c.config.Cgroups != nil && c.config.Cgroups.Resources != nil && c.config.Cgroups.Resources.Freezer == configs.Frozen {
return Paused, nil return Paused, nil
} }
return Running, nil return Running, nil

4
libcontainer/integration/exec_test.go
View File

@@ -517,7 +517,7 @@ func testCpuShares(t *testing.T, systemd bool) {
if systemd { if systemd {
config.Cgroups.Parent = "system.slice" config.Cgroups.Parent = "system.slice"
} }
config.Cgroups.CpuShares = 1 config.Cgroups.Resources.CpuShares = 1
_, _, err = runContainer(config, "", "ps") _, _, err = runContainer(config, "", "ps")
if err == nil { if err == nil {
@@ -548,7 +548,7 @@ func testRunWithKernelMemory(t *testing.T, systemd bool) {
if systemd { if systemd {
config.Cgroups.Parent = "system.slice" config.Cgroups.Parent = "system.slice"
} }
config.Cgroups.KernelMemory = 52428800 config.Cgroups.Resources.KernelMemory = 52428800
_, _, err = runContainer(config, "", "ps") _, _, err = runContainer(config, "", "ps")
if err != nil { if err != nil {

12
libcontainer/integration/template_test.go
View File

@@ -46,11 +46,13 @@ func newTemplateConfig(rootfs string) *configs.Config {
{Type: configs.NEWNET}, {Type: configs.NEWNET},
}), }),
Cgroups: &configs.Cgroup{ Cgroups: &configs.Cgroup{
Name: "test", Name: "test",
Parent: "integration", Parent: "integration",
MemorySwappiness: -1, Resources: &configs.Resources{
AllowAllDevices: false, MemorySwappiness: -1,
AllowedDevices: configs.DefaultAllowedDevices, AllowAllDevices: false,
AllowedDevices: configs.DefaultAllowedDevices,
},
}, },
MaskPaths: []string{ MaskPaths: []string{
"/proc/kcore", "/proc/kcore",

53
spec.go
View File

@@ -438,55 +438,56 @@ func createCgroupConfig(name string, spec *specs.LinuxRuntimeSpec, devices []*co
return nil, err return nil, err
} }
c := &configs.Cgroup{ c := &configs.Cgroup{
Name: name, Name: name,
Parent: myCgroupPath, Parent: myCgroupPath,
AllowedDevices: append(devices, allowedDevices...), Resources: &configs.Resources{},
} }
c.Resources.AllowedDevices = append(devices, allowedDevices...)
r := spec.Linux.Resources r := spec.Linux.Resources
c.Memory = r.Memory.Limit c.Resources.Memory = r.Memory.Limit
c.MemoryReservation = r.Memory.Reservation c.Resources.MemoryReservation = r.Memory.Reservation
c.MemorySwap = r.Memory.Swap c.Resources.MemorySwap = r.Memory.Swap
c.KernelMemory = r.Memory.Kernel c.Resources.KernelMemory = r.Memory.Kernel
c.MemorySwappiness = r.Memory.Swappiness c.Resources.MemorySwappiness = r.Memory.Swappiness
c.CpuShares = r.CPU.Shares c.Resources.CpuShares = r.CPU.Shares
c.CpuQuota = r.CPU.Quota c.Resources.CpuQuota = r.CPU.Quota
c.CpuPeriod = r.CPU.Period c.Resources.CpuPeriod = r.CPU.Period
c.CpuRtRuntime = r.CPU.RealtimeRuntime c.Resources.CpuRtRuntime = r.CPU.RealtimeRuntime
c.CpuRtPeriod = r.CPU.RealtimePeriod c.Resources.CpuRtPeriod = r.CPU.RealtimePeriod
c.CpusetCpus = r.CPU.Cpus c.Resources.CpusetCpus = r.CPU.Cpus
c.CpusetMems = r.CPU.Mems c.Resources.CpusetMems = r.CPU.Mems
c.BlkioWeight = r.BlockIO.Weight c.Resources.BlkioWeight = r.BlockIO.Weight
c.BlkioLeafWeight = r.BlockIO.LeafWeight c.Resources.BlkioLeafWeight = r.BlockIO.LeafWeight
for _, wd := range r.BlockIO.WeightDevice { for _, wd := range r.BlockIO.WeightDevice {
weightDevice := configs.NewWeightDevice(wd.Major, wd.Minor, wd.Weight, wd.LeafWeight) weightDevice := configs.NewWeightDevice(wd.Major, wd.Minor, wd.Weight, wd.LeafWeight)
c.BlkioWeightDevice = append(c.BlkioWeightDevice, weightDevice) c.Resources.BlkioWeightDevice = append(c.Resources.BlkioWeightDevice, weightDevice)
} }
for _, td := range r.BlockIO.ThrottleReadBpsDevice { for _, td := range r.BlockIO.ThrottleReadBpsDevice {
throttleDevice := configs.NewThrottleDevice(td.Major, td.Minor, td.Rate) throttleDevice := configs.NewThrottleDevice(td.Major, td.Minor, td.Rate)
c.BlkioThrottleReadBpsDevice = append(c.BlkioThrottleReadBpsDevice, throttleDevice) c.Resources.BlkioThrottleReadBpsDevice = append(c.Resources.BlkioThrottleReadBpsDevice, throttleDevice)
} }
for _, td := range r.BlockIO.ThrottleWriteBpsDevice { for _, td := range r.BlockIO.ThrottleWriteBpsDevice {
throttleDevice := configs.NewThrottleDevice(td.Major, td.Minor, td.Rate) throttleDevice := configs.NewThrottleDevice(td.Major, td.Minor, td.Rate)
c.BlkioThrottleWriteBpsDevice = append(c.BlkioThrottleWriteBpsDevice, throttleDevice) c.Resources.BlkioThrottleWriteBpsDevice = append(c.Resources.BlkioThrottleWriteBpsDevice, throttleDevice)
} }
for _, td := range r.BlockIO.ThrottleReadIOPSDevice { for _, td := range r.BlockIO.ThrottleReadIOPSDevice {
throttleDevice := configs.NewThrottleDevice(td.Major, td.Minor, td.Rate) throttleDevice := configs.NewThrottleDevice(td.Major, td.Minor, td.Rate)
c.BlkioThrottleReadIOPSDevice = append(c.BlkioThrottleReadIOPSDevice, throttleDevice) c.Resources.BlkioThrottleReadIOPSDevice = append(c.Resources.BlkioThrottleReadIOPSDevice, throttleDevice)
} }
for _, td := range r.BlockIO.ThrottleWriteIOPSDevice { for _, td := range r.BlockIO.ThrottleWriteIOPSDevice {
throttleDevice := configs.NewThrottleDevice(td.Major, td.Minor, td.Rate) throttleDevice := configs.NewThrottleDevice(td.Major, td.Minor, td.Rate)
c.BlkioThrottleWriteIOPSDevice = append(c.BlkioThrottleWriteIOPSDevice, throttleDevice) c.Resources.BlkioThrottleWriteIOPSDevice = append(c.Resources.BlkioThrottleWriteIOPSDevice, throttleDevice)
} }
for _, l := range r.HugepageLimits { for _, l := range r.HugepageLimits {
c.HugetlbLimit = append(c.HugetlbLimit, &configs.HugepageLimit{ c.Resources.HugetlbLimit = append(c.Resources.HugetlbLimit, &configs.HugepageLimit{
Pagesize: l.Pagesize, Pagesize: l.Pagesize,
Limit: l.Limit, Limit: l.Limit,
}) })
} }
c.OomKillDisable = r.DisableOOMKiller c.Resources.OomKillDisable = r.DisableOOMKiller
c.NetClsClassid = r.Network.ClassID c.Resources.NetClsClassid = r.Network.ClassID
for _, m := range r.Network.Priorities { for _, m := range r.Network.Priorities {
c.NetPrioIfpriomap = append(c.NetPrioIfpriomap, &configs.IfPrioMap{ c.Resources.NetPrioIfpriomap = append(c.Resources.NetPrioIfpriomap, &configs.IfPrioMap{
Interface: m.Name, Interface: m.Name,
Priority: m.Priority, Priority: m.Priority,
}) })