vendor: update google/cadvisor and opencontainers/runc

Signed-off-by: Giuseppe Scrivano <gscrivan@redhat.com>

vendor/github.com/google/cadvisor/perf/BUILD

@@ -12,6 +12,7 @@ go_library(
     importpath = "github.com/google/cadvisor/perf",
     visibility = ["//visibility:public"],
     deps = [
+        "//vendor/github.com/google/cadvisor/info/v1:go_default_library",
         "//vendor/github.com/google/cadvisor/stats:go_default_library",
         "//vendor/k8s.io/klog/v2:go_default_library",
     ],

vendor/github.com/google/cadvisor/perf/collector_libpfm.go

@@ -31,18 +31,21 @@ import (
 	"sync"
 	"unsafe"
 
-	info "github.com/google/cadvisor/info/v1"
 	"golang.org/x/sys/unix"
 	"k8s.io/klog/v2"
+
+	info "github.com/google/cadvisor/info/v1"
+	"github.com/google/cadvisor/stats"
 )
 
 type collector struct {
 	cgroupPath         string
-	events             Events
+	events             PerfEvents
 	cpuFiles           map[string]map[int]readerCloser
 	cpuFilesLock       sync.Mutex
 	numCores           int
 	eventToCustomEvent map[Event]*CustomEvent
+	uncore             stats.Collector
 }
 
 var (
@@ -61,50 +64,68 @@ func init() {
 	isLibpfmInitialized = true
 }
 
-func newCollector(cgroupPath string, events Events, numCores int) *collector {
-	collector := &collector{cgroupPath: cgroupPath, events: events, cpuFiles: map[string]map[int]readerCloser{}, numCores: numCores}
+func newCollector(cgroupPath string, events PerfEvents, numCores int, topology []info.Node) *collector {
+	collector := &collector{cgroupPath: cgroupPath, events: events, cpuFiles: map[string]map[int]readerCloser{}, numCores: numCores, uncore: NewUncoreCollector(cgroupPath, events, topology)}
 	mapEventsToCustomEvents(collector)
+
 	return collector
 }
 
 func (c *collector) UpdateStats(stats *info.ContainerStats) error {
+	err := c.uncore.UpdateStats(stats)
+	if err != nil {
+		klog.Errorf("Failed to get uncore perf event stats: %v", err)
+	}
+
 	c.cpuFilesLock.Lock()
 	defer c.cpuFilesLock.Unlock()
 
 	stats.PerfStats = []info.PerfStat{}
 	klog.V(5).Infof("Attempting to update perf_event stats from cgroup %q", c.cgroupPath)
-	for name, files := range c.cpuFiles {
-		for cpu, file := range files {
-			buf := make([]byte, 32)
-			_, err := file.Read(buf)
+	for name, cpus := range c.cpuFiles {
+		for cpu, file := range cpus {
+			stat, err := readPerfStat(file, name, cpu)
 			if err != nil {
-				klog.Warningf("Unable to read from perf_event file (event: %q, CPU: %d) for %q", name, cpu, c.cgroupPath)
+				klog.Warningf("Unable to read from perf_event_file (event: %q, CPU: %d) for %q: %q", name, cpu, c.cgroupPath, err.Error())
 				continue
 			}
-			perfData := &ReadFormat{}
-			reader := bytes.NewReader(buf)
-			err = binary.Read(reader, binary.LittleEndian, perfData)
-			if err != nil {
-				klog.Warningf("Unable to decode from binary format read from perf_event file (event: %q, CPU: %d) for %q", name, cpu, c.cgroupPath)
-				continue
-			}
-			klog.V(5).Infof("Read metric for event %q for cpu %d from cgroup %q: %d", name, cpu, c.cgroupPath, perfData.Value)
-			scalingRatio := 1.0
-			if perfData.TimeEnabled != 0 {
-				scalingRatio = float64(perfData.TimeRunning) / float64(perfData.TimeEnabled)
-			}
-			stat := info.PerfStat{
-				Value:        uint64(float64(perfData.Value) / scalingRatio),
-				Name:         name,
-				ScalingRatio: scalingRatio,
-				Cpu:          cpu,
-			}
-			stats.PerfStats = append(stats.PerfStats, stat)
+			klog.V(5).Infof("Read perf event (event: %q, CPU: %d) for %q: %d", name, cpu, c.cgroupPath, stat.Value)
+
+			stats.PerfStats = append(stats.PerfStats, *stat)
 		}
 	}
+
 	return nil
 }
 
+func readPerfStat(file readerCloser, name string, cpu int) (*info.PerfStat, error) {
+	buf := make([]byte, 32)
+	_, err := file.Read(buf)
+	if err != nil {
+		return nil, err
+	}
+	perfData := &ReadFormat{}
+	reader := bytes.NewReader(buf)
+	err = binary.Read(reader, binary.LittleEndian, perfData)
+	if err != nil {
+		return nil, err
+	}
+
+	scalingRatio := 1.0
+	if perfData.TimeEnabled != 0 {
+		scalingRatio = float64(perfData.TimeRunning) / float64(perfData.TimeEnabled)
+	}
+
+	stat := info.PerfStat{
+		Value:        uint64(float64(perfData.Value) / scalingRatio),
+		Name:         name,
+		ScalingRatio: scalingRatio,
+		Cpu:          cpu,
+	}
+
+	return &stat, nil
+}
+
 func (c *collector) setup() error {
 	cgroup, err := os.Open(c.cgroupPath)
 	if err != nil {
@@ -115,7 +136,7 @@ func (c *collector) setup() error {
 	c.cpuFilesLock.Lock()
 	defer c.cpuFilesLock.Unlock()
 	cgroupFd := int(cgroup.Fd())
-	for _, group := range c.events.Events {
+	for _, group := range c.events.Core.Events {
 		customEvent, ok := c.eventToCustomEvent[group[0]]
 		var err error
 		if ok {
@@ -127,6 +148,7 @@ func (c *collector) setup() error {
 			return err
 		}
 	}
+
 	return nil
 }
 
@@ -141,10 +163,10 @@ func (c *collector) setupRawNonGrouped(event *CustomEvent, cgroup int) error {
 	return nil
 }
 
-func (c *collector) registerEvent(config *unix.PerfEventAttr, name string, cgroup int) error {
+func (c *collector) registerEvent(config *unix.PerfEventAttr, name string, pid int) error {
 	var cpu int
 	for cpu = 0; cpu < c.numCores; cpu++ {
-		pid, groupFd, flags := cgroup, -1, unix.PERF_FLAG_FD_CLOEXEC|unix.PERF_FLAG_PID_CGROUP
+		groupFd, flags := -1, unix.PERF_FLAG_FD_CLOEXEC|unix.PERF_FLAG_PID_CGROUP
 		fd, err := unix.PerfEventOpen(config, pid, cpu, groupFd, flags)
 		if err != nil {
 			return fmt.Errorf("setting up perf event %#v failed: %q", config, err)
@@ -164,35 +186,18 @@ func (c *collector) addEventFile(name string, cpu int, perfFile *os.File) {
 	if !ok {
 		c.cpuFiles[name] = map[int]readerCloser{}
 	}
+
 	c.cpuFiles[name][cpu] = perfFile
 }
 
 func (c *collector) setupNonGrouped(name string, cgroup int) error {
-	if !isLibpfmInitialized {
-		return fmt.Errorf("libpfm4 is not initialized, cannot proceed with setting perf events up")
+	perfEventAttr, err := getPerfEventAttr(name)
+	if err != nil {
+		return err
 	}
+	defer C.free(unsafe.Pointer(perfEventAttr))
 
-	klog.V(5).Infof("Setting up non-grouped perf event %s", name)
-
-	perfEventAttrMemory := C.malloc(C.ulong(unsafe.Sizeof(unix.PerfEventAttr{})))
-	defer C.free(perfEventAttrMemory)
-	event := pfmPerfEncodeArgT{}
-
-	perfEventAttr := (*unix.PerfEventAttr)(perfEventAttrMemory)
-	fstr := C.CString("")
-	event.fstr = unsafe.Pointer(fstr)
-	event.attr = perfEventAttrMemory
-	event.size = C.ulong(unsafe.Sizeof(event))
-
-	cSafeName := C.CString(name)
-	pErr := C.pfm_get_os_event_encoding(cSafeName, C.PFM_PLM0|C.PFM_PLM3, C.PFM_OS_PERF_EVENT, unsafe.Pointer(&event))
-	if pErr != C.PFM_SUCCESS {
-		return fmt.Errorf("unable to transform event name %s to perf_event_attr: %d", name, int(pErr))
-	}
-
-	klog.V(5).Infof("perf_event_attr: %#v", perfEventAttr)
-	setAttributes(perfEventAttr)
-	return c.registerEvent(perfEventAttr, string(name), cgroup)
+	return c.registerEvent(perfEventAttr, name, cgroup)
 }
 
 func createPerfEventAttr(event CustomEvent) *unix.PerfEventAttr {
@@ -214,6 +219,34 @@ func createPerfEventAttr(event CustomEvent) *unix.PerfEventAttr {
 	return config
 }
 
+func getPerfEventAttr(name string) (*unix.PerfEventAttr, error) {
+	if !isLibpfmInitialized {
+		return nil, fmt.Errorf("libpfm4 is not initialized, cannot proceed with setting perf events up")
+	}
+
+	perfEventAttrMemory := C.malloc(C.ulong(unsafe.Sizeof(unix.PerfEventAttr{})))
+	event := pfmPerfEncodeArgT{}
+
+	perfEventAttr := (*unix.PerfEventAttr)(perfEventAttrMemory)
+	fstr := C.CString("")
+	event.fstr = unsafe.Pointer(fstr)
+	event.attr = perfEventAttrMemory
+	event.size = C.ulong(unsafe.Sizeof(event))
+
+	cSafeName := C.CString(name)
+
+	pErr := C.pfm_get_os_event_encoding(cSafeName, C.PFM_PLM0|C.PFM_PLM3, C.PFM_OS_PERF_EVENT, unsafe.Pointer(&event))
+	if pErr != C.PFM_SUCCESS {
+		return nil, fmt.Errorf("unable to transform event name %s to perf_event_attr: %v", name, int(pErr))
+	}
+
+	klog.V(5).Infof("perf_event_attr: %#v", perfEventAttr)
+
+	setAttributes(perfEventAttr)
+
+	return perfEventAttr, nil
+}
+
 func setAttributes(config *unix.PerfEventAttr) {
 	config.Sample_type = perfSampleIdentifier
 	config.Read_format = unix.PERF_FORMAT_TOTAL_TIME_ENABLED | unix.PERF_FORMAT_TOTAL_TIME_RUNNING | unix.PERF_FORMAT_ID
@@ -222,6 +255,7 @@ func setAttributes(config *unix.PerfEventAttr) {
 }
 
 func (c *collector) Destroy() {
+	c.uncore.Destroy()
 	c.cpuFilesLock.Lock()
 	defer c.cpuFilesLock.Unlock()
 
@@ -233,7 +267,6 @@ func (c *collector) Destroy() {
 				klog.Warningf("Unable to close perf_event file descriptor for cgroup %q, event %q and CPU %d", c.cgroupPath, name, cpu)
 			}
 		}
-
 		delete(c.cpuFiles, name)
 	}
 }
@@ -255,7 +288,7 @@ func Finalize() {
 
 func mapEventsToCustomEvents(collector *collector) {
 	collector.eventToCustomEvent = map[Event]*CustomEvent{}
-	for key, event := range collector.events.CustomEvents {
-		collector.eventToCustomEvent[event.Name] = &collector.events.CustomEvents[key]
+	for key, event := range collector.events.Core.CustomEvents {
+		collector.eventToCustomEvent[event.Name] = &collector.events.Core.CustomEvents[key]
 	}
 }

vendor/github.com/google/cadvisor/perf/config.go

@@ -24,9 +24,16 @@ import (
 	"k8s.io/klog/v2"
 )
 
+type PerfEvents struct {
+	// Core perf events to be measured.
+	Core Events `json:"core,omitempty"`
+
+	// Uncore perf events to be measured.
+	Uncore Events `json:"uncore,omitempty"`
+}
+
 type Events struct {
-	// List of perf events' names to be measured. Any value found in
-	// output of perf list can be used.
+	// List of perf events' names to be measured.
 	Events [][]Event `json:"events"`
 
 	// List of custom perf events' to be measured. It is impossible to
@@ -40,7 +47,7 @@ type Event string
 type CustomEvent struct {
 	// Type of the event. See perf_event_attr documentation
 	// at man perf_event_open.
-	Type uint32 `json:"type"`
+	Type uint32 `json:"type,omitempty"`
 
 	// Symbolically formed event like:
 	// pmu/config=PerfEvent.Config[0],config1=PerfEvent.Config[1],config2=PerfEvent.Config[2]
@@ -73,11 +80,11 @@ func (c *Config) UnmarshalJSON(b []byte) error {
 	return nil
 }
 
-func parseConfig(file *os.File) (events Events, err error) {
+func parseConfig(file *os.File) (events PerfEvents, err error) {
 	decoder := json.NewDecoder(file)
 	err = decoder.Decode(&events)
 	if err != nil {
-		err = fmt.Errorf("unable to load perf events cofiguration from %q: %q", file.Name(), err)
+		err = fmt.Errorf("unable to load perf events configuration from %q: %q", file.Name(), err)
 		return
 	}
 	return

vendor/github.com/google/cadvisor/perf/manager_libpfm.go

@@ -21,16 +21,18 @@ import (
 	"fmt"
 	"os"
 
+	info "github.com/google/cadvisor/info/v1"
 	"github.com/google/cadvisor/stats"
 )
 
 type manager struct {
-	events   Events
+	events   PerfEvents
 	numCores int
+	topology []info.Node
 	stats.NoopDestroy
 }
 
-func NewManager(configFile string, numCores int) (stats.Manager, error) {
+func NewManager(configFile string, numCores int, topology []info.Node) (stats.Manager, error) {
 	if configFile == "" {
 		return &stats.NoopManager{}, nil
 	}
@@ -49,11 +51,11 @@ func NewManager(configFile string, numCores int) (stats.Manager, error) {
 		return nil, fmt.Errorf("event grouping is not supported you must modify config file at %s", configFile)
 	}
 
-	return &manager{events: config, numCores: numCores}, nil
+	return &manager{events: config, numCores: numCores, topology: topology}, nil
 }
 
-func areGroupedEventsUsed(events Events) bool {
-	for _, group := range events.Events {
+func areGroupedEventsUsed(events PerfEvents) bool {
+	for _, group := range events.Core.Events {
 		if len(group) > 1 {
 			return true
 		}
@@ -62,7 +64,7 @@ func areGroupedEventsUsed(events Events) bool {
 }
 
 func (m *manager) GetCollector(cgroupPath string) (stats.Collector, error) {
-	collector := newCollector(cgroupPath, m.events, m.numCores)
+	collector := newCollector(cgroupPath, m.events, m.numCores, m.topology)
 	err := collector.setup()
 	if err != nil {
 		collector.Destroy()

vendor/github.com/google/cadvisor/perf/manager_no_libpfm.go

@@ -18,12 +18,13 @@
 package perf
 
 import (
+	info "github.com/google/cadvisor/info/v1"
 	"github.com/google/cadvisor/stats"
 
 	"k8s.io/klog/v2"
 )
 
-func NewManager(configFile string, numCores int) (stats.Manager, error) {
+func NewManager(configFile string, numCores int, topology []info.Node) (stats.Manager, error) {
 	klog.V(1).Info("cAdvisor is build without cgo and/or libpfm support. Perf event counters are not available.")
 	return &stats.NoopManager{}, nil
 }

vendor/github.com/google/cadvisor/perf/uncore_libpfm.go

@@ -0,0 +1,392 @@
+// +build libpfm,cgo
+
+// Copyright 2020 Google Inc. All Rights Reserved.
+//
+// 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.
+
+// Uncore perf events logic.
+package perf
+
+// #cgo CFLAGS: -I/usr/include
+// #cgo LDFLAGS: -lpfm
+// #include <perfmon/pfmlib.h>
+// #include <stdlib.h>
+import "C"
+import (
+	"bytes"
+	"encoding/binary"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"sync"
+	"unsafe"
+
+	"golang.org/x/sys/unix"
+	"k8s.io/klog/v2"
+
+	info "github.com/google/cadvisor/info/v1"
+	"github.com/google/cadvisor/stats"
+	"github.com/google/cadvisor/utils/sysinfo"
+)
+
+type pmu struct {
+	name   string
+	typeOf uint32
+	cpus   []uint32
+}
+
+const (
+	uncorePMUPrefix    = "uncore"
+	pmuTypeFilename    = "type"
+	pmuCpumaskFilename = "cpumask"
+	systemDevicesPath  = "/sys/devices"
+	rootPerfEventPath  = "/sys/fs/cgroup/perf_event"
+)
+
+func getPMU(pmus []pmu, gotType uint32) (*pmu, error) {
+	for _, pmu := range pmus {
+		if pmu.typeOf == gotType {
+			return &pmu, nil
+		}
+	}
+
+	return nil, fmt.Errorf("there is no pmu with event type: %#v", gotType)
+}
+
+type uncorePMUs map[string]pmu
+
+func readUncorePMU(path string, name string, cpumaskRegexp *regexp.Regexp) (*pmu, error) {
+	buf, err := ioutil.ReadFile(filepath.Join(path, pmuTypeFilename))
+	if err != nil {
+		return nil, err
+	}
+	typeString := strings.TrimSpace(string(buf))
+	eventType, err := strconv.ParseUint(typeString, 0, 32)
+	if err != nil {
+		return nil, err
+	}
+
+	buf, err = ioutil.ReadFile(filepath.Join(path, pmuCpumaskFilename))
+	if err != nil {
+		return nil, err
+	}
+	var cpus []uint32
+	cpumask := strings.TrimSpace(string(buf))
+	for _, cpu := range cpumaskRegexp.Split(cpumask, -1) {
+		parsedCPU, err := strconv.ParseUint(cpu, 0, 32)
+		if err != nil {
+			return nil, err
+		}
+		cpus = append(cpus, uint32(parsedCPU))
+	}
+
+	return &pmu{name: name, typeOf: uint32(eventType), cpus: cpus}, nil
+}
+
+func getUncorePMUs(devicesPath string) (uncorePMUs, error) {
+	pmus := make(uncorePMUs, 0)
+
+	// Depends on platform, cpu mask could be for example in form "0-1" or "0,1".
+	cpumaskRegexp := regexp.MustCompile("[-,\n]")
+	err := filepath.Walk(devicesPath, func(path string, info os.FileInfo, err error) error {
+		// Skip root path.
+		if path == devicesPath {
+			return nil
+		}
+		if info.IsDir() {
+			if strings.HasPrefix(info.Name(), uncorePMUPrefix) {
+				pmu, err := readUncorePMU(path, info.Name(), cpumaskRegexp)
+				if err != nil {
+					return err
+				}
+				pmus[info.Name()] = *pmu
+			}
+		}
+		return nil
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return pmus, nil
+}
+
+type uncoreCollector struct {
+	cpuFiles           map[string]map[string]map[int]readerCloser
+	cpuFilesLock       sync.Mutex
+	events             [][]Event
+	eventToCustomEvent map[Event]*CustomEvent
+	topology           []info.Node
+
+	// Handle for mocking purposes.
+	perfEventOpen func(attr *unix.PerfEventAttr, pid int, cpu int, groupFd int, flags int) (fd int, err error)
+}
+
+func NewUncoreCollector(cgroupPath string, events PerfEvents, topology []info.Node) stats.Collector {
+
+	if cgroupPath != rootPerfEventPath {
+		// Uncore metric doesn't exists for cgroups, only for entire platform.
+		return &stats.NoopCollector{}
+	}
+
+	collector := &uncoreCollector{topology: topology}
+
+	// Default implementation of Linux perf_event_open function.
+	collector.perfEventOpen = unix.PerfEventOpen
+
+	err := collector.setup(events, systemDevicesPath)
+	if err != nil {
+		formatedError := fmt.Errorf("unable to setup uncore perf event collector: %v", err)
+		klog.V(5).Infof("Perf uncore metrics will not be available: %s", formatedError)
+		return &stats.NoopCollector{}
+	}
+
+	return collector
+}
+
+func (c *uncoreCollector) setup(events PerfEvents, devicesPath string) error {
+	var err error
+	readUncorePMUs, err := getUncorePMUs(devicesPath)
+	if err != nil {
+		return err
+	}
+
+	// Maping from event name, pmu type, cpu.
+	c.cpuFiles = make(map[string]map[string]map[int]readerCloser)
+	c.events = events.Uncore.Events
+	c.eventToCustomEvent = parseUncoreEvents(events.Uncore)
+	c.cpuFilesLock.Lock()
+	defer c.cpuFilesLock.Unlock()
+
+	for _, group := range c.events {
+		if len(group) > 1 {
+			klog.Warning("grouping uncore perf events is not supported!")
+			continue
+		}
+
+		eventName, pmuPrefix := parseEventName(string(group[0]))
+
+		var err error
+		customEvent, ok := c.eventToCustomEvent[group[0]]
+		if ok {
+			if customEvent.Type != 0 {
+				pmus := obtainPMUs("uncore", readUncorePMUs)
+				err = c.setupRawNonGroupedUncore(customEvent, pmus)
+			} else {
+				pmus := obtainPMUs(pmuPrefix, readUncorePMUs)
+				err = c.setupRawNonGroupedUncore(customEvent, pmus)
+			}
+		} else {
+			pmus := obtainPMUs(pmuPrefix, readUncorePMUs)
+			err = c.setupNonGroupedUncore(eventName, pmus)
+		}
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func parseEventName(eventName string) (string, string) {
+	// First "/" separate pmu prefix and event name
+	// ex. "uncore_imc_0/cas_count_read" -> uncore_imc_0 and cas_count_read.
+	splittedEvent := strings.SplitN(eventName, "/", 2)
+	var pmuPrefix = ""
+	if len(splittedEvent) == 2 {
+		pmuPrefix = splittedEvent[0]
+		eventName = splittedEvent[1]
+	}
+	return eventName, pmuPrefix
+}
+
+func obtainPMUs(want string, gotPMUs uncorePMUs) []pmu {
+	var pmus []pmu
+	if want == "" {
+		return pmus
+	}
+	for _, pmu := range gotPMUs {
+		if strings.HasPrefix(pmu.name, want) {
+			pmus = append(pmus, pmu)
+		}
+	}
+
+	return pmus
+}
+
+func parseUncoreEvents(events Events) map[Event]*CustomEvent {
+	eventToCustomEvent := map[Event]*CustomEvent{}
+	for _, uncoreEvent := range events.Events {
+		for _, customEvent := range events.CustomEvents {
+			if uncoreEvent[0] == customEvent.Name {
+				eventToCustomEvent[customEvent.Name] = &customEvent
+				break
+			}
+		}
+	}
+
+	return eventToCustomEvent
+}
+
+func (c *uncoreCollector) Destroy() {
+	c.cpuFilesLock.Lock()
+	defer c.cpuFilesLock.Unlock()
+
+	for name, pmus := range c.cpuFiles {
+		for pmu, cpus := range pmus {
+			for cpu, file := range cpus {
+				klog.V(5).Infof("Closing uncore perf_event file descriptor for event %q, PMU %s and CPU %d", name, pmu, cpu)
+				err := file.Close()
+				if err != nil {
+					klog.Warningf("Unable to close perf_event file descriptor for event %q, PMU %s and CPU %d", name, pmu, cpu)
+				}
+			}
+			delete(pmus, pmu)
+		}
+		delete(c.cpuFiles, name)
+	}
+}
+
+func (c *uncoreCollector) UpdateStats(stats *info.ContainerStats) error {
+	klog.V(5).Info("Attempting to update uncore perf_event stats")
+
+	for name, pmus := range c.cpuFiles {
+		for pmu, cpus := range pmus {
+			for cpu, file := range cpus {
+				stat, err := readPerfUncoreStat(file, name, cpu, pmu, c.topology)
+				if err != nil {
+					return fmt.Errorf("unable to read from uncore perf_event_file (event: %q, CPU: %d, PMU: %s): %q", name, cpu, pmu, err.Error())
+				}
+				klog.V(5).Infof("Read uncore perf event (event: %q, CPU: %d, PMU: %s): %d", name, cpu, pmu, stat.Value)
+
+				stats.PerfUncoreStats = append(stats.PerfUncoreStats, *stat)
+			}
+		}
+	}
+
+	return nil
+}
+
+func (c *uncoreCollector) setupRawNonGroupedUncore(event *CustomEvent, pmus []pmu) error {
+	klog.V(5).Infof("Setting up non-grouped raw perf uncore event %#v", event)
+
+	if event.Type == 0 {
+		// PMU isn't set. Register event for all PMUs.
+		for _, pmu := range pmus {
+			newEvent := CustomEvent{
+				Type:   pmu.typeOf,
+				Config: event.Config,
+				Name:   event.Name,
+			}
+			config := createPerfEventAttr(newEvent)
+			err := c.registerUncoreEvent(config, string(newEvent.Name), pmu.cpus, pmu.name)
+			if err != nil {
+				return err
+			}
+		}
+		return nil
+	} else {
+		// Register event for the PMU.
+		config := createPerfEventAttr(*event)
+		pmu, err := getPMU(pmus, event.Type)
+		if err != nil {
+			return err
+		}
+		return c.registerUncoreEvent(config, string(event.Name), pmu.cpus, pmu.name)
+	}
+}
+
+func (c *uncoreCollector) setupNonGroupedUncore(name string, pmus []pmu) error {
+	perfEventAttr, err := getPerfEventAttr(name)
+	if err != nil {
+		return err
+	}
+	defer C.free(unsafe.Pointer(perfEventAttr))
+
+	klog.V(5).Infof("Setting up non-grouped uncore perf event %s", name)
+
+	// Register event for all memory controllers.
+	for _, pmu := range pmus {
+		perfEventAttr.Type = pmu.typeOf
+		err = c.registerUncoreEvent(perfEventAttr, name, pmu.cpus, pmu.name)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (c *uncoreCollector) registerUncoreEvent(config *unix.PerfEventAttr, name string, cpus []uint32, pmu string) error {
+	for _, cpu := range cpus {
+		groupFd, pid, flags := -1, -1, 0
+		fd, err := c.perfEventOpen(config, pid, int(cpu), groupFd, flags)
+		if err != nil {
+			return fmt.Errorf("setting up perf event %#v failed: %q", config, err)
+		}
+		perfFile := os.NewFile(uintptr(fd), name)
+		if perfFile == nil {
+			return fmt.Errorf("unable to create os.File from file descriptor %#v", fd)
+		}
+
+		c.addEventFile(name, pmu, int(cpu), perfFile)
+	}
+
+	return nil
+}
+
+func (c *uncoreCollector) addEventFile(name string, pmu string, cpu int, perfFile *os.File) {
+	_, ok := c.cpuFiles[name]
+	if !ok {
+		c.cpuFiles[name] = map[string]map[int]readerCloser{}
+	}
+
+	_, ok = c.cpuFiles[name][pmu]
+	if !ok {
+		c.cpuFiles[name][pmu] = map[int]readerCloser{}
+	}
+
+	c.cpuFiles[name][pmu][cpu] = perfFile
+}
+
+func readPerfUncoreStat(file readerCloser, name string, cpu int, pmu string, topology []info.Node) (*info.PerfUncoreStat, error) {
+	buf := make([]byte, 32)
+	_, err := file.Read(buf)
+	if err != nil {
+		return nil, err
+	}
+	perfData := &ReadFormat{}
+	reader := bytes.NewReader(buf)
+	err = binary.Read(reader, binary.LittleEndian, perfData)
+	if err != nil {
+		return nil, err
+	}
+
+	scalingRatio := 1.0
+	if perfData.TimeEnabled != 0 {
+		scalingRatio = float64(perfData.TimeRunning) / float64(perfData.TimeEnabled)
+	}
+
+	stat := info.PerfUncoreStat{
+		Value:        uint64(float64(perfData.Value) / scalingRatio),
+		Name:         name,
+		ScalingRatio: scalingRatio,
+		Socket:       sysinfo.GetSocketFromCPU(topology, cpu),
+		PMU:          pmu,
+	}
+
+	return &stat, nil
+}