Bump cAdvisor to v0.43.0

Bumping cAdvisor from v0.39.2 -> v0.43.0

* Also pin transitive dependencies
  * containerd v1.4.9 -> v1.4.11
  * docker v20.10.2+incompatible> v20.10.7+incompatible

Signed-off-by: David Porter <david@porter.me>

vendor/github.com/google/cadvisor/container/libcontainer/helpers.go

@@ -19,71 +19,49 @@ import (
 
 	info "github.com/google/cadvisor/info/v1"
 
-	"github.com/google/cadvisor/container"
 	"github.com/opencontainers/runc/libcontainer/cgroups"
 
+	"github.com/google/cadvisor/container"
+
 	fs "github.com/opencontainers/runc/libcontainer/cgroups/fs"
 	fs2 "github.com/opencontainers/runc/libcontainer/cgroups/fs2"
 	configs "github.com/opencontainers/runc/libcontainer/configs"
 	"k8s.io/klog/v2"
 )
 
-type CgroupSubsystems struct {
-	// Cgroup subsystem mounts.
-	// e.g.: "/sys/fs/cgroup/cpu" -> ["cpu", "cpuacct"]
-	Mounts []cgroups.Mount
-
-	// Cgroup subsystem to their mount location.
-	// e.g.: "cpu" -> "/sys/fs/cgroup/cpu"
-	MountPoints map[string]string
-}
-
-// Get information about the cgroup subsystems those we want
-func GetCgroupSubsystems(includedMetrics container.MetricSet) (CgroupSubsystems, error) {
+// GetCgroupSubsystems returns information about the cgroup subsystems that are
+// of interest as a map of cgroup controllers to their mount points.
+// For example, "cpu" -> "/sys/fs/cgroup/cpu".
+//
+// The incudeMetrics arguments specifies which metrics are requested,
+// and is used to filter out some cgroups and their mounts. If nil,
+// all supported cgroup subsystems are included.
+//
+// For cgroup v2, includedMetrics argument is unused, the only map key is ""
+// (empty string), and the value is the unified cgroup mount point.
+func GetCgroupSubsystems(includedMetrics container.MetricSet) (map[string]string, error) {
+	if cgroups.IsCgroup2UnifiedMode() {
+		return map[string]string{"": fs2.UnifiedMountpoint}, nil
+	}
 	// Get all cgroup mounts.
 	allCgroups, err := cgroups.GetCgroupMounts(true)
 	if err != nil {
-		return CgroupSubsystems{}, err
+		return nil, err
 	}
 
-	disableCgroups := map[string]struct{}{}
-
-	//currently we only support disable blkio subsystem
-	if !includedMetrics.Has(container.DiskIOMetrics) {
-		disableCgroups["blkio"] = struct{}{}
-		disableCgroups["io"] = struct{}{}
-	}
-	return getCgroupSubsystemsHelper(allCgroups, disableCgroups)
+	return getCgroupSubsystemsHelper(allCgroups, includedMetrics)
 }
 
-// Get information about all the cgroup subsystems.
-func GetAllCgroupSubsystems() (CgroupSubsystems, error) {
-	// Get all cgroup mounts.
-	allCgroups, err := cgroups.GetCgroupMounts(true)
-	if err != nil {
-		return CgroupSubsystems{}, err
-	}
-
-	emptyDisableCgroups := map[string]struct{}{}
-	return getCgroupSubsystemsHelper(allCgroups, emptyDisableCgroups)
-}
-
-func getCgroupSubsystemsHelper(allCgroups []cgroups.Mount, disableCgroups map[string]struct{}) (CgroupSubsystems, error) {
+func getCgroupSubsystemsHelper(allCgroups []cgroups.Mount, includedMetrics container.MetricSet) (map[string]string, error) {
 	if len(allCgroups) == 0 {
-		return CgroupSubsystems{}, fmt.Errorf("failed to find cgroup mounts")
+		return nil, fmt.Errorf("failed to find cgroup mounts")
 	}
 
 	// Trim the mounts to only the subsystems we care about.
-	supportedCgroups := make([]cgroups.Mount, 0, len(allCgroups))
-	recordedMountpoints := make(map[string]struct{}, len(allCgroups))
 	mountPoints := make(map[string]string, len(allCgroups))
 	for _, mount := range allCgroups {
 		for _, subsystem := range mount.Subsystems {
-			if _, exists := disableCgroups[subsystem]; exists {
-				continue
-			}
-			if _, ok := supportedSubsystems[subsystem]; !ok {
-				// Unsupported subsystem
+			if !needSubsys(subsystem, includedMetrics) {
 				continue
 			}
 			if _, ok := mountPoints[subsystem]; ok {
@@ -91,36 +69,44 @@ func getCgroupSubsystemsHelper(allCgroups []cgroups.Mount, disableCgroups map[st
 				klog.V(5).Infof("skipping %s, already using mount at %s", mount.Mountpoint, mountPoints[subsystem])
 				continue
 			}
-			if _, ok := recordedMountpoints[mount.Mountpoint]; !ok {
-				// avoid appending the same mount twice in e.g. `cpu,cpuacct` case
-				supportedCgroups = append(supportedCgroups, mount)
-				recordedMountpoints[mount.Mountpoint] = struct{}{}
-			}
 			mountPoints[subsystem] = mount.Mountpoint
 		}
 	}
 
-	return CgroupSubsystems{
-		Mounts:      supportedCgroups,
-		MountPoints: mountPoints,
-	}, nil
+	return mountPoints, nil
 }
 
-// Cgroup subsystems we support listing (should be the minimal set we need stats from).
-var supportedSubsystems map[string]struct{} = map[string]struct{}{
-	"cpu":        {},
-	"cpuacct":    {},
-	"memory":     {},
-	"hugetlb":    {},
-	"pids":       {},
-	"cpuset":     {},
-	"blkio":      {},
-	"io":         {},
-	"devices":    {},
-	"perf_event": {},
+// A map of cgroup subsystems we support listing (should be the minimal set
+// we need stats from) to a respective MetricKind.
+var supportedSubsystems = map[string]container.MetricKind{
+	"cpu":        container.CpuUsageMetrics,
+	"cpuacct":    container.CpuUsageMetrics,
+	"memory":     container.MemoryUsageMetrics,
+	"hugetlb":    container.HugetlbUsageMetrics,
+	"pids":       container.ProcessMetrics,
+	"cpuset":     container.CPUSetMetrics,
+	"blkio":      container.DiskIOMetrics,
+	"io":         container.DiskIOMetrics,
+	"devices":    "",
+	"perf_event": container.PerfMetrics,
 }
 
-func DiskStatsCopy0(major, minor uint64) *info.PerDiskStats {
+// Check if this cgroup subsystem/controller is of use.
+func needSubsys(name string, metrics container.MetricSet) bool {
+	// Check if supported.
+	metric, supported := supportedSubsystems[name]
+	if !supported {
+		return false
+	}
+	// Check if needed.
+	if metrics == nil || metric == "" {
+		return true
+	}
+
+	return metrics.Has(metric)
+}
+
+func diskStatsCopy0(major, minor uint64) *info.PerDiskStats {
 	disk := info.PerDiskStats{
 		Major: major,
 		Minor: minor,
@@ -129,12 +115,12 @@ func DiskStatsCopy0(major, minor uint64) *info.PerDiskStats {
 	return &disk
 }
 
-type DiskKey struct {
+type diskKey struct {
 	Major uint64
 	Minor uint64
 }
 
-func DiskStatsCopy1(diskStat map[DiskKey]*info.PerDiskStats) []info.PerDiskStats {
+func diskStatsCopy1(diskStat map[diskKey]*info.PerDiskStats) []info.PerDiskStats {
 	i := 0
 	stat := make([]info.PerDiskStats, len(diskStat))
 	for _, disk := range diskStat {
@@ -144,21 +130,21 @@ func DiskStatsCopy1(diskStat map[DiskKey]*info.PerDiskStats) []info.PerDiskStats
 	return stat
 }
 
-func DiskStatsCopy(blkioStats []cgroups.BlkioStatEntry) (stat []info.PerDiskStats) {
+func diskStatsCopy(blkioStats []cgroups.BlkioStatEntry) (stat []info.PerDiskStats) {
 	if len(blkioStats) == 0 {
 		return
 	}
-	diskStat := make(map[DiskKey]*info.PerDiskStats)
+	diskStat := make(map[diskKey]*info.PerDiskStats)
 	for i := range blkioStats {
 		major := blkioStats[i].Major
 		minor := blkioStats[i].Minor
-		key := DiskKey{
+		key := diskKey{
 			Major: major,
 			Minor: minor,
 		}
 		diskp, ok := diskStat[key]
 		if !ok {
-			diskp = DiskStatsCopy0(major, minor)
+			diskp = diskStatsCopy0(major, minor)
 			diskStat[key] = diskp
 		}
 		op := blkioStats[i].Op
@@ -167,12 +153,12 @@ func DiskStatsCopy(blkioStats []cgroups.BlkioStatEntry) (stat []info.PerDiskStat
 		}
 		diskp.Stats[op] = blkioStats[i].Value
 	}
-	return DiskStatsCopy1(diskStat)
+	return diskStatsCopy1(diskStat)
 }
 
 func NewCgroupManager(name string, paths map[string]string) (cgroups.Manager, error) {
 	if cgroups.IsCgroup2UnifiedMode() {
-		path := paths["cpu"]
+		path := paths[""]
 		return fs2.NewManager(nil, path, false)
 	}
 
@@ -180,5 +166,4 @@ func NewCgroupManager(name string, paths map[string]string) (cgroups.Manager, er
 		Name: name,
 	}
 	return fs.NewManager(&config, paths, false), nil
-
 }