Update to new cadvisor v0.48.1

Signed-off-by: Davanum Srinivas <davanum@gmail.com>

vendor/github.com/google/cadvisor/utils/sysfs/sysfs.go

@@ -17,7 +17,6 @@ package sysfs
 import (
 	"bytes"
 	"fmt"
-	"io/ioutil"
 	"os"
 	"path"
 	"path/filepath"
@@ -102,6 +101,9 @@ type SysFs interface {
 	GetBlockDeviceScheduler(string) (string, error)
 	// Get device major:minor number string.
 	GetBlockDeviceNumbers(string) (string, error)
+	// Is the device "hidden" (meaning will not have a device handle)
+	// This is the case with native nvme multipathing.
+	IsBlockDeviceHidden(string) (bool, error)
 
 	GetNetworkDevices() ([]os.FileInfo, error)
 	GetNetworkAddress(string) (string, error)
@@ -124,10 +126,14 @@ type SysFs interface {
 	IsCPUOnline(dir string) bool
 }
 
-type realSysFs struct{}
+type realSysFs struct {
+	cpuPath string
+}
 
 func NewRealSysFs() SysFs {
-	return &realSysFs{}
+	return &realSysFs{
+		cpuPath: "/sys/devices/system/cpu",
+	}
 }
 
 func (fs *realSysFs) GetNodesPaths() ([]string, error) {
@@ -142,7 +148,7 @@ func (fs *realSysFs) GetCPUsPaths(cpusPath string) ([]string, error) {
 
 func (fs *realSysFs) GetCoreID(cpuPath string) (string, error) {
 	coreIDFilePath := fmt.Sprintf("%s%s", cpuPath, coreIDFilePath)
-	coreID, err := ioutil.ReadFile(coreIDFilePath)
+	coreID, err := os.ReadFile(coreIDFilePath)
 	if err != nil {
 		return "", err
 	}
@@ -151,7 +157,7 @@ func (fs *realSysFs) GetCoreID(cpuPath string) (string, error) {
 
 func (fs *realSysFs) GetCPUPhysicalPackageID(cpuPath string) (string, error) {
 	packageIDFilePath := fmt.Sprintf("%s%s", cpuPath, packageIDFilePath)
-	packageID, err := ioutil.ReadFile(packageIDFilePath)
+	packageID, err := os.ReadFile(packageIDFilePath)
 	if err != nil {
 		return "", err
 	}
@@ -160,7 +166,7 @@ func (fs *realSysFs) GetCPUPhysicalPackageID(cpuPath string) (string, error) {
 
 func (fs *realSysFs) GetMemInfo(nodePath string) (string, error) {
 	meminfoPath := fmt.Sprintf("%s/%s", nodePath, meminfoFile)
-	meminfo, err := ioutil.ReadFile(meminfoPath)
+	meminfo, err := os.ReadFile(meminfoPath)
 	if err != nil {
 		return "", err
 	}
@@ -169,7 +175,7 @@ func (fs *realSysFs) GetMemInfo(nodePath string) (string, error) {
 
 func (fs *realSysFs) GetDistances(nodePath string) (string, error) {
 	distancePath := fmt.Sprintf("%s/%s", nodePath, distanceFile)
-	distance, err := ioutil.ReadFile(distancePath)
+	distance, err := os.ReadFile(distancePath)
 	if err != nil {
 		return "", err
 	}
@@ -177,12 +183,16 @@ func (fs *realSysFs) GetDistances(nodePath string) (string, error) {
 }
 
 func (fs *realSysFs) GetHugePagesInfo(hugePagesDirectory string) ([]os.FileInfo, error) {
-	return ioutil.ReadDir(hugePagesDirectory)
+	dirs, err := os.ReadDir(hugePagesDirectory)
+	if err != nil {
+		return nil, err
+	}
+	return toFileInfo(dirs)
 }
 
 func (fs *realSysFs) GetHugePagesNr(hugepagesDirectory string, hugePageName string) (string, error) {
 	hugePageFilePath := fmt.Sprintf("%s%s/%s", hugepagesDirectory, hugePageName, HugePagesNrFile)
-	hugePageFile, err := ioutil.ReadFile(hugePageFilePath)
+	hugePageFile, err := os.ReadFile(hugePageFilePath)
 	if err != nil {
 		return "", err
 	}
@@ -190,19 +200,43 @@ func (fs *realSysFs) GetHugePagesNr(hugepagesDirectory string, hugePageName stri
 }
 
 func (fs *realSysFs) GetBlockDevices() ([]os.FileInfo, error) {
-	return ioutil.ReadDir(blockDir)
+	dirs, err := os.ReadDir(blockDir)
+	if err != nil {
+		return nil, err
+	}
+	return toFileInfo(dirs)
 }
 
 func (fs *realSysFs) GetBlockDeviceNumbers(name string) (string, error) {
-	dev, err := ioutil.ReadFile(path.Join(blockDir, name, "/dev"))
+	dev, err := os.ReadFile(path.Join(blockDir, name, "/dev"))
 	if err != nil {
 		return "", err
 	}
 	return string(dev), nil
 }
 
+func (fs *realSysFs) IsBlockDeviceHidden(name string) (bool, error) {
+	// See: https://www.kernel.org/doc/Documentation/ABI/stable/sysfs-block
+	//      https://git.kernel.org/pub/scm/utils/util-linux/util-linux.git
+	//        - c8487d854ba5 ("lsblk: Ignore hidden devices")
+	devHiddenPath := path.Join(blockDir, name, "/hidden")
+	hidden, err := os.ReadFile(devHiddenPath)
+	if err != nil && os.IsNotExist(err) {
+		// older OS may not have /hidden sysfs entry, so for sure
+		// it is not a hidden device...
+		return false, nil
+	}
+	if err != nil {
+		return false, fmt.Errorf("failed to read %s: %w", devHiddenPath, err)
+	}
+	if string(hidden) == "1" {
+		return true, nil
+	}
+	return false, nil
+}
+
 func (fs *realSysFs) GetBlockDeviceScheduler(name string) (string, error) {
-	sched, err := ioutil.ReadFile(path.Join(blockDir, name, "/queue/scheduler"))
+	sched, err := os.ReadFile(path.Join(blockDir, name, "/queue/scheduler"))
 	if err != nil {
 		return "", err
 	}
@@ -210,7 +244,7 @@ func (fs *realSysFs) GetBlockDeviceScheduler(name string) (string, error) {
 }
 
 func (fs *realSysFs) GetBlockDeviceSize(name string) (string, error) {
-	size, err := ioutil.ReadFile(path.Join(blockDir, name, "/size"))
+	size, err := os.ReadFile(path.Join(blockDir, name, "/size"))
 	if err != nil {
 		return "", err
 	}
@@ -218,13 +252,17 @@ func (fs *realSysFs) GetBlockDeviceSize(name string) (string, error) {
 }
 
 func (fs *realSysFs) GetNetworkDevices() ([]os.FileInfo, error) {
-	files, err := ioutil.ReadDir(netDir)
+	dirs, err := os.ReadDir(netDir)
+	if err != nil {
+		return nil, err
+	}
+	files, err := toFileInfo(dirs)
 	if err != nil {
 		return nil, err
 	}
 
 	// Filter out non-directory & non-symlink files
-	var dirs []os.FileInfo
+	filtered := []os.FileInfo{}
 	for _, f := range files {
 		if f.Mode()|os.ModeSymlink != 0 {
 			f, err = os.Stat(path.Join(netDir, f.Name()))
@@ -233,14 +271,14 @@ func (fs *realSysFs) GetNetworkDevices() ([]os.FileInfo, error) {
 			}
 		}
 		if f.IsDir() {
-			dirs = append(dirs, f)
+			filtered = append(filtered, f)
 		}
 	}
-	return dirs, nil
+	return filtered, nil
 }
 
 func (fs *realSysFs) GetNetworkAddress(name string) (string, error) {
-	address, err := ioutil.ReadFile(path.Join(netDir, name, "/address"))
+	address, err := os.ReadFile(path.Join(netDir, name, "/address"))
 	if err != nil {
 		return "", err
 	}
@@ -248,7 +286,7 @@ func (fs *realSysFs) GetNetworkAddress(name string) (string, error) {
 }
 
 func (fs *realSysFs) GetNetworkMtu(name string) (string, error) {
-	mtu, err := ioutil.ReadFile(path.Join(netDir, name, "/mtu"))
+	mtu, err := os.ReadFile(path.Join(netDir, name, "/mtu"))
 	if err != nil {
 		return "", err
 	}
@@ -256,7 +294,7 @@ func (fs *realSysFs) GetNetworkMtu(name string) (string, error) {
 }
 
 func (fs *realSysFs) GetNetworkSpeed(name string) (string, error) {
-	speed, err := ioutil.ReadFile(path.Join(netDir, name, "/speed"))
+	speed, err := os.ReadFile(path.Join(netDir, name, "/speed"))
 	if err != nil {
 		return "", err
 	}
@@ -265,7 +303,7 @@ func (fs *realSysFs) GetNetworkSpeed(name string) (string, error) {
 
 func (fs *realSysFs) GetNetworkStatValue(dev string, stat string) (uint64, error) {
 	statPath := path.Join(netDir, dev, "/statistics", stat)
-	out, err := ioutil.ReadFile(statPath)
+	out, err := os.ReadFile(statPath)
 	if err != nil {
 		return 0, fmt.Errorf("failed to read stat from %q for device %q", statPath, dev)
 	}
@@ -279,7 +317,23 @@ func (fs *realSysFs) GetNetworkStatValue(dev string, stat string) (uint64, error
 
 func (fs *realSysFs) GetCaches(id int) ([]os.FileInfo, error) {
 	cpuPath := fmt.Sprintf("%s%d/cache", cacheDir, id)
-	return ioutil.ReadDir(cpuPath)
+	dir, err := os.ReadDir(cpuPath)
+	if err != nil {
+		return nil, err
+	}
+	return toFileInfo(dir)
+}
+
+func toFileInfo(dirs []os.DirEntry) ([]os.FileInfo, error) {
+	info := []os.FileInfo{}
+	for _, dir := range dirs {
+		fI, err := dir.Info()
+		if err != nil {
+			return nil, err
+		}
+		info = append(info, fI)
+	}
+	return info, nil
 }
 
 func bitCount(i uint64) (count int) {
@@ -293,7 +347,7 @@ func bitCount(i uint64) (count int) {
 }
 
 func getCPUCount(cache string) (count int, err error) {
-	out, err := ioutil.ReadFile(path.Join(cache, "/shared_cpu_map"))
+	out, err := os.ReadFile(path.Join(cache, "/shared_cpu_map"))
 	if err != nil {
 		return 0, err
 	}
@@ -311,7 +365,7 @@ func getCPUCount(cache string) (count int, err error) {
 
 func (fs *realSysFs) GetCacheInfo(cpu int, name string) (CacheInfo, error) {
 	cachePath := fmt.Sprintf("%s%d/cache/%s", cacheDir, cpu, name)
-	out, err := ioutil.ReadFile(path.Join(cachePath, "/id"))
+	out, err := os.ReadFile(path.Join(cachePath, "/id"))
 	if err != nil {
 		return CacheInfo{}, err
 	}
@@ -321,7 +375,7 @@ func (fs *realSysFs) GetCacheInfo(cpu int, name string) (CacheInfo, error) {
 		return CacheInfo{}, err
 	}
 
-	out, err = ioutil.ReadFile(path.Join(cachePath, "/size"))
+	out, err = os.ReadFile(path.Join(cachePath, "/size"))
 	if err != nil {
 		return CacheInfo{}, err
 	}
@@ -332,7 +386,7 @@ func (fs *realSysFs) GetCacheInfo(cpu int, name string) (CacheInfo, error) {
 	}
 	// convert to bytes
 	size = size * 1024
-	out, err = ioutil.ReadFile(path.Join(cachePath, "/level"))
+	out, err = os.ReadFile(path.Join(cachePath, "/level"))
 	if err != nil {
 		return CacheInfo{}, err
 	}
@@ -342,7 +396,7 @@ func (fs *realSysFs) GetCacheInfo(cpu int, name string) (CacheInfo, error) {
 		return CacheInfo{}, err
 	}
 
-	out, err = ioutil.ReadFile(path.Join(cachePath, "/type"))
+	out, err = os.ReadFile(path.Join(cachePath, "/type"))
 	if err != nil {
 		return CacheInfo{}, err
 	}
@@ -361,13 +415,13 @@ func (fs *realSysFs) GetCacheInfo(cpu int, name string) (CacheInfo, error) {
 }
 
 func (fs *realSysFs) GetSystemUUID() (string, error) {
-	if id, err := ioutil.ReadFile(path.Join(dmiDir, "id", "product_uuid")); err == nil {
+	if id, err := os.ReadFile(path.Join(dmiDir, "id", "product_uuid")); err == nil {
 		return strings.TrimSpace(string(id)), nil
-	} else if id, err = ioutil.ReadFile(path.Join(ppcDevTree, "system-id")); err == nil {
+	} else if id, err = os.ReadFile(path.Join(ppcDevTree, "system-id")); err == nil {
 		return strings.TrimSpace(strings.TrimRight(string(id), "\000")), nil
-	} else if id, err = ioutil.ReadFile(path.Join(ppcDevTree, "vm,uuid")); err == nil {
+	} else if id, err = os.ReadFile(path.Join(ppcDevTree, "vm,uuid")); err == nil {
 		return strings.TrimSpace(strings.TrimRight(string(id), "\000")), nil
-	} else if id, err = ioutil.ReadFile(path.Join(s390xDevTree, "machine-id")); err == nil {
+	} else if id, err = os.ReadFile(path.Join(s390xDevTree, "machine-id")); err == nil {
 		return strings.TrimSpace(string(id)), nil
 	} else {
 		return "", err
@@ -375,19 +429,19 @@ func (fs *realSysFs) GetSystemUUID() (string, error) {
 }
 
 func (fs *realSysFs) IsCPUOnline(cpuPath string) bool {
-	onlinePath, err := filepath.Abs(cpuPath + "/../online")
+	cpuOnlinePath, err := filepath.Abs(fs.cpuPath + "/online")
 	if err != nil {
 		klog.V(1).Infof("Unable to get absolute path for %s", cpuPath)
 		return false
 	}
 
 	// Quick check to determine if file exists: if it does not then kernel CPU hotplug is disabled and all CPUs are online.
-	_, err = os.Stat(onlinePath)
+	_, err = os.Stat(cpuOnlinePath)
 	if err != nil && os.IsNotExist(err) {
 		return true
 	}
 	if err != nil {
-		klog.V(1).Infof("Unable to stat %s: %s", onlinePath, err)
+		klog.V(1).Infof("Unable to stat %s: %s", cpuOnlinePath, err)
 	}
 
 	cpuID, err := getCPUID(cpuPath)
@@ -396,7 +450,7 @@ func (fs *realSysFs) IsCPUOnline(cpuPath string) bool {
 		return false
 	}
 
-	isOnline, err := isCPUOnline(onlinePath, cpuID)
+	isOnline, err := isCPUOnline(cpuOnlinePath, cpuID)
 	if err != nil {
 		klog.V(1).Infof("Unable to get online CPUs list: %s", err)
 		return false
@@ -422,7 +476,7 @@ func getCPUID(dir string) (uint16, error) {
 // It parses CPU list (such as: 0,3-5,10) into a struct that allows to determine quickly if CPU or particular ID is online.
 // see: https://github.com/opencontainers/runc/blob/ab27e12cebf148aa5d1ee3ad13d9fc7ae12bf0b6/libcontainer/cgroups/fs/cpuset.go#L45
 func isCPUOnline(path string, cpuID uint16) (bool, error) {
-	fileContent, err := ioutil.ReadFile(path)
+	fileContent, err := os.ReadFile(path)
 	if err != nil {
 		return false, err
 	}
@@ -448,10 +502,9 @@ func isCPUOnline(path string, cpuID uint16) (bool, error) {
 			if min > max {
 				return false, fmt.Errorf("invalid values in %s", path)
 			}
-			for i := min; i <= max; i++ {
-				if uint16(i) == cpuID {
-					return true, nil
-				}
+			// Return true, if the CPU under consideration is in the range of online CPUs.
+			if cpuID >= uint16(min) && cpuID <= uint16(max) {
+				return true, nil
 			}
 		case 1:
 			value, err := strconv.ParseUint(s, 10, 16)
@@ -469,21 +522,21 @@ func isCPUOnline(path string, cpuID uint16) (bool, error) {
 
 // Looks for sysfs cpu path containing given CPU property, e.g. core_id or physical_package_id
 // and returns number of unique values of given property, exemplary usage: getting number of CPU physical cores
-func GetUniqueCPUPropertyCount(cpuBusPath string, propertyName string) int {
-	absCPUBusPath, err := filepath.Abs(cpuBusPath)
+func GetUniqueCPUPropertyCount(cpuAttributesPath string, propertyName string) int {
+	absCPUAttributesPath, err := filepath.Abs(cpuAttributesPath)
 	if err != nil {
-		klog.Errorf("Cannot make %s absolute", cpuBusPath)
+		klog.Errorf("Cannot make %s absolute", cpuAttributesPath)
 		return 0
 	}
-	pathPattern := absCPUBusPath + "/cpu*[0-9]"
+	pathPattern := absCPUAttributesPath + "/cpu*[0-9]"
 	sysCPUPaths, err := filepath.Glob(pathPattern)
 	if err != nil {
 		klog.Errorf("Cannot find files matching pattern (pathPattern: %s),  number of unique %s set to 0", pathPattern, propertyName)
 		return 0
 	}
-	onlinePath, err := filepath.Abs(cpuBusPath + "/online")
+	cpuOnlinePath, err := filepath.Abs(cpuAttributesPath + "/online")
 	if err != nil {
-		klog.V(1).Infof("Unable to get absolute path for %s", cpuBusPath+"/../online")
+		klog.V(1).Infof("Unable to get absolute path for %s", cpuAttributesPath+"/../online")
 		return 0
 	}
 
@@ -498,7 +551,7 @@ func GetUniqueCPUPropertyCount(cpuBusPath string, propertyName string) int {
 			klog.V(1).Infof("Unable to get CPU ID from path %s: %s", sysCPUPath, err)
 			return 0
 		}
-		isOnline, err := isCPUOnline(onlinePath, cpuID)
+		isOnline, err := isCPUOnline(cpuOnlinePath, cpuID)
 		if err != nil && !os.IsNotExist(err) {
 			klog.V(1).Infof("Unable to determine CPU online state: %s", err)
 			continue
@@ -507,13 +560,13 @@ func GetUniqueCPUPropertyCount(cpuBusPath string, propertyName string) int {
 			continue
 		}
 		propertyPath := filepath.Join(sysCPUPath, sysFsCPUTopology, propertyName)
-		propertyVal, err := ioutil.ReadFile(propertyPath)
+		propertyVal, err := os.ReadFile(propertyPath)
 		if err != nil {
 			klog.Warningf("Cannot open %s, assuming 0 for %s of CPU %d", propertyPath, propertyName, cpuID)
 			propertyVal = []byte("0")
 		}
 		packagePath := filepath.Join(sysCPUPath, sysFsCPUTopology, CPUPhysicalPackageID)
-		packageVal, err := ioutil.ReadFile(packagePath)
+		packageVal, err := os.ReadFile(packagePath)
 		if err != nil {
 			klog.Warningf("Cannot open %s, assuming 0 %s of CPU %d", packagePath, CPUPhysicalPackageID, cpuID)
 			packageVal = []byte("0")