1 files changed, 259 insertions, 6 deletions

diff --git a/vendor/github.com/prometheus/procfs/cpuinfo.go b/vendor/github.com/prometheus/procfs/cpuinfo.go
index 2e02215..31d42f7 100644
--- a/vendor/github.com/prometheus/procfs/cpuinfo.go
+++ b/vendor/github.com/prometheus/procfs/cpuinfo.go
@@ -11,11 +11,15 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// +build linux
+
 package procfs
 
 import (
         "bufio"
         "bytes"
+        "errors"
+        "regexp"
         "strconv"
         "strings"
 
@@ -52,6 +56,11 @@ type CPUInfo struct {
         PowerManagement string
 }
 
+var (
+        cpuinfoClockRegexp          = regexp.MustCompile(`([\d.]+)`)
+        cpuinfoS390XProcessorRegexp = regexp.MustCompile(`^processor\s+(\d+):.*`)
+)
+
 // CPUInfo returns information about current system CPUs.
 // See https://www.kernel.org/doc/Documentation/filesystems/proc.txt
 func (fs FS) CPUInfo() ([]CPUInfo, error) {
@@ -62,14 +71,26 @@ func (fs FS) CPUInfo() ([]CPUInfo, error) {
         return parseCPUInfo(data)
 }
 
-// parseCPUInfo parses data from /proc/cpuinfo
-func parseCPUInfo(info []byte) ([]CPUInfo, error) {
-        cpuinfo := []CPUInfo{}
-        i := -1
+func parseCPUInfoX86(info []byte) ([]CPUInfo, error) {
         scanner := bufio.NewScanner(bytes.NewReader(info))
+
+        // find the first "processor" line
+        firstLine := firstNonEmptyLine(scanner)
+        if !strings.HasPrefix(firstLine, "processor") || !strings.Contains(firstLine, ":") {
+                return nil, errors.New("invalid cpuinfo file: " + firstLine)
+        }
+        field := strings.SplitN(firstLine, ": ", 2)
+        v, err := strconv.ParseUint(field[1], 0, 32)
+        if err != nil {
+                return nil, err
+        }
+        firstcpu := CPUInfo{Processor: uint(v)}
+        cpuinfo := []CPUInfo{firstcpu}
+        i := 0
+
         for scanner.Scan() {
                 line := scanner.Text()
-                if strings.TrimSpace(line) == "" {
+                if !strings.Contains(line, ":") {
                         continue
                 }
                 field := strings.SplitN(line, ": ", 2)
@@ -82,7 +103,7 @@ func parseCPUInfo(info []byte) ([]CPUInfo, error) {
                                 return nil, err
                         }
                         cpuinfo[i].Processor = uint(v)
-                case "vendor_id":
+                case "vendor", "vendor_id":
                         cpuinfo[i].VendorID = field[1]
                 case "cpu family":
                         cpuinfo[i].CPUFamily = field[1]
@@ -163,5 +184,237 @@ func parseCPUInfo(info []byte) ([]CPUInfo, error) {
                 }
         }
         return cpuinfo, nil
+}
+
+func parseCPUInfoARM(info []byte) ([]CPUInfo, error) {
+        scanner := bufio.NewScanner(bytes.NewReader(info))
+
+        firstLine := firstNonEmptyLine(scanner)
+        match, _ := regexp.MatchString("^[Pp]rocessor", firstLine)
+        if !match || !strings.Contains(firstLine, ":") {
+                return nil, errors.New("invalid cpuinfo file: " + firstLine)
+        }
+        field := strings.SplitN(firstLine, ": ", 2)
+        cpuinfo := []CPUInfo{}
+        featuresLine := ""
+        commonCPUInfo := CPUInfo{}
+        i := 0
+        if strings.TrimSpace(field[0]) == "Processor" {
+                commonCPUInfo = CPUInfo{ModelName: field[1]}
+                i = -1
+        } else {
+                v, err := strconv.ParseUint(field[1], 0, 32)
+                if err != nil {
+                        return nil, err
+                }
+                firstcpu := CPUInfo{Processor: uint(v)}
+                cpuinfo = []CPUInfo{firstcpu}
+        }
+
+        for scanner.Scan() {
+                line := scanner.Text()
+                if !strings.Contains(line, ":") {
+                        continue
+                }
+                field := strings.SplitN(line, ": ", 2)
+                switch strings.TrimSpace(field[0]) {
+                case "processor":
+                        cpuinfo = append(cpuinfo, commonCPUInfo) // start of the next processor
+                        i++
+                        v, err := strconv.ParseUint(field[1], 0, 32)
+                        if err != nil {
+                                return nil, err
+                        }
+                        cpuinfo[i].Processor = uint(v)
+                case "BogoMIPS":
+                        if i == -1 {
+                                cpuinfo = append(cpuinfo, commonCPUInfo) // There is only one processor
+                                i++
+                                cpuinfo[i].Processor = 0
+                        }
+                        v, err := strconv.ParseFloat(field[1], 64)
+                        if err != nil {
+                                return nil, err
+                        }
+                        cpuinfo[i].BogoMips = v
+                case "Features":
+                        featuresLine = line
+                case "model name":
+                        cpuinfo[i].ModelName = field[1]
+                }
+        }
+        fields := strings.SplitN(featuresLine, ": ", 2)
+        for i := range cpuinfo {
+                cpuinfo[i].Flags = strings.Fields(fields[1])
+        }
+        return cpuinfo, nil
+
+}
+
+func parseCPUInfoS390X(info []byte) ([]CPUInfo, error) {
+        scanner := bufio.NewScanner(bytes.NewReader(info))
+
+        firstLine := firstNonEmptyLine(scanner)
+        if !strings.HasPrefix(firstLine, "vendor_id") || !strings.Contains(firstLine, ":") {
+                return nil, errors.New("invalid cpuinfo file: " + firstLine)
+        }
+        field := strings.SplitN(firstLine, ": ", 2)
+        cpuinfo := []CPUInfo{}
+        commonCPUInfo := CPUInfo{VendorID: field[1]}
+
+        for scanner.Scan() {
+                line := scanner.Text()
+                if !strings.Contains(line, ":") {
+                        continue
+                }
+                field := strings.SplitN(line, ": ", 2)
+                switch strings.TrimSpace(field[0]) {
+                case "bogomips per cpu":
+                        v, err := strconv.ParseFloat(field[1], 64)
+                        if err != nil {
+                                return nil, err
+                        }
+                        commonCPUInfo.BogoMips = v
+                case "features":
+                        commonCPUInfo.Flags = strings.Fields(field[1])
+                }
+                if strings.HasPrefix(line, "processor") {
+                        match := cpuinfoS390XProcessorRegexp.FindStringSubmatch(line)
+                        if len(match) < 2 {
+                                return nil, errors.New("Invalid line found in cpuinfo: " + line)
+                        }
+                        cpu := commonCPUInfo
+                        v, err := strconv.ParseUint(match[1], 0, 32)
+                        if err != nil {
+                                return nil, err
+                        }
+                        cpu.Processor = uint(v)
+                        cpuinfo = append(cpuinfo, cpu)
+                }
+                if strings.HasPrefix(line, "cpu number") {
+                        break
+                }
+        }
+
+        i := 0
+        for scanner.Scan() {
+                line := scanner.Text()
+                if !strings.Contains(line, ":") {
+                        continue
+                }
+                field := strings.SplitN(line, ": ", 2)
+                switch strings.TrimSpace(field[0]) {
+                case "cpu number":
+                        i++
+                case "cpu MHz dynamic":
+                        clock := cpuinfoClockRegexp.FindString(strings.TrimSpace(field[1]))
+                        v, err := strconv.ParseFloat(clock, 64)
+                        if err != nil {
+                                return nil, err
+                        }
+                        cpuinfo[i].CPUMHz = v
+                }
+        }
+
+        return cpuinfo, nil
+}
+
+func parseCPUInfoMips(info []byte) ([]CPUInfo, error) {
+        scanner := bufio.NewScanner(bytes.NewReader(info))
+
+        // find the first "processor" line
+        firstLine := firstNonEmptyLine(scanner)
+        if !strings.HasPrefix(firstLine, "system type") || !strings.Contains(firstLine, ":") {
+                return nil, errors.New("invalid cpuinfo file: " + firstLine)
+        }
+        field := strings.SplitN(firstLine, ": ", 2)
+        cpuinfo := []CPUInfo{}
+        systemType := field[1]
+
+        i := 0
+
+        for scanner.Scan() {
+                line := scanner.Text()
+                if !strings.Contains(line, ":") {
+                        continue
+                }
+                field := strings.SplitN(line, ": ", 2)
+                switch strings.TrimSpace(field[0]) {
+                case "processor":
+                        v, err := strconv.ParseUint(field[1], 0, 32)
+                        if err != nil {
+                                return nil, err
+                        }
+                        i = int(v)
+                        cpuinfo = append(cpuinfo, CPUInfo{}) // start of the next processor
+                        cpuinfo[i].Processor = uint(v)
+                        cpuinfo[i].VendorID = systemType
+                case "cpu model":
+                        cpuinfo[i].ModelName = field[1]
+                case "BogoMIPS":
+                        v, err := strconv.ParseFloat(field[1], 64)
+                        if err != nil {
+                                return nil, err
+                        }
+                        cpuinfo[i].BogoMips = v
+                }
+        }
+        return cpuinfo, nil
+}
+
+func parseCPUInfoPPC(info []byte) ([]CPUInfo, error) {
+        scanner := bufio.NewScanner(bytes.NewReader(info))
+
+        firstLine := firstNonEmptyLine(scanner)
+        if !strings.HasPrefix(firstLine, "processor") || !strings.Contains(firstLine, ":") {
+                return nil, errors.New("invalid cpuinfo file: " + firstLine)
+        }
+        field := strings.SplitN(firstLine, ": ", 2)
+        v, err := strconv.ParseUint(field[1], 0, 32)
+        if err != nil {
+                return nil, err
+        }
+        firstcpu := CPUInfo{Processor: uint(v)}
+        cpuinfo := []CPUInfo{firstcpu}
+        i := 0
+
+        for scanner.Scan() {
+                line := scanner.Text()
+                if !strings.Contains(line, ":") {
+                        continue
+                }
+                field := strings.SplitN(line, ": ", 2)
+                switch strings.TrimSpace(field[0]) {
+                case "processor":
+                        cpuinfo = append(cpuinfo, CPUInfo{}) // start of the next processor
+                        i++
+                        v, err := strconv.ParseUint(field[1], 0, 32)
+                        if err != nil {
+                                return nil, err
+                        }
+                        cpuinfo[i].Processor = uint(v)
+                case "cpu":
+                        cpuinfo[i].VendorID = field[1]
+                case "clock":
+                        clock := cpuinfoClockRegexp.FindString(strings.TrimSpace(field[1]))
+                        v, err := strconv.ParseFloat(clock, 64)
+                        if err != nil {
+                                return nil, err
+                        }
+                        cpuinfo[i].CPUMHz = v
+                }
+        }
+        return cpuinfo, nil
+}
 
+// firstNonEmptyLine advances the scanner to the first non-empty line
+// and returns the contents of that line
+func firstNonEmptyLine(scanner *bufio.Scanner) string {
+        for scanner.Scan() {
+                line := scanner.Text()
+                if strings.TrimSpace(line) != "" {
+                        return line
+                }
+        }
+        return ""
 }