Add cgroupV2 CPUQuotaPeriodUSec support

Signed-off-by: Austin Vazquez <[email protected]>

Author: austinvazquez

cgroup2/cpu.go

@@ -24,12 +24,26 @@ import (
 
 type CPUMax string
 
+const (
+	// Default kernel value for cpu quota period is 100000 us (100 ms), same for v1 and v2.
+	// v1: https://www.kernel.org/doc/html/latest/scheduler/sched-bwc.html and
+	// v2: https://www.kernel.org/doc/html/latest/admin-guide/cgroup-v2.html
+	defaultCPUMax          = "max"
+	defaultCPUMaxPeriod    = 100000
+	defaultCPUMaxPeriodStr = "100000"
+)
+
 func NewCPUMax(quota *int64, period *uint64) CPUMax {
-	max := "max"
+	max := defaultCPUMax
 	if quota != nil {
 		max = strconv.FormatInt(*quota, 10)
 	}
-	return CPUMax(strings.Join([]string{max, strconv.FormatUint(*period, 10)}, " "))
+
+	duration := defaultCPUMaxPeriodStr
+	if period != nil {
+		duration = strconv.FormatUint(*period, 10)
+	}
+	return CPUMax(strings.Join([]string{max, duration}, " "))
 }
 
 type CPU struct {
@@ -39,19 +53,34 @@ type CPU struct {
 	Mems   string
 }
 
-func (c CPUMax) extractQuotaAndPeriod() (int64, uint64) {
+func (c CPUMax) extractQuotaAndPeriod() (int64, uint64, error) {
 	var (
-		quota  int64
-		period uint64
+		quota  int64  = math.MaxInt64
+		period uint64 = defaultCPUMaxPeriod
+		err    error
 	)
+
+	// value: quota [period]
 	values := strings.Split(string(c), " ")
-	if values[0] == "max" {
-		quota = math.MaxInt64
-	} else {
-		quota, _ = strconv.ParseInt(values[0], 10, 64)
+	if len(values) < 1 || len(values) > 2 {
+		return 0, 0, ErrInvalidFormat
 	}
-	period, _ = strconv.ParseUint(values[1], 10, 64)
-	return quota, period
+
+	if values[0] != defaultCPUMax {
+		quota, err = strconv.ParseInt(values[0], 10, 64)
+		if err != nil {
+			return 0, 0, err
+		}
+	}
+
+	if len(values) == 2 {
+		period, err = strconv.ParseUint(values[1], 10, 64)
+		if err != nil {
+			return 0, 0, err
+		}
+	}
+
+	return quota, period, nil
 }
 
 func (r *CPU) Values() (o []Value) {

cgroup2/cpuv2_test.go

@@ -83,22 +83,64 @@ func TestSystemdCgroupCpuController_NilWeight(t *testing.T) {
 }
 
 func TestExtractQuotaAndPeriod(t *testing.T) {
-	var (
-		period uint64
-		quota  int64
+	const (
+		defaultQuota  int64  = math.MaxInt64
+		defaultPeriod uint64 = 100000
 	)
-	quota = 10000
-	period = 8000
-	cpuMax := NewCPUMax(&quota, &period)
-	tquota, tPeriod := cpuMax.extractQuotaAndPeriod()
-
-	assert.Equal(t, quota, tquota)
-	assert.Equal(t, period, tPeriod)
-
-	// case with nil quota which makes it "max" - max int val
-	cpuMax2 := NewCPUMax(nil, &period)
-	tquota2, tPeriod2 := cpuMax2.extractQuotaAndPeriod()
 
-	assert.Equal(t, int64(math.MaxInt64), tquota2)
-	assert.Equal(t, period, tPeriod2)
+	require.Equal(t, defaultCPUMaxPeriodStr, strconv.Itoa(defaultCPUMaxPeriod), "Constant for default period does not match its string type constant.")
+
+	// Default "max 100000"
+	cpuMax := NewCPUMax(nil, nil)
+	assert.Equal(t, CPUMax("max 100000"), cpuMax)
+	quota, period, err := cpuMax.extractQuotaAndPeriod()
+	assert.NoError(t, err)
+	assert.Equal(t, defaultQuota, quota)
+	assert.Equal(t, defaultPeriod, period)
+
+	// Only specifing limit is valid.
+	cpuMax = CPUMax("max")
+	quota, period, err = cpuMax.extractQuotaAndPeriod()
+	assert.NoError(t, err)
+	assert.Equal(t, defaultQuota, quota)
+	assert.Equal(t, defaultPeriod, period)
+
+	tests := []struct {
+		cpuMax string
+		quota  int64
+		period uint64
+	}{
+		{
+			cpuMax: "0 0",
+			quota:  0,
+			period: 0,
+		},
+		{
+			cpuMax: "10000 8000",
+			quota:  10000,
+			period: 8000,
+		},
+		{
+			cpuMax: "42000 4200",
+			quota:  42000,
+			period: 4200,
+		},
+		{
+			cpuMax: "9223372036854775807 18446744073709551615",
+			quota:  9223372036854775807,
+			period: 18446744073709551615,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.cpuMax, func(t *testing.T) {
+			cpuMax := NewCPUMax(&test.quota, &test.period)
+			assert.Equal(t, CPUMax(test.cpuMax), cpuMax)
+
+			tquota, tPeriod, err := cpuMax.extractQuotaAndPeriod()
+			assert.NoError(t, err)
+			assert.Equal(t, test.quota, tquota)
+			assert.Equal(t, test.period, tPeriod)
+		})
+	}
 }

cgroup2/manager.go

@@ -27,6 +27,7 @@ import (
 	"path/filepath"
 	"strconv"
 	"strings"
+	"sync"
 	"time"
 
 	"github.com/containerd/cgroups/v3/cgroup2/stats"
@@ -47,7 +48,12 @@ const (
 	defaultSlice       = "system.slice"
 )
 
-var canDelegate bool
+var (
+	canDelegate bool
+
+	versionOnce sync.Once
+	version     int
+)
 
 type Event struct {
 	Low     uint64
@@ -875,7 +881,21 @@ func NewSystemd(slice, group string, pid int, resources *Resources) (*Manager, e
 	}
 
 	if resources.CPU != nil && resources.CPU.Max != "" {
-		quota, period := resources.CPU.Max.extractQuotaAndPeriod()
+		quota, period, err := resources.CPU.Max.extractQuotaAndPeriod()
+		if err != nil {
+			return &Manager{}, err
+		}
+
+		if period != 0 {
+			// systemd only supports CPUQuotaPeriodUSec since v242
+			if sdVer := systemdVersion(conn); sdVer >= 242 {
+				properties = append(properties, newSystemdProperty("CPUQuotaPeriodUSec", period))
+			} else {
+				log.G(context.TODO()).Debugf("systemd v%d is too old to support CPUQuotaPeriodSec "+
+					" (setting will still be applied to cgroupfs)", sdVer)
+			}
+		}
+
 		// cpu.cfs_quota_us and cpu.cfs_period_us are controlled by systemd.
 		// corresponds to USEC_INFINITY in systemd
 		// if USEC_INFINITY is provided, CPUQuota is left unbound by systemd
@@ -915,6 +935,41 @@ func NewSystemd(slice, group string, pid int, resources *Resources) (*Manager, e
 	}, nil
 }
 
+// Adapted from https://github.com/opencontainers/cgroups/blob/9657f5a18b8d60a0f39fbb34d0cb7771e28e6278/systemd/common.go#L245-L281
+func systemdVersion(conn *systemdDbus.Conn) int {
+	versionOnce.Do(func() {
+		version = -1
+		verStr, err := conn.GetManagerProperty("Version")
+		if err == nil {
+			version, err = systemdVersionAtoi(verStr)
+		}
+
+		if err != nil {
+			log.G(context.TODO()).WithError(err).Error("Unable to get systemd version")
+		}
+	})
+
+	return version
+}
+
+func systemdVersionAtoi(str string) (int, error) {
+	// Unconditionally remove the leading prefix ("v).
+	str = strings.TrimLeft(str, `"v`)
+	// Match on the first integer we can grab.
+	for i := range len(str) {
+		if str[i] < '0' || str[i] > '9' {
+			// First non-digit: cut the tail.
+			str = str[:i]
+			break
+		}
+	}
+	ver, err := strconv.Atoi(str)
+	if err != nil {
+		return -1, fmt.Errorf("can't parse version: %w", err)
+	}
+	return ver, nil
+}
+
 func startUnit(conn *systemdDbus.Conn, group string, properties []systemdDbus.Property, ignoreExists bool) error {
 	ctx := context.TODO()
 

cgroup2/manager_test.go

@@ -17,13 +17,15 @@
 package cgroup2
 
 import (
+	"context"
 	"fmt"
 	"os"
 	"os/exec"
 	"syscall"
 	"testing"
 	"time"
 
+	systemdDbus "github.com/coreos/go-systemd/v22/dbus"
 	"github.com/opencontainers/runtime-spec/specs-go"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -343,6 +345,83 @@ func TestSystemdCgroupPSIController(t *testing.T) {
 	}
 }
 
+func TestCPUQuotaPeriodUSec(t *testing.T) {
+	checkCgroupMode(t)
+
+	// Create a unique group name using the current process ID
+	group := fmt.Sprintf("testing-cpu-period-%d.scope", os.Getpid())
+
+	tests := []struct {
+		name   string
+		quota  int64
+		period uint64
+	}{
+		{
+			name:  "quota 100000, default period",
+			quota: 100000,
+		},
+		{
+			name:   "quota 10000, period 8000",
+			quota:  10000,
+			period: 8000,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			var (
+				cpuMax         CPUMax
+				expectedCPUMax string
+			)
+			if test.period == 0 {
+				cpuMax = NewCPUMax(&test.quota, nil)
+				expectedCPUMax = fmt.Sprintf("%d", test.quota)
+			} else {
+				cpuMax = NewCPUMax(&test.quota, &test.period)
+				expectedCPUMax = fmt.Sprintf("%d %d", test.quota, test.period)
+			}
+
+			c, err := NewSystemd("", group, os.Getpid(), &Resources{
+				CPU: &CPU{
+					Max: cpuMax,
+				},
+			})
+			require.NoError(t, err, "failed to init new cgroup systemd manager")
+
+			checkFileContent(t, c.path, "cpu.max", expectedCPUMax)
+
+			conn, err := systemdDbus.NewWithContext(context.TODO())
+			require.NoError(t, err, "failed to connect to systemd")
+			defer conn.Close()
+
+			sdVer := systemdVersion(conn)
+			if sdVer >= 242 {
+				unitName := systemdUnitFromPath(c.path)
+				props, err := conn.GetAllPropertiesContext(context.TODO(), unitName)
+				require.NoError(t, err, "failed to get unit properties")
+
+				periodUSec, ok := props["CPUQuotaPeriodUSec"]
+				require.True(t, ok, "CPUQuotaPeriodUSec property not found")
+				require.Equal(t, test.period, periodUSec.(uint64), "CPUQuotaPeriodUSec value doesn't match expected period")
+			} else {
+				t.Logf("Skipping CPUQuotaPeriodUSec test for systemd version %d", sdVer)
+			}
+		})
+	}
+
+	// // Also verify CPUQuotaPerSecUSec is set correctly
+	// quotaPerSecUSec, ok := props["CPUQuotaPerSecUSec"]
+	// require.True(t, ok, "CPUQuotaPerSecUSec property not found")
+
+	// // Calculate expected value: quota*1000000/period
+	// expectedQuotaPerSecUSec := uint64(quota*1000000) / period
+	// // Round up to nearest 10000 if needed
+	// if expectedQuotaPerSecUSec%10000 != 0 {
+	// 	expectedQuotaPerSecUSec = ((expectedQuotaPerSecUSec / 10000) + 1) * 10000
+	// }
+	// require.Equal(t, expectedQuotaPerSecUSec, quotaPerSecUSec.(uint64), "CPUQuotaPerSecUSec value doesn't match expected value")
+}
+
 func BenchmarkStat(b *testing.B) {
 	checkCgroupMode(b)
 	group := "/stat-test-cg"