eb5df869ba
The commands used were (roughly): hack/pin-dependency.sh github.com/opencontainers/runc v1.0.1 hack/lint-dependencies.sh # Follow its recommendations. hack/pin-dependency.sh github.com/cilium/ebpf v0.6.2 hack/pin-dependency.sh github.com/opencontainers/selinux v1.8.2 hack/pin-dependency.sh github.com/sirupsen/logrus v1.8.1 # Recheck. hack/lint-dependencies.sh GO111MODULE=on go mod edit -dropreplace github.com/willf/bitset hack/update-vendor.sh # Recheck. hack/lint-dependencies.sh hack/update-internal-modules.sh # Recheck. hack/lint-dependencies.sh Signed-off-by: Kir Kolyshkin <kolyshkin@gmail.com>
88 lines
2.0 KiB
Go
88 lines
2.0 KiB
Go
// +build linux
|
|
|
|
package libcontainer
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"io/ioutil"
|
|
"os"
|
|
"path/filepath"
|
|
|
|
"golang.org/x/sys/unix"
|
|
)
|
|
|
|
type PressureLevel uint
|
|
|
|
const (
|
|
LowPressure PressureLevel = iota
|
|
MediumPressure
|
|
CriticalPressure
|
|
)
|
|
|
|
func registerMemoryEvent(cgDir string, evName string, arg string) (<-chan struct{}, error) {
|
|
evFile, err := os.Open(filepath.Join(cgDir, evName))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
fd, err := unix.Eventfd(0, unix.EFD_CLOEXEC)
|
|
if err != nil {
|
|
evFile.Close()
|
|
return nil, err
|
|
}
|
|
|
|
eventfd := os.NewFile(uintptr(fd), "eventfd")
|
|
|
|
eventControlPath := filepath.Join(cgDir, "cgroup.event_control")
|
|
data := fmt.Sprintf("%d %d %s", eventfd.Fd(), evFile.Fd(), arg)
|
|
if err := ioutil.WriteFile(eventControlPath, []byte(data), 0o700); err != nil {
|
|
eventfd.Close()
|
|
evFile.Close()
|
|
return nil, err
|
|
}
|
|
ch := make(chan struct{})
|
|
go func() {
|
|
defer func() {
|
|
eventfd.Close()
|
|
evFile.Close()
|
|
close(ch)
|
|
}()
|
|
buf := make([]byte, 8)
|
|
for {
|
|
if _, err := eventfd.Read(buf); err != nil {
|
|
return
|
|
}
|
|
// When a cgroup is destroyed, an event is sent to eventfd.
|
|
// So if the control path is gone, return instead of notifying.
|
|
if _, err := os.Lstat(eventControlPath); os.IsNotExist(err) {
|
|
return
|
|
}
|
|
ch <- struct{}{}
|
|
}
|
|
}()
|
|
return ch, nil
|
|
}
|
|
|
|
// notifyOnOOM returns channel on which you can expect event about OOM,
|
|
// if process died without OOM this channel will be closed.
|
|
func notifyOnOOM(dir string) (<-chan struct{}, error) {
|
|
if dir == "" {
|
|
return nil, errors.New("memory controller missing")
|
|
}
|
|
|
|
return registerMemoryEvent(dir, "memory.oom_control", "")
|
|
}
|
|
|
|
func notifyMemoryPressure(dir string, level PressureLevel) (<-chan struct{}, error) {
|
|
if dir == "" {
|
|
return nil, errors.New("memory controller missing")
|
|
}
|
|
|
|
if level > CriticalPressure {
|
|
return nil, fmt.Errorf("invalid pressure level %d", level)
|
|
}
|
|
|
|
levelStr := []string{"low", "medium", "critical"}[level]
|
|
return registerMemoryEvent(dir, "memory.pressure_level", levelStr)
|
|
}
|