summaryrefslogtreecommitdiff
path: root/vendor/github.com/containerd/cgroups/v3/cgroup1/memory.go
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/github.com/containerd/cgroups/v3/cgroup1/memory.go')
-rw-r--r--vendor/github.com/containerd/cgroups/v3/cgroup1/memory.go480
1 files changed, 0 insertions, 480 deletions
diff --git a/vendor/github.com/containerd/cgroups/v3/cgroup1/memory.go b/vendor/github.com/containerd/cgroups/v3/cgroup1/memory.go
deleted file mode 100644
index e84ec2b3c..000000000
--- a/vendor/github.com/containerd/cgroups/v3/cgroup1/memory.go
+++ /dev/null
@@ -1,480 +0,0 @@
-/*
- Copyright The containerd Authors.
-
- Licensed under the Apache License, Version 2.0 (the "License");
- you may not use this file except in compliance with the License.
- You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
- Unless required by applicable law or agreed to in writing, software
- distributed under the License is distributed on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- See the License for the specific language governing permissions and
- limitations under the License.
-*/
-
-package cgroup1
-
-import (
- "bufio"
- "fmt"
- "io"
- "os"
- "path/filepath"
- "strconv"
- "strings"
-
- v1 "github.com/containerd/cgroups/v3/cgroup1/stats"
- specs "github.com/opencontainers/runtime-spec/specs-go"
- "golang.org/x/sys/unix"
-)
-
-// MemoryEvent is an interface that V1 memory Cgroup notifications implement. Arg returns the
-// file name whose fd should be written to "cgroups.event_control". EventFile returns the name of
-// the file that supports the notification api e.g. "memory.usage_in_bytes".
-type MemoryEvent interface {
- Arg() string
- EventFile() string
-}
-
-type memoryThresholdEvent struct {
- threshold uint64
- swap bool
-}
-
-// MemoryThresholdEvent returns a new [MemoryEvent] representing the memory threshold set.
-// If swap is true, the event will be registered using memory.memsw.usage_in_bytes
-func MemoryThresholdEvent(threshold uint64, swap bool) MemoryEvent {
- return &memoryThresholdEvent{
- threshold,
- swap,
- }
-}
-
-func (m *memoryThresholdEvent) Arg() string {
- return strconv.FormatUint(m.threshold, 10)
-}
-
-func (m *memoryThresholdEvent) EventFile() string {
- if m.swap {
- return "memory.memsw.usage_in_bytes"
- }
- return "memory.usage_in_bytes"
-}
-
-type oomEvent struct{}
-
-// OOMEvent returns a new oom event to be used with RegisterMemoryEvent.
-func OOMEvent() MemoryEvent {
- return &oomEvent{}
-}
-
-func (oom *oomEvent) Arg() string {
- return ""
-}
-
-func (oom *oomEvent) EventFile() string {
- return "memory.oom_control"
-}
-
-type memoryPressureEvent struct {
- pressureLevel MemoryPressureLevel
- hierarchy EventNotificationMode
-}
-
-// MemoryPressureEvent returns a new [MemoryEvent] representing the memory pressure set.
-func MemoryPressureEvent(pressureLevel MemoryPressureLevel, hierarchy EventNotificationMode) MemoryEvent {
- return &memoryPressureEvent{
- pressureLevel,
- hierarchy,
- }
-}
-
-func (m *memoryPressureEvent) Arg() string {
- return string(m.pressureLevel) + "," + string(m.hierarchy)
-}
-
-func (m *memoryPressureEvent) EventFile() string {
- return "memory.pressure_level"
-}
-
-// MemoryPressureLevel corresponds to the memory pressure levels defined
-// for memory cgroups.
-type MemoryPressureLevel string
-
-// The three memory pressure levels are as follows.
-// - The "low" level means that the system is reclaiming memory for new
-// allocations. Monitoring this reclaiming activity might be useful for
-// maintaining cache level. Upon notification, the program (typically
-// "Activity Manager") might analyze vmstat and act in advance (i.e.
-// prematurely shutdown unimportant services).
-// - The "medium" level means that the system is experiencing medium memory
-// pressure, the system might be making swap, paging out active file caches,
-// etc. Upon this event applications may decide to further analyze
-// vmstat/zoneinfo/memcg or internal memory usage statistics and free any
-// resources that can be easily reconstructed or re-read from a disk.
-// - The "critical" level means that the system is actively thrashing, it is
-// about to out of memory (OOM) or even the in-kernel OOM killer is on its
-// way to trigger. Applications should do whatever they can to help the
-// system. It might be too late to consult with vmstat or any other
-// statistics, so it is advisable to take an immediate action.
-// "https://www.kernel.org/doc/Documentation/cgroup-v1/memory.txt" Section 11
-const (
- LowPressure MemoryPressureLevel = "low"
- MediumPressure MemoryPressureLevel = "medium"
- CriticalPressure MemoryPressureLevel = "critical"
-)
-
-// EventNotificationMode corresponds to the notification modes
-// for the memory cgroups pressure level notifications.
-type EventNotificationMode string
-
-// There are three optional modes that specify different propagation behavior:
-// - "default": this is the default behavior specified above. This mode is the
-// same as omitting the optional mode parameter, preserved by backwards
-// compatibility.
-// - "hierarchy": events always propagate up to the root, similar to the default
-// behavior, except that propagation continues regardless of whether there are
-// event listeners at each level, with the "hierarchy" mode. In the above
-// example, groups A, B, and C will receive notification of memory pressure.
-// - "local": events are pass-through, i.e. they only receive notifications when
-// memory pressure is experienced in the memcg for which the notification is
-// registered. In the above example, group C will receive notification if
-// registered for "local" notification and the group experiences memory
-// pressure. However, group B will never receive notification, regardless if
-// there is an event listener for group C or not, if group B is registered for
-// local notification.
-// "https://www.kernel.org/doc/Documentation/cgroup-v1/memory.txt" Section 11
-const (
- DefaultMode EventNotificationMode = "default"
- LocalMode EventNotificationMode = "local"
- HierarchyMode EventNotificationMode = "hierarchy"
-)
-
-// NewMemory returns a Memory controller given the root folder of cgroups.
-// It may optionally accept other configuration options, such as IgnoreModules(...)
-func NewMemory(root string, options ...func(*memoryController)) *memoryController {
- mc := &memoryController{
- root: filepath.Join(root, string(Memory)),
- ignored: map[string]struct{}{},
- }
- for _, opt := range options {
- opt(mc)
- }
- return mc
-}
-
-// IgnoreModules configure the memory controller to not read memory metrics for some
-// module names (e.g. passing "memsw" would avoid all the memory.memsw.* entries)
-func IgnoreModules(names ...string) func(*memoryController) {
- return func(mc *memoryController) {
- for _, name := range names {
- mc.ignored[name] = struct{}{}
- }
- }
-}
-
-// OptionalSwap allows the memory controller to not fail if cgroups is not accounting
-// Swap memory (there are no memory.memsw.* entries)
-func OptionalSwap() func(*memoryController) {
- return func(mc *memoryController) {
- _, err := os.Stat(filepath.Join(mc.root, "memory.memsw.usage_in_bytes"))
- if os.IsNotExist(err) {
- mc.ignored["memsw"] = struct{}{}
- }
- }
-}
-
-type memoryController struct {
- root string
- ignored map[string]struct{}
-}
-
-func (m *memoryController) Name() Name {
- return Memory
-}
-
-func (m *memoryController) Path(path string) string {
- return filepath.Join(m.root, path)
-}
-
-func (m *memoryController) Create(path string, resources *specs.LinuxResources) error {
- if err := os.MkdirAll(m.Path(path), defaultDirPerm); err != nil {
- return err
- }
- if resources.Memory == nil {
- return nil
- }
- return m.set(path, getMemorySettings(resources))
-}
-
-func (m *memoryController) Update(path string, resources *specs.LinuxResources) error {
- if resources.Memory == nil {
- return nil
- }
- g := func(v *int64) bool {
- return v != nil && *v > 0
- }
- settings := getMemorySettings(resources)
- if g(resources.Memory.Limit) && g(resources.Memory.Swap) {
- // if the updated swap value is larger than the current memory limit set the swap changes first
- // then set the memory limit as swap must always be larger than the current limit
- current, err := readUint(filepath.Join(m.Path(path), "memory.limit_in_bytes"))
- if err != nil {
- return err
- }
- if current < uint64(*resources.Memory.Swap) {
- settings[0], settings[1] = settings[1], settings[0]
- }
- }
- return m.set(path, settings)
-}
-
-func (m *memoryController) Stat(path string, stats *v1.Metrics) error {
- fMemStat, err := os.Open(filepath.Join(m.Path(path), "memory.stat"))
- if err != nil {
- return err
- }
- defer fMemStat.Close()
- stats.Memory = &v1.MemoryStat{
- Usage: &v1.MemoryEntry{},
- Swap: &v1.MemoryEntry{},
- Kernel: &v1.MemoryEntry{},
- KernelTCP: &v1.MemoryEntry{},
- }
- if err := m.parseStats(fMemStat, stats.Memory); err != nil {
- return err
- }
-
- fMemOomControl, err := os.Open(filepath.Join(m.Path(path), "memory.oom_control"))
- if err != nil {
- return err
- }
- defer fMemOomControl.Close()
- stats.MemoryOomControl = &v1.MemoryOomControl{}
- if err := m.parseOomControlStats(fMemOomControl, stats.MemoryOomControl); err != nil {
- return err
- }
- for _, t := range []struct {
- module string
- entry *v1.MemoryEntry
- }{
- {
- module: "",
- entry: stats.Memory.Usage,
- },
- {
- module: "memsw",
- entry: stats.Memory.Swap,
- },
- {
- module: "kmem",
- entry: stats.Memory.Kernel,
- },
- {
- module: "kmem.tcp",
- entry: stats.Memory.KernelTCP,
- },
- } {
- if _, ok := m.ignored[t.module]; ok {
- continue
- }
- for _, tt := range []struct {
- name string
- value *uint64
- }{
- {
- name: "usage_in_bytes",
- value: &t.entry.Usage,
- },
- {
- name: "max_usage_in_bytes",
- value: &t.entry.Max,
- },
- {
- name: "failcnt",
- value: &t.entry.Failcnt,
- },
- {
- name: "limit_in_bytes",
- value: &t.entry.Limit,
- },
- } {
- parts := []string{"memory"}
- if t.module != "" {
- parts = append(parts, t.module)
- }
- parts = append(parts, tt.name)
- v, err := readUint(filepath.Join(m.Path(path), strings.Join(parts, ".")))
- if err != nil {
- return err
- }
- *tt.value = v
- }
- }
- return nil
-}
-
-func (m *memoryController) parseStats(r io.Reader, stat *v1.MemoryStat) error {
- var (
- raw = make(map[string]uint64)
- sc = bufio.NewScanner(r)
- line int
- )
- for sc.Scan() {
- key, v, err := parseKV(sc.Text())
- if err != nil {
- return fmt.Errorf("%d: %v", line, err)
- }
- raw[key] = v
- line++
- }
- if err := sc.Err(); err != nil {
- return err
- }
- stat.Cache = raw["cache"]
- stat.RSS = raw["rss"]
- stat.RSSHuge = raw["rss_huge"]
- stat.MappedFile = raw["mapped_file"]
- stat.Dirty = raw["dirty"]
- stat.Writeback = raw["writeback"]
- stat.PgPgIn = raw["pgpgin"]
- stat.PgPgOut = raw["pgpgout"]
- stat.PgFault = raw["pgfault"]
- stat.PgMajFault = raw["pgmajfault"]
- stat.InactiveAnon = raw["inactive_anon"]
- stat.ActiveAnon = raw["active_anon"]
- stat.InactiveFile = raw["inactive_file"]
- stat.ActiveFile = raw["active_file"]
- stat.Unevictable = raw["unevictable"]
- stat.HierarchicalMemoryLimit = raw["hierarchical_memory_limit"]
- stat.HierarchicalSwapLimit = raw["hierarchical_memsw_limit"]
- stat.TotalCache = raw["total_cache"]
- stat.TotalRSS = raw["total_rss"]
- stat.TotalRSSHuge = raw["total_rss_huge"]
- stat.TotalMappedFile = raw["total_mapped_file"]
- stat.TotalDirty = raw["total_dirty"]
- stat.TotalWriteback = raw["total_writeback"]
- stat.TotalPgPgIn = raw["total_pgpgin"]
- stat.TotalPgPgOut = raw["total_pgpgout"]
- stat.TotalPgFault = raw["total_pgfault"]
- stat.TotalPgMajFault = raw["total_pgmajfault"]
- stat.TotalInactiveAnon = raw["total_inactive_anon"]
- stat.TotalActiveAnon = raw["total_active_anon"]
- stat.TotalInactiveFile = raw["total_inactive_file"]
- stat.TotalActiveFile = raw["total_active_file"]
- stat.TotalUnevictable = raw["total_unevictable"]
- return nil
-}
-
-func (m *memoryController) parseOomControlStats(r io.Reader, stat *v1.MemoryOomControl) error {
- var (
- raw = make(map[string]uint64)
- sc = bufio.NewScanner(r)
- line int
- )
- for sc.Scan() {
- key, v, err := parseKV(sc.Text())
- if err != nil {
- return fmt.Errorf("%d: %v", line, err)
- }
- raw[key] = v
- line++
- }
- if err := sc.Err(); err != nil {
- return err
- }
- stat.OomKillDisable = raw["oom_kill_disable"]
- stat.UnderOom = raw["under_oom"]
- stat.OomKill = raw["oom_kill"]
- return nil
-}
-
-func (m *memoryController) set(path string, settings []memorySettings) error {
- for _, t := range settings {
- if t.value != nil {
- if err := os.WriteFile(
- filepath.Join(m.Path(path), "memory."+t.name),
- []byte(strconv.FormatInt(*t.value, 10)),
- defaultFilePerm,
- ); err != nil {
- return err
- }
- }
- }
- return nil
-}
-
-type memorySettings struct {
- name string
- value *int64
-}
-
-func getMemorySettings(resources *specs.LinuxResources) []memorySettings {
- mem := resources.Memory
- var swappiness *int64
- if mem.Swappiness != nil {
- v := int64(*mem.Swappiness)
- swappiness = &v
- }
- return []memorySettings{
- {
- name: "limit_in_bytes",
- value: mem.Limit,
- },
- {
- name: "soft_limit_in_bytes",
- value: mem.Reservation,
- },
- {
- name: "memsw.limit_in_bytes",
- value: mem.Swap,
- },
- {
- name: "kmem.limit_in_bytes",
- value: mem.Kernel,
- },
- {
- name: "kmem.tcp.limit_in_bytes",
- value: mem.KernelTCP,
- },
- {
- name: "oom_control",
- value: getOomControlValue(mem),
- },
- {
- name: "swappiness",
- value: swappiness,
- },
- }
-}
-
-func getOomControlValue(mem *specs.LinuxMemory) *int64 {
- if mem.DisableOOMKiller != nil && *mem.DisableOOMKiller {
- i := int64(1)
- return &i
- }
- return nil
-}
-
-func (m *memoryController) memoryEvent(path string, event MemoryEvent) (uintptr, error) {
- root := m.Path(path)
- efd, err := unix.Eventfd(0, unix.EFD_CLOEXEC)
- if err != nil {
- return 0, err
- }
- evtFile, err := os.Open(filepath.Join(root, event.EventFile()))
- if err != nil {
- unix.Close(efd)
- return 0, err
- }
- defer evtFile.Close()
- data := fmt.Sprintf("%d %d %s", efd, evtFile.Fd(), event.Arg())
- evctlPath := filepath.Join(root, "cgroup.event_control")
- if err := os.WriteFile(evctlPath, []byte(data), 0700); err != nil {
- unix.Close(efd)
- return 0, err
- }
- return uintptr(efd), nil
-}
generated by cgit v1.2.3 (git 2.46.0) at 2025-07-13 23:09:44 +0000