fix(injector): detect cgroupv1 unlimited sentinel

aymericDD · aymericDD · commit caa219f67f70 · 2026-02-25T18:04:07.000+01:00
On cgroupv1, no memory limit is reported as the sentinel
value 9223372036854771712 instead of "max". Without detection,
this overflows the target byte calculation making the disruption
a silent no-op.

Return a clear error when the sentinel is detected.
Add unit tests covering join failure, cgroupv2 "max",
cgroupv1 unlimited sentinel, and a real limit path.
diff --git a/examples/complete.yaml b/examples/complete.yaml
@@ -103,6 +103,9 @@ spec:
     delayJitter: 5 # add X % (1-100) of delay as jitter to delay (+- X% ms to original delay), defaults to 10%
     bandwidthLimit: 10000 # bandwidth limit in bytes
   cpuPressure: {} # cpu load generator
+  memoryPressure: # memory load generator
+    targetPercent: "50%" # percentage of available memory to consume (e.g. "50%")
+    rampDuration: 10m # optional, duration over which to gradually reach targetPercent
   diskPressure: # disk pressure
     path: /mnt/data # mount point (in the pod) to apply throttle on
     throttling:
diff --git a/examples/memory_pressure.yaml b/examples/memory_pressure.yaml
@@ -0,0 +1,14 @@
+apiVersion: chaos.datadoghq.com/v1beta1
+kind: Disruption
+metadata:
+  name: memory-pressure
+  namespace: chaos-demo
+spec:
+  level: pod
+  selector:
+    service: demo-curl
+  count: 100%
+  duration: 5m
+  memoryPressure:
+    targetPercent: "50%"
+    #rampDuration: 10m
diff --git a/injector/memory_stress.go b/injector/memory_stress.go
@@ -228,7 +228,19 @@ func (m *memoryStressInjector) readMemoryLimit() (int64, error) {
 		return 0, fmt.Errorf("unable to read memory.limit_in_bytes: %w", err)
 	}
 
-	return strconv.ParseInt(strings.TrimSpace(content), 10, 64)
+	limit, err := strconv.ParseInt(strings.TrimSpace(content), 10, 64)
+	if err != nil {
+		return 0, err
+	}
+
+	// cgroupv1 reports PAGE_ALIGN(math.MaxInt64) = 9223372036854771712 when no memory limit is set.
+	// Use a 4 PiB threshold to detect this sentinel: no real workload has that much RAM.
+	const cgroupV1UnlimitedThreshold = int64(4 * 1024 * 1024 * 1024 * 1024 * 1024) // 4 PiB
+	if limit >= cgroupV1UnlimitedThreshold {
+		return 0, fmt.Errorf("memory limit is unlimited (memory.limit_in_bytes=%d), cannot determine target bytes", limit)
+	}
+
+	return limit, nil
 }
 
 func (m *memoryStressInjector) readMemoryUsage() (int64, error) {
diff --git a/injector/memory_stress_test.go b/injector/memory_stress_test.go
@@ -0,0 +1,135 @@
+// Unless explicitly stated otherwise all files in this repository are licensed
+// under the Apache License Version 2.0.
+// This product includes software developed at Datadog (https://www.datadoghq.com/).
+// Copyright 2026 Datadog, Inc.
+
+package injector_test
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/DataDog/chaos-controller/cgroup"
+	. "github.com/DataDog/chaos-controller/injector"
+	"github.com/DataDog/chaos-controller/process"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("Memory stress", func() {
+	var (
+		config  Config
+		inj     Injector
+		cgroups *cgroup.ManagerMock
+		manager *process.ManagerMock
+	)
+
+	const processID = 42
+
+	BeforeEach(func() {
+		cgroups = cgroup.NewManagerMock(GinkgoT())
+		manager = process.NewManagerMock(GinkgoT())
+
+		config = Config{
+			Log:    log,
+			Cgroup: cgroups,
+		}
+	})
+
+	JustBeforeEach(func() {
+		inj = NewMemoryStressInjector(config, 80, time.Duration(0), manager)
+	})
+
+	Describe("Inject", func() {
+		Context("when cgroup Join fails", func() {
+			BeforeEach(func() {
+				cgroups.EXPECT().Join(processID).Return(fmt.Errorf("join error")).Once()
+				manager.EXPECT().ProcessID().Return(processID).Once()
+			})
+
+			It("returns an error", func() {
+				Expect(inj.Inject()).To(MatchError("unable to join cgroup for process '42': join error"))
+			})
+		})
+
+		Describe("cgroupv2", func() {
+			BeforeEach(func() {
+				cgroups.EXPECT().Join(processID).Return(nil).Once()
+				manager.EXPECT().ProcessID().Return(processID).Once()
+				cgroups.EXPECT().IsCgroupV2().Return(true)
+			})
+
+			Context("when memory.max read fails", func() {
+				BeforeEach(func() {
+					cgroups.EXPECT().Read("", "memory.max").Return("", fmt.Errorf("read error")).Once()
+				})
+
+				It("returns an error", func() {
+					Expect(inj.Inject()).To(MatchError(ContainSubstring("unable to read memory limit")))
+				})
+			})
+
+			Context("when memory.max is 'max' (unlimited)", func() {
+				BeforeEach(func() {
+					cgroups.EXPECT().Read("", "memory.max").Return("max", nil).Once()
+				})
+
+				It("returns an error containing 'unlimited'", func() {
+					Expect(inj.Inject()).To(MatchError(ContainSubstring("unlimited")))
+				})
+			})
+		})
+
+		Describe("cgroupv1", func() {
+			BeforeEach(func() {
+				cgroups.EXPECT().Join(processID).Return(nil).Once()
+				manager.EXPECT().ProcessID().Return(processID).Once()
+				cgroups.EXPECT().IsCgroupV2().Return(false)
+			})
+
+			Context("when memory.limit_in_bytes read fails", func() {
+				BeforeEach(func() {
+					cgroups.EXPECT().Read("memory", "memory.limit_in_bytes").Return("", fmt.Errorf("read error")).Once()
+				})
+
+				It("returns an error", func() {
+					Expect(inj.Inject()).To(MatchError(ContainSubstring("unable to read memory limit")))
+				})
+			})
+
+			Context("when memory.limit_in_bytes is the unlimited sentinel (9223372036854771712)", func() {
+				BeforeEach(func() {
+					cgroups.EXPECT().Read("memory", "memory.limit_in_bytes").Return("9223372036854771712", nil).Once()
+				})
+
+				It("returns an error containing 'unlimited'", func() {
+					Expect(inj.Inject()).To(MatchError(ContainSubstring("unlimited")))
+				})
+			})
+
+			Context("when memory.limit_in_bytes is set to a real limit", func() {
+				const memLimit = "536870912" // 512 MiB
+				const memUsage = "104857600" // 100 MiB
+
+				BeforeEach(func() {
+					cgroups.EXPECT().Read("memory", "memory.limit_in_bytes").Return(memLimit, nil).Once()
+					cgroups.EXPECT().IsCgroupV2().Return(false).Maybe()
+					cgroups.EXPECT().Read("memory", "memory.usage_in_bytes").Return(memUsage, nil).Once()
+				})
+
+				It("succeeds and starts allocating memory", func() {
+					Expect(inj.Inject()).To(Succeed())
+
+					// clean up background goroutine
+					Expect(inj.Clean()).To(Succeed())
+				})
+			})
+		})
+	})
+
+	Describe("Clean", func() {
+		It("succeeds when no injection has occurred", func() {
+			Expect(inj.Clean()).To(Succeed())
+		})
+	})
+})
