Initial commit

vendor/github.com/shirou/gopsutil/LICENSE

@@ -0,0 +1,61 @@
+gopsutil is distributed under BSD license reproduced below.
+
+Copyright (c) 2014, WAKAYAMA Shirou
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of the gopsutil authors nor the names of its contributors
+   may be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+-------
+internal/common/binary.go in the gopsutil is copied and modifid from golang/encoding/binary.go.
+
+
+
+Copyright (c) 2009 The Go Authors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+   * Neither the name of Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

vendor/github.com/shirou/gopsutil/cpu/BUILD.bazel

@@ -0,0 +1,52 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "cpu.go",
+        "cpu_darwin.go",
+        "cpu_darwin_cgo.go",
+        "cpu_darwin_nocgo.go",
+        "cpu_fallback.go",
+        "cpu_freebsd.go",
+        "cpu_freebsd_386.go",
+        "cpu_freebsd_amd64.go",
+        "cpu_linux.go",
+        "cpu_openbsd.go",
+        "cpu_solaris.go",
+        "cpu_windows.go",
+    ],
+    cgo = True,
+    importmap = "go-common/vendor/github.com/shirou/gopsutil/cpu",
+    importpath = "github.com/shirou/gopsutil/cpu",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//vendor/github.com/shirou/gopsutil/internal/common:go_default_library",
+    ] + select({
+        "@io_bazel_rules_go//go/platform:freebsd": [
+            "//vendor/golang.org/x/sys/unix:go_default_library",
+        ],
+        "@io_bazel_rules_go//go/platform:openbsd": [
+            "//vendor/golang.org/x/sys/unix:go_default_library",
+        ],
+        "@io_bazel_rules_go//go/platform:windows": [
+            "//vendor/github.com/StackExchange/wmi:go_default_library",
+            "//vendor/golang.org/x/sys/windows:go_default_library",
+        ],
+        "//conditions:default": [],
+    }),
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

vendor/github.com/shirou/gopsutil/cpu/cpu.go

@@ -0,0 +1,189 @@
+package cpu
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"runtime"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/shirou/gopsutil/internal/common"
+)
+
+// TimesStat contains the amounts of time the CPU has spent performing different
+// kinds of work. Time units are in USER_HZ or Jiffies (typically hundredths of
+// a second). It is based on linux /proc/stat file.
+type TimesStat struct {
+	CPU       string  `json:"cpu"`
+	User      float64 `json:"user"`
+	System    float64 `json:"system"`
+	Idle      float64 `json:"idle"`
+	Nice      float64 `json:"nice"`
+	Iowait    float64 `json:"iowait"`
+	Irq       float64 `json:"irq"`
+	Softirq   float64 `json:"softirq"`
+	Steal     float64 `json:"steal"`
+	Guest     float64 `json:"guest"`
+	GuestNice float64 `json:"guestNice"`
+	Stolen    float64 `json:"stolen"`
+}
+
+type InfoStat struct {
+	CPU        int32    `json:"cpu"`
+	VendorID   string   `json:"vendorId"`
+	Family     string   `json:"family"`
+	Model      string   `json:"model"`
+	Stepping   int32    `json:"stepping"`
+	PhysicalID string   `json:"physicalId"`
+	CoreID     string   `json:"coreId"`
+	Cores      int32    `json:"cores"`
+	ModelName  string   `json:"modelName"`
+	Mhz        float64  `json:"mhz"`
+	CacheSize  int32    `json:"cacheSize"`
+	Flags      []string `json:"flags"`
+	Microcode  string   `json:"microcode"`
+}
+
+type lastPercent struct {
+	sync.Mutex
+	lastCPUTimes    []TimesStat
+	lastPerCPUTimes []TimesStat
+}
+
+var lastCPUPercent lastPercent
+var invoke common.Invoker = common.Invoke{}
+
+func init() {
+	lastCPUPercent.Lock()
+	lastCPUPercent.lastCPUTimes, _ = Times(false)
+	lastCPUPercent.lastPerCPUTimes, _ = Times(true)
+	lastCPUPercent.Unlock()
+}
+
+func Counts(logical bool) (int, error) {
+	return CountsWithContext(context.Background(), logical)
+}
+
+func CountsWithContext(ctx context.Context, logical bool) (int, error) {
+	return runtime.NumCPU(), nil
+}
+
+func (c TimesStat) String() string {
+	v := []string{
+		`"cpu":"` + c.CPU + `"`,
+		`"user":` + strconv.FormatFloat(c.User, 'f', 1, 64),
+		`"system":` + strconv.FormatFloat(c.System, 'f', 1, 64),
+		`"idle":` + strconv.FormatFloat(c.Idle, 'f', 1, 64),
+		`"nice":` + strconv.FormatFloat(c.Nice, 'f', 1, 64),
+		`"iowait":` + strconv.FormatFloat(c.Iowait, 'f', 1, 64),
+		`"irq":` + strconv.FormatFloat(c.Irq, 'f', 1, 64),
+		`"softirq":` + strconv.FormatFloat(c.Softirq, 'f', 1, 64),
+		`"steal":` + strconv.FormatFloat(c.Steal, 'f', 1, 64),
+		`"guest":` + strconv.FormatFloat(c.Guest, 'f', 1, 64),
+		`"guestNice":` + strconv.FormatFloat(c.GuestNice, 'f', 1, 64),
+		`"stolen":` + strconv.FormatFloat(c.Stolen, 'f', 1, 64),
+	}
+
+	return `{` + strings.Join(v, ",") + `}`
+}
+
+// Total returns the total number of seconds in a CPUTimesStat
+func (c TimesStat) Total() float64 {
+	total := c.User + c.System + c.Nice + c.Iowait + c.Irq + c.Softirq + c.Steal +
+		c.Guest + c.GuestNice + c.Idle + c.Stolen
+	return total
+}
+
+func (c InfoStat) String() string {
+	s, _ := json.Marshal(c)
+	return string(s)
+}
+
+func getAllBusy(t TimesStat) (float64, float64) {
+	busy := t.User + t.System + t.Nice + t.Iowait + t.Irq +
+		t.Softirq + t.Steal + t.Guest + t.GuestNice + t.Stolen
+	return busy + t.Idle, busy
+}
+
+func calculateBusy(t1, t2 TimesStat) float64 {
+	t1All, t1Busy := getAllBusy(t1)
+	t2All, t2Busy := getAllBusy(t2)
+
+	if t2Busy <= t1Busy {
+		return 0
+	}
+	if t2All <= t1All {
+		return 1
+	}
+	return (t2Busy - t1Busy) / (t2All - t1All) * 100
+}
+
+func calculateAllBusy(t1, t2 []TimesStat) ([]float64, error) {
+	// Make sure the CPU measurements have the same length.
+	if len(t1) != len(t2) {
+		return nil, fmt.Errorf(
+			"received two CPU counts: %d != %d",
+			len(t1), len(t2),
+		)
+	}
+
+	ret := make([]float64, len(t1))
+	for i, t := range t2 {
+		ret[i] = calculateBusy(t1[i], t)
+	}
+	return ret, nil
+}
+
+// Percent calculates the percentage of cpu used either per CPU or combined.
+// If an interval of 0 is given it will compare the current cpu times against the last call.
+// Returns one value per cpu, or a single value if percpu is set to false.
+func Percent(interval time.Duration, percpu bool) ([]float64, error) {
+	return PercentWithContext(context.Background(), interval, percpu)
+}
+
+func PercentWithContext(ctx context.Context, interval time.Duration, percpu bool) ([]float64, error) {
+	if interval <= 0 {
+		return percentUsedFromLastCall(percpu)
+	}
+
+	// Get CPU usage at the start of the interval.
+	cpuTimes1, err := Times(percpu)
+	if err != nil {
+		return nil, err
+	}
+
+	time.Sleep(interval)
+
+	// And at the end of the interval.
+	cpuTimes2, err := Times(percpu)
+	if err != nil {
+		return nil, err
+	}
+
+	return calculateAllBusy(cpuTimes1, cpuTimes2)
+}
+
+func percentUsedFromLastCall(percpu bool) ([]float64, error) {
+	cpuTimes, err := Times(percpu)
+	if err != nil {
+		return nil, err
+	}
+	lastCPUPercent.Lock()
+	defer lastCPUPercent.Unlock()
+	var lastTimes []TimesStat
+	if percpu {
+		lastTimes = lastCPUPercent.lastPerCPUTimes
+		lastCPUPercent.lastPerCPUTimes = cpuTimes
+	} else {
+		lastTimes = lastCPUPercent.lastCPUTimes
+		lastCPUPercent.lastCPUTimes = cpuTimes
+	}
+
+	if lastTimes == nil {
+		return nil, fmt.Errorf("error getting times for cpu percent. lastTimes was nil")
+	}
+	return calculateAllBusy(lastTimes, cpuTimes)
+}

vendor/github.com/shirou/gopsutil/cpu/cpu_darwin.go

@@ -0,0 +1,115 @@
+// +build darwin
+
+package cpu
+
+import (
+	"context"
+	"os/exec"
+	"strconv"
+	"strings"
+)
+
+// sys/resource.h
+const (
+	CPUser    = 0
+	CPNice    = 1
+	CPSys     = 2
+	CPIntr    = 3
+	CPIdle    = 4
+	CPUStates = 5
+)
+
+// default value. from time.h
+var ClocksPerSec = float64(128)
+
+func Times(percpu bool) ([]TimesStat, error) {
+	return TimesWithContext(context.Background(), percpu)
+}
+
+func TimesWithContext(ctx context.Context, percpu bool) ([]TimesStat, error) {
+	if percpu {
+		return perCPUTimes()
+	}
+
+	return allCPUTimes()
+}
+
+// Returns only one CPUInfoStat on FreeBSD
+func Info() ([]InfoStat, error) {
+	return InfoWithContext(context.Background())
+}
+
+func InfoWithContext(ctx context.Context) ([]InfoStat, error) {
+	var ret []InfoStat
+	sysctl, err := exec.LookPath("/usr/sbin/sysctl")
+	if err != nil {
+		return ret, err
+	}
+	out, err := invoke.CommandWithContext(ctx, sysctl, "machdep.cpu")
+	if err != nil {
+		return ret, err
+	}
+
+	c := InfoStat{}
+	for _, line := range strings.Split(string(out), "\n") {
+		values := strings.Fields(line)
+		if len(values) < 1 {
+			continue
+		}
+
+		t, err := strconv.ParseInt(values[1], 10, 64)
+		// err is not checked here because some value is string.
+		if strings.HasPrefix(line, "machdep.cpu.brand_string") {
+			c.ModelName = strings.Join(values[1:], " ")
+		} else if strings.HasPrefix(line, "machdep.cpu.family") {
+			c.Family = values[1]
+		} else if strings.HasPrefix(line, "machdep.cpu.model") {
+			c.Model = values[1]
+		} else if strings.HasPrefix(line, "machdep.cpu.stepping") {
+			if err != nil {
+				return ret, err
+			}
+			c.Stepping = int32(t)
+		} else if strings.HasPrefix(line, "machdep.cpu.features") {
+			for _, v := range values[1:] {
+				c.Flags = append(c.Flags, strings.ToLower(v))
+			}
+		} else if strings.HasPrefix(line, "machdep.cpu.leaf7_features") {
+			for _, v := range values[1:] {
+				c.Flags = append(c.Flags, strings.ToLower(v))
+			}
+		} else if strings.HasPrefix(line, "machdep.cpu.extfeatures") {
+			for _, v := range values[1:] {
+				c.Flags = append(c.Flags, strings.ToLower(v))
+			}
+		} else if strings.HasPrefix(line, "machdep.cpu.core_count") {
+			if err != nil {
+				return ret, err
+			}
+			c.Cores = int32(t)
+		} else if strings.HasPrefix(line, "machdep.cpu.cache.size") {
+			if err != nil {
+				return ret, err
+			}
+			c.CacheSize = int32(t)
+		} else if strings.HasPrefix(line, "machdep.cpu.vendor") {
+			c.VendorID = values[1]
+		}
+	}
+
+	// Use the rated frequency of the CPU. This is a static value and does not
+	// account for low power or Turbo Boost modes.
+	out, err = invoke.CommandWithContext(ctx, sysctl, "hw.cpufrequency")
+	if err != nil {
+		return ret, err
+	}
+
+	values := strings.Fields(string(out))
+	hz, err := strconv.ParseFloat(values[1], 64)
+	if err != nil {
+		return ret, err
+	}
+	c.Mhz = hz / 1000000.0
+
+	return append(ret, c), nil
+}

vendor/github.com/shirou/gopsutil/cpu/cpu_darwin_cgo.go

@@ -0,0 +1,111 @@
+// +build darwin
+// +build cgo
+
+package cpu
+
+/*
+#include <stdlib.h>
+#include <sys/sysctl.h>
+#include <sys/mount.h>
+#include <mach/mach_init.h>
+#include <mach/mach_host.h>
+#include <mach/host_info.h>
+#if TARGET_OS_MAC
+#include <libproc.h>
+#endif
+#include <mach/processor_info.h>
+#include <mach/vm_map.h>
+*/
+import "C"
+
+import (
+	"bytes"
+	"encoding/binary"
+	"fmt"
+	"unsafe"
+)
+
+// these CPU times for darwin is borrowed from influxdb/telegraf.
+
+func perCPUTimes() ([]TimesStat, error) {
+	var (
+		count   C.mach_msg_type_number_t
+		cpuload *C.processor_cpu_load_info_data_t
+		ncpu    C.natural_t
+	)
+
+	status := C.host_processor_info(C.host_t(C.mach_host_self()),
+		C.PROCESSOR_CPU_LOAD_INFO,
+		&ncpu,
+		(*C.processor_info_array_t)(unsafe.Pointer(&cpuload)),
+		&count)
+
+	if status != C.KERN_SUCCESS {
+		return nil, fmt.Errorf("host_processor_info error=%d", status)
+	}
+
+	// jump through some cgo casting hoops and ensure we properly free
+	// the memory that cpuload points to
+	target := C.vm_map_t(C.mach_task_self_)
+	address := C.vm_address_t(uintptr(unsafe.Pointer(cpuload)))
+	defer C.vm_deallocate(target, address, C.vm_size_t(ncpu))
+
+	// the body of struct processor_cpu_load_info
+	// aka processor_cpu_load_info_data_t
+	var cpu_ticks [C.CPU_STATE_MAX]uint32
+
+	// copy the cpuload array to a []byte buffer
+	// where we can binary.Read the data
+	size := int(ncpu) * binary.Size(cpu_ticks)
+	buf := (*[1 << 30]byte)(unsafe.Pointer(cpuload))[:size:size]
+
+	bbuf := bytes.NewBuffer(buf)
+
+	var ret []TimesStat
+
+	for i := 0; i < int(ncpu); i++ {
+		err := binary.Read(bbuf, binary.LittleEndian, &cpu_ticks)
+		if err != nil {
+			return nil, err
+		}
+
+		c := TimesStat{
+			CPU:    fmt.Sprintf("cpu%d", i),
+			User:   float64(cpu_ticks[C.CPU_STATE_USER]) / ClocksPerSec,
+			System: float64(cpu_ticks[C.CPU_STATE_SYSTEM]) / ClocksPerSec,
+			Nice:   float64(cpu_ticks[C.CPU_STATE_NICE]) / ClocksPerSec,
+			Idle:   float64(cpu_ticks[C.CPU_STATE_IDLE]) / ClocksPerSec,
+		}
+
+		ret = append(ret, c)
+	}
+
+	return ret, nil
+}
+
+func allCPUTimes() ([]TimesStat, error) {
+	var count C.mach_msg_type_number_t
+	var cpuload C.host_cpu_load_info_data_t
+
+	count = C.HOST_CPU_LOAD_INFO_COUNT
+
+	status := C.host_statistics(C.host_t(C.mach_host_self()),
+		C.HOST_CPU_LOAD_INFO,
+		C.host_info_t(unsafe.Pointer(&cpuload)),
+		&count)
+
+	if status != C.KERN_SUCCESS {
+		return nil, fmt.Errorf("host_statistics error=%d", status)
+	}
+
+	c := TimesStat{
+		CPU:    "cpu-total",
+		User:   float64(cpuload.cpu_ticks[C.CPU_STATE_USER]) / ClocksPerSec,
+		System: float64(cpuload.cpu_ticks[C.CPU_STATE_SYSTEM]) / ClocksPerSec,
+		Nice:   float64(cpuload.cpu_ticks[C.CPU_STATE_NICE]) / ClocksPerSec,
+		Idle:   float64(cpuload.cpu_ticks[C.CPU_STATE_IDLE]) / ClocksPerSec,
+	}
+
+	return []TimesStat{c}, nil
+
+}

vendor/github.com/shirou/gopsutil/cpu/cpu_darwin_nocgo.go

@@ -0,0 +1,14 @@
+// +build darwin
+// +build !cgo
+
+package cpu
+
+import "github.com/shirou/gopsutil/internal/common"
+
+func perCPUTimes() ([]TimesStat, error) {
+	return []TimesStat{}, common.ErrNotImplementedError
+}
+
+func allCPUTimes() ([]TimesStat, error) {
+	return []TimesStat{}, common.ErrNotImplementedError
+}

vendor/github.com/shirou/gopsutil/cpu/cpu_fallback.go

@@ -0,0 +1,25 @@
+// +build !darwin,!linux,!freebsd,!openbsd,!solaris,!windows
+
+package cpu
+
+import (
+	"context"
+
+	"github.com/shirou/gopsutil/internal/common"
+)
+
+func Times(percpu bool) ([]TimesStat, error) {
+	return TimesWithContext(context.Background(), percpu)
+}
+
+func TimesWithContext(ctx context.Context, percpu bool) ([]TimesStat, error) {
+	return []TimesStat{}, common.ErrNotImplementedError
+}
+
+func Info() ([]InfoStat, error) {
+	return InfoWithContext(context.Background())
+}
+
+func InfoWithContext(ctx context.Context) ([]InfoStat, error) {
+	return []InfoStat{}, common.ErrNotImplementedError
+}

vendor/github.com/shirou/gopsutil/cpu/cpu_freebsd.go

@@ -0,0 +1,168 @@
+package cpu
+
+import (
+	"context"
+	"fmt"
+	"os/exec"
+	"reflect"
+	"regexp"
+	"strconv"
+	"strings"
+	"unsafe"
+
+	"github.com/shirou/gopsutil/internal/common"
+	"golang.org/x/sys/unix"
+)
+
+var ClocksPerSec = float64(128)
+var cpuMatch = regexp.MustCompile(`^CPU:`)
+var originMatch = regexp.MustCompile(`Origin\s*=\s*"(.+)"\s+Id\s*=\s*(.+)\s+Family\s*=\s*(.+)\s+Model\s*=\s*(.+)\s+Stepping\s*=\s*(.+)`)
+var featuresMatch = regexp.MustCompile(`Features=.+<(.+)>`)
+var featuresMatch2 = regexp.MustCompile(`Features2=[a-f\dx]+<(.+)>`)
+var cpuEnd = regexp.MustCompile(`^Trying to mount root`)
+var cpuCores = regexp.MustCompile(`FreeBSD/SMP: (\d*) package\(s\) x (\d*) core\(s\)`)
+var cpuTimesSize int
+var emptyTimes cpuTimes
+
+func init() {
+	getconf, err := exec.LookPath("/usr/bin/getconf")
+	if err != nil {
+		return
+	}
+	out, err := invoke.Command(getconf, "CLK_TCK")
+	// ignore errors
+	if err == nil {
+		i, err := strconv.ParseFloat(strings.TrimSpace(string(out)), 64)
+		if err == nil {
+			ClocksPerSec = float64(i)
+		}
+	}
+}
+
+func timeStat(name string, t *cpuTimes) *TimesStat {
+	return &TimesStat{
+		User:   float64(t.User) / ClocksPerSec,
+		Nice:   float64(t.Nice) / ClocksPerSec,
+		System: float64(t.Sys) / ClocksPerSec,
+		Idle:   float64(t.Idle) / ClocksPerSec,
+		Irq:    float64(t.Intr) / ClocksPerSec,
+		CPU:    name,
+	}
+}
+
+func Times(percpu bool) ([]TimesStat, error) {
+	return TimesWithContext(context.Background(), percpu)
+}
+
+func TimesWithContext(ctx context.Context, percpu bool) ([]TimesStat, error) {
+	if percpu {
+		buf, err := unix.SysctlRaw("kern.cp_times")
+		if err != nil {
+			return nil, err
+		}
+
+		// We can't do this in init due to the conflict with cpu.init()
+		if cpuTimesSize == 0 {
+			cpuTimesSize = int(reflect.TypeOf(cpuTimes{}).Size())
+		}
+
+		ncpus := len(buf) / cpuTimesSize
+		ret := make([]TimesStat, 0, ncpus)
+		for i := 0; i < ncpus; i++ {
+			times := (*cpuTimes)(unsafe.Pointer(&buf[i*cpuTimesSize]))
+			if *times == emptyTimes {
+				// CPU not present
+				continue
+			}
+			ret = append(ret, *timeStat(fmt.Sprintf("cpu%d", len(ret)), times))
+		}
+		return ret, nil
+	}
+
+	buf, err := unix.SysctlRaw("kern.cp_time")
+	if err != nil {
+		return nil, err
+	}
+
+	times := (*cpuTimes)(unsafe.Pointer(&buf[0]))
+	return []TimesStat{*timeStat("cpu-total", times)}, nil
+}
+
+// Returns only one InfoStat on FreeBSD.  The information regarding core
+// count, however is accurate and it is assumed that all InfoStat attributes
+// are the same across CPUs.
+func Info() ([]InfoStat, error) {
+	return InfoWithContext(context.Background())
+}
+
+func InfoWithContext(ctx context.Context) ([]InfoStat, error) {
+	const dmesgBoot = "/var/run/dmesg.boot"
+
+	c, num, err := parseDmesgBoot(dmesgBoot)
+	if err != nil {
+		return nil, err
+	}
+
+	var u32 uint32
+	if u32, err = unix.SysctlUint32("hw.clockrate"); err != nil {
+		return nil, err
+	}
+	c.Mhz = float64(u32)
+
+	if u32, err = unix.SysctlUint32("hw.ncpu"); err != nil {
+		return nil, err
+	}
+	c.Cores = int32(u32)
+
+	if c.ModelName, err = unix.Sysctl("hw.model"); err != nil {
+		return nil, err
+	}
+
+	ret := make([]InfoStat, num)
+	for i := 0; i < num; i++ {
+		ret[i] = c
+	}
+
+	return ret, nil
+}
+
+func parseDmesgBoot(fileName string) (InfoStat, int, error) {
+	c := InfoStat{}
+	lines, _ := common.ReadLines(fileName)
+	cpuNum := 1 // default cpu num is 1
+	for _, line := range lines {
+		if matches := cpuEnd.FindStringSubmatch(line); matches != nil {
+			break
+		} else if matches := originMatch.FindStringSubmatch(line); matches != nil {
+			c.VendorID = matches[1]
+			c.Family = matches[3]
+			c.Model = matches[4]
+			t, err := strconv.ParseInt(matches[5], 10, 32)
+			if err != nil {
+				return c, 0, fmt.Errorf("unable to parse FreeBSD CPU stepping information from %q: %v", line, err)
+			}
+			c.Stepping = int32(t)
+		} else if matches := featuresMatch.FindStringSubmatch(line); matches != nil {
+			for _, v := range strings.Split(matches[1], ",") {
+				c.Flags = append(c.Flags, strings.ToLower(v))
+			}
+		} else if matches := featuresMatch2.FindStringSubmatch(line); matches != nil {
+			for _, v := range strings.Split(matches[1], ",") {
+				c.Flags = append(c.Flags, strings.ToLower(v))
+			}
+		} else if matches := cpuCores.FindStringSubmatch(line); matches != nil {
+			t, err := strconv.ParseInt(matches[1], 10, 32)
+			if err != nil {
+				return c, 0, fmt.Errorf("unable to parse FreeBSD CPU Nums from %q: %v", line, err)
+			}
+			cpuNum = int(t)
+			t2, err := strconv.ParseInt(matches[2], 10, 32)
+			if err != nil {
+				return c, 0, fmt.Errorf("unable to parse FreeBSD CPU cores from %q: %v", line, err)
+			}
+			c.Cores = int32(t2)
+		}
+	}
+
+	return c, cpuNum, nil
+}

vendor/github.com/shirou/gopsutil/cpu/cpu_freebsd_386.go

@@ -0,0 +1,9 @@
+package cpu
+
+type cpuTimes struct {
+	User uint32
+	Nice uint32
+	Sys  uint32
+	Intr uint32
+	Idle uint32
+}

vendor/github.com/shirou/gopsutil/cpu/cpu_freebsd_amd64.go

@@ -0,0 +1,9 @@
+package cpu
+
+type cpuTimes struct {
+	User uint64
+	Nice uint64
+	Sys  uint64
+	Intr uint64
+	Idle uint64
+}

vendor/github.com/shirou/gopsutil/cpu/cpu_linux.go

@@ -0,0 +1,285 @@
+// +build linux
+
+package cpu
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os/exec"
+	"strconv"
+	"strings"
+
+	"github.com/shirou/gopsutil/internal/common"
+)
+
+var cpu_tick = float64(100)
+
+func init() {
+	getconf, err := exec.LookPath("/usr/bin/getconf")
+	if err != nil {
+		return
+	}
+	out, err := invoke.CommandWithContext(context.Background(), getconf, "CLK_TCK")
+	// ignore errors
+	if err == nil {
+		i, err := strconv.ParseFloat(strings.TrimSpace(string(out)), 64)
+		if err == nil {
+			cpu_tick = float64(i)
+		}
+	}
+}
+
+func Times(percpu bool) ([]TimesStat, error) {
+	return TimesWithContext(context.Background(), percpu)
+}
+
+func TimesWithContext(ctx context.Context, percpu bool) ([]TimesStat, error) {
+	filename := common.HostProc("stat")
+	var lines = []string{}
+	if percpu {
+		statlines, err := common.ReadLines(filename)
+		if err != nil || len(statlines) < 2 {
+			return []TimesStat{}, nil
+		}
+		for _, line := range statlines[1:] {
+			if !strings.HasPrefix(line, "cpu") {
+				break
+			}
+			lines = append(lines, line)
+		}
+	} else {
+		lines, _ = common.ReadLinesOffsetN(filename, 0, 1)
+	}
+
+	ret := make([]TimesStat, 0, len(lines))
+
+	for _, line := range lines {
+		ct, err := parseStatLine(line)
+		if err != nil {
+			continue
+		}
+		ret = append(ret, *ct)
+
+	}
+	return ret, nil
+}
+
+func sysCPUPath(cpu int32, relPath string) string {
+	return common.HostSys(fmt.Sprintf("devices/system/cpu/cpu%d", cpu), relPath)
+}
+
+func finishCPUInfo(c *InfoStat) error {
+	var lines []string
+	var err error
+	var value float64
+
+	if len(c.CoreID) == 0 {
+		lines, err = common.ReadLines(sysCPUPath(c.CPU, "topology/core_id"))
+		if err == nil {
+			c.CoreID = lines[0]
+		}
+	}
+
+	// override the value of c.Mhz with cpufreq/cpuinfo_max_freq regardless
+	// of the value from /proc/cpuinfo because we want to report the maximum
+	// clock-speed of the CPU for c.Mhz, matching the behaviour of Windows
+	lines, err = common.ReadLines(sysCPUPath(c.CPU, "cpufreq/cpuinfo_max_freq"))
+	// if we encounter errors below such as there are no cpuinfo_max_freq file,
+	// we just ignore. so let Mhz is 0.
+	if err != nil {
+		return nil
+	}
+	value, err = strconv.ParseFloat(lines[0], 64)
+	if err != nil {
+		return nil
+	}
+	c.Mhz = value / 1000.0 // value is in kHz
+	if c.Mhz > 9999 {
+		c.Mhz = c.Mhz / 1000.0 // value in Hz
+	}
+	return nil
+}
+
+// CPUInfo on linux will return 1 item per physical thread.
+//
+// CPUs have three levels of counting: sockets, cores, threads.
+// Cores with HyperThreading count as having 2 threads per core.
+// Sockets often come with many physical CPU cores.
+// For example a single socket board with two cores each with HT will
+// return 4 CPUInfoStat structs on Linux and the "Cores" field set to 1.
+func Info() ([]InfoStat, error) {
+	return InfoWithContext(context.Background())
+}
+
+func InfoWithContext(ctx context.Context) ([]InfoStat, error) {
+	filename := common.HostProc("cpuinfo")
+	lines, _ := common.ReadLines(filename)
+
+	var ret []InfoStat
+	var processorName string
+
+	c := InfoStat{CPU: -1, Cores: 1}
+	for _, line := range lines {
+		fields := strings.Split(line, ":")
+		if len(fields) < 2 {
+			continue
+		}
+		key := strings.TrimSpace(fields[0])
+		value := strings.TrimSpace(fields[1])
+
+		switch key {
+		case "Processor":
+			processorName = value
+		case "processor":
+			if c.CPU >= 0 {
+				err := finishCPUInfo(&c)
+				if err != nil {
+					return ret, err
+				}
+				ret = append(ret, c)
+			}
+			c = InfoStat{Cores: 1, ModelName: processorName}
+			t, err := strconv.ParseInt(value, 10, 64)
+			if err != nil {
+				return ret, err
+			}
+			c.CPU = int32(t)
+		case "vendorId", "vendor_id":
+			c.VendorID = value
+		case "cpu family":
+			c.Family = value
+		case "model":
+			c.Model = value
+		case "model name", "cpu":
+			c.ModelName = value
+			if strings.Contains(value, "POWER8") ||
+				strings.Contains(value, "POWER7") {
+				c.Model = strings.Split(value, " ")[0]
+				c.Family = "POWER"
+				c.VendorID = "IBM"
+			}
+		case "stepping", "revision":
+			val := value
+
+			if key == "revision" {
+				val = strings.Split(value, ".")[0]
+			}
+
+			t, err := strconv.ParseInt(val, 10, 64)
+			if err != nil {
+				return ret, err
+			}
+			c.Stepping = int32(t)
+		case "cpu MHz", "clock":
+			// treat this as the fallback value, thus we ignore error
+			if t, err := strconv.ParseFloat(strings.Replace(value, "MHz", "", 1), 64); err == nil {
+				c.Mhz = t
+			}
+		case "cache size":
+			t, err := strconv.ParseInt(strings.Replace(value, " KB", "", 1), 10, 64)
+			if err != nil {
+				return ret, err
+			}
+			c.CacheSize = int32(t)
+		case "physical id":
+			c.PhysicalID = value
+		case "core id":
+			c.CoreID = value
+		case "flags", "Features":
+			c.Flags = strings.FieldsFunc(value, func(r rune) bool {
+				return r == ',' || r == ' '
+			})
+		case "microcode":
+			c.Microcode = value
+		}
+	}
+	if c.CPU >= 0 {
+		err := finishCPUInfo(&c)
+		if err != nil {
+			return ret, err
+		}
+		ret = append(ret, c)
+	}
+	return ret, nil
+}
+
+func parseStatLine(line string) (*TimesStat, error) {
+	fields := strings.Fields(line)
+
+	if len(fields) == 0 {
+		return nil, errors.New("stat does not contain cpu info")
+	}
+
+	if strings.HasPrefix(fields[0], "cpu") == false {
+		//		return CPUTimesStat{}, e
+		return nil, errors.New("not contain cpu")
+	}
+
+	cpu := fields[0]
+	if cpu == "cpu" {
+		cpu = "cpu-total"
+	}
+	user, err := strconv.ParseFloat(fields[1], 64)
+	if err != nil {
+		return nil, err
+	}
+	nice, err := strconv.ParseFloat(fields[2], 64)
+	if err != nil {
+		return nil, err
+	}
+	system, err := strconv.ParseFloat(fields[3], 64)
+	if err != nil {
+		return nil, err
+	}
+	idle, err := strconv.ParseFloat(fields[4], 64)
+	if err != nil {
+		return nil, err
+	}
+	iowait, err := strconv.ParseFloat(fields[5], 64)
+	if err != nil {
+		return nil, err
+	}
+	irq, err := strconv.ParseFloat(fields[6], 64)
+	if err != nil {
+		return nil, err
+	}
+	softirq, err := strconv.ParseFloat(fields[7], 64)
+	if err != nil {
+		return nil, err
+	}
+
+	ct := &TimesStat{
+		CPU:     cpu,
+		User:    float64(user) / cpu_tick,
+		Nice:    float64(nice) / cpu_tick,
+		System:  float64(system) / cpu_tick,
+		Idle:    float64(idle) / cpu_tick,
+		Iowait:  float64(iowait) / cpu_tick,
+		Irq:     float64(irq) / cpu_tick,
+		Softirq: float64(softirq) / cpu_tick,
+	}
+	if len(fields) > 8 { // Linux >= 2.6.11
+		steal, err := strconv.ParseFloat(fields[8], 64)
+		if err != nil {
+			return nil, err
+		}
+		ct.Steal = float64(steal) / cpu_tick
+	}
+	if len(fields) > 9 { // Linux >= 2.6.24
+		guest, err := strconv.ParseFloat(fields[9], 64)
+		if err != nil {
+			return nil, err
+		}
+		ct.Guest = float64(guest) / cpu_tick
+	}
+	if len(fields) > 10 { // Linux >= 3.2.0
+		guestNice, err := strconv.ParseFloat(fields[10], 64)
+		if err != nil {
+			return nil, err
+		}
+		ct.GuestNice = float64(guestNice) / cpu_tick
+	}
+
+	return ct, nil
+}

vendor/github.com/shirou/gopsutil/cpu/cpu_openbsd.go

@@ -0,0 +1,119 @@
+// +build openbsd
+
+package cpu
+
+import (
+	"bytes"
+	"context"
+	"encoding/binary"
+	"fmt"
+	"os/exec"
+	"strconv"
+	"strings"
+
+	"github.com/shirou/gopsutil/internal/common"
+	"golang.org/x/sys/unix"
+)
+
+// sys/sched.h
+const (
+	CPUser    = 0
+	CPNice    = 1
+	CPSys     = 2
+	CPIntr    = 3
+	CPIdle    = 4
+	CPUStates = 5
+)
+
+// sys/sysctl.h
+const (
+	CTLKern     = 1  // "high kernel": proc, limits
+	KernCptime  = 40 // KERN_CPTIME
+	KernCptime2 = 71 // KERN_CPTIME2
+)
+
+var ClocksPerSec = float64(128)
+
+func init() {
+	getconf, err := exec.LookPath("/usr/bin/getconf")
+	if err != nil {
+		return
+	}
+	out, err := invoke.Command(getconf, "CLK_TCK")
+	// ignore errors
+	if err == nil {
+		i, err := strconv.ParseFloat(strings.TrimSpace(string(out)), 64)
+		if err == nil {
+			ClocksPerSec = float64(i)
+		}
+	}
+}
+
+func Times(percpu bool) ([]TimesStat, error) {
+	return TimesWithContext(context.Background(), percpu)
+}
+
+func TimesWithContext(ctx context.Context, percpu bool) ([]TimesStat, error) {
+	var ret []TimesStat
+
+	var ncpu int
+	if percpu {
+		ncpu, _ = Counts(true)
+	} else {
+		ncpu = 1
+	}
+
+	for i := 0; i < ncpu; i++ {
+		var cpuTimes [CPUStates]int64
+		var mib []int32
+		if percpu {
+			mib = []int32{CTLKern, KernCptime}
+		} else {
+			mib = []int32{CTLKern, KernCptime2, int32(i)}
+		}
+		buf, _, err := common.CallSyscall(mib)
+		if err != nil {
+			return ret, err
+		}
+
+		br := bytes.NewReader(buf)
+		err = binary.Read(br, binary.LittleEndian, &cpuTimes)
+		if err != nil {
+			return ret, err
+		}
+		c := TimesStat{
+			User:   float64(cpuTimes[CPUser]) / ClocksPerSec,
+			Nice:   float64(cpuTimes[CPNice]) / ClocksPerSec,
+			System: float64(cpuTimes[CPSys]) / ClocksPerSec,
+			Idle:   float64(cpuTimes[CPIdle]) / ClocksPerSec,
+			Irq:    float64(cpuTimes[CPIntr]) / ClocksPerSec,
+		}
+		if !percpu {
+			c.CPU = "cpu-total"
+		} else {
+			c.CPU = fmt.Sprintf("cpu%d", i)
+		}
+		ret = append(ret, c)
+	}
+
+	return ret, nil
+}
+
+// Returns only one (minimal) CPUInfoStat on OpenBSD
+func Info() ([]InfoStat, error) {
+	return InfoWithContext(context.Background())
+}
+
+func InfoWithContext(ctx context.Context) ([]InfoStat, error) {
+	var ret []InfoStat
+
+	c := InfoStat{}
+
+	v, err := unix.Sysctl("hw.model")
+	if err != nil {
+		return nil, err
+	}
+	c.ModelName = v
+
+	return append(ret, c), nil
+}

vendor/github.com/shirou/gopsutil/cpu/cpu_solaris.go

@@ -0,0 +1,198 @@
+package cpu
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os/exec"
+	"regexp"
+	"sort"
+	"strconv"
+	"strings"
+
+	"github.com/shirou/gopsutil/internal/common"
+)
+
+var ClocksPerSec = float64(128)
+
+func init() {
+	getconf, err := exec.LookPath("/usr/bin/getconf")
+	if err != nil {
+		return
+	}
+	out, err := invoke.Command(getconf, "CLK_TCK")
+	// ignore errors
+	if err == nil {
+		i, err := strconv.ParseFloat(strings.TrimSpace(string(out)), 64)
+		if err == nil {
+			ClocksPerSec = float64(i)
+		}
+	}
+}
+
+func Times(percpu bool) ([]TimesStat, error) {
+	return TimesWithContext(context.Background(), percpu)
+}
+
+func TimesWithContext(ctx context.Context, percpu bool) ([]TimesStat, error) {
+	return []TimesStat{}, common.ErrNotImplementedError
+}
+
+func Info() ([]InfoStat, error) {
+	return InfoWithContext(context.Background())
+}
+
+func InfoWithContext(ctx context.Context) ([]InfoStat, error) {
+	psrInfo, err := exec.LookPath("/usr/sbin/psrinfo")
+	if err != nil {
+		return nil, fmt.Errorf("cannot find psrinfo: %s", err)
+	}
+	psrInfoOut, err := invoke.CommandWithContext(ctx, psrInfo, "-p", "-v")
+	if err != nil {
+		return nil, fmt.Errorf("cannot execute psrinfo: %s", err)
+	}
+
+	isaInfo, err := exec.LookPath("/usr/bin/isainfo")
+	if err != nil {
+		return nil, fmt.Errorf("cannot find isainfo: %s", err)
+	}
+	isaInfoOut, err := invoke.CommandWithContext(ctx, isaInfo, "-b", "-v")
+	if err != nil {
+		return nil, fmt.Errorf("cannot execute isainfo: %s", err)
+	}
+
+	procs, err := parseProcessorInfo(string(psrInfoOut))
+	if err != nil {
+		return nil, fmt.Errorf("error parsing psrinfo output: %s", err)
+	}
+
+	flags, err := parseISAInfo(string(isaInfoOut))
+	if err != nil {
+		return nil, fmt.Errorf("error parsing isainfo output: %s", err)
+	}
+
+	result := make([]InfoStat, 0, len(flags))
+	for _, proc := range procs {
+		procWithFlags := proc
+		procWithFlags.Flags = flags
+		result = append(result, procWithFlags)
+	}
+
+	return result, nil
+}
+
+var flagsMatch = regexp.MustCompile(`[\w\.]+`)
+
+func parseISAInfo(cmdOutput string) ([]string, error) {
+	words := flagsMatch.FindAllString(cmdOutput, -1)
+
+	// Sanity check the output
+	if len(words) < 4 || words[1] != "bit" || words[3] != "applications" {
+		return nil, errors.New("attempted to parse invalid isainfo output")
+	}
+
+	flags := make([]string, len(words)-4)
+	for i, val := range words[4:] {
+		flags[i] = val
+	}
+	sort.Strings(flags)
+
+	return flags, nil
+}
+
+var psrInfoMatch = regexp.MustCompile(`The physical processor has (?:([\d]+) virtual processor \(([\d]+)\)|([\d]+) cores and ([\d]+) virtual processors[^\n]+)\n(?:\s+ The core has.+\n)*\s+.+ \((\w+) ([\S]+) family (.+) model (.+) step (.+) clock (.+) MHz\)\n[\s]*(.*)`)
+
+const (
+	psrNumCoresOffset   = 1
+	psrNumCoresHTOffset = 3
+	psrNumHTOffset      = 4
+	psrVendorIDOffset   = 5
+	psrFamilyOffset     = 7
+	psrModelOffset      = 8
+	psrStepOffset       = 9
+	psrClockOffset      = 10
+	psrModelNameOffset  = 11
+)
+
+func parseProcessorInfo(cmdOutput string) ([]InfoStat, error) {
+	matches := psrInfoMatch.FindAllStringSubmatch(cmdOutput, -1)
+
+	var infoStatCount int32
+	result := make([]InfoStat, 0, len(matches))
+	for physicalIndex, physicalCPU := range matches {
+		var step int32
+		var clock float64
+
+		if physicalCPU[psrStepOffset] != "" {
+			stepParsed, err := strconv.ParseInt(physicalCPU[psrStepOffset], 10, 32)
+			if err != nil {
+				return nil, fmt.Errorf("cannot parse value %q for step as 32-bit integer: %s", physicalCPU[9], err)
+			}
+			step = int32(stepParsed)
+		}
+
+		if physicalCPU[psrClockOffset] != "" {
+			clockParsed, err := strconv.ParseInt(physicalCPU[psrClockOffset], 10, 64)
+			if err != nil {
+				return nil, fmt.Errorf("cannot parse value %q for clock as 32-bit integer: %s", physicalCPU[10], err)
+			}
+			clock = float64(clockParsed)
+		}
+
+		var err error
+		var numCores int64
+		var numHT int64
+		switch {
+		case physicalCPU[psrNumCoresOffset] != "":
+			numCores, err = strconv.ParseInt(physicalCPU[psrNumCoresOffset], 10, 32)
+			if err != nil {
+				return nil, fmt.Errorf("cannot parse value %q for core count as 32-bit integer: %s", physicalCPU[1], err)
+			}
+
+			for i := 0; i < int(numCores); i++ {
+				result = append(result, InfoStat{
+					CPU:        infoStatCount,
+					PhysicalID: strconv.Itoa(physicalIndex),
+					CoreID:     strconv.Itoa(i),
+					Cores:      1,
+					VendorID:   physicalCPU[psrVendorIDOffset],
+					ModelName:  physicalCPU[psrModelNameOffset],
+					Family:     physicalCPU[psrFamilyOffset],
+					Model:      physicalCPU[psrModelOffset],
+					Stepping:   step,
+					Mhz:        clock,
+				})
+				infoStatCount++
+			}
+		case physicalCPU[psrNumCoresHTOffset] != "":
+			numCores, err = strconv.ParseInt(physicalCPU[psrNumCoresHTOffset], 10, 32)
+			if err != nil {
+				return nil, fmt.Errorf("cannot parse value %q for core count as 32-bit integer: %s", physicalCPU[3], err)
+			}
+
+			numHT, err = strconv.ParseInt(physicalCPU[psrNumHTOffset], 10, 32)
+			if err != nil {
+				return nil, fmt.Errorf("cannot parse value %q for hyperthread count as 32-bit integer: %s", physicalCPU[4], err)
+			}
+
+			for i := 0; i < int(numCores); i++ {
+				result = append(result, InfoStat{
+					CPU:        infoStatCount,
+					PhysicalID: strconv.Itoa(physicalIndex),
+					CoreID:     strconv.Itoa(i),
+					Cores:      int32(numHT) / int32(numCores),
+					VendorID:   physicalCPU[psrVendorIDOffset],
+					ModelName:  physicalCPU[psrModelNameOffset],
+					Family:     physicalCPU[psrFamilyOffset],
+					Model:      physicalCPU[psrModelOffset],
+					Stepping:   step,
+					Mhz:        clock,
+				})
+				infoStatCount++
+			}
+		default:
+			return nil, errors.New("values for cores with and without hyperthreading are both set")
+		}
+	}
+	return result, nil
+}

vendor/github.com/shirou/gopsutil/cpu/cpu_windows.go

@@ -0,0 +1,172 @@
+// +build windows
+
+package cpu
+
+import (
+	"context"
+	"fmt"
+	"unsafe"
+
+	"github.com/StackExchange/wmi"
+	"github.com/shirou/gopsutil/internal/common"
+	"golang.org/x/sys/windows"
+)
+
+type Win32_Processor struct {
+	LoadPercentage            *uint16
+	Family                    uint16
+	Manufacturer              string
+	Name                      string
+	NumberOfLogicalProcessors uint32
+	ProcessorID               *string
+	Stepping                  *string
+	MaxClockSpeed             uint32
+}
+
+// Win32_PerfFormattedData_Counters_ProcessorInformation stores instance value of the perf counters
+type Win32_PerfFormattedData_Counters_ProcessorInformation struct {
+	Name                  string
+	PercentDPCTime        uint64
+	PercentIdleTime       uint64
+	PercentUserTime       uint64
+	PercentProcessorTime  uint64
+	PercentInterruptTime  uint64
+	PercentPriorityTime   uint64
+	PercentPrivilegedTime uint64
+	InterruptsPerSec      uint32
+	ProcessorFrequency    uint32
+	DPCRate               uint32
+}
+
+// Win32_PerfFormattedData_PerfOS_System struct to have count of processes and processor queue length
+type Win32_PerfFormattedData_PerfOS_System struct {
+	Processes            uint32
+	ProcessorQueueLength uint32
+}
+
+// Times returns times stat per cpu and combined for all CPUs
+func Times(percpu bool) ([]TimesStat, error) {
+	return TimesWithContext(context.Background(), percpu)
+}
+
+func TimesWithContext(ctx context.Context, percpu bool) ([]TimesStat, error) {
+	if percpu {
+		return perCPUTimes()
+	}
+
+	var ret []TimesStat
+	var lpIdleTime common.FILETIME
+	var lpKernelTime common.FILETIME
+	var lpUserTime common.FILETIME
+	r, _, _ := common.ProcGetSystemTimes.Call(
+		uintptr(unsafe.Pointer(&lpIdleTime)),
+		uintptr(unsafe.Pointer(&lpKernelTime)),
+		uintptr(unsafe.Pointer(&lpUserTime)))
+	if r == 0 {
+		return ret, windows.GetLastError()
+	}
+
+	LOT := float64(0.0000001)
+	HIT := (LOT * 4294967296.0)
+	idle := ((HIT * float64(lpIdleTime.DwHighDateTime)) + (LOT * float64(lpIdleTime.DwLowDateTime)))
+	user := ((HIT * float64(lpUserTime.DwHighDateTime)) + (LOT * float64(lpUserTime.DwLowDateTime)))
+	kernel := ((HIT * float64(lpKernelTime.DwHighDateTime)) + (LOT * float64(lpKernelTime.DwLowDateTime)))
+	system := (kernel - idle)
+
+	ret = append(ret, TimesStat{
+		CPU:    "cpu-total",
+		Idle:   float64(idle),
+		User:   float64(user),
+		System: float64(system),
+	})
+	return ret, nil
+}
+
+func Info() ([]InfoStat, error) {
+	return InfoWithContext(context.Background())
+}
+
+func InfoWithContext(ctx context.Context) ([]InfoStat, error) {
+	var ret []InfoStat
+	var dst []Win32_Processor
+	q := wmi.CreateQuery(&dst, "")
+	if err := common.WMIQueryWithContext(ctx, q, &dst); err != nil {
+		return ret, err
+	}
+
+	var procID string
+	for i, l := range dst {
+		procID = ""
+		if l.ProcessorID != nil {
+			procID = *l.ProcessorID
+		}
+
+		cpu := InfoStat{
+			CPU:        int32(i),
+			Family:     fmt.Sprintf("%d", l.Family),
+			VendorID:   l.Manufacturer,
+			ModelName:  l.Name,
+			Cores:      int32(l.NumberOfLogicalProcessors),
+			PhysicalID: procID,
+			Mhz:        float64(l.MaxClockSpeed),
+			Flags:      []string{},
+		}
+		ret = append(ret, cpu)
+	}
+
+	return ret, nil
+}
+
+// PerfInfo returns the performance counter's instance value for ProcessorInformation.
+// Name property is the key by which overall, per cpu and per core metric is known.
+func PerfInfo() ([]Win32_PerfFormattedData_Counters_ProcessorInformation, error) {
+	return PerfInfoWithContext(context.Background())
+}
+
+func PerfInfoWithContext(ctx context.Context) ([]Win32_PerfFormattedData_Counters_ProcessorInformation, error) {
+	var ret []Win32_PerfFormattedData_Counters_ProcessorInformation
+
+	q := wmi.CreateQuery(&ret, "")
+	err := common.WMIQueryWithContext(ctx, q, &ret)
+	if err != nil {
+		return []Win32_PerfFormattedData_Counters_ProcessorInformation{}, err
+	}
+
+	return ret, err
+}
+
+// ProcInfo returns processes count and processor queue length in the system.
+// There is a single queue for processor even on multiprocessors systems.
+func ProcInfo() ([]Win32_PerfFormattedData_PerfOS_System, error) {
+	return ProcInfoWithContext(context.Background())
+}
+
+func ProcInfoWithContext(ctx context.Context) ([]Win32_PerfFormattedData_PerfOS_System, error) {
+	var ret []Win32_PerfFormattedData_PerfOS_System
+	q := wmi.CreateQuery(&ret, "")
+	err := common.WMIQueryWithContext(ctx, q, &ret)
+	if err != nil {
+		return []Win32_PerfFormattedData_PerfOS_System{}, err
+	}
+	return ret, err
+}
+
+// perCPUTimes returns times stat per cpu, per core and overall for all CPUs
+func perCPUTimes() ([]TimesStat, error) {
+	var ret []TimesStat
+	stats, err := PerfInfo()
+	if err != nil {
+		return nil, err
+	}
+	for _, v := range stats {
+		c := TimesStat{
+			CPU:    v.Name,
+			User:   float64(v.PercentUserTime),
+			System: float64(v.PercentPrivilegedTime),
+			Idle:   float64(v.PercentIdleTime),
+			Irq:    float64(v.PercentInterruptTime),
+		}
+		ret = append(ret, c)
+	}
+	return ret, nil
+}

vendor/github.com/shirou/gopsutil/disk/BUILD.bazel

@@ -0,0 +1,72 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "disk.go",
+        "disk_darwin.go",
+        "disk_darwin.h",
+        "disk_darwin_386.go",
+        "disk_darwin_amd64.go",
+        "disk_darwin_arm64.go",
+        "disk_darwin_cgo.go",
+        "disk_darwin_nocgo.go",
+        "disk_fallback.go",
+        "disk_freebsd.go",
+        "disk_freebsd_386.go",
+        "disk_freebsd_amd64.go",
+        "disk_linux.go",
+        "disk_openbsd.go",
+        "disk_openbsd_amd64.go",
+        "disk_solaris.go",
+        "disk_unix.go",
+        "disk_windows.go",
+    ],
+    cgo = True,
+    clinkopts = select({
+        "@io_bazel_rules_go//go/platform:darwin": [
+            "-lobjc -framework Foundation -framework IOKit",
+        ],
+        "//conditions:default": [],
+    }),
+    importmap = "go-common/vendor/github.com/shirou/gopsutil/disk",
+    importpath = "github.com/shirou/gopsutil/disk",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//vendor/github.com/shirou/gopsutil/internal/common:go_default_library",
+    ] + select({
+        "@io_bazel_rules_go//go/platform:darwin": [
+            "//vendor/golang.org/x/sys/unix:go_default_library",
+        ],
+        "@io_bazel_rules_go//go/platform:freebsd": [
+            "//vendor/golang.org/x/sys/unix:go_default_library",
+        ],
+        "@io_bazel_rules_go//go/platform:linux": [
+            "//vendor/golang.org/x/sys/unix:go_default_library",
+        ],
+        "@io_bazel_rules_go//go/platform:openbsd": [
+            "//vendor/golang.org/x/sys/unix:go_default_library",
+        ],
+        "@io_bazel_rules_go//go/platform:solaris": [
+            "//vendor/golang.org/x/sys/unix:go_default_library",
+        ],
+        "@io_bazel_rules_go//go/platform:windows": [
+            "//vendor/golang.org/x/sys/windows:go_default_library",
+        ],
+        "//conditions:default": [],
+    }),
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

vendor/github.com/shirou/gopsutil/disk/disk.go

@@ -0,0 +1,61 @@
+package disk
+
+import (
+	"encoding/json"
+
+	"github.com/shirou/gopsutil/internal/common"
+)
+
+var invoke common.Invoker = common.Invoke{}
+
+type UsageStat struct {
+	Path              string  `json:"path"`
+	Fstype            string  `json:"fstype"`
+	Total             uint64  `json:"total"`
+	Free              uint64  `json:"free"`
+	Used              uint64  `json:"used"`
+	UsedPercent       float64 `json:"usedPercent"`
+	InodesTotal       uint64  `json:"inodesTotal"`
+	InodesUsed        uint64  `json:"inodesUsed"`
+	InodesFree        uint64  `json:"inodesFree"`
+	InodesUsedPercent float64 `json:"inodesUsedPercent"`
+}
+
+type PartitionStat struct {
+	Device     string `json:"device"`
+	Mountpoint string `json:"mountpoint"`
+	Fstype     string `json:"fstype"`
+	Opts       string `json:"opts"`
+}
+
+type IOCountersStat struct {
+	ReadCount        uint64 `json:"readCount"`
+	MergedReadCount  uint64 `json:"mergedReadCount"`
+	WriteCount       uint64 `json:"writeCount"`
+	MergedWriteCount uint64 `json:"mergedWriteCount"`
+	ReadBytes        uint64 `json:"readBytes"`
+	WriteBytes       uint64 `json:"writeBytes"`
+	ReadTime         uint64 `json:"readTime"`
+	WriteTime        uint64 `json:"writeTime"`
+	IopsInProgress   uint64 `json:"iopsInProgress"`
+	IoTime           uint64 `json:"ioTime"`
+	WeightedIO       uint64 `json:"weightedIO"`
+	Name             string `json:"name"`
+	SerialNumber     string `json:"serialNumber"`
+	Label            string `json:"label"`
+}
+
+func (d UsageStat) String() string {
+	s, _ := json.Marshal(d)
+	return string(s)
+}
+
+func (d PartitionStat) String() string {
+	s, _ := json.Marshal(d)
+	return string(s)
+}
+
+func (d IOCountersStat) String() string {
+	s, _ := json.Marshal(d)
+	return string(s)
+}

vendor/github.com/shirou/gopsutil/disk/disk_darwin.go

@@ -0,0 +1,118 @@
+// +build darwin
+
+package disk
+
+import (
+	"context"
+	"path"
+	"unsafe"
+
+	"github.com/shirou/gopsutil/internal/common"
+	"golang.org/x/sys/unix"
+)
+
+func Partitions(all bool) ([]PartitionStat, error) {
+	return PartitionsWithContext(context.Background(), all)
+}
+
+func PartitionsWithContext(ctx context.Context, all bool) ([]PartitionStat, error) {
+	var ret []PartitionStat
+
+	count, err := Getfsstat(nil, MntWait)
+	if err != nil {
+		return ret, err
+	}
+	fs := make([]Statfs, count)
+	if _, err = Getfsstat(fs, MntWait); err != nil {
+		return ret, err
+	}
+	for _, stat := range fs {
+		opts := "rw"
+		if stat.Flags&MntReadOnly != 0 {
+			opts = "ro"
+		}
+		if stat.Flags&MntSynchronous != 0 {
+			opts += ",sync"
+		}
+		if stat.Flags&MntNoExec != 0 {
+			opts += ",noexec"
+		}
+		if stat.Flags&MntNoSuid != 0 {
+			opts += ",nosuid"
+		}
+		if stat.Flags&MntUnion != 0 {
+			opts += ",union"
+		}
+		if stat.Flags&MntAsync != 0 {
+			opts += ",async"
+		}
+		if stat.Flags&MntSuidDir != 0 {
+			opts += ",suiddir"
+		}
+		if stat.Flags&MntSoftDep != 0 {
+			opts += ",softdep"
+		}
+		if stat.Flags&MntNoSymFollow != 0 {
+			opts += ",nosymfollow"
+		}
+		if stat.Flags&MntGEOMJournal != 0 {
+			opts += ",gjounalc"
+		}
+		if stat.Flags&MntMultilabel != 0 {
+			opts += ",multilabel"
+		}
+		if stat.Flags&MntACLs != 0 {
+			opts += ",acls"
+		}
+		if stat.Flags&MntNoATime != 0 {
+			opts += ",noattime"
+		}
+		if stat.Flags&MntClusterRead != 0 {
+			opts += ",nocluster"
+		}
+		if stat.Flags&MntClusterWrite != 0 {
+			opts += ",noclusterw"
+		}
+		if stat.Flags&MntNFS4ACLs != 0 {
+			opts += ",nfs4acls"
+		}
+		d := PartitionStat{
+			Device:     common.IntToString(stat.Mntfromname[:]),
+			Mountpoint: common.IntToString(stat.Mntonname[:]),
+			Fstype:     common.IntToString(stat.Fstypename[:]),
+			Opts:       opts,
+		}
+		if all == false {
+			if !path.IsAbs(d.Device) || !common.PathExists(d.Device) {
+				continue
+			}
+		}
+
+		ret = append(ret, d)
+	}
+
+	return ret, nil
+}
+
+func Getfsstat(buf []Statfs, flags int) (n int, err error) {
+	return GetfsstatWithContext(context.Background(), buf, flags)
+}
+
+func GetfsstatWithContext(ctx context.Context, buf []Statfs, flags int) (n int, err error) {
+	var _p0 unsafe.Pointer
+	var bufsize uintptr
+	if len(buf) > 0 {
+		_p0 = unsafe.Pointer(&buf[0])
+		bufsize = unsafe.Sizeof(Statfs{}) * uintptr(len(buf))
+	}
+	r0, _, e1 := unix.Syscall(SYS_GETFSSTAT64, uintptr(_p0), bufsize, uintptr(flags))
+	n = int(r0)
+	if e1 != 0 {
+		err = e1
+	}
+	return
+}
+
+func getFsType(stat unix.Statfs_t) string {
+	return common.IntToString(stat.Fstypename[:])
+}

vendor/github.com/shirou/gopsutil/disk/disk_darwin.h

@@ -0,0 +1,164 @@
+#include <CoreFoundation/CoreFoundation.h>
+#include <IOKit/IOKitLib.h>
+#include <IOKit/storage/IOBlockStorageDriver.h>
+#include <IOKit/storage/IOMedia.h>
+#include <IOKit/IOBSD.h>
+
+// The iterator of all things disk. Allocated by StartIOCounterFetch, released
+// by EndIOCounterFetch.
+static io_iterator_t diskIter;
+
+// Begins fetching IO counters.
+//
+// Returns 1 if the fetch started successfully, false otherwise.
+//
+// If the fetch was started successfully, you must call EndIOCounterFetch once
+// done to release resources.
+int StartIOCounterFetch()
+{
+    if (IOServiceGetMatchingServices(kIOMasterPortDefault,
+                                     IOServiceMatching(kIOMediaClass),
+                                     &diskIter) != kIOReturnSuccess) {
+        return 0;
+    }
+
+    return 1;
+}
+
+// Releases resources from fetching IO counters.
+void EndIOCounterFetch()
+{
+    IOObjectRelease(diskIter);
+}
+
+// The current disk entry of interest. Allocated by FetchNextDisk(), released by
+// ReadDiskInfo().
+static io_registry_entry_t diskEntry;
+
+// The parent of diskEntry. Same lifetimes.
+static io_registry_entry_t parentEntry;
+
+// Fetches the next disk. Note that a disk entry is allocated, and will be held
+// until it is processed and freed by ReadDiskInfo.
+int FetchNextDisk()
+{
+    while ((diskEntry = IOIteratorNext(diskIter)) != 0) {
+        // We are iterating IOMedia. We need to get the parent too (IOBSD).
+        if (IORegistryEntryGetParentEntry(diskEntry, kIOServicePlane, &parentEntry) != kIOReturnSuccess) {
+            // something is wrong...
+            IOObjectRelease(diskEntry);
+            continue;
+        }
+
+        if (!IOObjectConformsTo(parentEntry, "IOBlockStorageDriver")) {
+            // no use to us, try the next disk
+            IOObjectRelease(diskEntry);
+            IOObjectRelease(parentEntry);
+            continue;
+        }
+
+        // Got a disk OK.
+        return 1;
+    }
+
+    // No more disks.
+    return 0;
+}
+
+// Reads the current disk (from iteration) info into DiskInfo struct.
+// Once done, all resources from the current iteration of reading are freed,
+// ready for FetchNextDisk() to be called again.
+int ReadDiskInfo(DiskInfo *info)
+{
+    // Parent props. Allocated by us.
+    CFDictionaryRef parentProps = NULL;
+
+    // Disk props. Allocated by us.
+    CFDictionaryRef diskProps = NULL;
+
+    // Disk stats, fetched by us, but not allocated by us.
+    CFDictionaryRef stats = NULL;
+
+    if (IORegistryEntryCreateCFProperties(diskEntry, (CFMutableDictionaryRef *)&parentProps,
+                                          kCFAllocatorDefault, kNilOptions) != kIOReturnSuccess)
+    {
+        // can't get parent props, give up
+        CFRelease(parentProps);
+        IOObjectRelease(diskEntry);
+        IOObjectRelease(parentEntry);
+        return -1;
+    }
+
+    if (IORegistryEntryCreateCFProperties(parentEntry, (CFMutableDictionaryRef *)&diskProps,
+                                          kCFAllocatorDefault, kNilOptions) != kIOReturnSuccess)
+    {
+        // can't get disk props, give up
+        CFRelease(parentProps);
+        CFRelease(diskProps);
+        IOObjectRelease(diskEntry);
+        IOObjectRelease(parentEntry);
+        return -1;
+    }
+
+    // Start fetching
+    CFStringRef cfDiskName = (CFStringRef)CFDictionaryGetValue(parentProps, CFSTR(kIOBSDNameKey));
+    CFStringGetCString(cfDiskName, info->DiskName, MAX_DISK_NAME, CFStringGetSystemEncoding());
+    stats = (CFDictionaryRef)CFDictionaryGetValue( diskProps, CFSTR(kIOBlockStorageDriverStatisticsKey));
+
+    if (stats == NULL) {
+        // stat fetch failed...
+        CFRelease(parentProps);
+        CFRelease(diskProps);
+        IOObjectRelease(parentEntry);
+        IOObjectRelease(diskEntry);
+        return -1;
+    }
+
+    CFNumberRef cfnum;
+
+    if ((cfnum = (CFNumberRef)CFDictionaryGetValue(stats, CFSTR(kIOBlockStorageDriverStatisticsReadsKey)))) {
+        CFNumberGetValue(cfnum, kCFNumberSInt64Type, &info->Reads);
+    } else {
+        info->Reads = 0;
+    }
+
+    if ((cfnum = (CFNumberRef)CFDictionaryGetValue(stats, CFSTR(kIOBlockStorageDriverStatisticsWritesKey)))) {
+        CFNumberGetValue(cfnum, kCFNumberSInt64Type, &info->Writes);
+    } else {
+        info->Writes = 0;
+    }
+
+    if ((cfnum = (CFNumberRef)CFDictionaryGetValue(stats, CFSTR(kIOBlockStorageDriverStatisticsBytesReadKey)))) {
+        CFNumberGetValue(cfnum, kCFNumberSInt64Type, &info->ReadBytes);
+    } else {
+        info->ReadBytes = 0;
+    }
+
+    if ((cfnum = (CFNumberRef)CFDictionaryGetValue(stats, CFSTR(kIOBlockStorageDriverStatisticsBytesWrittenKey)))) {
+        CFNumberGetValue(cfnum, kCFNumberSInt64Type, &info->WriteBytes);
+    } else {
+        info->WriteBytes = 0;
+    }
+
+    if ((cfnum = (CFNumberRef)CFDictionaryGetValue(stats, CFSTR(kIOBlockStorageDriverStatisticsTotalReadTimeKey)))) {
+        CFNumberGetValue(cfnum, kCFNumberSInt64Type, &info->ReadTime);
+    } else {
+        info->ReadTime = 0;
+    }
+    if ((cfnum = (CFNumberRef)CFDictionaryGetValue(stats, CFSTR(kIOBlockStorageDriverStatisticsTotalWriteTimeKey)))) {
+        CFNumberGetValue(cfnum, kCFNumberSInt64Type, &info->WriteTime);
+    } else {
+        info->WriteTime = 0;
+    }
+
+    // note: read/write time are in ns, but we want ms.
+    info->ReadTime = info->ReadTime / 1000 / 1000;
+    info->WriteTime = info->WriteTime / 1000 / 1000;
+
+    CFRelease(parentProps);
+    CFRelease(diskProps);
+    IOObjectRelease(parentEntry);
+    IOObjectRelease(diskEntry);
+    return 0;
+}
+

vendor/github.com/shirou/gopsutil/disk/disk_darwin_386.go

@@ -0,0 +1,59 @@
+// +build darwin
+// +build 386
+
+package disk
+
+const (
+	MntWait    = 1
+	MfsNameLen = 15 /* length of fs type name, not inc. nul */
+	MNameLen   = 90 /* length of buffer for returned name */
+
+	MFSTYPENAMELEN = 16 /* length of fs type name including null */
+	MAXPATHLEN     = 1024
+	MNAMELEN       = MAXPATHLEN
+
+	SYS_GETFSSTAT64 = 347
+)
+
+type Fsid struct{ val [2]int32 } /* file system id type */
+type uid_t int32
+
+// sys/mount.h
+const (
+	MntReadOnly     = 0x00000001 /* read only filesystem */
+	MntSynchronous  = 0x00000002 /* filesystem written synchronously */
+	MntNoExec       = 0x00000004 /* can't exec from filesystem */
+	MntNoSuid       = 0x00000008 /* don't honor setuid bits on fs */
+	MntUnion        = 0x00000020 /* union with underlying filesystem */
+	MntAsync        = 0x00000040 /* filesystem written asynchronously */
+	MntSuidDir      = 0x00100000 /* special handling of SUID on dirs */
+	MntSoftDep      = 0x00200000 /* soft updates being done */
+	MntNoSymFollow  = 0x00400000 /* do not follow symlinks */
+	MntGEOMJournal  = 0x02000000 /* GEOM journal support enabled */
+	MntMultilabel   = 0x04000000 /* MAC support for individual objects */
+	MntACLs         = 0x08000000 /* ACL support enabled */
+	MntNoATime      = 0x10000000 /* disable update of file access time */
+	MntClusterRead  = 0x40000000 /* disable cluster read */
+	MntClusterWrite = 0x80000000 /* disable cluster write */
+	MntNFS4ACLs     = 0x00000010
+)
+
+// https://github.com/golang/go/blob/master/src/syscall/ztypes_darwin_386.go#L82
+type Statfs struct {
+	Bsize       uint32
+	Iosize      int32
+	Blocks      uint64
+	Bfree       uint64
+	Bavail      uint64
+	Files       uint64
+	Ffree       uint64
+	Fsid        Fsid
+	Owner       uint32
+	Type        uint32
+	Flags       uint32
+	Fssubtype   uint32
+	Fstypename  [16]int8
+	Mntonname   [1024]int8
+	Mntfromname [1024]int8
+	Reserved    [8]uint32
+}

vendor/github.com/shirou/gopsutil/disk/disk_darwin_amd64.go

@@ -0,0 +1,58 @@
+// +build darwin
+// +build amd64
+
+package disk
+
+const (
+	MntWait    = 1
+	MfsNameLen = 15 /* length of fs type name, not inc. nul */
+	MNameLen   = 90 /* length of buffer for returned name */
+
+	MFSTYPENAMELEN = 16 /* length of fs type name including null */
+	MAXPATHLEN     = 1024
+	MNAMELEN       = MAXPATHLEN
+
+	SYS_GETFSSTAT64 = 347
+)
+
+type Fsid struct{ val [2]int32 } /* file system id type */
+type uid_t int32
+
+// sys/mount.h
+const (
+	MntReadOnly     = 0x00000001 /* read only filesystem */
+	MntSynchronous  = 0x00000002 /* filesystem written synchronously */
+	MntNoExec       = 0x00000004 /* can't exec from filesystem */
+	MntNoSuid       = 0x00000008 /* don't honor setuid bits on fs */
+	MntUnion        = 0x00000020 /* union with underlying filesystem */
+	MntAsync        = 0x00000040 /* filesystem written asynchronously */
+	MntSuidDir      = 0x00100000 /* special handling of SUID on dirs */
+	MntSoftDep      = 0x00200000 /* soft updates being done */
+	MntNoSymFollow  = 0x00400000 /* do not follow symlinks */
+	MntGEOMJournal  = 0x02000000 /* GEOM journal support enabled */
+	MntMultilabel   = 0x04000000 /* MAC support for individual objects */
+	MntACLs         = 0x08000000 /* ACL support enabled */
+	MntNoATime      = 0x10000000 /* disable update of file access time */
+	MntClusterRead  = 0x40000000 /* disable cluster read */
+	MntClusterWrite = 0x80000000 /* disable cluster write */
+	MntNFS4ACLs     = 0x00000010
+)
+
+type Statfs struct {
+	Bsize       uint32
+	Iosize      int32
+	Blocks      uint64
+	Bfree       uint64
+	Bavail      uint64
+	Files       uint64
+	Ffree       uint64
+	Fsid        Fsid
+	Owner       uint32
+	Type        uint32
+	Flags       uint32
+	Fssubtype   uint32
+	Fstypename  [16]int8
+	Mntonname   [1024]int8
+	Mntfromname [1024]int8
+	Reserved    [8]uint32
+}

vendor/github.com/shirou/gopsutil/disk/disk_darwin_arm64.go

@@ -0,0 +1,58 @@
+// +build darwin
+// +build arm64
+
+package disk
+
+const (
+	MntWait    = 1
+	MfsNameLen = 15 /* length of fs type name, not inc. nul */
+	MNameLen   = 90 /* length of buffer for returned name */
+
+	MFSTYPENAMELEN = 16 /* length of fs type name including null */
+	MAXPATHLEN     = 1024
+	MNAMELEN       = MAXPATHLEN
+
+	SYS_GETFSSTAT64 = 347
+)
+
+type Fsid struct{ val [2]int32 } /* file system id type */
+type uid_t int32
+
+// sys/mount.h
+const (
+	MntReadOnly     = 0x00000001 /* read only filesystem */
+	MntSynchronous  = 0x00000002 /* filesystem written synchronously */
+	MntNoExec       = 0x00000004 /* can't exec from filesystem */
+	MntNoSuid       = 0x00000008 /* don't honor setuid bits on fs */
+	MntUnion        = 0x00000020 /* union with underlying filesystem */
+	MntAsync        = 0x00000040 /* filesystem written asynchronously */
+	MntSuidDir      = 0x00100000 /* special handling of SUID on dirs */
+	MntSoftDep      = 0x00200000 /* soft updates being done */
+	MntNoSymFollow  = 0x00400000 /* do not follow symlinks */
+	MntGEOMJournal  = 0x02000000 /* GEOM journal support enabled */
+	MntMultilabel   = 0x04000000 /* MAC support for individual objects */
+	MntACLs         = 0x08000000 /* ACL support enabled */
+	MntNoATime      = 0x10000000 /* disable update of file access time */
+	MntClusterRead  = 0x40000000 /* disable cluster read */
+	MntClusterWrite = 0x80000000 /* disable cluster write */
+	MntNFS4ACLs     = 0x00000010
+)
+
+type Statfs struct {
+	Bsize       uint32
+	Iosize      int32
+	Blocks      uint64
+	Bfree       uint64
+	Bavail      uint64
+	Files       uint64
+	Ffree       uint64
+	Fsid        Fsid
+	Owner       uint32
+	Type        uint32
+	Flags       uint32
+	Fssubtype   uint32
+	Fstypename  [16]int8
+	Mntonname   [1024]int8
+	Mntfromname [1024]int8
+	Reserved    [8]uint32
+}

vendor/github.com/shirou/gopsutil/disk/disk_darwin_cgo.go

@@ -0,0 +1,95 @@
+// +build darwin
+// +build cgo
+
+package disk
+
+/*
+#cgo LDFLAGS: -lobjc -framework Foundation -framework IOKit
+#include <stdint.h>
+
+// ### enough?
+const int MAX_DISK_NAME = 100;
+
+typedef struct
+{
+    char DiskName[MAX_DISK_NAME];
+    int64_t Reads;
+    int64_t Writes;
+    int64_t ReadBytes;
+    int64_t WriteBytes;
+    int64_t ReadTime;
+    int64_t WriteTime;
+} DiskInfo;
+
+#include "disk_darwin.h"
+*/
+import "C"
+
+import (
+	"context"
+	"errors"
+	"strings"
+	"unsafe"
+
+	"github.com/shirou/gopsutil/internal/common"
+)
+
+func IOCounters(names ...string) (map[string]IOCountersStat, error) {
+	return IOCountersWithContext(context.Background(), names...)
+}
+
+func IOCountersWithContext(ctx context.Context, names ...string) (map[string]IOCountersStat, error) {
+	if C.StartIOCounterFetch() == 0 {
+		return nil, errors.New("Unable to fetch disk list")
+	}
+
+	// Clean up when we are done.
+	defer C.EndIOCounterFetch()
+	ret := make(map[string]IOCountersStat, 0)
+
+	for {
+		res := C.FetchNextDisk()
+		if res == -1 {
+			return nil, errors.New("Unable to fetch disk information")
+		} else if res == 0 {
+			break // done
+		}
+
+		di := C.DiskInfo{}
+		if C.ReadDiskInfo((*C.DiskInfo)(unsafe.Pointer(&di))) == -1 {
+			return nil, errors.New("Unable to fetch disk properties")
+		}
+
+		// Used to only get the necessary part of the C string.
+		isRuneNull := func(r rune) bool {
+			return r == '\u0000'
+		}
+
+		// Map from the darwin-specific C struct to the Go type
+		//
+		// ### missing: IopsInProgress, WeightedIO, MergedReadCount,
+		// MergedWriteCount, SerialNumber
+		// IOKit can give us at least the serial number I think...
+		d := IOCountersStat{
+			// Note: The Go type wants unsigned values, but CFNumberGetValue
+			// doesn't appear to be able to give us unsigned values. So, we
+			// cast, and hope for the best.
+			ReadBytes:  uint64(di.ReadBytes),
+			WriteBytes: uint64(di.WriteBytes),
+			ReadCount:  uint64(di.Reads),
+			WriteCount: uint64(di.Writes),
+			ReadTime:   uint64(di.ReadTime),
+			WriteTime:  uint64(di.WriteTime),
+			IoTime:     uint64(di.ReadTime + di.WriteTime),
+			Name:       strings.TrimFunc(C.GoStringN(&di.DiskName[0], C.MAX_DISK_NAME), isRuneNull),
+		}
+
+		if len(names) > 0 && !common.StringsHas(names, d.Name) {
+			continue
+		}
+
+		ret[d.Name] = d
+	}
+
+	return ret, nil
+}

vendor/github.com/shirou/gopsutil/disk/disk_darwin_nocgo.go

@@ -0,0 +1,18 @@
+// +build darwin
+// +build !cgo
+
+package disk
+
+import (
+	"context"
+
+	"github.com/shirou/gopsutil/internal/common"
+)
+
+func IOCounters(names ...string) (map[string]IOCountersStat, error) {
+	return IOCountersWithContext(context.Background(), names...)
+}
+
+func IOCountersWithContext(ctx context.Context, names ...string) (map[string]IOCountersStat, error) {
+	return nil, common.ErrNotImplementedError
+}

vendor/github.com/shirou/gopsutil/disk/disk_fallback.go

@@ -0,0 +1,33 @@
+// +build !darwin,!linux,!freebsd,!openbsd,!windows,!solaris
+
+package disk
+
+import (
+	"context"
+
+	"github.com/shirou/gopsutil/internal/common"
+)
+
+func IOCounters(names ...string) (map[string]IOCountersStat, error) {
+	return IOCountersWithContext(context.Background(), names...)
+}
+
+func IOCountersWithContext(ctx context.Context, names ...string) (map[string]IOCountersStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+
+func Partitions(all bool) ([]PartitionStat, error) {
+	return PartitionsWithContext(context.Background(), all)
+}
+
+func PartitionsWithContext(ctx context.Context, all bool) ([]PartitionStat, error) {
+	return []PartitionStat{}, common.ErrNotImplementedError
+}
+
+func Usage(path string) (*UsageStat, error) {
+	return UsageWithContext(context.Background(), path)
+}
+
+func UsageWithContext(ctx context.Context, path string) (*UsageStat, error) {
+	return nil, common.ErrNotImplementedError
+}

vendor/github.com/shirou/gopsutil/disk/disk_freebsd.go

@@ -0,0 +1,196 @@
+// +build freebsd
+
+package disk
+
+import (
+	"bytes"
+	"context"
+	"encoding/binary"
+	"path"
+	"strconv"
+	"unsafe"
+
+	"golang.org/x/sys/unix"
+
+	"github.com/shirou/gopsutil/internal/common"
+)
+
+func Partitions(all bool) ([]PartitionStat, error) {
+	return PartitionsWithContext(context.Background(), all)
+}
+
+func PartitionsWithContext(ctx context.Context, all bool) ([]PartitionStat, error) {
+	var ret []PartitionStat
+
+	// get length
+	count, err := unix.Getfsstat(nil, MNT_WAIT)
+	if err != nil {
+		return ret, err
+	}
+
+	fs := make([]Statfs, count)
+	if _, err = Getfsstat(fs, MNT_WAIT); err != nil {
+		return ret, err
+	}
+
+	for _, stat := range fs {
+		opts := "rw"
+		if stat.Flags&MNT_RDONLY != 0 {
+			opts = "ro"
+		}
+		if stat.Flags&MNT_SYNCHRONOUS != 0 {
+			opts += ",sync"
+		}
+		if stat.Flags&MNT_NOEXEC != 0 {
+			opts += ",noexec"
+		}
+		if stat.Flags&MNT_NOSUID != 0 {
+			opts += ",nosuid"
+		}
+		if stat.Flags&MNT_UNION != 0 {
+			opts += ",union"
+		}
+		if stat.Flags&MNT_ASYNC != 0 {
+			opts += ",async"
+		}
+		if stat.Flags&MNT_SUIDDIR != 0 {
+			opts += ",suiddir"
+		}
+		if stat.Flags&MNT_SOFTDEP != 0 {
+			opts += ",softdep"
+		}
+		if stat.Flags&MNT_NOSYMFOLLOW != 0 {
+			opts += ",nosymfollow"
+		}
+		if stat.Flags&MNT_GJOURNAL != 0 {
+			opts += ",gjounalc"
+		}
+		if stat.Flags&MNT_MULTILABEL != 0 {
+			opts += ",multilabel"
+		}
+		if stat.Flags&MNT_ACLS != 0 {
+			opts += ",acls"
+		}
+		if stat.Flags&MNT_NOATIME != 0 {
+			opts += ",noattime"
+		}
+		if stat.Flags&MNT_NOCLUSTERR != 0 {
+			opts += ",nocluster"
+		}
+		if stat.Flags&MNT_NOCLUSTERW != 0 {
+			opts += ",noclusterw"
+		}
+		if stat.Flags&MNT_NFS4ACLS != 0 {
+			opts += ",nfs4acls"
+		}
+
+		d := PartitionStat{
+			Device:     common.IntToString(stat.Mntfromname[:]),
+			Mountpoint: common.IntToString(stat.Mntonname[:]),
+			Fstype:     common.IntToString(stat.Fstypename[:]),
+			Opts:       opts,
+		}
+		if all == false {
+			if !path.IsAbs(d.Device) || !common.PathExists(d.Device) {
+				continue
+			}
+		}
+
+		ret = append(ret, d)
+	}
+
+	return ret, nil
+}
+
+func IOCounters(names ...string) (map[string]IOCountersStat, error) {
+	return IOCountersWithContext(context.Background(), names...)
+}
+
+func IOCountersWithContext(ctx context.Context, names ...string) (map[string]IOCountersStat, error) {
+	// statinfo->devinfo->devstat
+	// /usr/include/devinfo.h
+	ret := make(map[string]IOCountersStat)
+
+	r, err := unix.Sysctl("kern.devstat.all")
+	if err != nil {
+		return nil, err
+	}
+	buf := []byte(r)
+	length := len(buf)
+
+	count := int(uint64(length) / uint64(sizeOfDevstat))
+
+	buf = buf[8:] // devstat.all has version in the head.
+	// parse buf to Devstat
+	for i := 0; i < count; i++ {
+		b := buf[i*sizeOfDevstat : i*sizeOfDevstat+sizeOfDevstat]
+		d, err := parseDevstat(b)
+		if err != nil {
+			continue
+		}
+		un := strconv.Itoa(int(d.Unit_number))
+		name := common.IntToString(d.Device_name[:]) + un
+
+		if len(names) > 0 && !common.StringsHas(names, name) {
+			continue
+		}
+
+		ds := IOCountersStat{
+			ReadCount:  d.Operations[DEVSTAT_READ],
+			WriteCount: d.Operations[DEVSTAT_WRITE],
+			ReadBytes:  d.Bytes[DEVSTAT_READ],
+			WriteBytes: d.Bytes[DEVSTAT_WRITE],
+			ReadTime:   uint64(d.Duration[DEVSTAT_READ].Compute() * 1000),
+			WriteTime:  uint64(d.Duration[DEVSTAT_WRITE].Compute() * 1000),
+			IoTime:     uint64(d.Busy_time.Compute() * 1000),
+			Name:       name,
+		}
+		ret[name] = ds
+	}
+
+	return ret, nil
+}
+
+func (b Bintime) Compute() float64 {
+	BINTIME_SCALE := 5.42101086242752217003726400434970855712890625e-20
+	return float64(b.Sec) + float64(b.Frac)*BINTIME_SCALE
+}
+
+// BT2LD(time)     ((long double)(time).sec + (time).frac * BINTIME_SCALE)
+
+// Getfsstat is borrowed from pkg/syscall/syscall_freebsd.go
+// change Statfs_t to Statfs in order to get more information
+func Getfsstat(buf []Statfs, flags int) (n int, err error) {
+	return GetfsstatWithContext(context.Background(), buf, flags)
+}
+
+func GetfsstatWithContext(ctx context.Context, buf []Statfs, flags int) (n int, err error) {
+	var _p0 unsafe.Pointer
+	var bufsize uintptr
+	if len(buf) > 0 {
+		_p0 = unsafe.Pointer(&buf[0])
+		bufsize = unsafe.Sizeof(Statfs{}) * uintptr(len(buf))
+	}
+	r0, _, e1 := unix.Syscall(unix.SYS_GETFSSTAT, uintptr(_p0), bufsize, uintptr(flags))
+	n = int(r0)
+	if e1 != 0 {
+		err = e1
+	}
+	return
+}
+
+func parseDevstat(buf []byte) (Devstat, error) {
+	var ds Devstat
+	br := bytes.NewReader(buf)
+	//	err := binary.Read(br, binary.LittleEndian, &ds)
+	err := common.Read(br, binary.LittleEndian, &ds)
+	if err != nil {
+		return ds, err
+	}
+
+	return ds, nil
+}
+
+func getFsType(stat unix.Statfs_t) string {
+	return common.IntToString(stat.Fstypename[:])
+}

vendor/github.com/shirou/gopsutil/disk/disk_freebsd_386.go

@@ -0,0 +1,112 @@
+// Created by cgo -godefs - DO NOT EDIT
+// cgo -godefs types_freebsd.go
+
+package disk
+
+const (
+	sizeofPtr        = 0x4
+	sizeofShort      = 0x2
+	sizeofInt        = 0x4
+	sizeofLong       = 0x4
+	sizeofLongLong   = 0x8
+	sizeofLongDouble = 0x8
+
+	DEVSTAT_NO_DATA = 0x00
+	DEVSTAT_READ    = 0x01
+	DEVSTAT_WRITE   = 0x02
+	DEVSTAT_FREE    = 0x03
+
+	MNT_RDONLY      = 0x00000001
+	MNT_SYNCHRONOUS = 0x00000002
+	MNT_NOEXEC      = 0x00000004
+	MNT_NOSUID      = 0x00000008
+	MNT_UNION       = 0x00000020
+	MNT_ASYNC       = 0x00000040
+	MNT_SUIDDIR     = 0x00100000
+	MNT_SOFTDEP     = 0x00200000
+	MNT_NOSYMFOLLOW = 0x00400000
+	MNT_GJOURNAL    = 0x02000000
+	MNT_MULTILABEL  = 0x04000000
+	MNT_ACLS        = 0x08000000
+	MNT_NOATIME     = 0x10000000
+	MNT_NOCLUSTERR  = 0x40000000
+	MNT_NOCLUSTERW  = 0x80000000
+	MNT_NFS4ACLS    = 0x00000010
+
+	MNT_WAIT    = 1
+	MNT_NOWAIT  = 2
+	MNT_LAZY    = 3
+	MNT_SUSPEND = 4
+)
+
+const (
+	sizeOfDevstat = 0xf0
+)
+
+type (
+	_C_short       int16
+	_C_int         int32
+	_C_long        int32
+	_C_long_long   int64
+	_C_long_double int64
+)
+
+type Statfs struct {
+	Version     uint32
+	Type        uint32
+	Flags       uint64
+	Bsize       uint64
+	Iosize      uint64
+	Blocks      uint64
+	Bfree       uint64
+	Bavail      int64
+	Files       uint64
+	Ffree       int64
+	Syncwrites  uint64
+	Asyncwrites uint64
+	Syncreads   uint64
+	Asyncreads  uint64
+	Spare       [10]uint64
+	Namemax     uint32
+	Owner       uint32
+	Fsid        Fsid
+	Charspare   [80]int8
+	Fstypename  [16]int8
+	Mntfromname [88]int8
+	Mntonname   [88]int8
+}
+type Fsid struct {
+	Val [2]int32
+}
+
+type Devstat struct {
+	Sequence0     uint32
+	Allocated     int32
+	Start_count   uint32
+	End_count     uint32
+	Busy_from     Bintime
+	Dev_links     _Ctype_struct___0
+	Device_number uint32
+	Device_name   [16]int8
+	Unit_number   int32
+	Bytes         [4]uint64
+	Operations    [4]uint64
+	Duration      [4]Bintime
+	Busy_time     Bintime
+	Creation_time Bintime
+	Block_size    uint32
+	Tag_types     [3]uint64
+	Flags         uint32
+	Device_type   uint32
+	Priority      uint32
+	Id            *byte
+	Sequence1     uint32
+}
+type Bintime struct {
+	Sec  int32
+	Frac uint64
+}
+
+type _Ctype_struct___0 struct {
+	Empty uint32
+}

vendor/github.com/shirou/gopsutil/disk/disk_freebsd_amd64.go

@@ -0,0 +1,115 @@
+// Created by cgo -godefs - DO NOT EDIT
+// cgo -godefs types_freebsd.go
+
+package disk
+
+const (
+	sizeofPtr        = 0x8
+	sizeofShort      = 0x2
+	sizeofInt        = 0x4
+	sizeofLong       = 0x8
+	sizeofLongLong   = 0x8
+	sizeofLongDouble = 0x8
+
+	DEVSTAT_NO_DATA = 0x00
+	DEVSTAT_READ    = 0x01
+	DEVSTAT_WRITE   = 0x02
+	DEVSTAT_FREE    = 0x03
+
+	MNT_RDONLY      = 0x00000001
+	MNT_SYNCHRONOUS = 0x00000002
+	MNT_NOEXEC      = 0x00000004
+	MNT_NOSUID      = 0x00000008
+	MNT_UNION       = 0x00000020
+	MNT_ASYNC       = 0x00000040
+	MNT_SUIDDIR     = 0x00100000
+	MNT_SOFTDEP     = 0x00200000
+	MNT_NOSYMFOLLOW = 0x00400000
+	MNT_GJOURNAL    = 0x02000000
+	MNT_MULTILABEL  = 0x04000000
+	MNT_ACLS        = 0x08000000
+	MNT_NOATIME     = 0x10000000
+	MNT_NOCLUSTERR  = 0x40000000
+	MNT_NOCLUSTERW  = 0x80000000
+	MNT_NFS4ACLS    = 0x00000010
+
+	MNT_WAIT    = 1
+	MNT_NOWAIT  = 2
+	MNT_LAZY    = 3
+	MNT_SUSPEND = 4
+)
+
+const (
+	sizeOfDevstat = 0x120
+)
+
+type (
+	_C_short       int16
+	_C_int         int32
+	_C_long        int64
+	_C_long_long   int64
+	_C_long_double int64
+)
+
+type Statfs struct {
+	Version     uint32
+	Type        uint32
+	Flags       uint64
+	Bsize       uint64
+	Iosize      uint64
+	Blocks      uint64
+	Bfree       uint64
+	Bavail      int64
+	Files       uint64
+	Ffree       int64
+	Syncwrites  uint64
+	Asyncwrites uint64
+	Syncreads   uint64
+	Asyncreads  uint64
+	Spare       [10]uint64
+	Namemax     uint32
+	Owner       uint32
+	Fsid        Fsid
+	Charspare   [80]int8
+	Fstypename  [16]int8
+	Mntfromname [88]int8
+	Mntonname   [88]int8
+}
+type Fsid struct {
+	Val [2]int32
+}
+
+type Devstat struct {
+	Sequence0     uint32
+	Allocated     int32
+	Start_count   uint32
+	End_count     uint32
+	Busy_from     Bintime
+	Dev_links     _Ctype_struct___0
+	Device_number uint32
+	Device_name   [16]int8
+	Unit_number   int32
+	Bytes         [4]uint64
+	Operations    [4]uint64
+	Duration      [4]Bintime
+	Busy_time     Bintime
+	Creation_time Bintime
+	Block_size    uint32
+	Pad_cgo_0     [4]byte
+	Tag_types     [3]uint64
+	Flags         uint32
+	Device_type   uint32
+	Priority      uint32
+	Pad_cgo_1     [4]byte
+	ID            *byte
+	Sequence1     uint32
+	Pad_cgo_2     [4]byte
+}
+type Bintime struct {
+	Sec  int64
+	Frac uint64
+}
+
+type _Ctype_struct___0 struct {
+	Empty uint64
+}

vendor/github.com/shirou/gopsutil/disk/disk_linux.go

@@ -0,0 +1,447 @@
+// +build linux
+
+package disk
+
+import (
+	"bufio"
+	"bytes"
+	"context"
+	"fmt"
+	"io/ioutil"
+	"path/filepath"
+	"strconv"
+	"strings"
+
+	"golang.org/x/sys/unix"
+
+	"github.com/shirou/gopsutil/internal/common"
+)
+
+const (
+	SectorSize = 512
+)
+const (
+	// man statfs
+	ADFS_SUPER_MAGIC      = 0xadf5
+	AFFS_SUPER_MAGIC      = 0xADFF
+	BDEVFS_MAGIC          = 0x62646576
+	BEFS_SUPER_MAGIC      = 0x42465331
+	BFS_MAGIC             = 0x1BADFACE
+	BINFMTFS_MAGIC        = 0x42494e4d
+	BTRFS_SUPER_MAGIC     = 0x9123683E
+	CGROUP_SUPER_MAGIC    = 0x27e0eb
+	CIFS_MAGIC_NUMBER     = 0xFF534D42
+	CODA_SUPER_MAGIC      = 0x73757245
+	COH_SUPER_MAGIC       = 0x012FF7B7
+	CRAMFS_MAGIC          = 0x28cd3d45
+	DEBUGFS_MAGIC         = 0x64626720
+	DEVFS_SUPER_MAGIC     = 0x1373
+	DEVPTS_SUPER_MAGIC    = 0x1cd1
+	EFIVARFS_MAGIC        = 0xde5e81e4
+	EFS_SUPER_MAGIC       = 0x00414A53
+	EXT_SUPER_MAGIC       = 0x137D
+	EXT2_OLD_SUPER_MAGIC  = 0xEF51
+	EXT2_SUPER_MAGIC      = 0xEF53
+	EXT3_SUPER_MAGIC      = 0xEF53
+	EXT4_SUPER_MAGIC      = 0xEF53
+	FUSE_SUPER_MAGIC      = 0x65735546
+	FUTEXFS_SUPER_MAGIC   = 0xBAD1DEA
+	HFS_SUPER_MAGIC       = 0x4244
+	HOSTFS_SUPER_MAGIC    = 0x00c0ffee
+	HPFS_SUPER_MAGIC      = 0xF995E849
+	HUGETLBFS_MAGIC       = 0x958458f6
+	ISOFS_SUPER_MAGIC     = 0x9660
+	JFFS2_SUPER_MAGIC     = 0x72b6
+	JFS_SUPER_MAGIC       = 0x3153464a
+	MINIX_SUPER_MAGIC     = 0x137F /* orig. minix */
+	MINIX_SUPER_MAGIC2    = 0x138F /* 30 char minix */
+	MINIX2_SUPER_MAGIC    = 0x2468 /* minix V2 */
+	MINIX2_SUPER_MAGIC2   = 0x2478 /* minix V2, 30 char names */
+	MINIX3_SUPER_MAGIC    = 0x4d5a /* minix V3 fs, 60 char names */
+	MQUEUE_MAGIC          = 0x19800202
+	MSDOS_SUPER_MAGIC     = 0x4d44
+	NCP_SUPER_MAGIC       = 0x564c
+	NFS_SUPER_MAGIC       = 0x6969
+	NILFS_SUPER_MAGIC     = 0x3434
+	NTFS_SB_MAGIC         = 0x5346544e
+	OCFS2_SUPER_MAGIC     = 0x7461636f
+	OPENPROM_SUPER_MAGIC  = 0x9fa1
+	PIPEFS_MAGIC          = 0x50495045
+	PROC_SUPER_MAGIC      = 0x9fa0
+	PSTOREFS_MAGIC        = 0x6165676C
+	QNX4_SUPER_MAGIC      = 0x002f
+	QNX6_SUPER_MAGIC      = 0x68191122
+	RAMFS_MAGIC           = 0x858458f6
+	REISERFS_SUPER_MAGIC  = 0x52654973
+	ROMFS_MAGIC           = 0x7275
+	SELINUX_MAGIC         = 0xf97cff8c
+	SMACK_MAGIC           = 0x43415d53
+	SMB_SUPER_MAGIC       = 0x517B
+	SOCKFS_MAGIC          = 0x534F434B
+	SQUASHFS_MAGIC        = 0x73717368
+	SYSFS_MAGIC           = 0x62656572
+	SYSV2_SUPER_MAGIC     = 0x012FF7B6
+	SYSV4_SUPER_MAGIC     = 0x012FF7B5
+	TMPFS_MAGIC           = 0x01021994
+	UDF_SUPER_MAGIC       = 0x15013346
+	UFS_MAGIC             = 0x00011954
+	USBDEVICE_SUPER_MAGIC = 0x9fa2
+	V9FS_MAGIC            = 0x01021997
+	VXFS_SUPER_MAGIC      = 0xa501FCF5
+	XENFS_SUPER_MAGIC     = 0xabba1974
+	XENIX_SUPER_MAGIC     = 0x012FF7B4
+	XFS_SUPER_MAGIC       = 0x58465342
+	_XIAFS_SUPER_MAGIC    = 0x012FD16D
+
+	AFS_SUPER_MAGIC             = 0x5346414F
+	AUFS_SUPER_MAGIC            = 0x61756673
+	ANON_INODE_FS_SUPER_MAGIC   = 0x09041934
+	CEPH_SUPER_MAGIC            = 0x00C36400
+	ECRYPTFS_SUPER_MAGIC        = 0xF15F
+	FAT_SUPER_MAGIC             = 0x4006
+	FHGFS_SUPER_MAGIC           = 0x19830326
+	FUSEBLK_SUPER_MAGIC         = 0x65735546
+	FUSECTL_SUPER_MAGIC         = 0x65735543
+	GFS_SUPER_MAGIC             = 0x1161970
+	GPFS_SUPER_MAGIC            = 0x47504653
+	MTD_INODE_FS_SUPER_MAGIC    = 0x11307854
+	INOTIFYFS_SUPER_MAGIC       = 0x2BAD1DEA
+	ISOFS_R_WIN_SUPER_MAGIC     = 0x4004
+	ISOFS_WIN_SUPER_MAGIC       = 0x4000
+	JFFS_SUPER_MAGIC            = 0x07C0
+	KAFS_SUPER_MAGIC            = 0x6B414653
+	LUSTRE_SUPER_MAGIC          = 0x0BD00BD0
+	NFSD_SUPER_MAGIC            = 0x6E667364
+	PANFS_SUPER_MAGIC           = 0xAAD7AAEA
+	RPC_PIPEFS_SUPER_MAGIC      = 0x67596969
+	SECURITYFS_SUPER_MAGIC      = 0x73636673
+	UFS_BYTESWAPPED_SUPER_MAGIC = 0x54190100
+	VMHGFS_SUPER_MAGIC          = 0xBACBACBC
+	VZFS_SUPER_MAGIC            = 0x565A4653
+	ZFS_SUPER_MAGIC             = 0x2FC12FC1
+)
+
+// coreutils/src/stat.c
+var fsTypeMap = map[int64]string{
+	ADFS_SUPER_MAGIC:          "adfs",          /* 0xADF5 local */
+	AFFS_SUPER_MAGIC:          "affs",          /* 0xADFF local */
+	AFS_SUPER_MAGIC:           "afs",           /* 0x5346414F remote */
+	ANON_INODE_FS_SUPER_MAGIC: "anon-inode FS", /* 0x09041934 local */
+	AUFS_SUPER_MAGIC:          "aufs",          /* 0x61756673 remote */
+	//	AUTOFS_SUPER_MAGIC:          "autofs",              /* 0x0187 local */
+	BEFS_SUPER_MAGIC:            "befs",                /* 0x42465331 local */
+	BDEVFS_MAGIC:                "bdevfs",              /* 0x62646576 local */
+	BFS_MAGIC:                   "bfs",                 /* 0x1BADFACE local */
+	BINFMTFS_MAGIC:              "binfmt_misc",         /* 0x42494E4D local */
+	BTRFS_SUPER_MAGIC:           "btrfs",               /* 0x9123683E local */
+	CEPH_SUPER_MAGIC:            "ceph",                /* 0x00C36400 remote */
+	CGROUP_SUPER_MAGIC:          "cgroupfs",            /* 0x0027E0EB local */
+	CIFS_MAGIC_NUMBER:           "cifs",                /* 0xFF534D42 remote */
+	CODA_SUPER_MAGIC:            "coda",                /* 0x73757245 remote */
+	COH_SUPER_MAGIC:             "coh",                 /* 0x012FF7B7 local */
+	CRAMFS_MAGIC:                "cramfs",              /* 0x28CD3D45 local */
+	DEBUGFS_MAGIC:               "debugfs",             /* 0x64626720 local */
+	DEVFS_SUPER_MAGIC:           "devfs",               /* 0x1373 local */
+	DEVPTS_SUPER_MAGIC:          "devpts",              /* 0x1CD1 local */
+	ECRYPTFS_SUPER_MAGIC:        "ecryptfs",            /* 0xF15F local */
+	EFS_SUPER_MAGIC:             "efs",                 /* 0x00414A53 local */
+	EXT_SUPER_MAGIC:             "ext",                 /* 0x137D local */
+	EXT2_SUPER_MAGIC:            "ext2/ext3",           /* 0xEF53 local */
+	EXT2_OLD_SUPER_MAGIC:        "ext2",                /* 0xEF51 local */
+	FAT_SUPER_MAGIC:             "fat",                 /* 0x4006 local */
+	FHGFS_SUPER_MAGIC:           "fhgfs",               /* 0x19830326 remote */
+	FUSEBLK_SUPER_MAGIC:         "fuseblk",             /* 0x65735546 remote */
+	FUSECTL_SUPER_MAGIC:         "fusectl",             /* 0x65735543 remote */
+	FUTEXFS_SUPER_MAGIC:         "futexfs",             /* 0x0BAD1DEA local */
+	GFS_SUPER_MAGIC:             "gfs/gfs2",            /* 0x1161970 remote */
+	GPFS_SUPER_MAGIC:            "gpfs",                /* 0x47504653 remote */
+	HFS_SUPER_MAGIC:             "hfs",                 /* 0x4244 local */
+	HPFS_SUPER_MAGIC:            "hpfs",                /* 0xF995E849 local */
+	HUGETLBFS_MAGIC:             "hugetlbfs",           /* 0x958458F6 local */
+	MTD_INODE_FS_SUPER_MAGIC:    "inodefs",             /* 0x11307854 local */
+	INOTIFYFS_SUPER_MAGIC:       "inotifyfs",           /* 0x2BAD1DEA local */
+	ISOFS_SUPER_MAGIC:           "isofs",               /* 0x9660 local */
+	ISOFS_R_WIN_SUPER_MAGIC:     "isofs",               /* 0x4004 local */
+	ISOFS_WIN_SUPER_MAGIC:       "isofs",               /* 0x4000 local */
+	JFFS_SUPER_MAGIC:            "jffs",                /* 0x07C0 local */
+	JFFS2_SUPER_MAGIC:           "jffs2",               /* 0x72B6 local */
+	JFS_SUPER_MAGIC:             "jfs",                 /* 0x3153464A local */
+	KAFS_SUPER_MAGIC:            "k-afs",               /* 0x6B414653 remote */
+	LUSTRE_SUPER_MAGIC:          "lustre",              /* 0x0BD00BD0 remote */
+	MINIX_SUPER_MAGIC:           "minix",               /* 0x137F local */
+	MINIX_SUPER_MAGIC2:          "minix (30 char.)",    /* 0x138F local */
+	MINIX2_SUPER_MAGIC:          "minix v2",            /* 0x2468 local */
+	MINIX2_SUPER_MAGIC2:         "minix v2 (30 char.)", /* 0x2478 local */
+	MINIX3_SUPER_MAGIC:          "minix3",              /* 0x4D5A local */
+	MQUEUE_MAGIC:                "mqueue",              /* 0x19800202 local */
+	MSDOS_SUPER_MAGIC:           "msdos",               /* 0x4D44 local */
+	NCP_SUPER_MAGIC:             "novell",              /* 0x564C remote */
+	NFS_SUPER_MAGIC:             "nfs",                 /* 0x6969 remote */
+	NFSD_SUPER_MAGIC:            "nfsd",                /* 0x6E667364 remote */
+	NILFS_SUPER_MAGIC:           "nilfs",               /* 0x3434 local */
+	NTFS_SB_MAGIC:               "ntfs",                /* 0x5346544E local */
+	OPENPROM_SUPER_MAGIC:        "openprom",            /* 0x9FA1 local */
+	OCFS2_SUPER_MAGIC:           "ocfs2",               /* 0x7461636f remote */
+	PANFS_SUPER_MAGIC:           "panfs",               /* 0xAAD7AAEA remote */
+	PIPEFS_MAGIC:                "pipefs",              /* 0x50495045 remote */
+	PROC_SUPER_MAGIC:            "proc",                /* 0x9FA0 local */
+	PSTOREFS_MAGIC:              "pstorefs",            /* 0x6165676C local */
+	QNX4_SUPER_MAGIC:            "qnx4",                /* 0x002F local */
+	QNX6_SUPER_MAGIC:            "qnx6",                /* 0x68191122 local */
+	RAMFS_MAGIC:                 "ramfs",               /* 0x858458F6 local */
+	REISERFS_SUPER_MAGIC:        "reiserfs",            /* 0x52654973 local */
+	ROMFS_MAGIC:                 "romfs",               /* 0x7275 local */
+	RPC_PIPEFS_SUPER_MAGIC:      "rpc_pipefs",          /* 0x67596969 local */
+	SECURITYFS_SUPER_MAGIC:      "securityfs",          /* 0x73636673 local */
+	SELINUX_MAGIC:               "selinux",             /* 0xF97CFF8C local */
+	SMB_SUPER_MAGIC:             "smb",                 /* 0x517B remote */
+	SOCKFS_MAGIC:                "sockfs",              /* 0x534F434B local */
+	SQUASHFS_MAGIC:              "squashfs",            /* 0x73717368 local */
+	SYSFS_MAGIC:                 "sysfs",               /* 0x62656572 local */
+	SYSV2_SUPER_MAGIC:           "sysv2",               /* 0x012FF7B6 local */
+	SYSV4_SUPER_MAGIC:           "sysv4",               /* 0x012FF7B5 local */
+	TMPFS_MAGIC:                 "tmpfs",               /* 0x01021994 local */
+	UDF_SUPER_MAGIC:             "udf",                 /* 0x15013346 local */
+	UFS_MAGIC:                   "ufs",                 /* 0x00011954 local */
+	UFS_BYTESWAPPED_SUPER_MAGIC: "ufs",                 /* 0x54190100 local */
+	USBDEVICE_SUPER_MAGIC:       "usbdevfs",            /* 0x9FA2 local */
+	V9FS_MAGIC:                  "v9fs",                /* 0x01021997 local */
+	VMHGFS_SUPER_MAGIC:          "vmhgfs",              /* 0xBACBACBC remote */
+	VXFS_SUPER_MAGIC:            "vxfs",                /* 0xA501FCF5 local */
+	VZFS_SUPER_MAGIC:            "vzfs",                /* 0x565A4653 local */
+	XENFS_SUPER_MAGIC:           "xenfs",               /* 0xABBA1974 local */
+	XENIX_SUPER_MAGIC:           "xenix",               /* 0x012FF7B4 local */
+	XFS_SUPER_MAGIC:             "xfs",                 /* 0x58465342 local */
+	_XIAFS_SUPER_MAGIC:          "xia",                 /* 0x012FD16D local */
+	ZFS_SUPER_MAGIC:             "zfs",                 /* 0x2FC12FC1 local */
+}
+
+// Partitions returns disk partitions. If all is false, returns
+// physical devices only (e.g. hard disks, cd-rom drives, USB keys)
+// and ignore all others (e.g. memory partitions such as /dev/shm)
+func Partitions(all bool) ([]PartitionStat, error) {
+	return PartitionsWithContext(context.Background(), all)
+}
+
+func PartitionsWithContext(ctx context.Context, all bool) ([]PartitionStat, error) {
+	filename := common.HostProc("self/mounts")
+	lines, err := common.ReadLines(filename)
+	if err != nil {
+		return nil, err
+	}
+
+	fs, err := getFileSystems()
+	if err != nil {
+		return nil, err
+	}
+
+	ret := make([]PartitionStat, 0, len(lines))
+
+	for _, line := range lines {
+		fields := strings.Fields(line)
+		d := PartitionStat{
+			Device:     fields[0],
+			Mountpoint: fields[1],
+			Fstype:     fields[2],
+			Opts:       fields[3],
+		}
+		if all == false {
+			if d.Device == "none" || !common.StringsHas(fs, d.Fstype) {
+				continue
+			}
+		}
+		ret = append(ret, d)
+	}
+
+	return ret, nil
+}
+
+// getFileSystems returns supported filesystems from /proc/filesystems
+func getFileSystems() ([]string, error) {
+	filename := common.HostProc("filesystems")
+	lines, err := common.ReadLines(filename)
+	if err != nil {
+		return nil, err
+	}
+	var ret []string
+	for _, line := range lines {
+		if !strings.HasPrefix(line, "nodev") {
+			ret = append(ret, strings.TrimSpace(line))
+			continue
+		}
+		t := strings.Split(line, "\t")
+		if len(t) != 2 || t[1] != "zfs" {
+			continue
+		}
+		ret = append(ret, strings.TrimSpace(t[1]))
+	}
+
+	return ret, nil
+}
+
+func IOCounters(names ...string) (map[string]IOCountersStat, error) {
+	return IOCountersWithContext(context.Background(), names...)
+}
+
+func IOCountersWithContext(ctx context.Context, names ...string) (map[string]IOCountersStat, error) {
+	filename := common.HostProc("diskstats")
+	lines, err := common.ReadLines(filename)
+	if err != nil {
+		return nil, err
+	}
+	ret := make(map[string]IOCountersStat, 0)
+	empty := IOCountersStat{}
+
+	// use only basename such as "/dev/sda1" to "sda1"
+	for i, name := range names {
+		names[i] = filepath.Base(name)
+	}
+
+	for _, line := range lines {
+		fields := strings.Fields(line)
+		if len(fields) < 14 {
+			// malformed line in /proc/diskstats, avoid panic by ignoring.
+			continue
+		}
+		name := fields[2]
+
+		if len(names) > 0 && !common.StringsHas(names, name) {
+			continue
+		}
+
+		reads, err := strconv.ParseUint((fields[3]), 10, 64)
+		if err != nil {
+			return ret, err
+		}
+		mergedReads, err := strconv.ParseUint((fields[4]), 10, 64)
+		if err != nil {
+			return ret, err
+		}
+		rbytes, err := strconv.ParseUint((fields[5]), 10, 64)
+		if err != nil {
+			return ret, err
+		}
+		rtime, err := strconv.ParseUint((fields[6]), 10, 64)
+		if err != nil {
+			return ret, err
+		}
+		writes, err := strconv.ParseUint((fields[7]), 10, 64)
+		if err != nil {
+			return ret, err
+		}
+		mergedWrites, err := strconv.ParseUint((fields[8]), 10, 64)
+		if err != nil {
+			return ret, err
+		}
+		wbytes, err := strconv.ParseUint((fields[9]), 10, 64)
+		if err != nil {
+			return ret, err
+		}
+		wtime, err := strconv.ParseUint((fields[10]), 10, 64)
+		if err != nil {
+			return ret, err
+		}
+		iopsInProgress, err := strconv.ParseUint((fields[11]), 10, 64)
+		if err != nil {
+			return ret, err
+		}
+		iotime, err := strconv.ParseUint((fields[12]), 10, 64)
+		if err != nil {
+			return ret, err
+		}
+		weightedIO, err := strconv.ParseUint((fields[13]), 10, 64)
+		if err != nil {
+			return ret, err
+		}
+		d := IOCountersStat{
+			ReadBytes:        rbytes * SectorSize,
+			WriteBytes:       wbytes * SectorSize,
+			ReadCount:        reads,
+			WriteCount:       writes,
+			MergedReadCount:  mergedReads,
+			MergedWriteCount: mergedWrites,
+			ReadTime:         rtime,
+			WriteTime:        wtime,
+			IopsInProgress:   iopsInProgress,
+			IoTime:           iotime,
+			WeightedIO:       weightedIO,
+		}
+		if d == empty {
+			continue
+		}
+		d.Name = name
+
+		d.SerialNumber = GetDiskSerialNumber(name)
+		d.Label = GetLabel(name)
+
+		ret[name] = d
+	}
+	return ret, nil
+}
+
+// GetDiskSerialNumber returns Serial Number of given device or empty string
+// on error. Name of device is expected, eg. /dev/sda
+func GetDiskSerialNumber(name string) string {
+	return GetDiskSerialNumberWithContext(context.Background(), name)
+}
+
+func GetDiskSerialNumberWithContext(ctx context.Context, name string) string {
+	var stat unix.Stat_t
+	err := unix.Stat(name, &stat)
+	if err != nil {
+		return ""
+	}
+	major := unix.Major(uint64(stat.Rdev))
+	minor := unix.Minor(uint64(stat.Rdev))
+
+	// Try to get the serial from udev data
+	udevDataPath := common.HostRun(fmt.Sprintf("udev/data/b%d:%d", major, minor))
+	if udevdata, err := ioutil.ReadFile(udevDataPath); err == nil {
+		scanner := bufio.NewScanner(bytes.NewReader(udevdata))
+		for scanner.Scan() {
+			values := strings.Split(scanner.Text(), "=")
+			if len(values) == 2 && values[0] == "E:ID_SERIAL" {
+				return values[1]
+			}
+		}
+	}
+
+	// Try to get the serial from sysfs, look at the disk device (minor 0) directly
+	// because if it is a partition it is not going to contain any device information
+	devicePath := common.HostSys(fmt.Sprintf("dev/block/%d:0/device", major))
+	model, _ := ioutil.ReadFile(filepath.Join(devicePath, "model"))
+	serial, _ := ioutil.ReadFile(filepath.Join(devicePath, "serial"))
+	if len(model) > 0 && len(serial) > 0 {
+		return fmt.Sprintf("%s_%s", string(model), string(serial))
+	}
+	return ""
+}
+
+// GetLabel returns label of given device or empty string on error.
+// Name of device is expected, eg. /dev/sda
+// Supports label based on devicemapper name
+// See https://www.kernel.org/doc/Documentation/ABI/testing/sysfs-block-dm
+func GetLabel(name string) string {
+	// Try label based on devicemapper name
+	dmname_filename := common.HostSys(fmt.Sprintf("block/%s/dm/name", name))
+
+	if !common.PathExists(dmname_filename) {
+		return ""
+	}
+
+	dmname, err := ioutil.ReadFile(dmname_filename)
+	if err != nil {
+		return ""
+	} else {
+		return string(dmname)
+	}
+}
+
+func getFsType(stat unix.Statfs_t) string {
+	t := int64(stat.Type)
+	ret, ok := fsTypeMap[t]
+	if !ok {
+		return ""
+	}
+	return ret
+}

vendor/github.com/shirou/gopsutil/disk/disk_openbsd.go

@@ -0,0 +1,181 @@
+// +build openbsd
+
+package disk
+
+import (
+	"bytes"
+	"context"
+	"encoding/binary"
+	"path"
+	"unsafe"
+
+	"github.com/shirou/gopsutil/internal/common"
+	"golang.org/x/sys/unix"
+)
+
+func Partitions(all bool) ([]PartitionStat, error) {
+	return PartitionsWithContext(context.Background(), all)
+}
+
+func PartitionsWithContext(ctx context.Context, all bool) ([]PartitionStat, error) {
+	var ret []PartitionStat
+
+	// get length
+	count, err := unix.Getfsstat(nil, MNT_WAIT)
+	if err != nil {
+		return ret, err
+	}
+
+	fs := make([]Statfs, count)
+	if _, err = Getfsstat(fs, MNT_WAIT); err != nil {
+		return ret, err
+	}
+
+	for _, stat := range fs {
+		opts := "rw"
+		if stat.F_flags&MNT_RDONLY != 0 {
+			opts = "ro"
+		}
+		if stat.F_flags&MNT_SYNCHRONOUS != 0 {
+			opts += ",sync"
+		}
+		if stat.F_flags&MNT_NOEXEC != 0 {
+			opts += ",noexec"
+		}
+		if stat.F_flags&MNT_NOSUID != 0 {
+			opts += ",nosuid"
+		}
+		if stat.F_flags&MNT_NODEV != 0 {
+			opts += ",nodev"
+		}
+		if stat.F_flags&MNT_ASYNC != 0 {
+			opts += ",async"
+		}
+
+		d := PartitionStat{
+			Device:     common.IntToString(stat.F_mntfromname[:]),
+			Mountpoint: common.IntToString(stat.F_mntonname[:]),
+			Fstype:     common.IntToString(stat.F_fstypename[:]),
+			Opts:       opts,
+		}
+		if all == false {
+			if !path.IsAbs(d.Device) || !common.PathExists(d.Device) {
+				continue
+			}
+		}
+
+		ret = append(ret, d)
+	}
+
+	return ret, nil
+}
+
+func IOCounters(names ...string) (map[string]IOCountersStat, error) {
+	return IOCountersWithContext(context.Background(), names...)
+}
+
+func IOCountersWithContext(ctx context.Context, names ...string) (map[string]IOCountersStat, error) {
+	ret := make(map[string]IOCountersStat)
+
+	r, err := unix.SysctlRaw("hw.diskstats")
+	if err != nil {
+		return nil, err
+	}
+	buf := []byte(r)
+	length := len(buf)
+
+	count := int(uint64(length) / uint64(sizeOfDiskstats))
+
+	// parse buf to Diskstats
+	for i := 0; i < count; i++ {
+		b := buf[i*sizeOfDiskstats : i*sizeOfDiskstats+sizeOfDiskstats]
+		d, err := parseDiskstats(b)
+		if err != nil {
+			continue
+		}
+		name := common.IntToString(d.Name[:])
+
+		if len(names) > 0 && !common.StringsHas(names, name) {
+			continue
+		}
+
+		ds := IOCountersStat{
+			ReadCount:  d.Rxfer,
+			WriteCount: d.Wxfer,
+			ReadBytes:  d.Rbytes,
+			WriteBytes: d.Wbytes,
+			Name:       name,
+		}
+		ret[name] = ds
+	}
+
+	return ret, nil
+}
+
+// BT2LD(time)     ((long double)(time).sec + (time).frac * BINTIME_SCALE)
+
+// Getfsstat is borrowed from pkg/syscall/syscall_freebsd.go
+// change Statfs_t to Statfs in order to get more information
+func Getfsstat(buf []Statfs, flags int) (n int, err error) {
+	return GetfsstatWithContext(context.Background(), buf, flags)
+}
+
+func GetfsstatWithContext(ctx context.Context, buf []Statfs, flags int) (n int, err error) {
+	var _p0 unsafe.Pointer
+	var bufsize uintptr
+	if len(buf) > 0 {
+		_p0 = unsafe.Pointer(&buf[0])
+		bufsize = unsafe.Sizeof(Statfs{}) * uintptr(len(buf))
+	}
+	r0, _, e1 := unix.Syscall(unix.SYS_GETFSSTAT, uintptr(_p0), bufsize, uintptr(flags))
+	n = int(r0)
+	if e1 != 0 {
+		err = e1
+	}
+	return
+}
+
+func parseDiskstats(buf []byte) (Diskstats, error) {
+	var ds Diskstats
+	br := bytes.NewReader(buf)
+	//	err := binary.Read(br, binary.LittleEndian, &ds)
+	err := common.Read(br, binary.LittleEndian, &ds)
+	if err != nil {
+		return ds, err
+	}
+
+	return ds, nil
+}
+
+func Usage(path string) (*UsageStat, error) {
+	return UsageWithContext(context.Background(), path)
+}
+
+func UsageWithContext(ctx context.Context, path string) (*UsageStat, error) {
+	stat := unix.Statfs_t{}
+	err := unix.Statfs(path, &stat)
+	if err != nil {
+		return nil, err
+	}
+	bsize := stat.F_bsize
+
+	ret := &UsageStat{
+		Path:        path,
+		Fstype:      getFsType(stat),
+		Total:       (uint64(stat.F_blocks) * uint64(bsize)),
+		Free:        (uint64(stat.F_bavail) * uint64(bsize)),
+		InodesTotal: (uint64(stat.F_files)),
+		InodesFree:  (uint64(stat.F_ffree)),
+	}
+
+	ret.InodesUsed = (ret.InodesTotal - ret.InodesFree)
+	ret.InodesUsedPercent = (float64(ret.InodesUsed) / float64(ret.InodesTotal)) * 100.0
+	ret.Used = (uint64(stat.F_blocks) - uint64(stat.F_bfree)) * uint64(bsize)
+	ret.UsedPercent = (float64(ret.Used) / float64(ret.Total)) * 100.0
+
+	return ret, nil
+}
+
+func getFsType(stat unix.Statfs_t) string {
+	return common.IntToString(stat.F_fstypename[:])
+}

vendor/github.com/shirou/gopsutil/disk/disk_openbsd_amd64.go

@@ -0,0 +1,91 @@
+// Created by cgo -godefs - DO NOT EDIT
+// cgo -godefs types_openbsd.go
+
+package disk
+
+const (
+	sizeofPtr        = 0x8
+	sizeofShort      = 0x2
+	sizeofInt        = 0x4
+	sizeofLong       = 0x8
+	sizeofLongLong   = 0x8
+	sizeofLongDouble = 0x8
+
+	DEVSTAT_NO_DATA = 0x00
+	DEVSTAT_READ    = 0x01
+	DEVSTAT_WRITE   = 0x02
+	DEVSTAT_FREE    = 0x03
+
+	MNT_RDONLY      = 0x00000001
+	MNT_SYNCHRONOUS = 0x00000002
+	MNT_NOEXEC      = 0x00000004
+	MNT_NOSUID      = 0x00000008
+	MNT_NODEV       = 0x00000010
+	MNT_ASYNC       = 0x00000040
+
+	MNT_WAIT   = 1
+	MNT_NOWAIT = 2
+	MNT_LAZY   = 3
+)
+
+const (
+	sizeOfDiskstats = 0x70
+)
+
+type (
+	_C_short       int16
+	_C_int         int32
+	_C_long        int64
+	_C_long_long   int64
+	_C_long_double int64
+)
+
+type Statfs struct {
+	F_flags       uint32
+	F_bsize       uint32
+	F_iosize      uint32
+	Pad_cgo_0     [4]byte
+	F_blocks      uint64
+	F_bfree       uint64
+	F_bavail      int64
+	F_files       uint64
+	F_ffree       uint64
+	F_favail      int64
+	F_syncwrites  uint64
+	F_syncreads   uint64
+	F_asyncwrites uint64
+	F_asyncreads  uint64
+	F_fsid        Fsid
+	F_namemax     uint32
+	F_owner       uint32
+	F_ctime       uint64
+	F_fstypename  [16]int8
+	F_mntonname   [90]int8
+	F_mntfromname [90]int8
+	F_mntfromspec [90]int8
+	Pad_cgo_1     [2]byte
+	Mount_info    [160]byte
+}
+type Diskstats struct {
+	Name       [16]int8
+	Busy       int32
+	Pad_cgo_0  [4]byte
+	Rxfer      uint64
+	Wxfer      uint64
+	Seek       uint64
+	Rbytes     uint64
+	Wbytes     uint64
+	Attachtime Timeval
+	Timestamp  Timeval
+	Time       Timeval
+}
+type Fsid struct {
+	Val [2]int32
+}
+type Timeval struct {
+	Sec  int64
+	Usec int64
+}
+
+type Diskstat struct{}
+type Bintime struct{}

vendor/github.com/shirou/gopsutil/disk/disk_solaris.go

@@ -0,0 +1,127 @@
+// +build solaris
+
+package disk
+
+import (
+	"bufio"
+	"context"
+	"fmt"
+	"math"
+	"os"
+	"strings"
+
+	"github.com/shirou/gopsutil/internal/common"
+	"golang.org/x/sys/unix"
+)
+
+const (
+	// _DEFAULT_NUM_MOUNTS is set to `cat /etc/mnttab | wc -l` rounded up to the
+	// nearest power of two.
+	_DEFAULT_NUM_MOUNTS = 32
+
+	// _MNTTAB default place to read mount information
+	_MNTTAB = "/etc/mnttab"
+)
+
+var (
+	// A blacklist of read-only virtual filesystems.  Writable filesystems are of
+	// operational concern and must not be included in this list.
+	fsTypeBlacklist = map[string]struct{}{
+		"ctfs":   struct{}{},
+		"dev":    struct{}{},
+		"fd":     struct{}{},
+		"lofs":   struct{}{},
+		"lxproc": struct{}{},
+		"mntfs":  struct{}{},
+		"objfs":  struct{}{},
+		"proc":   struct{}{},
+	}
+)
+
+func Partitions(all bool) ([]PartitionStat, error) {
+	return PartitionsWithContext(context.Background(), all)
+}
+
+func PartitionsWithContext(ctx context.Context, all bool) ([]PartitionStat, error) {
+	ret := make([]PartitionStat, 0, _DEFAULT_NUM_MOUNTS)
+
+	// Scan mnttab(4)
+	f, err := os.Open(_MNTTAB)
+	if err != nil {
+	}
+	defer func() {
+		if err == nil {
+			err = f.Close()
+		} else {
+			f.Close()
+		}
+	}()
+
+	scanner := bufio.NewScanner(f)
+	for scanner.Scan() {
+		fields := strings.Split(scanner.Text(), "\t")
+
+		if _, found := fsTypeBlacklist[fields[2]]; found {
+			continue
+		}
+
+		ret = append(ret, PartitionStat{
+			// NOTE(seanc@): Device isn't exactly accurate: from mnttab(4): "The name
+			// of the resource that has been mounted."  Ideally this value would come
+			// from Statvfs_t.Fsid but I'm leaving it to the caller to traverse
+			// unix.Statvfs().
+			Device:     fields[0],
+			Mountpoint: fields[1],
+			Fstype:     fields[2],
+			Opts:       fields[3],
+		})
+	}
+	if err := scanner.Err(); err != nil {
+		return nil, fmt.Errorf("unable to scan %q: %v", _MNTTAB, err)
+	}
+
+	return ret, err
+}
+
+func IOCounters(names ...string) (map[string]IOCountersStat, error) {
+	return IOCountersWithContext(context.Background(), names...)
+}
+
+func IOCountersWithContext(ctx context.Context, names ...string) (map[string]IOCountersStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+
+func Usage(path string) (*UsageStat, error) {
+	return UsageWithContext(context.Background(), path)
+}
+
+func UsageWithContext(ctx context.Context, path string) (*UsageStat, error) {
+	statvfs := unix.Statvfs_t{}
+	if err := unix.Statvfs(path, &statvfs); err != nil {
+		return nil, fmt.Errorf("unable to call statvfs(2) on %q: %v", path, err)
+	}
+
+	usageStat := &UsageStat{
+		Path:   path,
+		Fstype: common.IntToString(statvfs.Basetype[:]),
+		Total:  statvfs.Blocks * statvfs.Frsize,
+		Free:   statvfs.Bfree * statvfs.Frsize,
+		Used:   (statvfs.Blocks - statvfs.Bfree) * statvfs.Frsize,
+
+		// NOTE: ZFS (and FreeBZSD's UFS2) use dynamic inode/dnode allocation.
+		// Explicitly return a near-zero value for InodesUsedPercent so that nothing
+		// attempts to garbage collect based on a lack of available inodes/dnodes.
+		// Similarly, don't use the zero value to prevent divide-by-zero situations
+		// and inject a faux near-zero value.  Filesystems evolve.  Has your
+		// filesystem evolved?  Probably not if you care about the number of
+		// available inodes.
+		InodesTotal:       1024.0 * 1024.0,
+		InodesUsed:        1024.0,
+		InodesFree:        math.MaxUint64,
+		InodesUsedPercent: (1024.0 / (1024.0 * 1024.0)) * 100.0,
+	}
+
+	usageStat.UsedPercent = (float64(usageStat.Used) / float64(usageStat.Total)) * 100.0
+
+	return usageStat, nil
+}

vendor/github.com/shirou/gopsutil/disk/disk_unix.go

@@ -0,0 +1,68 @@
+// +build freebsd linux darwin
+
+package disk
+
+import (
+	"context"
+	"strconv"
+
+	"golang.org/x/sys/unix"
+)
+
+// Usage returns a file system usage. path is a filessytem path such
+// as "/", not device file path like "/dev/vda1".  If you want to use
+// a return value of disk.Partitions, use "Mountpoint" not "Device".
+func Usage(path string) (*UsageStat, error) {
+	return UsageWithContext(context.Background(), path)
+}
+
+func UsageWithContext(ctx context.Context, path string) (*UsageStat, error) {
+	stat := unix.Statfs_t{}
+	err := unix.Statfs(path, &stat)
+	if err != nil {
+		return nil, err
+	}
+	bsize := stat.Bsize
+
+	ret := &UsageStat{
+		Path:        unescapeFstab(path),
+		Fstype:      getFsType(stat),
+		Total:       (uint64(stat.Blocks) * uint64(bsize)),
+		Free:        (uint64(stat.Bavail) * uint64(bsize)),
+		InodesTotal: (uint64(stat.Files)),
+		InodesFree:  (uint64(stat.Ffree)),
+	}
+
+	// if could not get InodesTotal, return empty
+	if ret.InodesTotal < ret.InodesFree {
+		return ret, nil
+	}
+
+	ret.InodesUsed = (ret.InodesTotal - ret.InodesFree)
+	ret.Used = (uint64(stat.Blocks) - uint64(stat.Bfree)) * uint64(bsize)
+
+	if ret.InodesTotal == 0 {
+		ret.InodesUsedPercent = 0
+	} else {
+		ret.InodesUsedPercent = (float64(ret.InodesUsed) / float64(ret.InodesTotal)) * 100.0
+	}
+
+	if (ret.Used + ret.Free) == 0 {
+		ret.UsedPercent = 0
+	} else {
+		// We don't use ret.Total to calculate percent.
+		// see https://github.com/shirou/gopsutil/issues/562
+		ret.UsedPercent = (float64(ret.Used) / float64(ret.Used+ret.Free)) * 100.0
+	}
+
+	return ret, nil
+}
+
+// Unescape escaped octal chars (like space 040, ampersand 046 and backslash 134) to their real value in fstab fields issue#555
+func unescapeFstab(path string) string {
+	escaped, err := strconv.Unquote(`"` + path + `"`)
+	if err != nil {
+		return path
+	}
+	return escaped
+}

vendor/github.com/shirou/gopsutil/disk/disk_windows.go

@@ -0,0 +1,171 @@
+// +build windows
+
+package disk
+
+import (
+	"bytes"
+	"context"
+	"unsafe"
+
+	"github.com/shirou/gopsutil/internal/common"
+	"golang.org/x/sys/windows"
+)
+
+var (
+	procGetDiskFreeSpaceExW     = common.Modkernel32.NewProc("GetDiskFreeSpaceExW")
+	procGetLogicalDriveStringsW = common.Modkernel32.NewProc("GetLogicalDriveStringsW")
+	procGetDriveType            = common.Modkernel32.NewProc("GetDriveTypeW")
+	provGetVolumeInformation    = common.Modkernel32.NewProc("GetVolumeInformationW")
+)
+
+var (
+	FileFileCompression = int64(16)     // 0x00000010
+	FileReadOnlyVolume  = int64(524288) // 0x00080000
+)
+
+type Win32_PerfFormattedData struct {
+	Name                    string
+	AvgDiskBytesPerRead     uint64
+	AvgDiskBytesPerWrite    uint64
+	AvgDiskReadQueueLength  uint64
+	AvgDiskWriteQueueLength uint64
+	AvgDisksecPerRead       uint64
+	AvgDisksecPerWrite      uint64
+}
+
+const WaitMSec = 500
+
+func Usage(path string) (*UsageStat, error) {
+	return UsageWithContext(context.Background(), path)
+}
+
+func UsageWithContext(ctx context.Context, path string) (*UsageStat, error) {
+	ret := &UsageStat{}
+
+	lpFreeBytesAvailable := int64(0)
+	lpTotalNumberOfBytes := int64(0)
+	lpTotalNumberOfFreeBytes := int64(0)
+	diskret, _, err := procGetDiskFreeSpaceExW.Call(
+		uintptr(unsafe.Pointer(windows.StringToUTF16Ptr(path))),
+		uintptr(unsafe.Pointer(&lpFreeBytesAvailable)),
+		uintptr(unsafe.Pointer(&lpTotalNumberOfBytes)),
+		uintptr(unsafe.Pointer(&lpTotalNumberOfFreeBytes)))
+	if diskret == 0 {
+		return nil, err
+	}
+	ret = &UsageStat{
+		Path:        path,
+		Total:       uint64(lpTotalNumberOfBytes),
+		Free:        uint64(lpTotalNumberOfFreeBytes),
+		Used:        uint64(lpTotalNumberOfBytes) - uint64(lpTotalNumberOfFreeBytes),
+		UsedPercent: (float64(lpTotalNumberOfBytes) - float64(lpTotalNumberOfFreeBytes)) / float64(lpTotalNumberOfBytes) * 100,
+		// InodesTotal: 0,
+		// InodesFree: 0,
+		// InodesUsed: 0,
+		// InodesUsedPercent: 0,
+	}
+	return ret, nil
+}
+
+func Partitions(all bool) ([]PartitionStat, error) {
+	return PartitionsWithContext(context.Background(), all)
+}
+
+func PartitionsWithContext(ctx context.Context, all bool) ([]PartitionStat, error) {
+	var ret []PartitionStat
+	lpBuffer := make([]byte, 254)
+	diskret, _, err := procGetLogicalDriveStringsW.Call(
+		uintptr(len(lpBuffer)),
+		uintptr(unsafe.Pointer(&lpBuffer[0])))
+	if diskret == 0 {
+		return ret, err
+	}
+	for _, v := range lpBuffer {
+		if v >= 65 && v <= 90 {
+			path := string(v) + ":"
+			if path == "A:" || path == "B:" { // skip floppy drives
+				continue
+			}
+			typepath, _ := windows.UTF16PtrFromString(path)
+			typeret, _, _ := procGetDriveType.Call(uintptr(unsafe.Pointer(typepath)))
+			if typeret == 0 {
+				return ret, windows.GetLastError()
+			}
+			// 2: DRIVE_REMOVABLE 3: DRIVE_FIXED 4: DRIVE_REMOTE 5: DRIVE_CDROM
+
+			if typeret == 2 || typeret == 3 || typeret == 4 || typeret == 5 {
+				lpVolumeNameBuffer := make([]byte, 256)
+				lpVolumeSerialNumber := int64(0)
+				lpMaximumComponentLength := int64(0)
+				lpFileSystemFlags := int64(0)
+				lpFileSystemNameBuffer := make([]byte, 256)
+				volpath, _ := windows.UTF16PtrFromString(string(v) + ":/")
+				driveret, _, err := provGetVolumeInformation.Call(
+					uintptr(unsafe.Pointer(volpath)),
+					uintptr(unsafe.Pointer(&lpVolumeNameBuffer[0])),
+					uintptr(len(lpVolumeNameBuffer)),
+					uintptr(unsafe.Pointer(&lpVolumeSerialNumber)),
+					uintptr(unsafe.Pointer(&lpMaximumComponentLength)),
+					uintptr(unsafe.Pointer(&lpFileSystemFlags)),
+					uintptr(unsafe.Pointer(&lpFileSystemNameBuffer[0])),
+					uintptr(len(lpFileSystemNameBuffer)))
+				if driveret == 0 {
+					if typeret == 5 || typeret == 2 {
+						continue //device is not ready will happen if there is no disk in the drive
+					}
+					return ret, err
+				}
+				opts := "rw"
+				if lpFileSystemFlags&FileReadOnlyVolume != 0 {
+					opts = "ro"
+				}
+				if lpFileSystemFlags&FileFileCompression != 0 {
+					opts += ".compress"
+				}
+
+				d := PartitionStat{
+					Mountpoint: path,
+					Device:     path,
+					Fstype:     string(bytes.Replace(lpFileSystemNameBuffer, []byte("\x00"), []byte(""), -1)),
+					Opts:       opts,
+				}
+				ret = append(ret, d)
+			}
+		}
+	}
+	return ret, nil
+}
+
+func IOCounters(names ...string) (map[string]IOCountersStat, error) {
+	return IOCountersWithContext(context.Background(), names...)
+}
+
+func IOCountersWithContext(ctx context.Context, names ...string) (map[string]IOCountersStat, error) {
+	ret := make(map[string]IOCountersStat, 0)
+	var dst []Win32_PerfFormattedData
+
+	err := common.WMIQueryWithContext(ctx, "SELECT * FROM Win32_PerfFormattedData_PerfDisk_LogicalDisk", &dst)
+	if err != nil {
+		return ret, err
+	}
+	for _, d := range dst {
+		if len(d.Name) > 3 { // not get _Total or Harddrive
+			continue
+		}
+
+		if len(names) > 0 && !common.StringsHas(names, d.Name) {
+			continue
+		}
+
+		ret[d.Name] = IOCountersStat{
+			Name:       d.Name,
+			ReadCount:  uint64(d.AvgDiskReadQueueLength),
+			WriteCount: d.AvgDiskWriteQueueLength,
+			ReadBytes:  uint64(d.AvgDiskBytesPerRead),
+			WriteBytes: uint64(d.AvgDiskBytesPerWrite),
+			ReadTime:   d.AvgDisksecPerRead,
+			WriteTime:  d.AvgDisksecPerWrite,
+		}
+	}
+	return ret, nil
+}

vendor/github.com/shirou/gopsutil/host/BUILD.bazel

@@ -0,0 +1,68 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "host.go",
+        "host_darwin.go",
+        "host_darwin_386.go",
+        "host_darwin_amd64.go",
+        "host_fallback.go",
+        "host_freebsd.go",
+        "host_freebsd_386.go",
+        "host_freebsd_amd64.go",
+        "host_freebsd_arm.go",
+        "host_linux.go",
+        "host_linux_386.go",
+        "host_linux_amd64.go",
+        "host_linux_arm.go",
+        "host_linux_arm64.go",
+        "host_linux_mips.go",
+        "host_linux_mips64.go",
+        "host_linux_mips64le.go",
+        "host_linux_mipsle.go",
+        "host_linux_ppc64le.go",
+        "host_linux_s390x.go",
+        "host_openbsd.go",
+        "host_openbsd_amd64.go",
+        "host_solaris.go",
+        "host_windows.go",
+    ],
+    importmap = "go-common/vendor/github.com/shirou/gopsutil/host",
+    importpath = "github.com/shirou/gopsutil/host",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//vendor/github.com/shirou/gopsutil/internal/common:go_default_library",
+    ] + select({
+        "@io_bazel_rules_go//go/platform:darwin": [
+            "//vendor/github.com/shirou/gopsutil/process:go_default_library",
+        ],
+        "@io_bazel_rules_go//go/platform:freebsd": [
+            "//vendor/github.com/shirou/gopsutil/process:go_default_library",
+            "//vendor/golang.org/x/sys/unix:go_default_library",
+        ],
+        "@io_bazel_rules_go//go/platform:openbsd": [
+            "//vendor/github.com/shirou/gopsutil/process:go_default_library",
+        ],
+        "@io_bazel_rules_go//go/platform:windows": [
+            "//vendor/github.com/StackExchange/wmi:go_default_library",
+            "//vendor/github.com/shirou/gopsutil/process:go_default_library",
+            "//vendor/golang.org/x/sys/windows:go_default_library",
+        ],
+        "//conditions:default": [],
+    }),
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

vendor/github.com/shirou/gopsutil/host/host.go

@@ -0,0 +1,53 @@
+package host
+
+import (
+	"encoding/json"
+
+	"github.com/shirou/gopsutil/internal/common"
+)
+
+var invoke common.Invoker = common.Invoke{}
+
+// A HostInfoStat describes the host status.
+// This is not in the psutil but it useful.
+type InfoStat struct {
+	Hostname             string `json:"hostname"`
+	Uptime               uint64 `json:"uptime"`
+	BootTime             uint64 `json:"bootTime"`
+	Procs                uint64 `json:"procs"`           // number of processes
+	OS                   string `json:"os"`              // ex: freebsd, linux
+	Platform             string `json:"platform"`        // ex: ubuntu, linuxmint
+	PlatformFamily       string `json:"platformFamily"`  // ex: debian, rhel
+	PlatformVersion      string `json:"platformVersion"` // version of the complete OS
+	KernelVersion        string `json:"kernelVersion"`   // version of the OS kernel (if available)
+	VirtualizationSystem string `json:"virtualizationSystem"`
+	VirtualizationRole   string `json:"virtualizationRole"` // guest or host
+	HostID               string `json:"hostid"`             // ex: uuid
+}
+
+type UserStat struct {
+	User     string `json:"user"`
+	Terminal string `json:"terminal"`
+	Host     string `json:"host"`
+	Started  int    `json:"started"`
+}
+
+type TemperatureStat struct {
+	SensorKey   string  `json:"sensorKey"`
+	Temperature float64 `json:"sensorTemperature"`
+}
+
+func (h InfoStat) String() string {
+	s, _ := json.Marshal(h)
+	return string(s)
+}
+
+func (u UserStat) String() string {
+	s, _ := json.Marshal(u)
+	return string(s)
+}
+
+func (t TemperatureStat) String() string {
+	s, _ := json.Marshal(t)
+	return string(s)
+}

vendor/github.com/shirou/gopsutil/host/host_darwin.go

@@ -0,0 +1,227 @@
+// +build darwin
+
+package host
+
+import (
+	"bytes"
+	"context"
+	"encoding/binary"
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"runtime"
+	"strconv"
+	"strings"
+	"sync/atomic"
+	"time"
+	"unsafe"
+
+	"github.com/shirou/gopsutil/internal/common"
+	"github.com/shirou/gopsutil/process"
+)
+
+// from utmpx.h
+const USER_PROCESS = 7
+
+func Info() (*InfoStat, error) {
+	return InfoWithContext(context.Background())
+}
+
+func InfoWithContext(ctx context.Context) (*InfoStat, error) {
+	ret := &InfoStat{
+		OS:             runtime.GOOS,
+		PlatformFamily: "darwin",
+	}
+
+	hostname, err := os.Hostname()
+	if err == nil {
+		ret.Hostname = hostname
+	}
+
+	uname, err := exec.LookPath("uname")
+	if err == nil {
+		out, err := invoke.CommandWithContext(ctx, uname, "-r")
+		if err == nil {
+			ret.KernelVersion = strings.ToLower(strings.TrimSpace(string(out)))
+		}
+	}
+
+	platform, family, pver, err := PlatformInformation()
+	if err == nil {
+		ret.Platform = platform
+		ret.PlatformFamily = family
+		ret.PlatformVersion = pver
+	}
+
+	system, role, err := Virtualization()
+	if err == nil {
+		ret.VirtualizationSystem = system
+		ret.VirtualizationRole = role
+	}
+
+	boot, err := BootTime()
+	if err == nil {
+		ret.BootTime = boot
+		ret.Uptime = uptime(boot)
+	}
+
+	procs, err := process.Pids()
+	if err == nil {
+		ret.Procs = uint64(len(procs))
+	}
+
+	values, err := common.DoSysctrlWithContext(ctx, "kern.uuid")
+	if err == nil && len(values) == 1 && values[0] != "" {
+		ret.HostID = strings.ToLower(values[0])
+	}
+
+	return ret, nil
+}
+
+// cachedBootTime must be accessed via atomic.Load/StoreUint64
+var cachedBootTime uint64
+
+func BootTime() (uint64, error) {
+	return BootTimeWithContext(context.Background())
+}
+
+func BootTimeWithContext(ctx context.Context) (uint64, error) {
+	t := atomic.LoadUint64(&cachedBootTime)
+	if t != 0 {
+		return t, nil
+	}
+	values, err := common.DoSysctrlWithContext(ctx, "kern.boottime")
+	if err != nil {
+		return 0, err
+	}
+	// ex: { sec = 1392261637, usec = 627534 } Thu Feb 13 12:20:37 2014
+	v := strings.Replace(values[2], ",", "", 1)
+	boottime, err := strconv.ParseInt(v, 10, 64)
+	if err != nil {
+		return 0, err
+	}
+	t = uint64(boottime)
+	atomic.StoreUint64(&cachedBootTime, t)
+
+	return t, nil
+}
+
+func uptime(boot uint64) uint64 {
+	return uint64(time.Now().Unix()) - boot
+}
+
+func Uptime() (uint64, error) {
+	return UptimeWithContext(context.Background())
+}
+
+func UptimeWithContext(ctx context.Context) (uint64, error) {
+	boot, err := BootTime()
+	if err != nil {
+		return 0, err
+	}
+	return uptime(boot), nil
+}
+
+func Users() ([]UserStat, error) {
+	return UsersWithContext(context.Background())
+}
+
+func UsersWithContext(ctx context.Context) ([]UserStat, error) {
+	utmpfile := "/var/run/utmpx"
+	var ret []UserStat
+
+	file, err := os.Open(utmpfile)
+	if err != nil {
+		return ret, err
+	}
+	defer file.Close()
+
+	buf, err := ioutil.ReadAll(file)
+	if err != nil {
+		return ret, err
+	}
+
+	u := Utmpx{}
+	entrySize := int(unsafe.Sizeof(u))
+	count := len(buf) / entrySize
+
+	for i := 0; i < count; i++ {
+		b := buf[i*entrySize : i*entrySize+entrySize]
+
+		var u Utmpx
+		br := bytes.NewReader(b)
+		err := binary.Read(br, binary.LittleEndian, &u)
+		if err != nil {
+			continue
+		}
+		if u.Type != USER_PROCESS {
+			continue
+		}
+		user := UserStat{
+			User:     common.IntToString(u.User[:]),
+			Terminal: common.IntToString(u.Line[:]),
+			Host:     common.IntToString(u.Host[:]),
+			Started:  int(u.Tv.Sec),
+		}
+		ret = append(ret, user)
+	}
+
+	return ret, nil
+
+}
+
+func PlatformInformation() (string, string, string, error) {
+	return PlatformInformationWithContext(context.Background())
+}
+
+func PlatformInformationWithContext(ctx context.Context) (string, string, string, error) {
+	platform := ""
+	family := ""
+	pver := ""
+
+	sw_vers, err := exec.LookPath("sw_vers")
+	if err != nil {
+		return "", "", "", err
+	}
+	uname, err := exec.LookPath("uname")
+	if err != nil {
+		return "", "", "", err
+	}
+
+	out, err := invoke.CommandWithContext(ctx, uname, "-s")
+	if err == nil {
+		platform = strings.ToLower(strings.TrimSpace(string(out)))
+	}
+
+	out, err = invoke.CommandWithContext(ctx, sw_vers, "-productVersion")
+	if err == nil {
+		pver = strings.ToLower(strings.TrimSpace(string(out)))
+	}
+
+	return platform, family, pver, nil
+}
+
+func Virtualization() (string, string, error) {
+	return VirtualizationWithContext(context.Background())
+}
+
+func VirtualizationWithContext(ctx context.Context) (string, string, error) {
+	return "", "", common.ErrNotImplementedError
+}
+
+func KernelVersion() (string, error) {
+	return KernelVersionWithContext(context.Background())
+}
+
+func KernelVersionWithContext(ctx context.Context) (string, error) {
+	_, _, version, err := PlatformInformation()
+	return version, err
+}
+
+func SensorsTemperatures() ([]TemperatureStat, error) {
+	return SensorsTemperaturesWithContext(context.Background())
+}
+
+func SensorsTemperaturesWithContext(ctx context.Context) ([]TemperatureStat, error) {
+	return []TemperatureStat{}, common.ErrNotImplementedError
+}

vendor/github.com/shirou/gopsutil/host/host_darwin_386.go

@@ -0,0 +1,19 @@
+// Created by cgo -godefs - DO NOT EDIT
+// cgo -godefs types_darwin.go
+
+package host
+
+type Utmpx struct {
+	User      [256]int8
+	ID        [4]int8
+	Line      [32]int8
+	Pid       int32
+	Type      int16
+	Pad_cgo_0 [6]byte
+	Tv        Timeval
+	Host      [256]int8
+	Pad       [16]uint32
+}
+type Timeval struct {
+	Sec int32
+}

vendor/github.com/shirou/gopsutil/host/host_darwin_amd64.go

@@ -0,0 +1,19 @@
+// Created by cgo -godefs - DO NOT EDIT
+// cgo -godefs types_darwin.go
+
+package host
+
+type Utmpx struct {
+	User      [256]int8
+	ID        [4]int8
+	Line      [32]int8
+	Pid       int32
+	Type      int16
+	Pad_cgo_0 [6]byte
+	Tv        Timeval
+	Host      [256]int8
+	Pad       [16]uint32
+}
+type Timeval struct {
+	Sec int32
+}

vendor/github.com/shirou/gopsutil/host/host_fallback.go

@@ -0,0 +1,65 @@
+// +build !darwin,!linux,!freebsd,!openbsd,!solaris,!windows
+
+package host
+
+import (
+	"context"
+
+	"github.com/shirou/gopsutil/internal/common"
+)
+
+func Info() (*InfoStat, error) {
+	return InfoWithContext(context.Background())
+}
+
+func InfoWithContext(ctx context.Context) (*InfoStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+
+func BootTime() (uint64, error) {
+	return BootTimeWithContext(context.Background())
+}
+
+func BootTimeWithContext(ctx context.Context) (uint64, error) {
+	return 0, common.ErrNotImplementedError
+}
+
+func Uptime() (uint64, error) {
+	return UptimeWithContext(context.Background())
+}
+
+func UptimeWithContext(ctx context.Context) (uint64, error) {
+	return 0, common.ErrNotImplementedError
+}
+
+func Users() ([]UserStat, error) {
+	return UsersWithContext(context.Background())
+}
+
+func UsersWithContext(ctx context.Context) ([]UserStat, error) {
+	return []UserStat{}, common.ErrNotImplementedError
+}
+
+func Virtualization() (string, string, error) {
+	return VirtualizationWithContext(context.Background())
+}
+
+func VirtualizationWithContext(ctx context.Context) (string, string, error) {
+	return "", "", common.ErrNotImplementedError
+}
+
+func KernelVersion() (string, error) {
+	return KernelVersionWithContext(context.Background())
+}
+
+func KernelVersionWithContext(ctx context.Context) (string, error) {
+	return "", common.ErrNotImplementedError
+}
+
+func PlatformInformation() (string, string, string, error) {
+	return PlatformInformationWithContext(context.Background())
+}
+
+func PlatformInformationWithContext(ctx context.Context) (string, string, string, error) {
+	return "", "", "", common.ErrNotImplementedError
+}

vendor/github.com/shirou/gopsutil/host/host_freebsd.go

@@ -0,0 +1,245 @@
+// +build freebsd
+
+package host
+
+import (
+	"bytes"
+	"context"
+	"encoding/binary"
+	"io/ioutil"
+	"os"
+	"runtime"
+	"strings"
+	"sync/atomic"
+	"syscall"
+	"time"
+	"unsafe"
+
+	"github.com/shirou/gopsutil/internal/common"
+	"github.com/shirou/gopsutil/process"
+	"golang.org/x/sys/unix"
+)
+
+const (
+	UTNameSize = 16 /* see MAXLOGNAME in <sys/param.h> */
+	UTLineSize = 8
+	UTHostSize = 16
+)
+
+func Info() (*InfoStat, error) {
+	return InfoWithContext(context.Background())
+}
+
+func InfoWithContext(ctx context.Context) (*InfoStat, error) {
+	ret := &InfoStat{
+		OS:             runtime.GOOS,
+		PlatformFamily: "freebsd",
+	}
+
+	hostname, err := os.Hostname()
+	if err == nil {
+		ret.Hostname = hostname
+	}
+
+	platform, family, version, err := PlatformInformation()
+	if err == nil {
+		ret.Platform = platform
+		ret.PlatformFamily = family
+		ret.PlatformVersion = version
+		ret.KernelVersion = version
+	}
+
+	system, role, err := Virtualization()
+	if err == nil {
+		ret.VirtualizationSystem = system
+		ret.VirtualizationRole = role
+	}
+
+	boot, err := BootTime()
+	if err == nil {
+		ret.BootTime = boot
+		ret.Uptime = uptime(boot)
+	}
+
+	procs, err := process.Pids()
+	if err == nil {
+		ret.Procs = uint64(len(procs))
+	}
+
+	hostid, err := unix.Sysctl("kern.hostuuid")
+	if err == nil && hostid != "" {
+		ret.HostID = strings.ToLower(hostid)
+	}
+
+	return ret, nil
+}
+
+// cachedBootTime must be accessed via atomic.Load/StoreUint64
+var cachedBootTime uint64
+
+func BootTime() (uint64, error) {
+	return BootTimeWithContext(context.Background())
+}
+
+func BootTimeWithContext(ctx context.Context) (uint64, error) {
+	t := atomic.LoadUint64(&cachedBootTime)
+	if t != 0 {
+		return t, nil
+	}
+	buf, err := unix.SysctlRaw("kern.boottime")
+	if err != nil {
+		return 0, err
+	}
+
+	tv := *(*syscall.Timeval)(unsafe.Pointer((&buf[0])))
+	atomic.StoreUint64(&cachedBootTime, uint64(tv.Sec))
+
+	return t, nil
+}
+
+func uptime(boot uint64) uint64 {
+	return uint64(time.Now().Unix()) - boot
+}
+
+func Uptime() (uint64, error) {
+	return UptimeWithContext(context.Background())
+}
+
+func UptimeWithContext(ctx context.Context) (uint64, error) {
+	boot, err := BootTime()
+	if err != nil {
+		return 0, err
+	}
+	return uptime(boot), nil
+}
+
+func Users() ([]UserStat, error) {
+	return UsersWithContext(context.Background())
+}
+
+func UsersWithContext(ctx context.Context) ([]UserStat, error) {
+	utmpfile := "/var/run/utx.active"
+	if !common.PathExists(utmpfile) {
+		utmpfile = "/var/run/utmp" // before 9.0
+		return getUsersFromUtmp(utmpfile)
+	}
+
+	var ret []UserStat
+	file, err := os.Open(utmpfile)
+	if err != nil {
+		return ret, err
+	}
+	defer file.Close()
+
+	buf, err := ioutil.ReadAll(file)
+	if err != nil {
+		return ret, err
+	}
+
+	entrySize := sizeOfUtmpx
+	count := len(buf) / entrySize
+
+	for i := 0; i < count; i++ {
+		b := buf[i*sizeOfUtmpx : (i+1)*sizeOfUtmpx]
+		var u Utmpx
+		br := bytes.NewReader(b)
+		err := binary.Read(br, binary.LittleEndian, &u)
+		if err != nil || u.Type != 4 {
+			continue
+		}
+		sec := (binary.LittleEndian.Uint32(u.Tv.Sec[:])) / 2 // TODO:
+		user := UserStat{
+			User:     common.IntToString(u.User[:]),
+			Terminal: common.IntToString(u.Line[:]),
+			Host:     common.IntToString(u.Host[:]),
+			Started:  int(sec),
+		}
+
+		ret = append(ret, user)
+	}
+
+	return ret, nil
+
+}
+
+func PlatformInformation() (string, string, string, error) {
+	return PlatformInformationWithContext(context.Background())
+}
+
+func PlatformInformationWithContext(ctx context.Context) (string, string, string, error) {
+	platform, err := unix.Sysctl("kern.ostype")
+	if err != nil {
+		return "", "", "", err
+	}
+
+	version, err := unix.Sysctl("kern.osrelease")
+	if err != nil {
+		return "", "", "", err
+	}
+
+	return strings.ToLower(platform), "", strings.ToLower(version), nil
+}
+
+func Virtualization() (string, string, error) {
+	return VirtualizationWithContext(context.Background())
+}
+
+func VirtualizationWithContext(ctx context.Context) (string, string, error) {
+	return "", "", common.ErrNotImplementedError
+}
+
+// before 9.0
+func getUsersFromUtmp(utmpfile string) ([]UserStat, error) {
+	var ret []UserStat
+	file, err := os.Open(utmpfile)
+	if err != nil {
+		return ret, err
+	}
+	defer file.Close()
+
+	buf, err := ioutil.ReadAll(file)
+	if err != nil {
+		return ret, err
+	}
+
+	u := Utmp{}
+	entrySize := int(unsafe.Sizeof(u))
+	count := len(buf) / entrySize
+
+	for i := 0; i < count; i++ {
+		b := buf[i*entrySize : i*entrySize+entrySize]
+		var u Utmp
+		br := bytes.NewReader(b)
+		err := binary.Read(br, binary.LittleEndian, &u)
+		if err != nil || u.Time == 0 {
+			continue
+		}
+		user := UserStat{
+			User:     common.IntToString(u.Name[:]),
+			Terminal: common.IntToString(u.Line[:]),
+			Host:     common.IntToString(u.Host[:]),
+			Started:  int(u.Time),
+		}
+
+		ret = append(ret, user)
+	}
+
+	return ret, nil
+}
+
+func SensorsTemperatures() ([]TemperatureStat, error) {
+	return SensorsTemperaturesWithContext(context.Background())
+}
+
+func SensorsTemperaturesWithContext(ctx context.Context) ([]TemperatureStat, error) {
+	return []TemperatureStat{}, common.ErrNotImplementedError
+}
+
+func KernelVersion() (string, error) {
+	return KernelVersionWithContext(context.Background())
+}
+
+func KernelVersionWithContext(ctx context.Context) (string, error) {
+	_, _, version, err := PlatformInformation()
+	return version, err
+}

vendor/github.com/shirou/gopsutil/host/host_freebsd_386.go

@@ -0,0 +1,43 @@
+// Created by cgo -godefs - DO NOT EDIT
+// cgo -godefs types_freebsd.go
+
+package host
+
+const (
+	sizeofPtr      = 0x4
+	sizeofShort    = 0x2
+	sizeofInt      = 0x4
+	sizeofLong     = 0x4
+	sizeofLongLong = 0x8
+	sizeOfUtmpx    = 197 // TODO why should 197
+)
+
+type (
+	_C_short     int16
+	_C_int       int32
+	_C_long      int32
+	_C_long_long int64
+)
+
+type Utmp struct {
+	Line [8]int8
+	Name [16]int8
+	Host [16]int8
+	Time int32
+}
+
+type Utmpx struct {
+	Type int16
+	Tv   Timeval
+	Id   [8]int8
+	Pid  int32
+	User [32]int8
+	Line [16]int8
+	Host [125]int8
+	//      X__ut_spare     [64]int8
+}
+
+type Timeval struct {
+	Sec  [4]byte
+	Usec [3]byte
+}

vendor/github.com/shirou/gopsutil/host/host_freebsd_amd64.go

@@ -0,0 +1,44 @@
+// Created by cgo -godefs - DO NOT EDIT
+// cgo -godefs types_freebsd.go
+
+package host
+
+const (
+	sizeofPtr      = 0x8
+	sizeofShort    = 0x2
+	sizeofInt      = 0x4
+	sizeofLong     = 0x8
+	sizeofLongLong = 0x8
+	sizeOfUtmpx    = 197 // TODO: why should 197, not 0x118
+)
+
+type (
+	_C_short     int16
+	_C_int       int32
+	_C_long      int64
+	_C_long_long int64
+)
+
+type Utmp struct {
+	Line [8]int8
+	Name [16]int8
+	Host [16]int8
+	Time int32
+}
+
+type Utmpx struct {
+	Type int16
+	Tv   Timeval
+	Id   [8]int8
+	Pid  int32
+	User [32]int8
+	Line [16]int8
+	Host [125]int8
+	//      Host [128]int8
+	//      X__ut_spare [64]int8
+}
+
+type Timeval struct {
+	Sec  [4]byte
+	Usec [3]byte
+}

vendor/github.com/shirou/gopsutil/host/host_freebsd_arm.go

@@ -0,0 +1,44 @@
+// Created by cgo -godefs - DO NOT EDIT
+// cgo -godefs types_freebsd.go
+
+package host
+
+const (
+	sizeofPtr      = 0x4
+	sizeofShort    = 0x2
+	sizeofInt      = 0x4
+	sizeofLong     = 0x8
+	sizeofLongLong = 0x8
+	sizeOfUtmpx    = 197 // TODO: why should 197, not 0x118
+)
+
+type (
+	_C_short     int16
+	_C_int       int32
+	_C_long      int32
+	_C_long_long int64
+)
+
+type Utmp struct {
+	Line [8]int8
+	Name [16]int8
+	Host [16]int8
+	Time int32
+}
+
+type Utmpx struct {
+	Type int16
+	Tv   Timeval
+	Id   [8]int8
+	Pid  int32
+	User [32]int8
+	Line [16]int8
+	Host [125]int8
+	//      Host [128]int8
+	//      X__ut_spare [64]int8
+}
+
+type Timeval struct {
+	Sec  [4]byte
+	Usec [3]byte
+}

vendor/github.com/shirou/gopsutil/host/host_linux.go

@@ -0,0 +1,669 @@
+// +build linux
+
+package host
+
+import (
+	"bytes"
+	"context"
+	"encoding/binary"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strconv"
+	"strings"
+	"sync/atomic"
+	"time"
+
+	"github.com/shirou/gopsutil/internal/common"
+)
+
+type LSB struct {
+	ID          string
+	Release     string
+	Codename    string
+	Description string
+}
+
+// from utmp.h
+const USER_PROCESS = 7
+
+func Info() (*InfoStat, error) {
+	return InfoWithContext(context.Background())
+}
+
+func InfoWithContext(ctx context.Context) (*InfoStat, error) {
+	ret := &InfoStat{
+		OS: runtime.GOOS,
+	}
+
+	hostname, err := os.Hostname()
+	if err == nil {
+		ret.Hostname = hostname
+	}
+
+	platform, family, version, err := PlatformInformation()
+	if err == nil {
+		ret.Platform = platform
+		ret.PlatformFamily = family
+		ret.PlatformVersion = version
+	}
+	kernelVersion, err := KernelVersion()
+	if err == nil {
+		ret.KernelVersion = kernelVersion
+	}
+
+	system, role, err := Virtualization()
+	if err == nil {
+		ret.VirtualizationSystem = system
+		ret.VirtualizationRole = role
+	}
+
+	boot, err := BootTime()
+	if err == nil {
+		ret.BootTime = boot
+		ret.Uptime = uptime(boot)
+	}
+
+	if numProcs, err := common.NumProcs(); err == nil {
+		ret.Procs = numProcs
+	}
+
+	sysProductUUID := common.HostSys("class/dmi/id/product_uuid")
+	switch {
+	case common.PathExists(sysProductUUID):
+		lines, err := common.ReadLines(sysProductUUID)
+		if err == nil && len(lines) > 0 && lines[0] != "" {
+			ret.HostID = strings.ToLower(lines[0])
+			break
+		}
+		fallthrough
+	default:
+		values, err := common.DoSysctrl("kernel.random.boot_id")
+		if err == nil && len(values) == 1 && values[0] != "" {
+			ret.HostID = strings.ToLower(values[0])
+		}
+	}
+
+	return ret, nil
+}
+
+// cachedBootTime must be accessed via atomic.Load/StoreUint64
+var cachedBootTime uint64
+
+// BootTime returns the system boot time expressed in seconds since the epoch.
+func BootTime() (uint64, error) {
+	return BootTimeWithContext(context.Background())
+}
+
+func BootTimeWithContext(ctx context.Context) (uint64, error) {
+	t := atomic.LoadUint64(&cachedBootTime)
+	if t != 0 {
+		return t, nil
+	}
+
+	system, role, err := Virtualization()
+	if err != nil {
+		return 0, err
+	}
+
+	statFile := "stat"
+	if system == "lxc" && role == "guest" {
+		// if lxc, /proc/uptime is used.
+		statFile = "uptime"
+	} else if system == "docker" && role == "guest" {
+		// also docker, guest
+		statFile = "uptime"
+	}
+
+	filename := common.HostProc(statFile)
+	lines, err := common.ReadLines(filename)
+	if err != nil {
+		return 0, err
+	}
+
+	if statFile == "stat" {
+		for _, line := range lines {
+			if strings.HasPrefix(line, "btime") {
+				f := strings.Fields(line)
+				if len(f) != 2 {
+					return 0, fmt.Errorf("wrong btime format")
+				}
+				b, err := strconv.ParseInt(f[1], 10, 64)
+				if err != nil {
+					return 0, err
+				}
+				t = uint64(b)
+				atomic.StoreUint64(&cachedBootTime, t)
+				return t, nil
+			}
+		}
+	} else if statFile == "uptime" {
+		if len(lines) != 1 {
+			return 0, fmt.Errorf("wrong uptime format")
+		}
+		f := strings.Fields(lines[0])
+		b, err := strconv.ParseFloat(f[0], 64)
+		if err != nil {
+			return 0, err
+		}
+		t = uint64(time.Now().Unix()) - uint64(b)
+		atomic.StoreUint64(&cachedBootTime, t)
+		return t, nil
+	}
+
+	return 0, fmt.Errorf("could not find btime")
+}
+
+func uptime(boot uint64) uint64 {
+	return uint64(time.Now().Unix()) - boot
+}
+
+func Uptime() (uint64, error) {
+	return UptimeWithContext(context.Background())
+}
+
+func UptimeWithContext(ctx context.Context) (uint64, error) {
+	boot, err := BootTime()
+	if err != nil {
+		return 0, err
+	}
+	return uptime(boot), nil
+}
+
+func Users() ([]UserStat, error) {
+	return UsersWithContext(context.Background())
+}
+
+func UsersWithContext(ctx context.Context) ([]UserStat, error) {
+	utmpfile := common.HostVar("run/utmp")
+
+	file, err := os.Open(utmpfile)
+	if err != nil {
+		return nil, err
+	}
+	defer file.Close()
+
+	buf, err := ioutil.ReadAll(file)
+	if err != nil {
+		return nil, err
+	}
+
+	count := len(buf) / sizeOfUtmp
+
+	ret := make([]UserStat, 0, count)
+
+	for i := 0; i < count; i++ {
+		b := buf[i*sizeOfUtmp : (i+1)*sizeOfUtmp]
+
+		var u utmp
+		br := bytes.NewReader(b)
+		err := binary.Read(br, binary.LittleEndian, &u)
+		if err != nil {
+			continue
+		}
+		if u.Type != USER_PROCESS {
+			continue
+		}
+		user := UserStat{
+			User:     common.IntToString(u.User[:]),
+			Terminal: common.IntToString(u.Line[:]),
+			Host:     common.IntToString(u.Host[:]),
+			Started:  int(u.Tv.Sec),
+		}
+		ret = append(ret, user)
+	}
+
+	return ret, nil
+
+}
+
+func getOSRelease() (platform string, version string, err error) {
+	contents, err := common.ReadLines(common.HostEtc("os-release"))
+	if err != nil {
+		return "", "", nil // return empty
+	}
+	for _, line := range contents {
+		field := strings.Split(line, "=")
+		if len(field) < 2 {
+			continue
+		}
+		switch field[0] {
+		case "ID": // use ID for lowercase
+			platform = field[1]
+		case "VERSION":
+			version = field[1]
+		}
+	}
+	return platform, version, nil
+}
+
+func getLSB() (*LSB, error) {
+	ret := &LSB{}
+	if common.PathExists(common.HostEtc("lsb-release")) {
+		contents, err := common.ReadLines(common.HostEtc("lsb-release"))
+		if err != nil {
+			return ret, err // return empty
+		}
+		for _, line := range contents {
+			field := strings.Split(line, "=")
+			if len(field) < 2 {
+				continue
+			}
+			switch field[0] {
+			case "DISTRIB_ID":
+				ret.ID = field[1]
+			case "DISTRIB_RELEASE":
+				ret.Release = field[1]
+			case "DISTRIB_CODENAME":
+				ret.Codename = field[1]
+			case "DISTRIB_DESCRIPTION":
+				ret.Description = field[1]
+			}
+		}
+	} else if common.PathExists("/usr/bin/lsb_release") {
+		lsb_release, err := exec.LookPath("/usr/bin/lsb_release")
+		if err != nil {
+			return ret, err
+		}
+		out, err := invoke.Command(lsb_release)
+		if err != nil {
+			return ret, err
+		}
+		for _, line := range strings.Split(string(out), "\n") {
+			field := strings.Split(line, ":")
+			if len(field) < 2 {
+				continue
+			}
+			switch field[0] {
+			case "Distributor ID":
+				ret.ID = field[1]
+			case "Release":
+				ret.Release = field[1]
+			case "Codename":
+				ret.Codename = field[1]
+			case "Description":
+				ret.Description = field[1]
+			}
+		}
+
+	}
+
+	return ret, nil
+}
+
+func PlatformInformation() (platform string, family string, version string, err error) {
+	return PlatformInformationWithContext(context.Background())
+}
+
+func PlatformInformationWithContext(ctx context.Context) (platform string, family string, version string, err error) {
+
+	lsb, err := getLSB()
+	if err != nil {
+		lsb = &LSB{}
+	}
+
+	if common.PathExists(common.HostEtc("oracle-release")) {
+		platform = "oracle"
+		contents, err := common.ReadLines(common.HostEtc("oracle-release"))
+		if err == nil {
+			version = getRedhatishVersion(contents)
+		}
+
+	} else if common.PathExists(common.HostEtc("enterprise-release")) {
+		platform = "oracle"
+		contents, err := common.ReadLines(common.HostEtc("enterprise-release"))
+		if err == nil {
+			version = getRedhatishVersion(contents)
+		}
+	} else if common.PathExists(common.HostEtc("slackware-version")) {
+		platform = "slackware"
+		contents, err := common.ReadLines(common.HostEtc("slackware-version"))
+		if err == nil {
+			version = getSlackwareVersion(contents)
+		}
+	} else if common.PathExists(common.HostEtc("debian_version")) {
+		if lsb.ID == "Ubuntu" {
+			platform = "ubuntu"
+			version = lsb.Release
+		} else if lsb.ID == "LinuxMint" {
+			platform = "linuxmint"
+			version = lsb.Release
+		} else {
+			if common.PathExists("/usr/bin/raspi-config") {
+				platform = "raspbian"
+			} else {
+				platform = "debian"
+			}
+			contents, err := common.ReadLines(common.HostEtc("debian_version"))
+			if err == nil {
+				version = contents[0]
+			}
+		}
+	} else if common.PathExists(common.HostEtc("redhat-release")) {
+		contents, err := common.ReadLines(common.HostEtc("redhat-release"))
+		if err == nil {
+			version = getRedhatishVersion(contents)
+			platform = getRedhatishPlatform(contents)
+		}
+	} else if common.PathExists(common.HostEtc("system-release")) {
+		contents, err := common.ReadLines(common.HostEtc("system-release"))
+		if err == nil {
+			version = getRedhatishVersion(contents)
+			platform = getRedhatishPlatform(contents)
+		}
+	} else if common.PathExists(common.HostEtc("gentoo-release")) {
+		platform = "gentoo"
+		contents, err := common.ReadLines(common.HostEtc("gentoo-release"))
+		if err == nil {
+			version = getRedhatishVersion(contents)
+		}
+	} else if common.PathExists(common.HostEtc("SuSE-release")) {
+		contents, err := common.ReadLines(common.HostEtc("SuSE-release"))
+		if err == nil {
+			version = getSuseVersion(contents)
+			platform = getSusePlatform(contents)
+		}
+		// TODO: slackware detecion
+	} else if common.PathExists(common.HostEtc("arch-release")) {
+		platform = "arch"
+		version = lsb.Release
+	} else if common.PathExists(common.HostEtc("alpine-release")) {
+		platform = "alpine"
+		contents, err := common.ReadLines(common.HostEtc("alpine-release"))
+		if err == nil && len(contents) > 0 {
+			version = contents[0]
+		}
+	} else if common.PathExists(common.HostEtc("os-release")) {
+		p, v, err := getOSRelease()
+		if err == nil {
+			platform = p
+			version = v
+		}
+	} else if lsb.ID == "RedHat" {
+		platform = "redhat"
+		version = lsb.Release
+	} else if lsb.ID == "Amazon" {
+		platform = "amazon"
+		version = lsb.Release
+	} else if lsb.ID == "ScientificSL" {
+		platform = "scientific"
+		version = lsb.Release
+	} else if lsb.ID == "XenServer" {
+		platform = "xenserver"
+		version = lsb.Release
+	} else if lsb.ID != "" {
+		platform = strings.ToLower(lsb.ID)
+		version = lsb.Release
+	}
+
+	switch platform {
+	case "debian", "ubuntu", "linuxmint", "raspbian":
+		family = "debian"
+	case "fedora":
+		family = "fedora"
+	case "oracle", "centos", "redhat", "scientific", "enterpriseenterprise", "amazon", "xenserver", "cloudlinux", "ibm_powerkvm":
+		family = "rhel"
+	case "suse", "opensuse":
+		family = "suse"
+	case "gentoo":
+		family = "gentoo"
+	case "slackware":
+		family = "slackware"
+	case "arch":
+		family = "arch"
+	case "exherbo":
+		family = "exherbo"
+	case "alpine":
+		family = "alpine"
+	case "coreos":
+		family = "coreos"
+	}
+
+	return platform, family, version, nil
+
+}
+
+func KernelVersion() (version string, err error) {
+	return KernelVersionWithContext(context.Background())
+}
+
+func KernelVersionWithContext(ctx context.Context) (version string, err error) {
+	filename := common.HostProc("sys/kernel/osrelease")
+	if common.PathExists(filename) {
+		contents, err := common.ReadLines(filename)
+		if err != nil {
+			return "", err
+		}
+
+		if len(contents) > 0 {
+			version = contents[0]
+		}
+	}
+
+	return version, nil
+}
+
+func getSlackwareVersion(contents []string) string {
+	c := strings.ToLower(strings.Join(contents, ""))
+	c = strings.Replace(c, "slackware ", "", 1)
+	return c
+}
+
+func getRedhatishVersion(contents []string) string {
+	c := strings.ToLower(strings.Join(contents, ""))
+
+	if strings.Contains(c, "rawhide") {
+		return "rawhide"
+	}
+	if matches := regexp.MustCompile(`release (\d[\d.]*)`).FindStringSubmatch(c); matches != nil {
+		return matches[1]
+	}
+	return ""
+}
+
+func getRedhatishPlatform(contents []string) string {
+	c := strings.ToLower(strings.Join(contents, ""))
+
+	if strings.Contains(c, "red hat") {
+		return "redhat"
+	}
+	f := strings.Split(c, " ")
+
+	return f[0]
+}
+
+func getSuseVersion(contents []string) string {
+	version := ""
+	for _, line := range contents {
+		if matches := regexp.MustCompile(`VERSION = ([\d.]+)`).FindStringSubmatch(line); matches != nil {
+			version = matches[1]
+		} else if matches := regexp.MustCompile(`PATCHLEVEL = ([\d]+)`).FindStringSubmatch(line); matches != nil {
+			version = version + "." + matches[1]
+		}
+	}
+	return version
+}
+
+func getSusePlatform(contents []string) string {
+	c := strings.ToLower(strings.Join(contents, ""))
+	if strings.Contains(c, "opensuse") {
+		return "opensuse"
+	}
+	return "suse"
+}
+
+func Virtualization() (string, string, error) {
+	return VirtualizationWithContext(context.Background())
+}
+
+func VirtualizationWithContext(ctx context.Context) (string, string, error) {
+	var system string
+	var role string
+
+	filename := common.HostProc("xen")
+	if common.PathExists(filename) {
+		system = "xen"
+		role = "guest" // assume guest
+
+		if common.PathExists(filepath.Join(filename, "capabilities")) {
+			contents, err := common.ReadLines(filepath.Join(filename, "capabilities"))
+			if err == nil {
+				if common.StringsContains(contents, "control_d") {
+					role = "host"
+				}
+			}
+		}
+	}
+
+	filename = common.HostProc("modules")
+	if common.PathExists(filename) {
+		contents, err := common.ReadLines(filename)
+		if err == nil {
+			if common.StringsContains(contents, "kvm") {
+				system = "kvm"
+				role = "host"
+			} else if common.StringsContains(contents, "vboxdrv") {
+				system = "vbox"
+				role = "host"
+			} else if common.StringsContains(contents, "vboxguest") {
+				system = "vbox"
+				role = "guest"
+			} else if common.StringsContains(contents, "vmware") {
+				system = "vmware"
+				role = "guest"
+			}
+		}
+	}
+
+	filename = common.HostProc("cpuinfo")
+	if common.PathExists(filename) {
+		contents, err := common.ReadLines(filename)
+		if err == nil {
+			if common.StringsContains(contents, "QEMU Virtual CPU") ||
+				common.StringsContains(contents, "Common KVM processor") ||
+				common.StringsContains(contents, "Common 32-bit KVM processor") {
+				system = "kvm"
+				role = "guest"
+			}
+		}
+	}
+
+	filename = common.HostProc()
+	if common.PathExists(filepath.Join(filename, "bc", "0")) {
+		system = "openvz"
+		role = "host"
+	} else if common.PathExists(filepath.Join(filename, "vz")) {
+		system = "openvz"
+		role = "guest"
+	}
+
+	// not use dmidecode because it requires root
+	if common.PathExists(filepath.Join(filename, "self", "status")) {
+		contents, err := common.ReadLines(filepath.Join(filename, "self", "status"))
+		if err == nil {
+
+			if common.StringsContains(contents, "s_context:") ||
+				common.StringsContains(contents, "VxID:") {
+				system = "linux-vserver"
+			}
+			// TODO: guest or host
+		}
+	}
+
+	if common.PathExists(filepath.Join(filename, "self", "cgroup")) {
+		contents, err := common.ReadLines(filepath.Join(filename, "self", "cgroup"))
+		if err == nil {
+			if common.StringsContains(contents, "lxc") {
+				system = "lxc"
+				role = "guest"
+			} else if common.StringsContains(contents, "docker") {
+				system = "docker"
+				role = "guest"
+			} else if common.StringsContains(contents, "machine-rkt") {
+				system = "rkt"
+				role = "guest"
+			} else if common.PathExists("/usr/bin/lxc-version") {
+				system = "lxc"
+				role = "host"
+			}
+		}
+	}
+
+	if common.PathExists(common.HostEtc("os-release")) {
+		p, _, err := getOSRelease()
+		if err == nil && p == "coreos" {
+			system = "rkt" // Is it true?
+			role = "host"
+		}
+	}
+	return system, role, nil
+}
+
+func SensorsTemperatures() ([]TemperatureStat, error) {
+	return SensorsTemperaturesWithContext(context.Background())
+}
+
+func SensorsTemperaturesWithContext(ctx context.Context) ([]TemperatureStat, error) {
+	var temperatures []TemperatureStat
+	files, err := filepath.Glob(common.HostSys("/class/hwmon/hwmon*/temp*_*"))
+	if err != nil {
+		return temperatures, err
+	}
+	if len(files) == 0 {
+		// CentOS has an intermediate /device directory:
+		// https://github.com/giampaolo/psutil/issues/971
+		files, err = filepath.Glob(common.HostSys("/class/hwmon/hwmon*/device/temp*_*"))
+		if err != nil {
+			return temperatures, err
+		}
+	}
+
+	// example directory
+	// device/           temp1_crit_alarm  temp2_crit_alarm  temp3_crit_alarm  temp4_crit_alarm  temp5_crit_alarm  temp6_crit_alarm  temp7_crit_alarm
+	// name              temp1_input       temp2_input       temp3_input       temp4_input       temp5_input       temp6_input       temp7_input
+	// power/            temp1_label       temp2_label       temp3_label       temp4_label       temp5_label       temp6_label       temp7_label
+	// subsystem/        temp1_max         temp2_max         temp3_max         temp4_max         temp5_max         temp6_max         temp7_max
+	// temp1_crit        temp2_crit        temp3_crit        temp4_crit        temp5_crit        temp6_crit        temp7_crit        uevent
+	for _, file := range files {
+		filename := strings.Split(filepath.Base(file), "_")
+		if filename[1] == "label" {
+			// Do not try to read the temperature of the label file
+			continue
+		}
+
+		// Get the label of the temperature you are reading
+		var label string
+		c, _ := ioutil.ReadFile(filepath.Join(filepath.Dir(file), filename[0]+"_label"))
+		if c != nil {
+			//format the label from "Core 0" to "core0_"
+			label = fmt.Sprintf("%s_", strings.Join(strings.Split(strings.TrimSpace(strings.ToLower(string(c))), " "), ""))
+		}
+
+		// Get the name of the tempearture you are reading
+		name, err := ioutil.ReadFile(filepath.Join(filepath.Dir(file), "name"))
+		if err != nil {
+			return temperatures, err
+		}
+
+		// Get the temperature reading
+		current, err := ioutil.ReadFile(file)
+		if err != nil {
+			return temperatures, err
+		}
+		temperature, err := strconv.ParseFloat(strings.TrimSpace(string(current)), 64)
+		if err != nil {
+			continue
+		}
+
+		tempName := strings.TrimSpace(strings.ToLower(string(strings.Join(filename[1:], ""))))
+		temperatures = append(temperatures, TemperatureStat{
+			SensorKey:   fmt.Sprintf("%s_%s%s", strings.TrimSpace(string(name)), label, tempName),
+			Temperature: temperature / 1000.0,
+		})
+	}
+	return temperatures, nil
+}

vendor/github.com/shirou/gopsutil/host/host_linux_386.go

@@ -0,0 +1,45 @@
+// ATTENTION - FILE MANUAL FIXED AFTER CGO.
+// Fixed line: Tv		_Ctype_struct_timeval -> Tv		UtTv
+// Created by cgo -godefs, MANUAL FIXED
+// cgo -godefs types_linux.go
+
+package host
+
+const (
+	sizeofPtr      = 0x4
+	sizeofShort    = 0x2
+	sizeofInt      = 0x4
+	sizeofLong     = 0x4
+	sizeofLongLong = 0x8
+	sizeOfUtmp     = 0x180
+)
+
+type (
+	_C_short     int16
+	_C_int       int32
+	_C_long      int32
+	_C_long_long int64
+)
+
+type utmp struct {
+	Type      int16
+	Pad_cgo_0 [2]byte
+	Pid       int32
+	Line      [32]int8
+	ID        [4]int8
+	User      [32]int8
+	Host      [256]int8
+	Exit      exit_status
+	Session   int32
+	Tv        UtTv
+	Addr_v6   [4]int32
+	X__unused [20]int8
+}
+type exit_status struct {
+	Termination int16
+	Exit        int16
+}
+type UtTv struct {
+	Sec  int32
+	Usec int32
+}

vendor/github.com/shirou/gopsutil/host/host_linux_amd64.go

@@ -0,0 +1,48 @@
+// Created by cgo -godefs - DO NOT EDIT
+// cgo -godefs types_linux.go
+
+package host
+
+const (
+	sizeofPtr      = 0x8
+	sizeofShort    = 0x2
+	sizeofInt      = 0x4
+	sizeofLong     = 0x8
+	sizeofLongLong = 0x8
+	sizeOfUtmp     = 0x180
+)
+
+type (
+	_C_short     int16
+	_C_int       int32
+	_C_long      int64
+	_C_long_long int64
+)
+
+type utmp struct {
+	Type              int16
+	Pad_cgo_0         [2]byte
+	Pid               int32
+	Line              [32]int8
+	Id                [4]int8
+	User              [32]int8
+	Host              [256]int8
+	Exit              exit_status
+	Session           int32
+	Tv                _Ctype_struct___0
+	Addr_v6           [4]int32
+	X__glibc_reserved [20]int8
+}
+type exit_status struct {
+	Termination int16
+	Exit        int16
+}
+type timeval struct {
+	Sec  int64
+	Usec int64
+}
+
+type _Ctype_struct___0 struct {
+	Sec  int32
+	Usec int32
+}

vendor/github.com/shirou/gopsutil/host/host_linux_arm.go

@@ -0,0 +1,43 @@
+// Created by cgo -godefs - DO NOT EDIT
+// cgo -godefs types_linux.go | sed "s/uint8/int8/g"
+
+package host
+
+const (
+	sizeofPtr      = 0x4
+	sizeofShort    = 0x2
+	sizeofInt      = 0x4
+	sizeofLong     = 0x4
+	sizeofLongLong = 0x8
+	sizeOfUtmp     = 0x180
+)
+
+type (
+	_C_short     int16
+	_C_int       int32
+	_C_long      int32
+	_C_long_long int64
+)
+
+type utmp struct {
+	Type              int16
+	Pad_cgo_0         [2]byte
+	Pid               int32
+	Line              [32]int8
+	Id                [4]int8
+	User              [32]int8
+	Host              [256]int8
+	Exit              exit_status
+	Session           int32
+	Tv                timeval
+	Addr_v6           [4]int32
+	X__glibc_reserved [20]int8
+}
+type exit_status struct {
+	Termination int16
+	Exit        int16
+}
+type timeval struct {
+	Sec  int32
+	Usec int32
+}

vendor/github.com/shirou/gopsutil/host/host_linux_arm64.go

@@ -0,0 +1,43 @@
+// Created by cgo -godefs - DO NOT EDIT
+// cgo -godefs types_linux.go
+
+package host
+
+const (
+	sizeofPtr      = 0x8
+	sizeofShort    = 0x2
+	sizeofInt      = 0x4
+	sizeofLong     = 0x8
+	sizeofLongLong = 0x8
+	sizeOfUtmp     = 0x180
+)
+
+type (
+	_C_short     int16
+	_C_int       int32
+	_C_long      int64
+	_C_long_long int64
+)
+
+type utmp struct {
+	Type              int16
+	Pad_cgo_0         [2]byte
+	Pid               int32
+	Line              [32]int8
+	Id                [4]int8
+	User              [32]int8
+	Host              [256]int8
+	Exit              exit_status
+	Session           int32
+	Tv                timeval
+	Addr_v6           [4]int32
+	X__glibc_reserved [20]int8
+}
+type exit_status struct {
+	Termination int16
+	Exit        int16
+}
+type timeval struct {
+	Sec  int64
+	Usec int64
+}

vendor/github.com/shirou/gopsutil/host/host_linux_mips.go

@@ -0,0 +1,43 @@
+// Created by cgo -godefs - DO NOT EDIT
+// cgo -godefs types_linux.go
+
+package host
+
+const (
+	sizeofPtr      = 0x4
+	sizeofShort    = 0x2
+	sizeofInt      = 0x4
+	sizeofLong     = 0x4
+	sizeofLongLong = 0x8
+	sizeOfUtmp     = 0x180
+)
+
+type (
+	_C_short     int16
+	_C_int       int32
+	_C_long      int32
+	_C_long_long int64
+)
+
+type utmp struct {
+	Type      int16
+	Pad_cgo_0 [2]byte
+	Pid       int32
+	Line      [32]int8
+	Id        [4]int8
+	User      [32]int8
+	Host      [256]int8
+	Exit      exit_status
+	Session   int32
+	Tv        timeval
+	Addr_v6   [4]int32
+	X__unused [20]int8
+}
+type exit_status struct {
+	Termination int16
+	Exit        int16
+}
+type timeval struct {
+	Sec  int32
+	Usec int32
+}

vendor/github.com/shirou/gopsutil/host/host_linux_mips64.go

@@ -0,0 +1,43 @@
+// Created by cgo -godefs - DO NOT EDIT
+// cgo -godefs types_linux.go
+
+package host
+
+const (
+	sizeofPtr      = 0x4
+	sizeofShort    = 0x2
+	sizeofInt      = 0x4
+	sizeofLong     = 0x4
+	sizeofLongLong = 0x8
+	sizeOfUtmp     = 0x180
+)
+
+type (
+	_C_short     int16
+	_C_int       int32
+	_C_long      int32
+	_C_long_long int64
+)
+
+type utmp struct {
+	Type      int16
+	Pad_cgo_0 [2]byte
+	Pid       int32
+	Line      [32]int8
+	Id        [4]int8
+	User      [32]int8
+	Host      [256]int8
+	Exit      exit_status
+	Session   int32
+	Tv        timeval
+	Addr_v6   [4]int32
+	X__unused [20]int8
+}
+type exit_status struct {
+	Termination int16
+	Exit        int16
+}
+type timeval struct {
+	Sec  int32
+	Usec int32
+}

vendor/github.com/shirou/gopsutil/host/host_linux_mips64le.go

@@ -0,0 +1,43 @@
+// Created by cgo -godefs - DO NOT EDIT
+// cgo -godefs types_linux.go
+
+package host
+
+const (
+	sizeofPtr      = 0x4
+	sizeofShort    = 0x2
+	sizeofInt      = 0x4
+	sizeofLong     = 0x4
+	sizeofLongLong = 0x8
+	sizeOfUtmp     = 0x180
+)
+
+type (
+	_C_short     int16
+	_C_int       int32
+	_C_long      int32
+	_C_long_long int64
+)
+
+type utmp struct {
+	Type      int16
+	Pad_cgo_0 [2]byte
+	Pid       int32
+	Line      [32]int8
+	Id        [4]int8
+	User      [32]int8
+	Host      [256]int8
+	Exit      exit_status
+	Session   int32
+	Tv        timeval
+	Addr_v6   [4]int32
+	X__unused [20]int8
+}
+type exit_status struct {
+	Termination int16
+	Exit        int16
+}
+type timeval struct {
+	Sec  int32
+	Usec int32
+}

vendor/github.com/shirou/gopsutil/host/host_linux_mipsle.go

@@ -0,0 +1,43 @@
+// Created by cgo -godefs - DO NOT EDIT
+// cgo -godefs types_linux.go
+
+package host
+
+const (
+	sizeofPtr      = 0x4
+	sizeofShort    = 0x2
+	sizeofInt      = 0x4
+	sizeofLong     = 0x4
+	sizeofLongLong = 0x8
+	sizeOfUtmp     = 0x180
+)
+
+type (
+	_C_short     int16
+	_C_int       int32
+	_C_long      int32
+	_C_long_long int64
+)
+
+type utmp struct {
+	Type      int16
+	Pad_cgo_0 [2]byte
+	Pid       int32
+	Line      [32]int8
+	Id        [4]int8
+	User      [32]int8
+	Host      [256]int8
+	Exit      exit_status
+	Session   int32
+	Tv        timeval
+	Addr_v6   [4]int32
+	X__unused [20]int8
+}
+type exit_status struct {
+	Termination int16
+	Exit        int16
+}
+type timeval struct {
+	Sec  int32
+	Usec int32
+}

vendor/github.com/shirou/gopsutil/host/host_linux_ppc64le.go

@@ -0,0 +1,45 @@
+// +build linux
+// +build ppc64le
+// Created by cgo -godefs - DO NOT EDIT
+// cgo -godefs types_linux.go
+
+package host
+
+const (
+	sizeofPtr      = 0x8
+	sizeofShort    = 0x2
+	sizeofInt      = 0x4
+	sizeofLong     = 0x8
+	sizeofLongLong = 0x8
+	sizeOfUtmp     = 0x180
+)
+
+type (
+	_C_short     int16
+	_C_int       int32
+	_C_long      int64
+	_C_long_long int64
+)
+
+type utmp struct {
+	Type              int16
+	Pad_cgo_0         [2]byte
+	Pid               int32
+	Line              [32]int8
+	Id                [4]int8
+	User              [32]int8
+	Host              [256]int8
+	Exit              exit_status
+	Session           int32
+	Tv                timeval
+	Addr_v6           [4]int32
+	X__glibc_reserved [20]int8
+}
+type exit_status struct {
+	Termination int16
+	Exit        int16
+}
+type timeval struct {
+	Sec  int64
+	Usec int64
+}

vendor/github.com/shirou/gopsutil/host/host_linux_s390x.go

@@ -0,0 +1,45 @@
+// +build linux
+// +build s390x
+// Created by cgo -godefs - DO NOT EDIT
+// cgo -godefs types_linux.go
+
+package host
+
+const (
+	sizeofPtr      = 0x8
+	sizeofShort    = 0x2
+	sizeofInt      = 0x4
+	sizeofLong     = 0x8
+	sizeofLongLong = 0x8
+	sizeOfUtmp     = 0x180
+)
+
+type (
+	_C_short     int16
+	_C_int       int32
+	_C_long      int64
+	_C_long_long int64
+)
+
+type utmp struct {
+	Type              int16
+	Pad_cgo_0         [2]byte
+	Pid               int32
+	Line              [32]int8
+	Id                [4]int8
+	User              [32]int8
+	Host              [256]int8
+	Exit              exit_status
+	Session           int32
+	Tv                timeval
+	Addr_v6           [4]int32
+	X__glibc_reserved [20]int8
+}
+type exit_status struct {
+	Termination int16
+	Exit        int16
+}
+type timeval struct {
+	Sec  int64
+	Usec int64
+}

vendor/github.com/shirou/gopsutil/host/host_openbsd.go

@@ -0,0 +1,195 @@
+// +build openbsd
+
+package host
+
+import (
+	"bytes"
+	"context"
+	"encoding/binary"
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"runtime"
+	"strconv"
+	"strings"
+	"time"
+	"unsafe"
+
+	"github.com/shirou/gopsutil/internal/common"
+	"github.com/shirou/gopsutil/process"
+)
+
+const (
+	UTNameSize = 32 /* see MAXLOGNAME in <sys/param.h> */
+	UTLineSize = 8
+	UTHostSize = 16
+)
+
+func Info() (*InfoStat, error) {
+	return InfoWithContext(context.Background())
+}
+
+func InfoWithContext(ctx context.Context) (*InfoStat, error) {
+	ret := &InfoStat{
+		OS:             runtime.GOOS,
+		PlatformFamily: "openbsd",
+	}
+
+	hostname, err := os.Hostname()
+	if err == nil {
+		ret.Hostname = hostname
+	}
+
+	platform, family, version, err := PlatformInformation()
+	if err == nil {
+		ret.Platform = platform
+		ret.PlatformFamily = family
+		ret.PlatformVersion = version
+	}
+	system, role, err := Virtualization()
+	if err == nil {
+		ret.VirtualizationSystem = system
+		ret.VirtualizationRole = role
+	}
+
+	procs, err := process.Pids()
+	if err == nil {
+		ret.Procs = uint64(len(procs))
+	}
+
+	boot, err := BootTime()
+	if err == nil {
+		ret.BootTime = boot
+		ret.Uptime = uptime(boot)
+	}
+
+	return ret, nil
+}
+
+func BootTime() (uint64, error) {
+	return BootTimeWithContext(context.Background())
+}
+
+func BootTimeWithContext(ctx context.Context) (uint64, error) {
+	val, err := common.DoSysctrl("kern.boottime")
+	if err != nil {
+		return 0, err
+	}
+
+	boottime, err := strconv.ParseUint(val[0], 10, 64)
+	if err != nil {
+		return 0, err
+	}
+
+	return boottime, nil
+}
+
+func uptime(boot uint64) uint64 {
+	return uint64(time.Now().Unix()) - boot
+}
+
+func Uptime() (uint64, error) {
+	return UptimeWithContext(context.Background())
+}
+
+func UptimeWithContext(ctx context.Context) (uint64, error) {
+	boot, err := BootTime()
+	if err != nil {
+		return 0, err
+	}
+	return uptime(boot), nil
+}
+
+func PlatformInformation() (string, string, string, error) {
+	return PlatformInformationWithContext(context.Background())
+}
+
+func PlatformInformationWithContext(ctx context.Context) (string, string, string, error) {
+	platform := ""
+	family := ""
+	version := ""
+	uname, err := exec.LookPath("uname")
+	if err != nil {
+		return "", "", "", err
+	}
+
+	out, err := invoke.CommandWithContext(ctx, uname, "-s")
+	if err == nil {
+		platform = strings.ToLower(strings.TrimSpace(string(out)))
+	}
+
+	out, err = invoke.CommandWithContext(ctx, uname, "-r")
+	if err == nil {
+		version = strings.ToLower(strings.TrimSpace(string(out)))
+	}
+
+	return platform, family, version, nil
+}
+
+func Virtualization() (string, string, error) {
+	return VirtualizationWithContext(context.Background())
+}
+
+func VirtualizationWithContext(ctx context.Context) (string, string, error) {
+	return "", "", common.ErrNotImplementedError
+}
+
+func Users() ([]UserStat, error) {
+	return UsersWithContext(context.Background())
+}
+
+func UsersWithContext(ctx context.Context) ([]UserStat, error) {
+	var ret []UserStat
+	utmpfile := "/var/run/utmp"
+	file, err := os.Open(utmpfile)
+	if err != nil {
+		return ret, err
+	}
+	defer file.Close()
+
+	buf, err := ioutil.ReadAll(file)
+	if err != nil {
+		return ret, err
+	}
+
+	u := Utmp{}
+	entrySize := int(unsafe.Sizeof(u))
+	count := len(buf) / entrySize
+
+	for i := 0; i < count; i++ {
+		b := buf[i*entrySize : i*entrySize+entrySize]
+		var u Utmp
+		br := bytes.NewReader(b)
+		err := binary.Read(br, binary.LittleEndian, &u)
+		if err != nil || u.Time == 0 {
+			continue
+		}
+		user := UserStat{
+			User:     common.IntToString(u.Name[:]),
+			Terminal: common.IntToString(u.Line[:]),
+			Host:     common.IntToString(u.Host[:]),
+			Started:  int(u.Time),
+		}
+
+		ret = append(ret, user)
+	}
+
+	return ret, nil
+}
+
+func SensorsTemperatures() ([]TemperatureStat, error) {
+	return SensorsTemperaturesWithContext(context.Background())
+}
+
+func SensorsTemperaturesWithContext(ctx context.Context) ([]TemperatureStat, error) {
+	return []TemperatureStat{}, common.ErrNotImplementedError
+}
+
+func KernelVersion() (string, error) {
+	return KernelVersionWithContext(context.Background())
+}
+
+func KernelVersionWithContext(ctx context.Context) (string, error) {
+	_, _, version, err := PlatformInformation()
+	return version, err
+}

vendor/github.com/shirou/gopsutil/host/host_openbsd_amd64.go

@@ -0,0 +1,31 @@
+// Created by cgo -godefs - DO NOT EDIT
+// cgo -godefs types_openbsd.go
+
+package host
+
+const (
+	sizeofPtr      = 0x8
+	sizeofShort    = 0x2
+	sizeofInt      = 0x4
+	sizeofLong     = 0x8
+	sizeofLongLong = 0x8
+	sizeOfUtmp     = 0x130
+)
+
+type (
+	_C_short     int16
+	_C_int       int32
+	_C_long      int64
+	_C_long_long int64
+)
+
+type Utmp struct {
+	Line [8]int8
+	Name [32]int8
+	Host [256]int8
+	Time int64
+}
+type Timeval struct {
+	Sec  int64
+	Usec int64
+}

vendor/github.com/shirou/gopsutil/host/host_solaris.go

@@ -0,0 +1,248 @@
+package host
+
+import (
+	"bufio"
+	"bytes"
+	"context"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"regexp"
+	"runtime"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/shirou/gopsutil/internal/common"
+)
+
+func Info() (*InfoStat, error) {
+	return InfoWithContext(context.Background())
+}
+
+func InfoWithContext(ctx context.Context) (*InfoStat, error) {
+	result := &InfoStat{
+		OS: runtime.GOOS,
+	}
+
+	hostname, err := os.Hostname()
+	if err != nil {
+		return nil, err
+	}
+	result.Hostname = hostname
+
+	// Parse versions from output of `uname(1)`
+	uname, err := exec.LookPath("/usr/bin/uname")
+	if err != nil {
+		return nil, err
+	}
+
+	out, err := invoke.CommandWithContext(ctx, uname, "-srv")
+	if err != nil {
+		return nil, err
+	}
+
+	fields := strings.Fields(string(out))
+	if len(fields) >= 1 {
+		result.PlatformFamily = fields[0]
+	}
+	if len(fields) >= 2 {
+		result.KernelVersion = fields[1]
+	}
+	if len(fields) == 3 {
+		result.PlatformVersion = fields[2]
+	}
+
+	// Find distribution name from /etc/release
+	fh, err := os.Open("/etc/release")
+	if err != nil {
+		return nil, err
+	}
+	defer fh.Close()
+
+	sc := bufio.NewScanner(fh)
+	if sc.Scan() {
+		line := strings.TrimSpace(sc.Text())
+		switch {
+		case strings.HasPrefix(line, "SmartOS"):
+			result.Platform = "SmartOS"
+		case strings.HasPrefix(line, "OpenIndiana"):
+			result.Platform = "OpenIndiana"
+		case strings.HasPrefix(line, "OmniOS"):
+			result.Platform = "OmniOS"
+		case strings.HasPrefix(line, "Open Storage"):
+			result.Platform = "NexentaStor"
+		case strings.HasPrefix(line, "Solaris"):
+			result.Platform = "Solaris"
+		case strings.HasPrefix(line, "Oracle Solaris"):
+			result.Platform = "Solaris"
+		default:
+			result.Platform = strings.Fields(line)[0]
+		}
+	}
+
+	switch result.Platform {
+	case "SmartOS":
+		// If everything works, use the current zone ID as the HostID if present.
+		zonename, err := exec.LookPath("/usr/bin/zonename")
+		if err == nil {
+			out, err := invoke.CommandWithContext(ctx, zonename)
+			if err == nil {
+				sc := bufio.NewScanner(bytes.NewReader(out))
+				for sc.Scan() {
+					line := sc.Text()
+
+					// If we're in the global zone, rely on the hostname.
+					if line == "global" {
+						hostname, err := os.Hostname()
+						if err == nil {
+							result.HostID = hostname
+						}
+					} else {
+						result.HostID = strings.TrimSpace(line)
+						break
+					}
+				}
+			}
+		}
+	}
+
+	// If HostID is still empty, use hostid(1), which can lie to callers but at
+	// this point there are no hardware facilities available.  This behavior
+	// matches that of other supported OSes.
+	if result.HostID == "" {
+		hostID, err := exec.LookPath("/usr/bin/hostid")
+		if err == nil {
+			out, err := invoke.CommandWithContext(ctx, hostID)
+			if err == nil {
+				sc := bufio.NewScanner(bytes.NewReader(out))
+				for sc.Scan() {
+					line := sc.Text()
+					result.HostID = strings.TrimSpace(line)
+					break
+				}
+			}
+		}
+	}
+
+	// Find the boot time and calculate uptime relative to it
+	bootTime, err := BootTime()
+	if err != nil {
+		return nil, err
+	}
+	result.BootTime = bootTime
+	result.Uptime = uptimeSince(bootTime)
+
+	// Count number of processes based on the number of entries in /proc
+	dirs, err := ioutil.ReadDir("/proc")
+	if err != nil {
+		return nil, err
+	}
+	result.Procs = uint64(len(dirs))
+
+	return result, nil
+}
+
+var kstatMatch = regexp.MustCompile(`([^\s]+)[\s]+([^\s]*)`)
+
+func BootTime() (uint64, error) {
+	return BootTimeWithContext(context.Background())
+}
+
+func BootTimeWithContext(ctx context.Context) (uint64, error) {
+	kstat, err := exec.LookPath("/usr/bin/kstat")
+	if err != nil {
+		return 0, err
+	}
+
+	out, err := invoke.CommandWithContext(ctx, kstat, "-p", "unix:0:system_misc:boot_time")
+	if err != nil {
+		return 0, err
+	}
+
+	kstats := kstatMatch.FindAllStringSubmatch(string(out), -1)
+	if len(kstats) != 1 {
+		return 0, fmt.Errorf("expected 1 kstat, found %d", len(kstats))
+	}
+
+	return strconv.ParseUint(kstats[0][2], 10, 64)
+}
+
+func Uptime() (uint64, error) {
+	return UptimeWithContext(context.Background())
+}
+
+func UptimeWithContext(ctx context.Context) (uint64, error) {
+	bootTime, err := BootTime()
+	if err != nil {
+		return 0, err
+	}
+	return uptimeSince(bootTime), nil
+}
+
+func uptimeSince(since uint64) uint64 {
+	return uint64(time.Now().Unix()) - since
+}
+
+func Users() ([]UserStat, error) {
+	return UsersWithContext(context.Background())
+}
+
+func UsersWithContext(ctx context.Context) ([]UserStat, error) {
+	return []UserStat{}, common.ErrNotImplementedError
+}
+
+func SensorsTemperatures() ([]TemperatureStat, error) {
+	return SensorsTemperaturesWithContext(context.Background())
+}
+
+func SensorsTemperaturesWithContext(ctx context.Context) ([]TemperatureStat, error) {
+	return []TemperatureStat{}, common.ErrNotImplementedError
+}
+
+func Virtualization() (string, string, error) {
+	return VirtualizationWithContext(context.Background())
+}
+
+func VirtualizationWithContext(ctx context.Context) (string, string, error) {
+	return "", "", common.ErrNotImplementedError
+}
+
+func KernelVersion() (string, error) {
+	return KernelVersionWithContext(context.Background())
+}
+
+func KernelVersionWithContext(ctx context.Context) (string, error) {
+	// Parse versions from output of `uname(1)`
+	uname, err := exec.LookPath("/usr/bin/uname")
+	if err != nil {
+		return "", err
+	}
+
+	out, err := invoke.CommandWithContext(ctx, uname, "-srv")
+	if err != nil {
+		return "", err
+	}
+
+	fields := strings.Fields(string(out))
+	if len(fields) >= 2 {
+		return fields[1], nil
+	}
+	return "", fmt.Errorf("could not get kernel version")
+}
+
+func PlatformInformation() (platform string, family string, version string, err error) {
+	return PlatformInformationWithContext(context.Background())
+}
+
+func PlatformInformationWithContext(ctx context.Context) (platform string, family string, version string, err error) {
+	/* This is not finished yet at all. Please contribute! */
+
+	version, err = KernelVersion()
+	if err != nil {
+		return "", "", "", err
+	}
+
+	return "solaris", "solaris", version, nil
+}

vendor/github.com/shirou/gopsutil/host/host_windows.go

@@ -0,0 +1,295 @@
+// +build windows
+
+package host
+
+import (
+	"context"
+	"fmt"
+	"math"
+	"os"
+	"runtime"
+	"strings"
+	"sync/atomic"
+	"syscall"
+	"time"
+	"unsafe"
+
+	"github.com/StackExchange/wmi"
+	"github.com/shirou/gopsutil/internal/common"
+	process "github.com/shirou/gopsutil/process"
+	"golang.org/x/sys/windows"
+)
+
+var (
+	procGetSystemTimeAsFileTime = common.Modkernel32.NewProc("GetSystemTimeAsFileTime")
+	procGetTickCount32          = common.Modkernel32.NewProc("GetTickCount")
+	procGetTickCount64          = common.Modkernel32.NewProc("GetTickCount64")
+	procRtlGetVersion           = common.ModNt.NewProc("RtlGetVersion")
+)
+
+// https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/ns-wdm-_osversioninfoexw
+type osVersionInfoExW struct {
+	dwOSVersionInfoSize uint32
+	dwMajorVersion      uint32
+	dwMinorVersion      uint32
+	dwBuildNumber       uint32
+	dwPlatformId        uint32
+	szCSDVersion        [128]uint16
+	wServicePackMajor   uint16
+	wServicePackMinor   uint16
+	wSuiteMask          uint16
+	wProductType        uint8
+	wReserved           uint8
+}
+
+type msAcpi_ThermalZoneTemperature struct {
+	Active             bool
+	CriticalTripPoint  uint32
+	CurrentTemperature uint32
+	InstanceName       string
+}
+
+func Info() (*InfoStat, error) {
+	return InfoWithContext(context.Background())
+}
+
+func InfoWithContext(ctx context.Context) (*InfoStat, error) {
+	ret := &InfoStat{
+		OS: runtime.GOOS,
+	}
+
+	{
+		hostname, err := os.Hostname()
+		if err == nil {
+			ret.Hostname = hostname
+		}
+	}
+
+	{
+		platform, family, version, err := PlatformInformationWithContext(ctx)
+		if err == nil {
+			ret.Platform = platform
+			ret.PlatformFamily = family
+			ret.PlatformVersion = version
+		} else {
+			return ret, err
+		}
+	}
+
+	{
+		boot, err := BootTime()
+		if err == nil {
+			ret.BootTime = boot
+			ret.Uptime, _ = Uptime()
+		}
+	}
+
+	{
+		hostID, err := getMachineGuid()
+		if err == nil {
+			ret.HostID = strings.ToLower(hostID)
+		}
+	}
+
+	{
+		procs, err := process.Pids()
+		if err == nil {
+			ret.Procs = uint64(len(procs))
+		}
+	}
+
+	return ret, nil
+}
+
+func getMachineGuid() (string, error) {
+	// there has been reports of issues on 32bit using golang.org/x/sys/windows/registry, see https://github.com/shirou/gopsutil/pull/312#issuecomment-277422612
+	// for rationale of using windows.RegOpenKeyEx/RegQueryValueEx instead of registry.OpenKey/GetStringValue
+	var h windows.Handle
+	err := windows.RegOpenKeyEx(windows.HKEY_LOCAL_MACHINE, windows.StringToUTF16Ptr(`SOFTWARE\Microsoft\Cryptography`), 0, windows.KEY_READ|windows.KEY_WOW64_64KEY, &h)
+	if err != nil {
+		return "", err
+	}
+	defer windows.RegCloseKey(h)
+
+	const windowsRegBufLen = 74 // len(`{`) + len(`abcdefgh-1234-456789012-123345456671` * 2) + len(`}`) // 2 == bytes/UTF16
+	const uuidLen = 36
+
+	var regBuf [windowsRegBufLen]uint16
+	bufLen := uint32(windowsRegBufLen)
+	var valType uint32
+	err = windows.RegQueryValueEx(h, windows.StringToUTF16Ptr(`MachineGuid`), nil, &valType, (*byte)(unsafe.Pointer(&regBuf[0])), &bufLen)
+	if err != nil {
+		return "", err
+	}
+
+	hostID := windows.UTF16ToString(regBuf[:])
+	hostIDLen := len(hostID)
+	if hostIDLen != uuidLen {
+		return "", fmt.Errorf("HostID incorrect: %q\n", hostID)
+	}
+
+	return hostID, nil
+}
+
+func Uptime() (uint64, error) {
+	return UptimeWithContext(context.Background())
+}
+
+func UptimeWithContext(ctx context.Context) (uint64, error) {
+	procGetTickCount := procGetTickCount64
+	err := procGetTickCount64.Find()
+	if err != nil {
+		procGetTickCount = procGetTickCount32 // handle WinXP, but keep in mind that "the time will wrap around to zero if the system is run continuously for 49.7 days." from MSDN
+	}
+	r1, _, lastErr := syscall.Syscall(procGetTickCount.Addr(), 0, 0, 0, 0)
+	if lastErr != 0 {
+		return 0, lastErr
+	}
+	return uint64((time.Duration(r1) * time.Millisecond).Seconds()), nil
+}
+
+func bootTimeFromUptime(up uint64) uint64 {
+	return uint64(time.Now().Unix()) - up
+}
+
+// cachedBootTime must be accessed via atomic.Load/StoreUint64
+var cachedBootTime uint64
+
+func BootTime() (uint64, error) {
+	return BootTimeWithContext(context.Background())
+}
+
+func BootTimeWithContext(ctx context.Context) (uint64, error) {
+	t := atomic.LoadUint64(&cachedBootTime)
+	if t != 0 {
+		return t, nil
+	}
+	up, err := Uptime()
+	if err != nil {
+		return 0, err
+	}
+	t = bootTimeFromUptime(up)
+	atomic.StoreUint64(&cachedBootTime, t)
+	return t, nil
+}
+
+func PlatformInformation() (platform string, family string, version string, err error) {
+	return PlatformInformationWithContext(context.Background())
+}
+
+func PlatformInformationWithContext(ctx context.Context) (platform string, family string, version string, err error) {
+	// GetVersionEx lies on Windows 8.1 and returns as Windows 8 if we don't declare compatibility in manifest
+	// RtlGetVersion bypasses this lying layer and returns the true Windows version
+	// https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/nf-wdm-rtlgetversion
+	// https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/ns-wdm-_osversioninfoexw
+	var osInfo osVersionInfoExW
+	osInfo.dwOSVersionInfoSize = uint32(unsafe.Sizeof(osInfo))
+	ret, _, err := procRtlGetVersion.Call(uintptr(unsafe.Pointer(&osInfo)))
+	if ret != 0 {
+		return
+	}
+
+	// Platform
+	var h windows.Handle // like getMachineGuid(), we query the registry using the raw windows.RegOpenKeyEx/RegQueryValueEx
+	err = windows.RegOpenKeyEx(windows.HKEY_LOCAL_MACHINE, windows.StringToUTF16Ptr(`SOFTWARE\Microsoft\Windows NT\CurrentVersion`), 0, windows.KEY_READ|windows.KEY_WOW64_64KEY, &h)
+	if err != nil {
+		return
+	}
+	defer windows.RegCloseKey(h)
+	var bufLen uint32
+	var valType uint32
+	err = windows.RegQueryValueEx(h, windows.StringToUTF16Ptr(`ProductName`), nil, &valType, nil, &bufLen)
+	if err != nil {
+		return
+	}
+	regBuf := make([]uint16, bufLen/2+1)
+	err = windows.RegQueryValueEx(h, windows.StringToUTF16Ptr(`ProductName`), nil, &valType, (*byte)(unsafe.Pointer(&regBuf[0])), &bufLen)
+	if err != nil {
+		return
+	}
+	platform = windows.UTF16ToString(regBuf[:])
+	if !strings.HasPrefix(platform, "Microsoft") {
+		platform = "Microsoft " + platform
+	}
+	err = windows.RegQueryValueEx(h, windows.StringToUTF16Ptr(`CSDVersion`), nil, &valType, nil, &bufLen) // append Service Pack number, only on success
+	if err == nil {                                                                                       // don't return an error if only the Service Pack retrieval fails
+		regBuf = make([]uint16, bufLen/2+1)
+		err = windows.RegQueryValueEx(h, windows.StringToUTF16Ptr(`CSDVersion`), nil, &valType, (*byte)(unsafe.Pointer(&regBuf[0])), &bufLen)
+		if err == nil {
+			platform += " " + windows.UTF16ToString(regBuf[:])
+		}
+	}
+
+	// PlatformFamily
+	switch osInfo.wProductType {
+	case 1:
+		family = "Standalone Workstation"
+	case 2:
+		family = "Server (Domain Controller)"
+	case 3:
+		family = "Server"
+	}
+
+	// Platform Version
+	version = fmt.Sprintf("%d.%d.%d Build %d", osInfo.dwMajorVersion, osInfo.dwMinorVersion, osInfo.dwBuildNumber, osInfo.dwBuildNumber)
+
+	return platform, family, version, nil
+}
+
+func Users() ([]UserStat, error) {
+	return UsersWithContext(context.Background())
+}
+
+func UsersWithContext(ctx context.Context) ([]UserStat, error) {
+	var ret []UserStat
+
+	return ret, nil
+}
+
+func SensorsTemperatures() ([]TemperatureStat, error) {
+	return SensorsTemperaturesWithContext(context.Background())
+}
+
+func SensorsTemperaturesWithContext(ctx context.Context) ([]TemperatureStat, error) {
+	var ret []TemperatureStat
+	var dst []msAcpi_ThermalZoneTemperature
+	q := wmi.CreateQuery(&dst, "")
+	if err := common.WMIQueryWithContext(ctx, q, &dst, nil, "root/wmi"); err != nil {
+		return ret, err
+	}
+
+	for _, v := range dst {
+		ts := TemperatureStat{
+			SensorKey:   v.InstanceName,
+			Temperature: kelvinToCelsius(v.CurrentTemperature, 2),
+		}
+		ret = append(ret, ts)
+	}
+
+	return ret, nil
+}
+
+func kelvinToCelsius(temp uint32, n int) float64 {
+	// wmi return temperature Kelvin * 10, so need to divide the result by 10,
+	// and then minus 273.15 to get °Celsius.
+	t := float64(temp/10) - 273.15
+	n10 := math.Pow10(n)
+	return math.Trunc((t+0.5/n10)*n10) / n10
+}
+
+func Virtualization() (string, string, error) {
+	return VirtualizationWithContext(context.Background())
+}
+
+func VirtualizationWithContext(ctx context.Context) (string, string, error) {
+	return "", "", common.ErrNotImplementedError
+}
+
+func KernelVersion() (string, error) {
+	return KernelVersionWithContext(context.Background())
+}
+
+func KernelVersionWithContext(ctx context.Context) (string, error) {
+	_, _, version, err := PlatformInformation()
+	return version, err
+}

vendor/github.com/shirou/gopsutil/internal/common/BUILD.bazel

@@ -0,0 +1,48 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "binary.go",
+        "common.go",
+        "common_darwin.go",
+        "common_freebsd.go",
+        "common_linux.go",
+        "common_openbsd.go",
+        "common_unix.go",
+        "common_windows.go",
+    ],
+    importmap = "go-common/vendor/github.com/shirou/gopsutil/internal/common",
+    importpath = "github.com/shirou/gopsutil/internal/common",
+    visibility = ["//vendor/github.com/shirou/gopsutil:__subpackages__"],
+    deps = select({
+        "@io_bazel_rules_go//go/platform:darwin": [
+            "//vendor/golang.org/x/sys/unix:go_default_library",
+        ],
+        "@io_bazel_rules_go//go/platform:freebsd": [
+            "//vendor/golang.org/x/sys/unix:go_default_library",
+        ],
+        "@io_bazel_rules_go//go/platform:openbsd": [
+            "//vendor/golang.org/x/sys/unix:go_default_library",
+        ],
+        "@io_bazel_rules_go//go/platform:windows": [
+            "//vendor/github.com/StackExchange/wmi:go_default_library",
+            "//vendor/golang.org/x/sys/windows:go_default_library",
+        ],
+        "//conditions:default": [],
+    }),
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

vendor/github.com/shirou/gopsutil/internal/common/binary.go

@@ -0,0 +1,634 @@
+package common
+
+// Copyright 2009 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package binary implements simple translation between numbers and byte
+// sequences and encoding and decoding of varints.
+//
+// Numbers are translated by reading and writing fixed-size values.
+// A fixed-size value is either a fixed-size arithmetic
+// type (int8, uint8, int16, float32, complex64, ...)
+// or an array or struct containing only fixed-size values.
+//
+// The varint functions encode and decode single integer values using
+// a variable-length encoding; smaller values require fewer bytes.
+// For a specification, see
+// http://code.google.com/apis/protocolbuffers/docs/encoding.html.
+//
+// This package favors simplicity over efficiency. Clients that require
+// high-performance serialization, especially for large data structures,
+// should look at more advanced solutions such as the encoding/gob
+// package or protocol buffers.
+import (
+	"errors"
+	"io"
+	"math"
+	"reflect"
+)
+
+// A ByteOrder specifies how to convert byte sequences into
+// 16-, 32-, or 64-bit unsigned integers.
+type ByteOrder interface {
+	Uint16([]byte) uint16
+	Uint32([]byte) uint32
+	Uint64([]byte) uint64
+	PutUint16([]byte, uint16)
+	PutUint32([]byte, uint32)
+	PutUint64([]byte, uint64)
+	String() string
+}
+
+// LittleEndian is the little-endian implementation of ByteOrder.
+var LittleEndian littleEndian
+
+// BigEndian is the big-endian implementation of ByteOrder.
+var BigEndian bigEndian
+
+type littleEndian struct{}
+
+func (littleEndian) Uint16(b []byte) uint16 { return uint16(b[0]) | uint16(b[1])<<8 }
+
+func (littleEndian) PutUint16(b []byte, v uint16) {
+	b[0] = byte(v)
+	b[1] = byte(v >> 8)
+}
+
+func (littleEndian) Uint32(b []byte) uint32 {
+	return uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
+}
+
+func (littleEndian) PutUint32(b []byte, v uint32) {
+	b[0] = byte(v)
+	b[1] = byte(v >> 8)
+	b[2] = byte(v >> 16)
+	b[3] = byte(v >> 24)
+}
+
+func (littleEndian) Uint64(b []byte) uint64 {
+	return uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 |
+		uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56
+}
+
+func (littleEndian) PutUint64(b []byte, v uint64) {
+	b[0] = byte(v)
+	b[1] = byte(v >> 8)
+	b[2] = byte(v >> 16)
+	b[3] = byte(v >> 24)
+	b[4] = byte(v >> 32)
+	b[5] = byte(v >> 40)
+	b[6] = byte(v >> 48)
+	b[7] = byte(v >> 56)
+}
+
+func (littleEndian) String() string { return "LittleEndian" }
+
+func (littleEndian) GoString() string { return "binary.LittleEndian" }
+
+type bigEndian struct{}
+
+func (bigEndian) Uint16(b []byte) uint16 { return uint16(b[1]) | uint16(b[0])<<8 }
+
+func (bigEndian) PutUint16(b []byte, v uint16) {
+	b[0] = byte(v >> 8)
+	b[1] = byte(v)
+}
+
+func (bigEndian) Uint32(b []byte) uint32 {
+	return uint32(b[3]) | uint32(b[2])<<8 | uint32(b[1])<<16 | uint32(b[0])<<24
+}
+
+func (bigEndian) PutUint32(b []byte, v uint32) {
+	b[0] = byte(v >> 24)
+	b[1] = byte(v >> 16)
+	b[2] = byte(v >> 8)
+	b[3] = byte(v)
+}
+
+func (bigEndian) Uint64(b []byte) uint64 {
+	return uint64(b[7]) | uint64(b[6])<<8 | uint64(b[5])<<16 | uint64(b[4])<<24 |
+		uint64(b[3])<<32 | uint64(b[2])<<40 | uint64(b[1])<<48 | uint64(b[0])<<56
+}
+
+func (bigEndian) PutUint64(b []byte, v uint64) {
+	b[0] = byte(v >> 56)
+	b[1] = byte(v >> 48)
+	b[2] = byte(v >> 40)
+	b[3] = byte(v >> 32)
+	b[4] = byte(v >> 24)
+	b[5] = byte(v >> 16)
+	b[6] = byte(v >> 8)
+	b[7] = byte(v)
+}
+
+func (bigEndian) String() string { return "BigEndian" }
+
+func (bigEndian) GoString() string { return "binary.BigEndian" }
+
+// Read reads structured binary data from r into data.
+// Data must be a pointer to a fixed-size value or a slice
+// of fixed-size values.
+// Bytes read from r are decoded using the specified byte order
+// and written to successive fields of the data.
+// When reading into structs, the field data for fields with
+// blank (_) field names is skipped; i.e., blank field names
+// may be used for padding.
+// When reading into a struct, all non-blank fields must be exported.
+func Read(r io.Reader, order ByteOrder, data interface{}) error {
+	// Fast path for basic types and slices.
+	if n := intDataSize(data); n != 0 {
+		var b [8]byte
+		var bs []byte
+		if n > len(b) {
+			bs = make([]byte, n)
+		} else {
+			bs = b[:n]
+		}
+		if _, err := io.ReadFull(r, bs); err != nil {
+			return err
+		}
+		switch data := data.(type) {
+		case *int8:
+			*data = int8(b[0])
+		case *uint8:
+			*data = b[0]
+		case *int16:
+			*data = int16(order.Uint16(bs))
+		case *uint16:
+			*data = order.Uint16(bs)
+		case *int32:
+			*data = int32(order.Uint32(bs))
+		case *uint32:
+			*data = order.Uint32(bs)
+		case *int64:
+			*data = int64(order.Uint64(bs))
+		case *uint64:
+			*data = order.Uint64(bs)
+		case []int8:
+			for i, x := range bs { // Easier to loop over the input for 8-bit values.
+				data[i] = int8(x)
+			}
+		case []uint8:
+			copy(data, bs)
+		case []int16:
+			for i := range data {
+				data[i] = int16(order.Uint16(bs[2*i:]))
+			}
+		case []uint16:
+			for i := range data {
+				data[i] = order.Uint16(bs[2*i:])
+			}
+		case []int32:
+			for i := range data {
+				data[i] = int32(order.Uint32(bs[4*i:]))
+			}
+		case []uint32:
+			for i := range data {
+				data[i] = order.Uint32(bs[4*i:])
+			}
+		case []int64:
+			for i := range data {
+				data[i] = int64(order.Uint64(bs[8*i:]))
+			}
+		case []uint64:
+			for i := range data {
+				data[i] = order.Uint64(bs[8*i:])
+			}
+		}
+		return nil
+	}
+
+	// Fallback to reflect-based decoding.
+	v := reflect.ValueOf(data)
+	size := -1
+	switch v.Kind() {
+	case reflect.Ptr:
+		v = v.Elem()
+		size = dataSize(v)
+	case reflect.Slice:
+		size = dataSize(v)
+	}
+	if size < 0 {
+		return errors.New("binary.Read: invalid type " + reflect.TypeOf(data).String())
+	}
+	d := &decoder{order: order, buf: make([]byte, size)}
+	if _, err := io.ReadFull(r, d.buf); err != nil {
+		return err
+	}
+	d.value(v)
+	return nil
+}
+
+// Write writes the binary representation of data into w.
+// Data must be a fixed-size value or a slice of fixed-size
+// values, or a pointer to such data.
+// Bytes written to w are encoded using the specified byte order
+// and read from successive fields of the data.
+// When writing structs, zero values are written for fields
+// with blank (_) field names.
+func Write(w io.Writer, order ByteOrder, data interface{}) error {
+	// Fast path for basic types and slices.
+	if n := intDataSize(data); n != 0 {
+		var b [8]byte
+		var bs []byte
+		if n > len(b) {
+			bs = make([]byte, n)
+		} else {
+			bs = b[:n]
+		}
+		switch v := data.(type) {
+		case *int8:
+			bs = b[:1]
+			b[0] = byte(*v)
+		case int8:
+			bs = b[:1]
+			b[0] = byte(v)
+		case []int8:
+			for i, x := range v {
+				bs[i] = byte(x)
+			}
+		case *uint8:
+			bs = b[:1]
+			b[0] = *v
+		case uint8:
+			bs = b[:1]
+			b[0] = byte(v)
+		case []uint8:
+			bs = v
+		case *int16:
+			bs = b[:2]
+			order.PutUint16(bs, uint16(*v))
+		case int16:
+			bs = b[:2]
+			order.PutUint16(bs, uint16(v))
+		case []int16:
+			for i, x := range v {
+				order.PutUint16(bs[2*i:], uint16(x))
+			}
+		case *uint16:
+			bs = b[:2]
+			order.PutUint16(bs, *v)
+		case uint16:
+			bs = b[:2]
+			order.PutUint16(bs, v)
+		case []uint16:
+			for i, x := range v {
+				order.PutUint16(bs[2*i:], x)
+			}
+		case *int32:
+			bs = b[:4]
+			order.PutUint32(bs, uint32(*v))
+		case int32:
+			bs = b[:4]
+			order.PutUint32(bs, uint32(v))
+		case []int32:
+			for i, x := range v {
+				order.PutUint32(bs[4*i:], uint32(x))
+			}
+		case *uint32:
+			bs = b[:4]
+			order.PutUint32(bs, *v)
+		case uint32:
+			bs = b[:4]
+			order.PutUint32(bs, v)
+		case []uint32:
+			for i, x := range v {
+				order.PutUint32(bs[4*i:], x)
+			}
+		case *int64:
+			bs = b[:8]
+			order.PutUint64(bs, uint64(*v))
+		case int64:
+			bs = b[:8]
+			order.PutUint64(bs, uint64(v))
+		case []int64:
+			for i, x := range v {
+				order.PutUint64(bs[8*i:], uint64(x))
+			}
+		case *uint64:
+			bs = b[:8]
+			order.PutUint64(bs, *v)
+		case uint64:
+			bs = b[:8]
+			order.PutUint64(bs, v)
+		case []uint64:
+			for i, x := range v {
+				order.PutUint64(bs[8*i:], x)
+			}
+		}
+		_, err := w.Write(bs)
+		return err
+	}
+
+	// Fallback to reflect-based encoding.
+	v := reflect.Indirect(reflect.ValueOf(data))
+	size := dataSize(v)
+	if size < 0 {
+		return errors.New("binary.Write: invalid type " + reflect.TypeOf(data).String())
+	}
+	buf := make([]byte, size)
+	e := &encoder{order: order, buf: buf}
+	e.value(v)
+	_, err := w.Write(buf)
+	return err
+}
+
+// Size returns how many bytes Write would generate to encode the value v, which
+// must be a fixed-size value or a slice of fixed-size values, or a pointer to such data.
+// If v is neither of these, Size returns -1.
+func Size(v interface{}) int {
+	return dataSize(reflect.Indirect(reflect.ValueOf(v)))
+}
+
+// dataSize returns the number of bytes the actual data represented by v occupies in memory.
+// For compound structures, it sums the sizes of the elements. Thus, for instance, for a slice
+// it returns the length of the slice times the element size and does not count the memory
+// occupied by the header. If the type of v is not acceptable, dataSize returns -1.
+func dataSize(v reflect.Value) int {
+	if v.Kind() == reflect.Slice {
+		if s := sizeof(v.Type().Elem()); s >= 0 {
+			return s * v.Len()
+		}
+		return -1
+	}
+	return sizeof(v.Type())
+}
+
+// sizeof returns the size >= 0 of variables for the given type or -1 if the type is not acceptable.
+func sizeof(t reflect.Type) int {
+	switch t.Kind() {
+	case reflect.Array:
+		if s := sizeof(t.Elem()); s >= 0 {
+			return s * t.Len()
+		}
+
+	case reflect.Struct:
+		sum := 0
+		for i, n := 0, t.NumField(); i < n; i++ {
+			s := sizeof(t.Field(i).Type)
+			if s < 0 {
+				return -1
+			}
+			sum += s
+		}
+		return sum
+
+	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
+		reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
+		reflect.Float32, reflect.Float64, reflect.Complex64, reflect.Complex128, reflect.Ptr:
+		return int(t.Size())
+	}
+
+	return -1
+}
+
+type coder struct {
+	order ByteOrder
+	buf   []byte
+}
+
+type decoder coder
+type encoder coder
+
+func (d *decoder) uint8() uint8 {
+	x := d.buf[0]
+	d.buf = d.buf[1:]
+	return x
+}
+
+func (e *encoder) uint8(x uint8) {
+	e.buf[0] = x
+	e.buf = e.buf[1:]
+}
+
+func (d *decoder) uint16() uint16 {
+	x := d.order.Uint16(d.buf[0:2])
+	d.buf = d.buf[2:]
+	return x
+}
+
+func (e *encoder) uint16(x uint16) {
+	e.order.PutUint16(e.buf[0:2], x)
+	e.buf = e.buf[2:]
+}
+
+func (d *decoder) uint32() uint32 {
+	x := d.order.Uint32(d.buf[0:4])
+	d.buf = d.buf[4:]
+	return x
+}
+
+func (e *encoder) uint32(x uint32) {
+	e.order.PutUint32(e.buf[0:4], x)
+	e.buf = e.buf[4:]
+}
+
+func (d *decoder) uint64() uint64 {
+	x := d.order.Uint64(d.buf[0:8])
+	d.buf = d.buf[8:]
+	return x
+}
+
+func (e *encoder) uint64(x uint64) {
+	e.order.PutUint64(e.buf[0:8], x)
+	e.buf = e.buf[8:]
+}
+
+func (d *decoder) int8() int8 { return int8(d.uint8()) }
+
+func (e *encoder) int8(x int8) { e.uint8(uint8(x)) }
+
+func (d *decoder) int16() int16 { return int16(d.uint16()) }
+
+func (e *encoder) int16(x int16) { e.uint16(uint16(x)) }
+
+func (d *decoder) int32() int32 { return int32(d.uint32()) }
+
+func (e *encoder) int32(x int32) { e.uint32(uint32(x)) }
+
+func (d *decoder) int64() int64 { return int64(d.uint64()) }
+
+func (e *encoder) int64(x int64) { e.uint64(uint64(x)) }
+
+func (d *decoder) value(v reflect.Value) {
+	switch v.Kind() {
+	case reflect.Array:
+		l := v.Len()
+		for i := 0; i < l; i++ {
+			d.value(v.Index(i))
+		}
+
+	case reflect.Struct:
+		t := v.Type()
+		l := v.NumField()
+		for i := 0; i < l; i++ {
+			// Note: Calling v.CanSet() below is an optimization.
+			// It would be sufficient to check the field name,
+			// but creating the StructField info for each field is
+			// costly (run "go test -bench=ReadStruct" and compare
+			// results when making changes to this code).
+			if v := v.Field(i); v.CanSet() || t.Field(i).Name != "_" {
+				d.value(v)
+			} else {
+				d.skip(v)
+			}
+		}
+
+	case reflect.Slice:
+		l := v.Len()
+		for i := 0; i < l; i++ {
+			d.value(v.Index(i))
+		}
+
+	case reflect.Int8:
+		v.SetInt(int64(d.int8()))
+	case reflect.Int16:
+		v.SetInt(int64(d.int16()))
+	case reflect.Int32:
+		v.SetInt(int64(d.int32()))
+	case reflect.Int64:
+		v.SetInt(d.int64())
+
+	case reflect.Uint8:
+		v.SetUint(uint64(d.uint8()))
+	case reflect.Uint16:
+		v.SetUint(uint64(d.uint16()))
+	case reflect.Uint32:
+		v.SetUint(uint64(d.uint32()))
+	case reflect.Uint64:
+		v.SetUint(d.uint64())
+
+	case reflect.Float32:
+		v.SetFloat(float64(math.Float32frombits(d.uint32())))
+	case reflect.Float64:
+		v.SetFloat(math.Float64frombits(d.uint64()))
+
+	case reflect.Complex64:
+		v.SetComplex(complex(
+			float64(math.Float32frombits(d.uint32())),
+			float64(math.Float32frombits(d.uint32())),
+		))
+	case reflect.Complex128:
+		v.SetComplex(complex(
+			math.Float64frombits(d.uint64()),
+			math.Float64frombits(d.uint64()),
+		))
+	}
+}
+
+func (e *encoder) value(v reflect.Value) {
+	switch v.Kind() {
+	case reflect.Array:
+		l := v.Len()
+		for i := 0; i < l; i++ {
+			e.value(v.Index(i))
+		}
+
+	case reflect.Struct:
+		t := v.Type()
+		l := v.NumField()
+		for i := 0; i < l; i++ {
+			// see comment for corresponding code in decoder.value()
+			if v := v.Field(i); v.CanSet() || t.Field(i).Name != "_" {
+				e.value(v)
+			} else {
+				e.skip(v)
+			}
+		}
+
+	case reflect.Slice:
+		l := v.Len()
+		for i := 0; i < l; i++ {
+			e.value(v.Index(i))
+		}
+
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		switch v.Type().Kind() {
+		case reflect.Int8:
+			e.int8(int8(v.Int()))
+		case reflect.Int16:
+			e.int16(int16(v.Int()))
+		case reflect.Int32:
+			e.int32(int32(v.Int()))
+		case reflect.Int64:
+			e.int64(v.Int())
+		}
+
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		switch v.Type().Kind() {
+		case reflect.Uint8:
+			e.uint8(uint8(v.Uint()))
+		case reflect.Uint16:
+			e.uint16(uint16(v.Uint()))
+		case reflect.Uint32:
+			e.uint32(uint32(v.Uint()))
+		case reflect.Uint64:
+			e.uint64(v.Uint())
+		}
+
+	case reflect.Float32, reflect.Float64:
+		switch v.Type().Kind() {
+		case reflect.Float32:
+			e.uint32(math.Float32bits(float32(v.Float())))
+		case reflect.Float64:
+			e.uint64(math.Float64bits(v.Float()))
+		}
+
+	case reflect.Complex64, reflect.Complex128:
+		switch v.Type().Kind() {
+		case reflect.Complex64:
+			x := v.Complex()
+			e.uint32(math.Float32bits(float32(real(x))))
+			e.uint32(math.Float32bits(float32(imag(x))))
+		case reflect.Complex128:
+			x := v.Complex()
+			e.uint64(math.Float64bits(real(x)))
+			e.uint64(math.Float64bits(imag(x)))
+		}
+	}
+}
+
+func (d *decoder) skip(v reflect.Value) {
+	d.buf = d.buf[dataSize(v):]
+}
+
+func (e *encoder) skip(v reflect.Value) {
+	n := dataSize(v)
+	for i := range e.buf[0:n] {
+		e.buf[i] = 0
+	}
+	e.buf = e.buf[n:]
+}
+
+// intDataSize returns the size of the data required to represent the data when encoded.
+// It returns zero if the type cannot be implemented by the fast path in Read or Write.
+func intDataSize(data interface{}) int {
+	switch data := data.(type) {
+	case int8, *int8, *uint8:
+		return 1
+	case []int8:
+		return len(data)
+	case []uint8:
+		return len(data)
+	case int16, *int16, *uint16:
+		return 2
+	case []int16:
+		return 2 * len(data)
+	case []uint16:
+		return 2 * len(data)
+	case int32, *int32, *uint32:
+		return 4
+	case []int32:
+		return 4 * len(data)
+	case []uint32:
+		return 4 * len(data)
+	case int64, *int64, *uint64:
+		return 8
+	case []int64:
+		return 8 * len(data)
+	case []uint64:
+		return 8 * len(data)
+	}
+	return 0
+}

vendor/github.com/shirou/gopsutil/internal/common/common.go

@@ -0,0 +1,392 @@
+package common
+
+//
+// gopsutil is a port of psutil(http://pythonhosted.org/psutil/).
+// This covers these architectures.
+//  - linux (amd64, arm)
+//  - freebsd (amd64)
+//  - windows (amd64)
+import (
+	"bufio"
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"io/ioutil"
+	"net/url"
+	"os"
+	"os/exec"
+	"path"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strconv"
+	"strings"
+	"time"
+)
+
+var (
+	Timeout    = 3 * time.Second
+	ErrTimeout = errors.New("command timed out")
+)
+
+type Invoker interface {
+	Command(string, ...string) ([]byte, error)
+	CommandWithContext(context.Context, string, ...string) ([]byte, error)
+}
+
+type Invoke struct{}
+
+func (i Invoke) Command(name string, arg ...string) ([]byte, error) {
+	ctx, cancel := context.WithTimeout(context.Background(), Timeout)
+	defer cancel()
+	return i.CommandWithContext(ctx, name, arg...)
+}
+
+func (i Invoke) CommandWithContext(ctx context.Context, name string, arg ...string) ([]byte, error) {
+	cmd := exec.CommandContext(ctx, name, arg...)
+
+	var buf bytes.Buffer
+	cmd.Stdout = &buf
+	cmd.Stderr = &buf
+
+	if err := cmd.Start(); err != nil {
+		return buf.Bytes(), err
+	}
+
+	if err := cmd.Wait(); err != nil {
+		return buf.Bytes(), err
+	}
+
+	return buf.Bytes(), nil
+}
+
+type FakeInvoke struct {
+	Suffix string // Suffix species expected file name suffix such as "fail"
+	Error  error  // If Error specfied, return the error.
+}
+
+// Command in FakeInvoke returns from expected file if exists.
+func (i FakeInvoke) Command(name string, arg ...string) ([]byte, error) {
+	if i.Error != nil {
+		return []byte{}, i.Error
+	}
+
+	arch := runtime.GOOS
+
+	commandName := filepath.Base(name)
+
+	fname := strings.Join(append([]string{commandName}, arg...), "")
+	fname = url.QueryEscape(fname)
+	fpath := path.Join("testdata", arch, fname)
+	if i.Suffix != "" {
+		fpath += "_" + i.Suffix
+	}
+	if PathExists(fpath) {
+		return ioutil.ReadFile(fpath)
+	}
+	return []byte{}, fmt.Errorf("could not find testdata: %s", fpath)
+}
+
+func (i FakeInvoke) CommandWithContext(ctx context.Context, name string, arg ...string) ([]byte, error) {
+	return i.Command(name, arg...)
+}
+
+var ErrNotImplementedError = errors.New("not implemented yet")
+
+// ReadLines reads contents from a file and splits them by new lines.
+// A convenience wrapper to ReadLinesOffsetN(filename, 0, -1).
+func ReadLines(filename string) ([]string, error) {
+	return ReadLinesOffsetN(filename, 0, -1)
+}
+
+// ReadLines reads contents from file and splits them by new line.
+// The offset tells at which line number to start.
+// The count determines the number of lines to read (starting from offset):
+//   n >= 0: at most n lines
+//   n < 0: whole file
+func ReadLinesOffsetN(filename string, offset uint, n int) ([]string, error) {
+	f, err := os.Open(filename)
+	if err != nil {
+		return []string{""}, err
+	}
+	defer f.Close()
+
+	var ret []string
+
+	r := bufio.NewReader(f)
+	for i := 0; i < n+int(offset) || n < 0; i++ {
+		line, err := r.ReadString('\n')
+		if err != nil {
+			break
+		}
+		if i < int(offset) {
+			continue
+		}
+		ret = append(ret, strings.Trim(line, "\n"))
+	}
+
+	return ret, nil
+}
+
+func IntToString(orig []int8) string {
+	ret := make([]byte, len(orig))
+	size := -1
+	for i, o := range orig {
+		if o == 0 {
+			size = i
+			break
+		}
+		ret[i] = byte(o)
+	}
+	if size == -1 {
+		size = len(orig)
+	}
+
+	return string(ret[0:size])
+}
+
+func UintToString(orig []uint8) string {
+	ret := make([]byte, len(orig))
+	size := -1
+	for i, o := range orig {
+		if o == 0 {
+			size = i
+			break
+		}
+		ret[i] = byte(o)
+	}
+	if size == -1 {
+		size = len(orig)
+	}
+
+	return string(ret[0:size])
+}
+
+func ByteToString(orig []byte) string {
+	n := -1
+	l := -1
+	for i, b := range orig {
+		// skip left side null
+		if l == -1 && b == 0 {
+			continue
+		}
+		if l == -1 {
+			l = i
+		}
+
+		if b == 0 {
+			break
+		}
+		n = i + 1
+	}
+	if n == -1 {
+		return string(orig)
+	}
+	return string(orig[l:n])
+}
+
+// ReadInts reads contents from single line file and returns them as []int32.
+func ReadInts(filename string) ([]int64, error) {
+	f, err := os.Open(filename)
+	if err != nil {
+		return []int64{}, err
+	}
+	defer f.Close()
+
+	var ret []int64
+
+	r := bufio.NewReader(f)
+
+	// The int files that this is concerned with should only be one liners.
+	line, err := r.ReadString('\n')
+	if err != nil {
+		return []int64{}, err
+	}
+
+	i, err := strconv.ParseInt(strings.Trim(line, "\n"), 10, 32)
+	if err != nil {
+		return []int64{}, err
+	}
+	ret = append(ret, i)
+
+	return ret, nil
+}
+
+// Parse to int32 without error
+func mustParseInt32(val string) int32 {
+	vv, _ := strconv.ParseInt(val, 10, 32)
+	return int32(vv)
+}
+
+// Parse to uint64 without error
+func mustParseUint64(val string) uint64 {
+	vv, _ := strconv.ParseInt(val, 10, 64)
+	return uint64(vv)
+}
+
+// Parse to Float64 without error
+func mustParseFloat64(val string) float64 {
+	vv, _ := strconv.ParseFloat(val, 64)
+	return vv
+}
+
+// StringsHas checks the target string slice contains src or not
+func StringsHas(target []string, src string) bool {
+	for _, t := range target {
+		if strings.TrimSpace(t) == src {
+			return true
+		}
+	}
+	return false
+}
+
+// StringsContains checks the src in any string of the target string slice
+func StringsContains(target []string, src string) bool {
+	for _, t := range target {
+		if strings.Contains(t, src) {
+			return true
+		}
+	}
+	return false
+}
+
+// IntContains checks the src in any int of the target int slice.
+func IntContains(target []int, src int) bool {
+	for _, t := range target {
+		if src == t {
+			return true
+		}
+	}
+	return false
+}
+
+// get struct attributes.
+// This method is used only for debugging platform dependent code.
+func attributes(m interface{}) map[string]reflect.Type {
+	typ := reflect.TypeOf(m)
+	if typ.Kind() == reflect.Ptr {
+		typ = typ.Elem()
+	}
+
+	attrs := make(map[string]reflect.Type)
+	if typ.Kind() != reflect.Struct {
+		return nil
+	}
+
+	for i := 0; i < typ.NumField(); i++ {
+		p := typ.Field(i)
+		if !p.Anonymous {
+			attrs[p.Name] = p.Type
+		}
+	}
+
+	return attrs
+}
+
+func PathExists(filename string) bool {
+	if _, err := os.Stat(filename); err == nil {
+		return true
+	}
+	return false
+}
+
+//GetEnv retrieves the environment variable key. If it does not exist it returns the default.
+func GetEnv(key string, dfault string, combineWith ...string) string {
+	value := os.Getenv(key)
+	if value == "" {
+		value = dfault
+	}
+
+	switch len(combineWith) {
+	case 0:
+		return value
+	case 1:
+		return filepath.Join(value, combineWith[0])
+	default:
+		all := make([]string, len(combineWith)+1)
+		all[0] = value
+		copy(all[1:], combineWith)
+		return filepath.Join(all...)
+	}
+	panic("invalid switch case")
+}
+
+func HostProc(combineWith ...string) string {
+	return GetEnv("HOST_PROC", "/proc", combineWith...)
+}
+
+func HostSys(combineWith ...string) string {
+	return GetEnv("HOST_SYS", "/sys", combineWith...)
+}
+
+func HostEtc(combineWith ...string) string {
+	return GetEnv("HOST_ETC", "/etc", combineWith...)
+}
+
+func HostVar(combineWith ...string) string {
+	return GetEnv("HOST_VAR", "/var", combineWith...)
+}
+
+func HostRun(combineWith ...string) string {
+	return GetEnv("HOST_RUN", "/run", combineWith...)
+}
+
+// https://gist.github.com/kylelemons/1525278
+func Pipeline(cmds ...*exec.Cmd) ([]byte, []byte, error) {
+	// Require at least one command
+	if len(cmds) < 1 {
+		return nil, nil, nil
+	}
+
+	// Collect the output from the command(s)
+	var output bytes.Buffer
+	var stderr bytes.Buffer
+
+	last := len(cmds) - 1
+	for i, cmd := range cmds[:last] {
+		var err error
+		// Connect each command's stdin to the previous command's stdout
+		if cmds[i+1].Stdin, err = cmd.StdoutPipe(); err != nil {
+			return nil, nil, err
+		}
+		// Connect each command's stderr to a buffer
+		cmd.Stderr = &stderr
+	}
+
+	// Connect the output and error for the last command
+	cmds[last].Stdout, cmds[last].Stderr = &output, &stderr
+
+	// Start each command
+	for _, cmd := range cmds {
+		if err := cmd.Start(); err != nil {
+			return output.Bytes(), stderr.Bytes(), err
+		}
+	}
+
+	// Wait for each command to complete
+	for _, cmd := range cmds {
+		if err := cmd.Wait(); err != nil {
+			return output.Bytes(), stderr.Bytes(), err
+		}
+	}
+
+	// Return the pipeline output and the collected standard error
+	return output.Bytes(), stderr.Bytes(), nil
+}
+
+// getSysctrlEnv sets LC_ALL=C in a list of env vars for use when running
+// sysctl commands (see DoSysctrl).
+func getSysctrlEnv(env []string) []string {
+	foundLC := false
+	for i, line := range env {
+		if strings.HasPrefix(line, "LC_ALL") {
+			env[i] = "LC_ALL=C"
+			foundLC = true
+		}
+	}
+	if !foundLC {
+		env = append(env, "LC_ALL=C")
+	}
+	return env
+}

vendor/github.com/shirou/gopsutil/internal/common/common_darwin.go

@@ -0,0 +1,69 @@
+// +build darwin
+
+package common
+
+import (
+	"context"
+	"os"
+	"os/exec"
+	"strings"
+	"unsafe"
+
+	"golang.org/x/sys/unix"
+)
+
+func DoSysctrlWithContext(ctx context.Context, mib string) ([]string, error) {
+	sysctl, err := exec.LookPath("/usr/sbin/sysctl")
+	if err != nil {
+		return []string{}, err
+	}
+	cmd := exec.CommandContext(ctx, sysctl, "-n", mib)
+	cmd.Env = getSysctrlEnv(os.Environ())
+	out, err := cmd.Output()
+	if err != nil {
+		return []string{}, err
+	}
+	v := strings.Replace(string(out), "{ ", "", 1)
+	v = strings.Replace(string(v), " }", "", 1)
+	values := strings.Fields(string(v))
+
+	return values, nil
+}
+
+func CallSyscall(mib []int32) ([]byte, uint64, error) {
+	miblen := uint64(len(mib))
+
+	// get required buffer size
+	length := uint64(0)
+	_, _, err := unix.Syscall6(
+		unix.SYS___SYSCTL,
+		uintptr(unsafe.Pointer(&mib[0])),
+		uintptr(miblen),
+		0,
+		uintptr(unsafe.Pointer(&length)),
+		0,
+		0)
+	if err != 0 {
+		var b []byte
+		return b, length, err
+	}
+	if length == 0 {
+		var b []byte
+		return b, length, err
+	}
+	// get proc info itself
+	buf := make([]byte, length)
+	_, _, err = unix.Syscall6(
+		unix.SYS___SYSCTL,
+		uintptr(unsafe.Pointer(&mib[0])),
+		uintptr(miblen),
+		uintptr(unsafe.Pointer(&buf[0])),
+		uintptr(unsafe.Pointer(&length)),
+		0,
+		0)
+	if err != 0 {
+		return buf, length, err
+	}
+
+	return buf, length, nil
+}

vendor/github.com/shirou/gopsutil/internal/common/common_freebsd.go

@@ -0,0 +1,69 @@
+// +build freebsd openbsd
+
+package common
+
+import (
+	"os"
+	"os/exec"
+	"strings"
+	"unsafe"
+
+	"golang.org/x/sys/unix"
+)
+
+func DoSysctrl(mib string) ([]string, error) {
+	sysctl, err := exec.LookPath("/sbin/sysctl")
+	if err != nil {
+		return []string{}, err
+	}
+	cmd := exec.Command(sysctl, "-n", mib)
+	cmd.Env = getSysctrlEnv(os.Environ())
+	out, err := cmd.Output()
+	if err != nil {
+		return []string{}, err
+	}
+	v := strings.Replace(string(out), "{ ", "", 1)
+	v = strings.Replace(string(v), " }", "", 1)
+	values := strings.Fields(string(v))
+
+	return values, nil
+}
+
+func CallSyscall(mib []int32) ([]byte, uint64, error) {
+	mibptr := unsafe.Pointer(&mib[0])
+	miblen := uint64(len(mib))
+
+	// get required buffer size
+	length := uint64(0)
+	_, _, err := unix.Syscall6(
+		unix.SYS___SYSCTL,
+		uintptr(mibptr),
+		uintptr(miblen),
+		0,
+		uintptr(unsafe.Pointer(&length)),
+		0,
+		0)
+	if err != 0 {
+		var b []byte
+		return b, length, err
+	}
+	if length == 0 {
+		var b []byte
+		return b, length, err
+	}
+	// get proc info itself
+	buf := make([]byte, length)
+	_, _, err = unix.Syscall6(
+		unix.SYS___SYSCTL,
+		uintptr(mibptr),
+		uintptr(miblen),
+		uintptr(unsafe.Pointer(&buf[0])),
+		uintptr(unsafe.Pointer(&length)),
+		0,
+		0)
+	if err != 0 {
+		return buf, length, err
+	}
+
+	return buf, length, nil
+}

vendor/github.com/shirou/gopsutil/internal/common/common_linux.go

@@ -0,0 +1,41 @@
+// +build linux
+
+package common
+
+import (
+	"os"
+	"os/exec"
+	"strings"
+)
+
+func DoSysctrl(mib string) ([]string, error) {
+	sysctl, err := exec.LookPath("/sbin/sysctl")
+	if err != nil {
+		return []string{}, err
+	}
+	cmd := exec.Command(sysctl, "-n", mib)
+	cmd.Env = getSysctrlEnv(os.Environ())
+	out, err := cmd.Output()
+	if err != nil {
+		return []string{}, err
+	}
+	v := strings.Replace(string(out), "{ ", "", 1)
+	v = strings.Replace(string(v), " }", "", 1)
+	values := strings.Fields(string(v))
+
+	return values, nil
+}
+
+func NumProcs() (uint64, error) {
+	f, err := os.Open(HostProc())
+	if err != nil {
+		return 0, err
+	}
+	defer f.Close()
+
+	list, err := f.Readdirnames(-1)
+	if err != nil {
+		return 0, err
+	}
+	return uint64(len(list)), err
+}

vendor/github.com/shirou/gopsutil/internal/common/common_openbsd.go

@@ -0,0 +1,69 @@
+// +build openbsd
+
+package common
+
+import (
+	"os"
+	"os/exec"
+	"strings"
+	"unsafe"
+
+	"golang.org/x/sys/unix"
+)
+
+func DoSysctrl(mib string) ([]string, error) {
+	sysctl, err := exec.LookPath("/sbin/sysctl")
+	if err != nil {
+		return []string{}, err
+	}
+	cmd := exec.Command(sysctl, "-n", mib)
+	cmd.Env = getSysctrlEnv(os.Environ())
+	out, err := cmd.Output()
+	if err != nil {
+		return []string{}, err
+	}
+	v := strings.Replace(string(out), "{ ", "", 1)
+	v = strings.Replace(string(v), " }", "", 1)
+	values := strings.Fields(string(v))
+
+	return values, nil
+}
+
+func CallSyscall(mib []int32) ([]byte, uint64, error) {
+	mibptr := unsafe.Pointer(&mib[0])
+	miblen := uint64(len(mib))
+
+	// get required buffer size
+	length := uint64(0)
+	_, _, err := unix.Syscall6(
+		unix.SYS___SYSCTL,
+		uintptr(mibptr),
+		uintptr(miblen),
+		0,
+		uintptr(unsafe.Pointer(&length)),
+		0,
+		0)
+	if err != 0 {
+		var b []byte
+		return b, length, err
+	}
+	if length == 0 {
+		var b []byte
+		return b, length, err
+	}
+	// get proc info itself
+	buf := make([]byte, length)
+	_, _, err = unix.Syscall6(
+		unix.SYS___SYSCTL,
+		uintptr(mibptr),
+		uintptr(miblen),
+		uintptr(unsafe.Pointer(&buf[0])),
+		uintptr(unsafe.Pointer(&length)),
+		0,
+		0)
+	if err != 0 {
+		return buf, length, err
+	}
+
+	return buf, length, nil
+}

vendor/github.com/shirou/gopsutil/internal/common/common_unix.go

@@ -0,0 +1,67 @@
+// +build linux freebsd darwin openbsd
+
+package common
+
+import (
+	"context"
+	"os/exec"
+	"strconv"
+	"strings"
+)
+
+func CallLsofWithContext(ctx context.Context, invoke Invoker, pid int32, args ...string) ([]string, error) {
+	var cmd []string
+	if pid == 0 { // will get from all processes.
+		cmd = []string{"-a", "-n", "-P"}
+	} else {
+		cmd = []string{"-a", "-n", "-P", "-p", strconv.Itoa(int(pid))}
+	}
+	cmd = append(cmd, args...)
+	lsof, err := exec.LookPath("lsof")
+	if err != nil {
+		return []string{}, err
+	}
+	out, err := invoke.CommandWithContext(ctx, lsof, cmd...)
+	if err != nil {
+		// if no pid found, lsof returnes code 1.
+		if err.Error() == "exit status 1" && len(out) == 0 {
+			return []string{}, nil
+		}
+	}
+	lines := strings.Split(string(out), "\n")
+
+	var ret []string
+	for _, l := range lines[1:] {
+		if len(l) == 0 {
+			continue
+		}
+		ret = append(ret, l)
+	}
+	return ret, nil
+}
+
+func CallPgrepWithContext(ctx context.Context, invoke Invoker, pid int32) ([]int32, error) {
+	var cmd []string
+	cmd = []string{"-P", strconv.Itoa(int(pid))}
+	pgrep, err := exec.LookPath("pgrep")
+	if err != nil {
+		return []int32{}, err
+	}
+	out, err := invoke.CommandWithContext(ctx, pgrep, cmd...)
+	if err != nil {
+		return []int32{}, err
+	}
+	lines := strings.Split(string(out), "\n")
+	ret := make([]int32, 0, len(lines))
+	for _, l := range lines {
+		if len(l) == 0 {
+			continue
+		}
+		i, err := strconv.Atoi(l)
+		if err != nil {
+			continue
+		}
+		ret = append(ret, int32(i))
+	}
+	return ret, nil
+}

vendor/github.com/shirou/gopsutil/internal/common/common_windows.go

@@ -0,0 +1,135 @@
+// +build windows
+
+package common
+
+import (
+	"context"
+	"unsafe"
+
+	"github.com/StackExchange/wmi"
+	"golang.org/x/sys/windows"
+)
+
+// for double values
+type PDH_FMT_COUNTERVALUE_DOUBLE struct {
+	CStatus     uint32
+	DoubleValue float64
+}
+
+// for 64 bit integer values
+type PDH_FMT_COUNTERVALUE_LARGE struct {
+	CStatus    uint32
+	LargeValue int64
+}
+
+// for long values
+type PDH_FMT_COUNTERVALUE_LONG struct {
+	CStatus   uint32
+	LongValue int32
+	padding   [4]byte
+}
+
+// windows system const
+const (
+	ERROR_SUCCESS        = 0
+	ERROR_FILE_NOT_FOUND = 2
+	DRIVE_REMOVABLE      = 2
+	DRIVE_FIXED          = 3
+	HKEY_LOCAL_MACHINE   = 0x80000002
+	RRF_RT_REG_SZ        = 0x00000002
+	RRF_RT_REG_DWORD     = 0x00000010
+	PDH_FMT_LONG         = 0x00000100
+	PDH_FMT_DOUBLE       = 0x00000200
+	PDH_FMT_LARGE        = 0x00000400
+	PDH_INVALID_DATA     = 0xc0000bc6
+	PDH_INVALID_HANDLE   = 0xC0000bbc
+	PDH_NO_DATA          = 0x800007d5
+)
+
+var (
+	Modkernel32 = windows.NewLazyDLL("kernel32.dll")
+	ModNt       = windows.NewLazyDLL("ntdll.dll")
+	ModPdh      = windows.NewLazyDLL("pdh.dll")
+	ModPsapi    = windows.NewLazyDLL("psapi.dll")
+
+	ProcGetSystemTimes           = Modkernel32.NewProc("GetSystemTimes")
+	ProcNtQuerySystemInformation = ModNt.NewProc("NtQuerySystemInformation")
+	PdhOpenQuery                 = ModPdh.NewProc("PdhOpenQuery")
+	PdhAddCounter                = ModPdh.NewProc("PdhAddCounterW")
+	PdhCollectQueryData          = ModPdh.NewProc("PdhCollectQueryData")
+	PdhGetFormattedCounterValue  = ModPdh.NewProc("PdhGetFormattedCounterValue")
+	PdhCloseQuery                = ModPdh.NewProc("PdhCloseQuery")
+)
+
+type FILETIME struct {
+	DwLowDateTime  uint32
+	DwHighDateTime uint32
+}
+
+// borrowed from net/interface_windows.go
+func BytePtrToString(p *uint8) string {
+	a := (*[10000]uint8)(unsafe.Pointer(p))
+	i := 0
+	for a[i] != 0 {
+		i++
+	}
+	return string(a[:i])
+}
+
+// CounterInfo
+// copied from https://github.com/mackerelio/mackerel-agent/
+type CounterInfo struct {
+	PostName    string
+	CounterName string
+	Counter     windows.Handle
+}
+
+// CreateQuery XXX
+// copied from https://github.com/mackerelio/mackerel-agent/
+func CreateQuery() (windows.Handle, error) {
+	var query windows.Handle
+	r, _, err := PdhOpenQuery.Call(0, 0, uintptr(unsafe.Pointer(&query)))
+	if r != 0 {
+		return 0, err
+	}
+	return query, nil
+}
+
+// CreateCounter XXX
+func CreateCounter(query windows.Handle, pname, cname string) (*CounterInfo, error) {
+	var counter windows.Handle
+	r, _, err := PdhAddCounter.Call(
+		uintptr(query),
+		uintptr(unsafe.Pointer(windows.StringToUTF16Ptr(cname))),
+		0,
+		uintptr(unsafe.Pointer(&counter)))
+	if r != 0 {
+		return nil, err
+	}
+	return &CounterInfo{
+		PostName:    pname,
+		CounterName: cname,
+		Counter:     counter,
+	}, nil
+}
+
+// WMIQueryWithContext - wraps wmi.Query with a timed-out context to avoid hanging
+func WMIQueryWithContext(ctx context.Context, query string, dst interface{}, connectServerArgs ...interface{}) error {
+	if _, ok := ctx.Deadline(); !ok {
+		ctxTimeout, cancel := context.WithTimeout(ctx, Timeout)
+		defer cancel()
+		ctx = ctxTimeout
+	}
+
+	errChan := make(chan error, 1)
+	go func() {
+		errChan <- wmi.Query(query, dst, connectServerArgs...)
+	}()
+
+	select {
+	case <-ctx.Done():
+		return ctx.Err()
+	case err := <-errChan:
+		return err
+	}
+}

vendor/github.com/shirou/gopsutil/mem/BUILD.bazel

@@ -0,0 +1,53 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "mem.go",
+        "mem_darwin.go",
+        "mem_darwin_cgo.go",
+        "mem_darwin_nocgo.go",
+        "mem_fallback.go",
+        "mem_freebsd.go",
+        "mem_linux.go",
+        "mem_openbsd.go",
+        "mem_openbsd_amd64.go",
+        "mem_solaris.go",
+        "mem_windows.go",
+    ],
+    cgo = True,
+    importmap = "go-common/vendor/github.com/shirou/gopsutil/mem",
+    importpath = "github.com/shirou/gopsutil/mem",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//vendor/github.com/shirou/gopsutil/internal/common:go_default_library",
+    ] + select({
+        "@io_bazel_rules_go//go/platform:darwin": [
+            "//vendor/golang.org/x/sys/unix:go_default_library",
+        ],
+        "@io_bazel_rules_go//go/platform:freebsd": [
+            "//vendor/golang.org/x/sys/unix:go_default_library",
+        ],
+        "@io_bazel_rules_go//go/platform:linux": [
+            "//vendor/golang.org/x/sys/unix:go_default_library",
+        ],
+        "@io_bazel_rules_go//go/platform:windows": [
+            "//vendor/golang.org/x/sys/windows:go_default_library",
+        ],
+        "//conditions:default": [],
+    }),
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

vendor/github.com/shirou/gopsutil/mem/mem.go

@@ -0,0 +1,92 @@
+package mem
+
+import (
+	"encoding/json"
+
+	"github.com/shirou/gopsutil/internal/common"
+)
+
+var invoke common.Invoker = common.Invoke{}
+
+// Memory usage statistics. Total, Available and Used contain numbers of bytes
+// for human consumption.
+//
+// The other fields in this struct contain kernel specific values.
+type VirtualMemoryStat struct {
+	// Total amount of RAM on this system
+	Total uint64 `json:"total"`
+
+	// RAM available for programs to allocate
+	//
+	// This value is computed from the kernel specific values.
+	Available uint64 `json:"available"`
+
+	// RAM used by programs
+	//
+	// This value is computed from the kernel specific values.
+	Used uint64 `json:"used"`
+
+	// Percentage of RAM used by programs
+	//
+	// This value is computed from the kernel specific values.
+	UsedPercent float64 `json:"usedPercent"`
+
+	// This is the kernel's notion of free memory; RAM chips whose bits nobody
+	// cares about the value of right now. For a human consumable number,
+	// Available is what you really want.
+	Free uint64 `json:"free"`
+
+	// OS X / BSD specific numbers:
+	// http://www.macyourself.com/2010/02/17/what-is-free-wired-active-and-inactive-system-memory-ram/
+	Active   uint64 `json:"active"`
+	Inactive uint64 `json:"inactive"`
+	Wired    uint64 `json:"wired"`
+
+	// Linux specific numbers
+	// https://www.centos.org/docs/5/html/5.1/Deployment_Guide/s2-proc-meminfo.html
+	// https://www.kernel.org/doc/Documentation/filesystems/proc.txt
+	// https://www.kernel.org/doc/Documentation/vm/overcommit-accounting
+	Buffers        uint64 `json:"buffers"`
+	Cached         uint64 `json:"cached"`
+	Writeback      uint64 `json:"writeback"`
+	Dirty          uint64 `json:"dirty"`
+	WritebackTmp   uint64 `json:"writebacktmp"`
+	Shared         uint64 `json:"shared"`
+	Slab           uint64 `json:"slab"`
+	PageTables     uint64 `json:"pagetables"`
+	SwapCached     uint64 `json:"swapcached"`
+	CommitLimit    uint64 `json:"commitlimit"`
+	CommittedAS    uint64 `json:"committedas"`
+	HighTotal      uint64 `json:"hightotal"`
+	HighFree       uint64 `json:"highfree"`
+	LowTotal       uint64 `json:"lowtotal"`
+	LowFree        uint64 `json:"lowfree"`
+	SwapTotal      uint64 `json:"swaptotal"`
+	SwapFree       uint64 `json:"swapfree"`
+	Mapped         uint64 `json:"mapped"`
+	VMallocTotal   uint64 `json:"vmalloctotal"`
+	VMallocUsed    uint64 `json:"vmallocused"`
+	VMallocChunk   uint64 `json:"vmallocchunk"`
+	HugePagesTotal uint64 `json:"hugepagestotal"`
+	HugePagesFree  uint64 `json:"hugepagesfree"`
+	HugePageSize   uint64 `json:"hugepagesize"`
+}
+
+type SwapMemoryStat struct {
+	Total       uint64  `json:"total"`
+	Used        uint64  `json:"used"`
+	Free        uint64  `json:"free"`
+	UsedPercent float64 `json:"usedPercent"`
+	Sin         uint64  `json:"sin"`
+	Sout        uint64  `json:"sout"`
+}
+
+func (m VirtualMemoryStat) String() string {
+	s, _ := json.Marshal(m)
+	return string(s)
+}
+
+func (m SwapMemoryStat) String() string {
+	s, _ := json.Marshal(m)
+	return string(s)
+}

vendor/github.com/shirou/gopsutil/mem/mem_darwin.go

@@ -0,0 +1,74 @@
+// +build darwin
+
+package mem
+
+import (
+	"context"
+	"encoding/binary"
+	"strconv"
+	"strings"
+
+	"github.com/shirou/gopsutil/internal/common"
+	"golang.org/x/sys/unix"
+)
+
+func getHwMemsize() (uint64, error) {
+	totalString, err := unix.Sysctl("hw.memsize")
+	if err != nil {
+		return 0, err
+	}
+
+	// unix.sysctl() helpfully assumes the result is a null-terminated string and
+	// removes the last byte of the result if it's 0 :/
+	totalString += "\x00"
+
+	total := uint64(binary.LittleEndian.Uint64([]byte(totalString)))
+
+	return total, nil
+}
+
+// SwapMemory returns swapinfo.
+func SwapMemory() (*SwapMemoryStat, error) {
+	return SwapMemoryWithContext(context.Background())
+}
+
+func SwapMemoryWithContext(ctx context.Context) (*SwapMemoryStat, error) {
+	var ret *SwapMemoryStat
+
+	swapUsage, err := common.DoSysctrlWithContext(ctx, "vm.swapusage")
+	if err != nil {
+		return ret, err
+	}
+
+	total := strings.Replace(swapUsage[2], "M", "", 1)
+	used := strings.Replace(swapUsage[5], "M", "", 1)
+	free := strings.Replace(swapUsage[8], "M", "", 1)
+
+	total_v, err := strconv.ParseFloat(total, 64)
+	if err != nil {
+		return nil, err
+	}
+	used_v, err := strconv.ParseFloat(used, 64)
+	if err != nil {
+		return nil, err
+	}
+	free_v, err := strconv.ParseFloat(free, 64)
+	if err != nil {
+		return nil, err
+	}
+
+	u := float64(0)
+	if total_v != 0 {
+		u = ((total_v - free_v) / total_v) * 100.0
+	}
+
+	// vm.swapusage shows "M", multiply 1024 * 1024 to convert bytes.
+	ret = &SwapMemoryStat{
+		Total:       uint64(total_v * 1024 * 1024),
+		Used:        uint64(used_v * 1024 * 1024),
+		Free:        uint64(free_v * 1024 * 1024),
+		UsedPercent: u,
+	}
+
+	return ret, nil
+}

vendor/github.com/shirou/gopsutil/mem/mem_darwin_cgo.go

@@ -0,0 +1,59 @@
+// +build darwin
+// +build cgo
+
+package mem
+
+/*
+#include <mach/mach_host.h>
+*/
+import "C"
+
+import (
+	"context"
+	"fmt"
+	"unsafe"
+
+	"golang.org/x/sys/unix"
+)
+
+// VirtualMemory returns VirtualmemoryStat.
+func VirtualMemory() (*VirtualMemoryStat, error) {
+	return VirtualMemoryWithContext(context.Background())
+}
+
+func VirtualMemoryWithContext(ctx context.Context) (*VirtualMemoryStat, error) {
+	count := C.mach_msg_type_number_t(C.HOST_VM_INFO_COUNT)
+	var vmstat C.vm_statistics_data_t
+
+	status := C.host_statistics(C.host_t(C.mach_host_self()),
+		C.HOST_VM_INFO,
+		C.host_info_t(unsafe.Pointer(&vmstat)),
+		&count)
+
+	if status != C.KERN_SUCCESS {
+		return nil, fmt.Errorf("host_statistics error=%d", status)
+	}
+
+	pageSize := uint64(unix.Getpagesize())
+	total, err := getHwMemsize()
+	if err != nil {
+		return nil, err
+	}
+	totalCount := C.natural_t(total / pageSize)
+
+	availableCount := vmstat.inactive_count + vmstat.free_count
+	usedPercent := 100 * float64(totalCount-availableCount) / float64(totalCount)
+
+	usedCount := totalCount - availableCount
+
+	return &VirtualMemoryStat{
+		Total:       total,
+		Available:   pageSize * uint64(availableCount),
+		Used:        pageSize * uint64(usedCount),
+		UsedPercent: usedPercent,
+		Free:        pageSize * uint64(vmstat.free_count),
+		Active:      pageSize * uint64(vmstat.active_count),
+		Inactive:    pageSize * uint64(vmstat.inactive_count),
+		Wired:       pageSize * uint64(vmstat.wire_count),
+	}, nil
+}

vendor/github.com/shirou/gopsutil/mem/mem_darwin_nocgo.go

@@ -0,0 +1,94 @@
+// +build darwin
+// +build !cgo
+
+package mem
+
+import (
+	"context"
+	"os/exec"
+	"strconv"
+	"strings"
+
+	"golang.org/x/sys/unix"
+)
+
+// Runs vm_stat and returns Free and inactive pages
+func getVMStat(vms *VirtualMemoryStat) error {
+	vm_stat, err := exec.LookPath("vm_stat")
+	if err != nil {
+		return err
+	}
+	out, err := invoke.Command(vm_stat)
+	if err != nil {
+		return err
+	}
+	return parseVMStat(string(out), vms)
+}
+
+func parseVMStat(out string, vms *VirtualMemoryStat) error {
+	var err error
+
+	lines := strings.Split(out, "\n")
+	pagesize := uint64(unix.Getpagesize())
+	for _, line := range lines {
+		fields := strings.Split(line, ":")
+		if len(fields) < 2 {
+			continue
+		}
+		key := strings.TrimSpace(fields[0])
+		value := strings.Trim(fields[1], " .")
+		switch key {
+		case "Pages free":
+			free, e := strconv.ParseUint(value, 10, 64)
+			if e != nil {
+				err = e
+			}
+			vms.Free = free * pagesize
+		case "Pages inactive":
+			inactive, e := strconv.ParseUint(value, 10, 64)
+			if e != nil {
+				err = e
+			}
+			vms.Inactive = inactive * pagesize
+		case "Pages active":
+			active, e := strconv.ParseUint(value, 10, 64)
+			if e != nil {
+				err = e
+			}
+			vms.Active = active * pagesize
+		case "Pages wired down":
+			wired, e := strconv.ParseUint(value, 10, 64)
+			if e != nil {
+				err = e
+			}
+			vms.Wired = wired * pagesize
+		}
+	}
+	return err
+}
+
+// VirtualMemory returns VirtualmemoryStat.
+func VirtualMemory() (*VirtualMemoryStat, error) {
+	return VirtualMemoryWithContext(context.Background())
+}
+
+func VirtualMemoryWithContext(ctx context.Context) (*VirtualMemoryStat, error) {
+	ret := &VirtualMemoryStat{}
+
+	total, err := getHwMemsize()
+	if err != nil {
+		return nil, err
+	}
+	err = getVMStat(ret)
+	if err != nil {
+		return nil, err
+	}
+
+	ret.Available = ret.Free + ret.Inactive
+	ret.Total = total
+
+	ret.Used = ret.Total - ret.Available
+	ret.UsedPercent = 100 * float64(ret.Used) / float64(ret.Total)
+
+	return ret, nil
+}

vendor/github.com/shirou/gopsutil/mem/mem_fallback.go

@@ -0,0 +1,25 @@
+// +build !darwin,!linux,!freebsd,!openbsd,!solaris,!windows
+
+package mem
+
+import (
+	"context"
+
+	"github.com/shirou/gopsutil/internal/common"
+)
+
+func VirtualMemory() (*VirtualMemoryStat, error) {
+	return VirtualMemoryWithContext(context.Background())
+}
+
+func VirtualMemoryWithContext(ctx context.Context) (*VirtualMemoryStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+
+func SwapMemory() (*SwapMemoryStat, error) {
+	return SwapMemoryWithContext(context.Background())
+}
+
+func SwapMemoryWithContext(ctx context.Context) (*SwapMemoryStat, error) {
+	return nil, common.ErrNotImplementedError
+}

vendor/github.com/shirou/gopsutil/mem/mem_freebsd.go

@@ -0,0 +1,132 @@
+// +build freebsd
+
+package mem
+
+import (
+	"context"
+	"errors"
+	"unsafe"
+
+	"golang.org/x/sys/unix"
+)
+
+func VirtualMemory() (*VirtualMemoryStat, error) {
+	return VirtualMemoryWithContext(context.Background())
+}
+
+func VirtualMemoryWithContext(ctx context.Context) (*VirtualMemoryStat, error) {
+	pageSize, err := unix.SysctlUint32("vm.stats.vm.v_page_size")
+	if err != nil {
+		return nil, err
+	}
+	pageCount, err := unix.SysctlUint32("vm.stats.vm.v_page_count")
+	if err != nil {
+		return nil, err
+	}
+	free, err := unix.SysctlUint32("vm.stats.vm.v_free_count")
+	if err != nil {
+		return nil, err
+	}
+	active, err := unix.SysctlUint32("vm.stats.vm.v_active_count")
+	if err != nil {
+		return nil, err
+	}
+	inactive, err := unix.SysctlUint32("vm.stats.vm.v_inactive_count")
+	if err != nil {
+		return nil, err
+	}
+	cached, err := unix.SysctlUint32("vm.stats.vm.v_cache_count")
+	if err != nil {
+		return nil, err
+	}
+	buffers, err := unix.SysctlUint64("vfs.bufspace")
+	if err != nil {
+		return nil, err
+	}
+	wired, err := unix.SysctlUint32("vm.stats.vm.v_wire_count")
+	if err != nil {
+		return nil, err
+	}
+
+	p := uint64(pageSize)
+	ret := &VirtualMemoryStat{
+		Total:    uint64(pageCount) * p,
+		Free:     uint64(free) * p,
+		Active:   uint64(active) * p,
+		Inactive: uint64(inactive) * p,
+		Cached:   uint64(cached) * p,
+		Buffers:  uint64(buffers),
+		Wired:    uint64(wired) * p,
+	}
+
+	ret.Available = ret.Inactive + ret.Cached + ret.Free
+	ret.Used = ret.Total - ret.Available
+	ret.UsedPercent = float64(ret.Used) / float64(ret.Total) * 100.0
+
+	return ret, nil
+}
+
+// Return swapinfo
+func SwapMemory() (*SwapMemoryStat, error) {
+	return SwapMemoryWithContext(context.Background())
+}
+
+// Constants from vm/vm_param.h
+// nolint: golint
+const (
+	XSWDEV_VERSION = 1
+)
+
+// Types from vm/vm_param.h
+type xswdev struct {
+	Version uint32 // Version is the version
+	Dev     uint32 // Dev is the device identifier
+	Flags   int32  // Flags is the swap flags applied to the device
+	NBlks   int32  // NBlks is the total number of blocks
+	Used    int32  // Used is the number of blocks used
+}
+
+func SwapMemoryWithContext(ctx context.Context) (*SwapMemoryStat, error) {
+	// FreeBSD can have multiple swap devices so we total them up
+	i, err := unix.SysctlUint32("vm.nswapdev")
+	if err != nil {
+		return nil, err
+	}
+
+	if i == 0 {
+		return nil, errors.New("no swap devices found")
+	}
+
+	c := int(i)
+
+	i, err = unix.SysctlUint32("vm.stats.vm.v_page_size")
+	if err != nil {
+		return nil, err
+	}
+	pageSize := uint64(i)
+
+	var buf []byte
+	s := &SwapMemoryStat{}
+	for n := 0; n < c; n++ {
+		buf, err = unix.SysctlRaw("vm.swap_info", n)
+		if err != nil {
+			return nil, err
+		}
+
+		xsw := (*xswdev)(unsafe.Pointer(&buf[0]))
+		if xsw.Version != XSWDEV_VERSION {
+			return nil, errors.New("xswdev version mismatch")
+		}
+		s.Total += uint64(xsw.NBlks)
+		s.Used += uint64(xsw.Used)
+	}
+
+	if s.Total != 0 {
+		s.UsedPercent = float64(s.Used) / float64(s.Total) * 100
+	}
+	s.Total *= pageSize
+	s.Used *= pageSize
+	s.Free = s.Total - s.Used
+
+	return s, nil
+}

vendor/github.com/shirou/gopsutil/mem/mem_linux.go

@@ -0,0 +1,153 @@
+// +build linux
+
+package mem
+
+import (
+	"context"
+	"strconv"
+	"strings"
+
+	"github.com/shirou/gopsutil/internal/common"
+	"golang.org/x/sys/unix"
+)
+
+func VirtualMemory() (*VirtualMemoryStat, error) {
+	return VirtualMemoryWithContext(context.Background())
+}
+
+func VirtualMemoryWithContext(ctx context.Context) (*VirtualMemoryStat, error) {
+	filename := common.HostProc("meminfo")
+	lines, _ := common.ReadLines(filename)
+	// flag if MemAvailable is in /proc/meminfo (kernel 3.14+)
+	memavail := false
+
+	ret := &VirtualMemoryStat{}
+	for _, line := range lines {
+		fields := strings.Split(line, ":")
+		if len(fields) != 2 {
+			continue
+		}
+		key := strings.TrimSpace(fields[0])
+		value := strings.TrimSpace(fields[1])
+		value = strings.Replace(value, " kB", "", -1)
+
+		t, err := strconv.ParseUint(value, 10, 64)
+		if err != nil {
+			return ret, err
+		}
+		switch key {
+		case "MemTotal":
+			ret.Total = t * 1024
+		case "MemFree":
+			ret.Free = t * 1024
+		case "MemAvailable":
+			memavail = true
+			ret.Available = t * 1024
+		case "Buffers":
+			ret.Buffers = t * 1024
+		case "Cached":
+			ret.Cached = t * 1024
+		case "Active":
+			ret.Active = t * 1024
+		case "Inactive":
+			ret.Inactive = t * 1024
+		case "Writeback":
+			ret.Writeback = t * 1024
+		case "WritebackTmp":
+			ret.WritebackTmp = t * 1024
+		case "Dirty":
+			ret.Dirty = t * 1024
+		case "Shmem":
+			ret.Shared = t * 1024
+		case "Slab":
+			ret.Slab = t * 1024
+		case "PageTables":
+			ret.PageTables = t * 1024
+		case "SwapCached":
+			ret.SwapCached = t * 1024
+		case "CommitLimit":
+			ret.CommitLimit = t * 1024
+		case "Committed_AS":
+			ret.CommittedAS = t * 1024
+		case "HighTotal":
+			ret.HighTotal = t * 1024
+		case "HighFree":
+			ret.HighFree = t * 1024
+		case "LowTotal":
+			ret.LowTotal = t * 1024
+		case "LowFree":
+			ret.LowFree = t * 1024
+		case "SwapTotal":
+			ret.SwapTotal = t * 1024
+		case "SwapFree":
+			ret.SwapFree = t * 1024
+		case "Mapped":
+			ret.Mapped = t * 1024
+		case "VmallocTotal":
+			ret.VMallocTotal = t * 1024
+		case "VmallocUsed":
+			ret.VMallocUsed = t * 1024
+		case "VmallocChunk":
+			ret.VMallocChunk = t * 1024
+		case "HugePages_Total":
+			ret.HugePagesTotal = t
+		case "HugePages_Free":
+			ret.HugePagesFree = t
+		case "Hugepagesize":
+			ret.HugePageSize = t * 1024
+		}
+	}
+	if !memavail {
+		ret.Available = ret.Free + ret.Buffers + ret.Cached
+	}
+	ret.Used = ret.Total - ret.Free - ret.Buffers - ret.Cached
+	ret.UsedPercent = float64(ret.Used) / float64(ret.Total) * 100.0
+
+	return ret, nil
+}
+
+func SwapMemory() (*SwapMemoryStat, error) {
+	return SwapMemoryWithContext(context.Background())
+}
+
+func SwapMemoryWithContext(ctx context.Context) (*SwapMemoryStat, error) {
+	sysinfo := &unix.Sysinfo_t{}
+
+	if err := unix.Sysinfo(sysinfo); err != nil {
+		return nil, err
+	}
+	ret := &SwapMemoryStat{
+		Total: uint64(sysinfo.Totalswap) * uint64(sysinfo.Unit),
+		Free:  uint64(sysinfo.Freeswap) * uint64(sysinfo.Unit),
+	}
+	ret.Used = ret.Total - ret.Free
+	//check Infinity
+	if ret.Total != 0 {
+		ret.UsedPercent = float64(ret.Total-ret.Free) / float64(ret.Total) * 100.0
+	} else {
+		ret.UsedPercent = 0
+	}
+	filename := common.HostProc("vmstat")
+	lines, _ := common.ReadLines(filename)
+	for _, l := range lines {
+		fields := strings.Fields(l)
+		if len(fields) < 2 {
+			continue
+		}
+		switch fields[0] {
+		case "pswpin":
+			value, err := strconv.ParseUint(fields[1], 10, 64)
+			if err != nil {
+				continue
+			}
+			ret.Sin = value * 4 * 1024
+		case "pswpout":
+			value, err := strconv.ParseUint(fields[1], 10, 64)
+			if err != nil {
+				continue
+			}
+			ret.Sout = value * 4 * 1024
+		}
+	}
+	return ret, nil
+}

vendor/github.com/shirou/gopsutil/mem/mem_openbsd.go

@@ -0,0 +1,124 @@
+// +build openbsd
+
+package mem
+
+import (
+	"bytes"
+	"context"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"os/exec"
+
+	"github.com/shirou/gopsutil/internal/common"
+)
+
+func GetPageSize() (uint64, error) {
+	return GetPageSizeWithContext(context.Background())
+}
+
+func GetPageSizeWithContext(ctx context.Context) (uint64, error) {
+	mib := []int32{CTLVm, VmUvmexp}
+	buf, length, err := common.CallSyscall(mib)
+	if err != nil {
+		return 0, err
+	}
+	if length < sizeOfUvmexp {
+		return 0, fmt.Errorf("short syscall ret %d bytes", length)
+	}
+	var uvmexp Uvmexp
+	br := bytes.NewReader(buf)
+	err = common.Read(br, binary.LittleEndian, &uvmexp)
+	if err != nil {
+		return 0, err
+	}
+	return uint64(uvmexp.Pagesize), nil
+}
+
+func VirtualMemory() (*VirtualMemoryStat, error) {
+	return VirtualMemoryWithContext(context.Background())
+}
+
+func VirtualMemoryWithContext(ctx context.Context) (*VirtualMemoryStat, error) {
+	mib := []int32{CTLVm, VmUvmexp}
+	buf, length, err := common.CallSyscall(mib)
+	if err != nil {
+		return nil, err
+	}
+	if length < sizeOfUvmexp {
+		return nil, fmt.Errorf("short syscall ret %d bytes", length)
+	}
+	var uvmexp Uvmexp
+	br := bytes.NewReader(buf)
+	err = common.Read(br, binary.LittleEndian, &uvmexp)
+	if err != nil {
+		return nil, err
+	}
+	p := uint64(uvmexp.Pagesize)
+
+	ret := &VirtualMemoryStat{
+		Total:    uint64(uvmexp.Npages) * p,
+		Free:     uint64(uvmexp.Free) * p,
+		Active:   uint64(uvmexp.Active) * p,
+		Inactive: uint64(uvmexp.Inactive) * p,
+		Cached:   0, // not available
+		Wired:    uint64(uvmexp.Wired) * p,
+	}
+
+	ret.Available = ret.Inactive + ret.Cached + ret.Free
+	ret.Used = ret.Total - ret.Available
+	ret.UsedPercent = float64(ret.Used) / float64(ret.Total) * 100.0
+
+	mib = []int32{CTLVfs, VfsGeneric, VfsBcacheStat}
+	buf, length, err = common.CallSyscall(mib)
+	if err != nil {
+		return nil, err
+	}
+	if length < sizeOfBcachestats {
+		return nil, fmt.Errorf("short syscall ret %d bytes", length)
+	}
+	var bcs Bcachestats
+	br = bytes.NewReader(buf)
+	err = common.Read(br, binary.LittleEndian, &bcs)
+	if err != nil {
+		return nil, err
+	}
+	ret.Buffers = uint64(bcs.Numbufpages) * p
+
+	return ret, nil
+}
+
+// Return swapctl summary info
+func SwapMemory() (*SwapMemoryStat, error) {
+	return SwapMemoryWithContext(context.Background())
+}
+
+func SwapMemoryWithContext(ctx context.Context) (*SwapMemoryStat, error) {
+	swapctl, err := exec.LookPath("swapctl")
+	if err != nil {
+		return nil, err
+	}
+
+	out, err := invoke.CommandWithContext(ctx, swapctl, "-sk")
+	if err != nil {
+		return &SwapMemoryStat{}, nil
+	}
+
+	line := string(out)
+	var total, used, free uint64
+
+	_, err = fmt.Sscanf(line,
+		"total: %d 1K-blocks allocated, %d used, %d available",
+		&total, &used, &free)
+	if err != nil {
+		return nil, errors.New("failed to parse swapctl output")
+	}
+
+	percent := float64(used) / float64(total) * 100
+	return &SwapMemoryStat{
+		Total:       total * 1024,
+		Used:        used * 1024,
+		Free:        free * 1024,
+		UsedPercent: percent,
+	}, nil
+}

vendor/github.com/shirou/gopsutil/mem/mem_openbsd_amd64.go

@@ -0,0 +1,122 @@
+// Created by cgo -godefs - DO NOT EDIT
+// cgo -godefs types_openbsd.go
+
+package mem
+
+const (
+	CTLVm         = 2
+	CTLVfs        = 10
+	VmUvmexp      = 4
+	VfsGeneric    = 0
+	VfsBcacheStat = 3
+)
+
+const (
+	sizeOfUvmexp      = 0x154
+	sizeOfBcachestats = 0x78
+)
+
+type Uvmexp struct {
+	Pagesize           int32
+	Pagemask           int32
+	Pageshift          int32
+	Npages             int32
+	Free               int32
+	Active             int32
+	Inactive           int32
+	Paging             int32
+	Wired              int32
+	Zeropages          int32
+	Reserve_pagedaemon int32
+	Reserve_kernel     int32
+	Anonpages          int32
+	Vnodepages         int32
+	Vtextpages         int32
+	Freemin            int32
+	Freetarg           int32
+	Inactarg           int32
+	Wiredmax           int32
+	Anonmin            int32
+	Vtextmin           int32
+	Vnodemin           int32
+	Anonminpct         int32
+	Vtextminpct        int32
+	Vnodeminpct        int32
+	Nswapdev           int32
+	Swpages            int32
+	Swpginuse          int32
+	Swpgonly           int32
+	Nswget             int32
+	Nanon              int32
+	Nanonneeded        int32
+	Nfreeanon          int32
+	Faults             int32
+	Traps              int32
+	Intrs              int32
+	Swtch              int32
+	Softs              int32
+	Syscalls           int32
+	Pageins            int32
+	Obsolete_swapins   int32
+	Obsolete_swapouts  int32
+	Pgswapin           int32
+	Pgswapout          int32
+	Forks              int32
+	Forks_ppwait       int32
+	Forks_sharevm      int32
+	Pga_zerohit        int32
+	Pga_zeromiss       int32
+	Zeroaborts         int32
+	Fltnoram           int32
+	Fltnoanon          int32
+	Fltpgwait          int32
+	Fltpgrele          int32
+	Fltrelck           int32
+	Fltrelckok         int32
+	Fltanget           int32
+	Fltanretry         int32
+	Fltamcopy          int32
+	Fltnamap           int32
+	Fltnomap           int32
+	Fltlget            int32
+	Fltget             int32
+	Flt_anon           int32
+	Flt_acow           int32
+	Flt_obj            int32
+	Flt_prcopy         int32
+	Flt_przero         int32
+	Pdwoke             int32
+	Pdrevs             int32
+	Pdswout            int32
+	Pdfreed            int32
+	Pdscans            int32
+	Pdanscan           int32
+	Pdobscan           int32
+	Pdreact            int32
+	Pdbusy             int32
+	Pdpageouts         int32
+	Pdpending          int32
+	Pddeact            int32
+	Pdreanon           int32
+	Pdrevnode          int32
+	Pdrevtext          int32
+	Fpswtch            int32
+	Kmapent            int32
+}
+type Bcachestats struct {
+	Numbufs       int64
+	Numbufpages   int64
+	Numdirtypages int64
+	Numcleanpages int64
+	Pendingwrites int64
+	Pendingreads  int64
+	Numwrites     int64
+	Numreads      int64
+	Cachehits     int64
+	Busymapped    int64
+	Dmapages      int64
+	Highpages     int64
+	Delwribufs    int64
+	Kvaslots      int64
+	Avail         int64
+}

vendor/github.com/shirou/gopsutil/mem/mem_solaris.go

@@ -0,0 +1,121 @@
+package mem
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os/exec"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"github.com/shirou/gopsutil/internal/common"
+)
+
+// VirtualMemory for Solaris is a minimal implementation which only returns
+// what Nomad needs. It does take into account global vs zone, however.
+func VirtualMemory() (*VirtualMemoryStat, error) {
+	return VirtualMemoryWithContext(context.Background())
+}
+
+func VirtualMemoryWithContext(ctx context.Context) (*VirtualMemoryStat, error) {
+	result := &VirtualMemoryStat{}
+
+	zoneName, err := zoneName()
+	if err != nil {
+		return nil, err
+	}
+
+	if zoneName == "global" {
+		cap, err := globalZoneMemoryCapacity()
+		if err != nil {
+			return nil, err
+		}
+		result.Total = cap
+	} else {
+		cap, err := nonGlobalZoneMemoryCapacity()
+		if err != nil {
+			return nil, err
+		}
+		result.Total = cap
+	}
+
+	return result, nil
+}
+
+func SwapMemory() (*SwapMemoryStat, error) {
+	return SwapMemoryWithContext(context.Background())
+}
+
+func SwapMemoryWithContext(ctx context.Context) (*SwapMemoryStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+
+func zoneName() (string, error) {
+	zonename, err := exec.LookPath("/usr/bin/zonename")
+	if err != nil {
+		return "", err
+	}
+
+	ctx := context.Background()
+	out, err := invoke.CommandWithContext(ctx, zonename)
+	if err != nil {
+		return "", err
+	}
+
+	return strings.TrimSpace(string(out)), nil
+}
+
+var globalZoneMemoryCapacityMatch = regexp.MustCompile(`memory size: ([\d]+) Megabytes`)
+
+func globalZoneMemoryCapacity() (uint64, error) {
+	prtconf, err := exec.LookPath("/usr/sbin/prtconf")
+	if err != nil {
+		return 0, err
+	}
+
+	ctx := context.Background()
+	out, err := invoke.CommandWithContext(ctx, prtconf)
+	if err != nil {
+		return 0, err
+	}
+
+	match := globalZoneMemoryCapacityMatch.FindAllStringSubmatch(string(out), -1)
+	if len(match) != 1 {
+		return 0, errors.New("memory size not contained in output of /usr/sbin/prtconf")
+	}
+
+	totalMB, err := strconv.ParseUint(match[0][1], 10, 64)
+	if err != nil {
+		return 0, err
+	}
+
+	return totalMB * 1024 * 1024, nil
+}
+
+var kstatMatch = regexp.MustCompile(`([^\s]+)[\s]+([^\s]*)`)
+
+func nonGlobalZoneMemoryCapacity() (uint64, error) {
+	kstat, err := exec.LookPath("/usr/bin/kstat")
+	if err != nil {
+		return 0, err
+	}
+
+	ctx := context.Background()
+	out, err := invoke.CommandWithContext(ctx, kstat, "-p", "-c", "zone_memory_cap", "memory_cap:*:*:physcap")
+	if err != nil {
+		return 0, err
+	}
+
+	kstats := kstatMatch.FindAllStringSubmatch(string(out), -1)
+	if len(kstats) != 1 {
+		return 0, fmt.Errorf("expected 1 kstat, found %d", len(kstats))
+	}
+
+	memSizeBytes, err := strconv.ParseUint(kstats[0][2], 10, 64)
+	if err != nil {
+		return 0, err
+	}
+
+	return memSizeBytes, nil
+}

vendor/github.com/shirou/gopsutil/mem/mem_windows.go

@@ -0,0 +1,97 @@
+// +build windows
+
+package mem
+
+import (
+	"context"
+	"unsafe"
+
+	"github.com/shirou/gopsutil/internal/common"
+	"golang.org/x/sys/windows"
+)
+
+var (
+	procGlobalMemoryStatusEx = common.Modkernel32.NewProc("GlobalMemoryStatusEx")
+	procGetPerformanceInfo   = common.ModPsapi.NewProc("GetPerformanceInfo")
+)
+
+type memoryStatusEx struct {
+	cbSize                  uint32
+	dwMemoryLoad            uint32
+	ullTotalPhys            uint64 // in bytes
+	ullAvailPhys            uint64
+	ullTotalPageFile        uint64
+	ullAvailPageFile        uint64
+	ullTotalVirtual         uint64
+	ullAvailVirtual         uint64
+	ullAvailExtendedVirtual uint64
+}
+
+func VirtualMemory() (*VirtualMemoryStat, error) {
+	return VirtualMemoryWithContext(context.Background())
+}
+
+func VirtualMemoryWithContext(ctx context.Context) (*VirtualMemoryStat, error) {
+	var memInfo memoryStatusEx
+	memInfo.cbSize = uint32(unsafe.Sizeof(memInfo))
+	mem, _, _ := procGlobalMemoryStatusEx.Call(uintptr(unsafe.Pointer(&memInfo)))
+	if mem == 0 {
+		return nil, windows.GetLastError()
+	}
+
+	ret := &VirtualMemoryStat{
+		Total:       memInfo.ullTotalPhys,
+		Available:   memInfo.ullAvailPhys,
+		UsedPercent: float64(memInfo.dwMemoryLoad),
+	}
+
+	ret.Used = ret.Total - ret.Available
+	return ret, nil
+}
+
+type performanceInformation struct {
+	cb                uint32
+	commitTotal       uint64
+	commitLimit       uint64
+	commitPeak        uint64
+	physicalTotal     uint64
+	physicalAvailable uint64
+	systemCache       uint64
+	kernelTotal       uint64
+	kernelPaged       uint64
+	kernelNonpaged    uint64
+	pageSize          uint64
+	handleCount       uint32
+	processCount      uint32
+	threadCount       uint32
+}
+
+func SwapMemory() (*SwapMemoryStat, error) {
+	return SwapMemoryWithContext(context.Background())
+}
+
+func SwapMemoryWithContext(ctx context.Context) (*SwapMemoryStat, error) {
+	var perfInfo performanceInformation
+	perfInfo.cb = uint32(unsafe.Sizeof(perfInfo))
+	mem, _, _ := procGetPerformanceInfo.Call(uintptr(unsafe.Pointer(&perfInfo)), uintptr(perfInfo.cb))
+	if mem == 0 {
+		return nil, windows.GetLastError()
+	}
+	tot := perfInfo.commitLimit * perfInfo.pageSize
+	used := perfInfo.commitTotal * perfInfo.pageSize
+	free := tot - used
+	var usedPercent float64
+	if tot == 0 {
+		usedPercent = 0
+	} else {
+		usedPercent = float64(used) / float64(tot)
+	}
+	ret := &SwapMemoryStat{
+		Total:       tot,
+		Used:        used,
+		Free:        free,
+		UsedPercent: usedPercent,
+	}
+
+	return ret, nil
+}

vendor/github.com/shirou/gopsutil/net/BUILD.bazel

@@ -0,0 +1,40 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "net.go",
+        "net_darwin.go",
+        "net_fallback.go",
+        "net_freebsd.go",
+        "net_linux.go",
+        "net_openbsd.go",
+        "net_unix.go",
+        "net_windows.go",
+    ],
+    importmap = "go-common/vendor/github.com/shirou/gopsutil/net",
+    importpath = "github.com/shirou/gopsutil/net",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//vendor/github.com/shirou/gopsutil/internal/common:go_default_library",
+    ] + select({
+        "@io_bazel_rules_go//go/platform:windows": [
+            "//vendor/golang.org/x/sys/windows:go_default_library",
+        ],
+        "//conditions:default": [],
+    }),
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

vendor/github.com/shirou/gopsutil/net/net.go

@@ -0,0 +1,259 @@
+package net
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net"
+	"strconv"
+	"strings"
+	"syscall"
+
+	"github.com/shirou/gopsutil/internal/common"
+)
+
+var invoke common.Invoker = common.Invoke{}
+
+type IOCountersStat struct {
+	Name        string `json:"name"`        // interface name
+	BytesSent   uint64 `json:"bytesSent"`   // number of bytes sent
+	BytesRecv   uint64 `json:"bytesRecv"`   // number of bytes received
+	PacketsSent uint64 `json:"packetsSent"` // number of packets sent
+	PacketsRecv uint64 `json:"packetsRecv"` // number of packets received
+	Errin       uint64 `json:"errin"`       // total number of errors while receiving
+	Errout      uint64 `json:"errout"`      // total number of errors while sending
+	Dropin      uint64 `json:"dropin"`      // total number of incoming packets which were dropped
+	Dropout     uint64 `json:"dropout"`     // total number of outgoing packets which were dropped (always 0 on OSX and BSD)
+	Fifoin      uint64 `json:"fifoin"`      // total number of FIFO buffers errors while receiving
+	Fifoout     uint64 `json:"fifoout"`     // total number of FIFO buffers errors while sending
+
+}
+
+// Addr is implemented compatibility to psutil
+type Addr struct {
+	IP   string `json:"ip"`
+	Port uint32 `json:"port"`
+}
+
+type ConnectionStat struct {
+	Fd     uint32  `json:"fd"`
+	Family uint32  `json:"family"`
+	Type   uint32  `json:"type"`
+	Laddr  Addr    `json:"localaddr"`
+	Raddr  Addr    `json:"remoteaddr"`
+	Status string  `json:"status"`
+	Uids   []int32 `json:"uids"`
+	Pid    int32   `json:"pid"`
+}
+
+// System wide stats about different network protocols
+type ProtoCountersStat struct {
+	Protocol string           `json:"protocol"`
+	Stats    map[string]int64 `json:"stats"`
+}
+
+// NetInterfaceAddr is designed for represent interface addresses
+type InterfaceAddr struct {
+	Addr string `json:"addr"`
+}
+
+type InterfaceStat struct {
+	MTU          int             `json:"mtu"`          // maximum transmission unit
+	Name         string          `json:"name"`         // e.g., "en0", "lo0", "eth0.100"
+	HardwareAddr string          `json:"hardwareaddr"` // IEEE MAC-48, EUI-48 and EUI-64 form
+	Flags        []string        `json:"flags"`        // e.g., FlagUp, FlagLoopback, FlagMulticast
+	Addrs        []InterfaceAddr `json:"addrs"`
+}
+
+type FilterStat struct {
+	ConnTrackCount int64 `json:"conntrackCount"`
+	ConnTrackMax   int64 `json:"conntrackMax"`
+}
+
+var constMap = map[string]int{
+	"unix": syscall.AF_UNIX,
+	"TCP":  syscall.SOCK_STREAM,
+	"UDP":  syscall.SOCK_DGRAM,
+	"IPv4": syscall.AF_INET,
+	"IPv6": syscall.AF_INET6,
+}
+
+func (n IOCountersStat) String() string {
+	s, _ := json.Marshal(n)
+	return string(s)
+}
+
+func (n ConnectionStat) String() string {
+	s, _ := json.Marshal(n)
+	return string(s)
+}
+
+func (n ProtoCountersStat) String() string {
+	s, _ := json.Marshal(n)
+	return string(s)
+}
+
+func (a Addr) String() string {
+	s, _ := json.Marshal(a)
+	return string(s)
+}
+
+func (n InterfaceStat) String() string {
+	s, _ := json.Marshal(n)
+	return string(s)
+}
+
+func (n InterfaceAddr) String() string {
+	s, _ := json.Marshal(n)
+	return string(s)
+}
+
+func Interfaces() ([]InterfaceStat, error) {
+	return InterfacesWithContext(context.Background())
+}
+
+func InterfacesWithContext(ctx context.Context) ([]InterfaceStat, error) {
+	is, err := net.Interfaces()
+	if err != nil {
+		return nil, err
+	}
+	ret := make([]InterfaceStat, 0, len(is))
+	for _, ifi := range is {
+
+		var flags []string
+		if ifi.Flags&net.FlagUp != 0 {
+			flags = append(flags, "up")
+		}
+		if ifi.Flags&net.FlagBroadcast != 0 {
+			flags = append(flags, "broadcast")
+		}
+		if ifi.Flags&net.FlagLoopback != 0 {
+			flags = append(flags, "loopback")
+		}
+		if ifi.Flags&net.FlagPointToPoint != 0 {
+			flags = append(flags, "pointtopoint")
+		}
+		if ifi.Flags&net.FlagMulticast != 0 {
+			flags = append(flags, "multicast")
+		}
+
+		r := InterfaceStat{
+			Name:         ifi.Name,
+			MTU:          ifi.MTU,
+			HardwareAddr: ifi.HardwareAddr.String(),
+			Flags:        flags,
+		}
+		addrs, err := ifi.Addrs()
+		if err == nil {
+			r.Addrs = make([]InterfaceAddr, 0, len(addrs))
+			for _, addr := range addrs {
+				r.Addrs = append(r.Addrs, InterfaceAddr{
+					Addr: addr.String(),
+				})
+			}
+
+		}
+		ret = append(ret, r)
+	}
+
+	return ret, nil
+}
+
+func getIOCountersAll(n []IOCountersStat) ([]IOCountersStat, error) {
+	r := IOCountersStat{
+		Name: "all",
+	}
+	for _, nic := range n {
+		r.BytesRecv += nic.BytesRecv
+		r.PacketsRecv += nic.PacketsRecv
+		r.Errin += nic.Errin
+		r.Dropin += nic.Dropin
+		r.BytesSent += nic.BytesSent
+		r.PacketsSent += nic.PacketsSent
+		r.Errout += nic.Errout
+		r.Dropout += nic.Dropout
+	}
+
+	return []IOCountersStat{r}, nil
+}
+
+func parseNetLine(line string) (ConnectionStat, error) {
+	f := strings.Fields(line)
+	if len(f) < 8 {
+		return ConnectionStat{}, fmt.Errorf("wrong line,%s", line)
+	}
+
+	if len(f) == 8 {
+		f = append(f, f[7])
+		f[7] = "unix"
+	}
+
+	pid, err := strconv.Atoi(f[1])
+	if err != nil {
+		return ConnectionStat{}, err
+	}
+	fd, err := strconv.Atoi(strings.Trim(f[3], "u"))
+	if err != nil {
+		return ConnectionStat{}, fmt.Errorf("unknown fd, %s", f[3])
+	}
+	netFamily, ok := constMap[f[4]]
+	if !ok {
+		return ConnectionStat{}, fmt.Errorf("unknown family, %s", f[4])
+	}
+	netType, ok := constMap[f[7]]
+	if !ok {
+		return ConnectionStat{}, fmt.Errorf("unknown type, %s", f[7])
+	}
+
+	var laddr, raddr Addr
+	if f[7] == "unix" {
+		laddr.IP = f[8]
+	} else {
+		laddr, raddr, err = parseNetAddr(f[8])
+		if err != nil {
+			return ConnectionStat{}, fmt.Errorf("failed to parse netaddr, %s", f[8])
+		}
+	}
+
+	n := ConnectionStat{
+		Fd:     uint32(fd),
+		Family: uint32(netFamily),
+		Type:   uint32(netType),
+		Laddr:  laddr,
+		Raddr:  raddr,
+		Pid:    int32(pid),
+	}
+	if len(f) == 10 {
+		n.Status = strings.Trim(f[9], "()")
+	}
+
+	return n, nil
+}
+
+func parseNetAddr(line string) (laddr Addr, raddr Addr, err error) {
+	parse := func(l string) (Addr, error) {
+		host, port, err := net.SplitHostPort(l)
+		if err != nil {
+			return Addr{}, fmt.Errorf("wrong addr, %s", l)
+		}
+		lport, err := strconv.Atoi(port)
+		if err != nil {
+			return Addr{}, err
+		}
+		return Addr{IP: host, Port: uint32(lport)}, nil
+	}
+
+	addrs := strings.Split(line, "->")
+	if len(addrs) == 0 {
+		return laddr, raddr, fmt.Errorf("wrong netaddr, %s", line)
+	}
+	laddr, err = parse(addrs[0])
+	if len(addrs) == 2 { // remote addr exists
+		raddr, err = parse(addrs[1])
+		if err != nil {
+			return laddr, raddr, err
+		}
+	}
+
+	return laddr, raddr, err
+}

vendor/github.com/shirou/gopsutil/net/net_darwin.go

@@ -0,0 +1,284 @@
+// +build darwin
+
+package net
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os/exec"
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+var (
+	errNetstatHeader  = errors.New("Can't parse header of netstat output")
+	netstatLinkRegexp = regexp.MustCompile(`^<Link#(\d+)>$`)
+)
+
+const endOfLine = "\n"
+
+func parseNetstatLine(line string) (stat *IOCountersStat, linkID *uint, err error) {
+	var (
+		numericValue uint64
+		columns      = strings.Fields(line)
+	)
+
+	if columns[0] == "Name" {
+		err = errNetstatHeader
+		return
+	}
+
+	// try to extract the numeric value from <Link#123>
+	if subMatch := netstatLinkRegexp.FindStringSubmatch(columns[2]); len(subMatch) == 2 {
+		numericValue, err = strconv.ParseUint(subMatch[1], 10, 64)
+		if err != nil {
+			return
+		}
+		linkIDUint := uint(numericValue)
+		linkID = &linkIDUint
+	}
+
+	base := 1
+	numberColumns := len(columns)
+	// sometimes Address is ommitted
+	if numberColumns < 12 {
+		base = 0
+	}
+	if numberColumns < 11 || numberColumns > 13 {
+		err = fmt.Errorf("Line %q do have an invalid number of columns %d", line, numberColumns)
+		return
+	}
+
+	parsed := make([]uint64, 0, 7)
+	vv := []string{
+		columns[base+3], // Ipkts == PacketsRecv
+		columns[base+4], // Ierrs == Errin
+		columns[base+5], // Ibytes == BytesRecv
+		columns[base+6], // Opkts == PacketsSent
+		columns[base+7], // Oerrs == Errout
+		columns[base+8], // Obytes == BytesSent
+	}
+	if len(columns) == 12 {
+		vv = append(vv, columns[base+10])
+	}
+
+	for _, target := range vv {
+		if target == "-" {
+			parsed = append(parsed, 0)
+			continue
+		}
+
+		if numericValue, err = strconv.ParseUint(target, 10, 64); err != nil {
+			return
+		}
+		parsed = append(parsed, numericValue)
+	}
+
+	stat = &IOCountersStat{
+		Name:        strings.Trim(columns[0], "*"), // remove the * that sometimes is on right on interface
+		PacketsRecv: parsed[0],
+		Errin:       parsed[1],
+		BytesRecv:   parsed[2],
+		PacketsSent: parsed[3],
+		Errout:      parsed[4],
+		BytesSent:   parsed[5],
+	}
+	if len(parsed) == 7 {
+		stat.Dropout = parsed[6]
+	}
+	return
+}
+
+type netstatInterface struct {
+	linkID *uint
+	stat   *IOCountersStat
+}
+
+func parseNetstatOutput(output string) ([]netstatInterface, error) {
+	var (
+		err   error
+		lines = strings.Split(strings.Trim(output, endOfLine), endOfLine)
+	)
+
+	// number of interfaces is number of lines less one for the header
+	numberInterfaces := len(lines) - 1
+
+	interfaces := make([]netstatInterface, numberInterfaces)
+	// no output beside header
+	if numberInterfaces == 0 {
+		return interfaces, nil
+	}
+
+	for index := 0; index < numberInterfaces; index++ {
+		nsIface := netstatInterface{}
+		if nsIface.stat, nsIface.linkID, err = parseNetstatLine(lines[index+1]); err != nil {
+			return nil, err
+		}
+		interfaces[index] = nsIface
+	}
+	return interfaces, nil
+}
+
+// map that hold the name of a network interface and the number of usage
+type mapInterfaceNameUsage map[string]uint
+
+func newMapInterfaceNameUsage(ifaces []netstatInterface) mapInterfaceNameUsage {
+	output := make(mapInterfaceNameUsage)
+	for index := range ifaces {
+		if ifaces[index].linkID != nil {
+			ifaceName := ifaces[index].stat.Name
+			usage, ok := output[ifaceName]
+			if ok {
+				output[ifaceName] = usage + 1
+			} else {
+				output[ifaceName] = 1
+			}
+		}
+	}
+	return output
+}
+
+func (min mapInterfaceNameUsage) isTruncated() bool {
+	for _, usage := range min {
+		if usage > 1 {
+			return true
+		}
+	}
+	return false
+}
+
+func (min mapInterfaceNameUsage) notTruncated() []string {
+	output := make([]string, 0)
+	for ifaceName, usage := range min {
+		if usage == 1 {
+			output = append(output, ifaceName)
+		}
+	}
+	return output
+}
+
+// example of `netstat -ibdnW` output on yosemite
+// Name  Mtu   Network       Address            Ipkts Ierrs     Ibytes    Opkts Oerrs     Obytes  Coll Drop
+// lo0   16384 <Link#1>                        869107     0  169411755   869107     0  169411755     0   0
+// lo0   16384 ::1/128     ::1                 869107     -  169411755   869107     -  169411755     -   -
+// lo0   16384 127           127.0.0.1         869107     -  169411755   869107     -  169411755     -   -
+func IOCounters(pernic bool) ([]IOCountersStat, error) {
+	return IOCountersWithContext(context.Background(), pernic)
+}
+
+func IOCountersWithContext(ctx context.Context, pernic bool) ([]IOCountersStat, error) {
+	var (
+		ret      []IOCountersStat
+		retIndex int
+	)
+
+	netstat, err := exec.LookPath("/usr/sbin/netstat")
+	if err != nil {
+		return nil, err
+	}
+
+	// try to get all interface metrics, and hope there won't be any truncated
+	out, err := invoke.CommandWithContext(ctx, netstat, "-ibdnW")
+	if err != nil {
+		return nil, err
+	}
+
+	nsInterfaces, err := parseNetstatOutput(string(out))
+	if err != nil {
+		return nil, err
+	}
+
+	ifaceUsage := newMapInterfaceNameUsage(nsInterfaces)
+	notTruncated := ifaceUsage.notTruncated()
+	ret = make([]IOCountersStat, len(notTruncated))
+
+	if !ifaceUsage.isTruncated() {
+		// no truncated interface name, return stats of all interface with <Link#...>
+		for index := range nsInterfaces {
+			if nsInterfaces[index].linkID != nil {
+				ret[retIndex] = *nsInterfaces[index].stat
+				retIndex++
+			}
+		}
+	} else {
+		// duplicated interface, list all interfaces
+		ifconfig, err := exec.LookPath("/sbin/ifconfig")
+		if err != nil {
+			return nil, err
+		}
+		if out, err = invoke.CommandWithContext(ctx, ifconfig, "-l"); err != nil {
+			return nil, err
+		}
+		interfaceNames := strings.Fields(strings.TrimRight(string(out), endOfLine))
+
+		// for each of the interface name, run netstat if we don't have any stats yet
+		for _, interfaceName := range interfaceNames {
+			truncated := true
+			for index := range nsInterfaces {
+				if nsInterfaces[index].linkID != nil && nsInterfaces[index].stat.Name == interfaceName {
+					// handle the non truncated name to avoid execute netstat for them again
+					ret[retIndex] = *nsInterfaces[index].stat
+					retIndex++
+					truncated = false
+					break
+				}
+			}
+			if truncated {
+				// run netstat with -I$ifacename
+				if out, err = invoke.CommandWithContext(ctx, netstat, "-ibdnWI"+interfaceName); err != nil {
+					return nil, err
+				}
+				parsedIfaces, err := parseNetstatOutput(string(out))
+				if err != nil {
+					return nil, err
+				}
+				if len(parsedIfaces) == 0 {
+					// interface had been removed since `ifconfig -l` had been executed
+					continue
+				}
+				for index := range parsedIfaces {
+					if parsedIfaces[index].linkID != nil {
+						ret = append(ret, *parsedIfaces[index].stat)
+						break
+					}
+				}
+			}
+		}
+	}
+
+	if pernic == false {
+		return getIOCountersAll(ret)
+	}
+	return ret, nil
+}
+
+// NetIOCountersByFile is an method which is added just a compatibility for linux.
+func IOCountersByFile(pernic bool, filename string) ([]IOCountersStat, error) {
+	return IOCountersByFileWithContext(context.Background(), pernic, filename)
+}
+
+func IOCountersByFileWithContext(ctx context.Context, pernic bool, filename string) ([]IOCountersStat, error) {
+	return IOCounters(pernic)
+}
+
+func FilterCounters() ([]FilterStat, error) {
+	return FilterCountersWithContext(context.Background())
+}
+
+func FilterCountersWithContext(ctx context.Context) ([]FilterStat, error) {
+	return nil, errors.New("NetFilterCounters not implemented for darwin")
+}
+
+// NetProtoCounters returns network statistics for the entire system
+// If protocols is empty then all protocols are returned, otherwise
+// just the protocols in the list are returned.
+// Not Implemented for Darwin
+func ProtoCounters(protocols []string) ([]ProtoCountersStat, error) {
+	return ProtoCountersWithContext(context.Background(), protocols)
+}
+
+func ProtoCountersWithContext(ctx context.Context, protocols []string) ([]ProtoCountersStat, error) {
+	return nil, errors.New("NetProtoCounters not implemented for darwin")
+}

vendor/github.com/shirou/gopsutil/net/net_fallback.go

@@ -0,0 +1,49 @@
+// +build !darwin,!linux,!freebsd,!openbsd,!windows
+
+package net
+
+import (
+	"context"
+
+	"github.com/shirou/gopsutil/internal/common"
+)
+
+func IOCounters(pernic bool) ([]IOCountersStat, error) {
+	return IOCountersWithContext(context.Background(), pernic)
+}
+
+func IOCountersWithContext(ctx context.Context, pernic bool) ([]IOCountersStat, error) {
+	return []IOCountersStat{}, common.ErrNotImplementedError
+}
+
+func FilterCounters() ([]FilterStat, error) {
+	return FilterCountersWithContext(context.Background())
+}
+
+func FilterCountersWithContext(ctx context.Context) ([]FilterStat, error) {
+	return []FilterStat{}, common.ErrNotImplementedError
+}
+
+func ProtoCounters(protocols []string) ([]ProtoCountersStat, error) {
+	return ProtoCountersWithContext(context.Background(), protocols)
+}
+
+func ProtoCountersWithContext(ctx context.Context, protocols []string) ([]ProtoCountersStat, error) {
+	return []ProtoCountersStat{}, common.ErrNotImplementedError
+}
+
+func Connections(kind string) ([]ConnectionStat, error) {
+	return ConnectionsWithContext(context.Background(), kind)
+}
+
+func ConnectionsWithContext(ctx context.Context, kind string) ([]ConnectionStat, error) {
+	return []ConnectionStat{}, common.ErrNotImplementedError
+}
+
+func ConnectionsMax(kind string, max int) ([]ConnectionStat, error) {
+	return ConnectionsMaxWithContext(context.Background(), kind, max)
+}
+
+func ConnectionsMaxWithContext(ctx context.Context, kind string, max int) ([]ConnectionStat, error) {
+	return []ConnectionStat{}, common.ErrNotImplementedError
+}

vendor/github.com/shirou/gopsutil/net/net_freebsd.go

@@ -0,0 +1,125 @@
+// +build freebsd
+
+package net
+
+import (
+	"context"
+	"errors"
+	"os/exec"
+	"strconv"
+	"strings"
+
+	"github.com/shirou/gopsutil/internal/common"
+)
+
+func IOCounters(pernic bool) ([]IOCountersStat, error) {
+	return IOCountersWithContext(context.Background(), pernic)
+}
+
+func IOCountersWithContext(ctx context.Context, pernic bool) ([]IOCountersStat, error) {
+	netstat, err := exec.LookPath("/usr/bin/netstat")
+	if err != nil {
+		return nil, err
+	}
+	out, err := invoke.CommandWithContext(ctx, netstat, "-ibdnW")
+	if err != nil {
+		return nil, err
+	}
+
+	lines := strings.Split(string(out), "\n")
+	ret := make([]IOCountersStat, 0, len(lines)-1)
+	exists := make([]string, 0, len(ret))
+
+	for _, line := range lines {
+		values := strings.Fields(line)
+		if len(values) < 1 || values[0] == "Name" {
+			continue
+		}
+		if common.StringsHas(exists, values[0]) {
+			// skip if already get
+			continue
+		}
+		exists = append(exists, values[0])
+
+		if len(values) < 12 {
+			continue
+		}
+		base := 1
+		// sometimes Address is ommitted
+		if len(values) < 13 {
+			base = 0
+		}
+
+		parsed := make([]uint64, 0, 8)
+		vv := []string{
+			values[base+3],  // PacketsRecv
+			values[base+4],  // Errin
+			values[base+5],  // Dropin
+			values[base+6],  // BytesRecvn
+			values[base+7],  // PacketSent
+			values[base+8],  // Errout
+			values[base+9],  // BytesSent
+			values[base+11], // Dropout
+		}
+		for _, target := range vv {
+			if target == "-" {
+				parsed = append(parsed, 0)
+				continue
+			}
+
+			t, err := strconv.ParseUint(target, 10, 64)
+			if err != nil {
+				return nil, err
+			}
+			parsed = append(parsed, t)
+		}
+
+		n := IOCountersStat{
+			Name:        values[0],
+			PacketsRecv: parsed[0],
+			Errin:       parsed[1],
+			Dropin:      parsed[2],
+			BytesRecv:   parsed[3],
+			PacketsSent: parsed[4],
+			Errout:      parsed[5],
+			BytesSent:   parsed[6],
+			Dropout:     parsed[7],
+		}
+		ret = append(ret, n)
+	}
+
+	if pernic == false {
+		return getIOCountersAll(ret)
+	}
+
+	return ret, nil
+}
+
+// NetIOCountersByFile is an method which is added just a compatibility for linux.
+func IOCountersByFile(pernic bool, filename string) ([]IOCountersStat, error) {
+	return IOCountersByFileWithContext(context.Background(), pernic, filename)
+}
+
+func IOCountersByFileWithContext(ctx context.Context, pernic bool, filename string) ([]IOCountersStat, error) {
+	return IOCounters(pernic)
+}
+
+func FilterCounters() ([]FilterStat, error) {
+	return FilterCountersWithContext(context.Background())
+}
+
+func FilterCountersWithContext(ctx context.Context) ([]FilterStat, error) {
+	return nil, errors.New("NetFilterCounters not implemented for freebsd")
+}
+
+// NetProtoCounters returns network statistics for the entire system
+// If protocols is empty then all protocols are returned, otherwise
+// just the protocols in the list are returned.
+// Not Implemented for FreeBSD
+func ProtoCounters(protocols []string) ([]ProtoCountersStat, error) {
+	return ProtoCountersWithContext(context.Background(), protocols)
+}
+
+func ProtoCountersWithContext(ctx context.Context, protocols []string) ([]ProtoCountersStat, error) {
+	return nil, errors.New("NetProtoCounters not implemented for freebsd")
+}

vendor/github.com/shirou/gopsutil/net/net_linux.go

@@ -0,0 +1,791 @@
+// +build linux
+
+package net
+
+import (
+	"bytes"
+	"context"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"io/ioutil"
+	"net"
+	"os"
+	"strconv"
+	"strings"
+	"syscall"
+
+	"github.com/shirou/gopsutil/internal/common"
+)
+
+// NetIOCounters returnes network I/O statistics for every network
+// interface installed on the system.  If pernic argument is false,
+// return only sum of all information (which name is 'all'). If true,
+// every network interface installed on the system is returned
+// separately.
+func IOCounters(pernic bool) ([]IOCountersStat, error) {
+	return IOCountersWithContext(context.Background(), pernic)
+}
+
+func IOCountersWithContext(ctx context.Context, pernic bool) ([]IOCountersStat, error) {
+	filename := common.HostProc("net/dev")
+	return IOCountersByFile(pernic, filename)
+}
+
+func IOCountersByFile(pernic bool, filename string) ([]IOCountersStat, error) {
+	return IOCountersByFileWithContext(context.Background(), pernic, filename)
+}
+
+func IOCountersByFileWithContext(ctx context.Context, pernic bool, filename string) ([]IOCountersStat, error) {
+	lines, err := common.ReadLines(filename)
+	if err != nil {
+		return nil, err
+	}
+
+	parts := make([]string, 2)
+
+	statlen := len(lines) - 1
+
+	ret := make([]IOCountersStat, 0, statlen)
+
+	for _, line := range lines[2:] {
+		separatorPos := strings.LastIndex(line, ":")
+		if separatorPos == -1 {
+			continue
+		}
+		parts[0] = line[0:separatorPos]
+		parts[1] = line[separatorPos+1:]
+
+		interfaceName := strings.TrimSpace(parts[0])
+		if interfaceName == "" {
+			continue
+		}
+
+		fields := strings.Fields(strings.TrimSpace(parts[1]))
+		bytesRecv, err := strconv.ParseUint(fields[0], 10, 64)
+		if err != nil {
+			return ret, err
+		}
+		packetsRecv, err := strconv.ParseUint(fields[1], 10, 64)
+		if err != nil {
+			return ret, err
+		}
+		errIn, err := strconv.ParseUint(fields[2], 10, 64)
+		if err != nil {
+			return ret, err
+		}
+		dropIn, err := strconv.ParseUint(fields[3], 10, 64)
+		if err != nil {
+			return ret, err
+		}
+		fifoIn, err := strconv.ParseUint(fields[4], 10, 64)
+		if err != nil {
+			return ret, err
+		}
+		bytesSent, err := strconv.ParseUint(fields[8], 10, 64)
+		if err != nil {
+			return ret, err
+		}
+		packetsSent, err := strconv.ParseUint(fields[9], 10, 64)
+		if err != nil {
+			return ret, err
+		}
+		errOut, err := strconv.ParseUint(fields[10], 10, 64)
+		if err != nil {
+			return ret, err
+		}
+		dropOut, err := strconv.ParseUint(fields[11], 10, 64)
+		if err != nil {
+			return ret, err
+		}
+		fifoOut, err := strconv.ParseUint(fields[12], 10, 64)
+		if err != nil {
+			return ret, err
+		}
+
+		nic := IOCountersStat{
+			Name:        interfaceName,
+			BytesRecv:   bytesRecv,
+			PacketsRecv: packetsRecv,
+			Errin:       errIn,
+			Dropin:      dropIn,
+			Fifoin:      fifoIn,
+			BytesSent:   bytesSent,
+			PacketsSent: packetsSent,
+			Errout:      errOut,
+			Dropout:     dropOut,
+			Fifoout:     fifoOut,
+		}
+		ret = append(ret, nic)
+	}
+
+	if pernic == false {
+		return getIOCountersAll(ret)
+	}
+
+	return ret, nil
+}
+
+var netProtocols = []string{
+	"ip",
+	"icmp",
+	"icmpmsg",
+	"tcp",
+	"udp",
+	"udplite",
+}
+
+// NetProtoCounters returns network statistics for the entire system
+// If protocols is empty then all protocols are returned, otherwise
+// just the protocols in the list are returned.
+// Available protocols:
+//   ip,icmp,icmpmsg,tcp,udp,udplite
+func ProtoCounters(protocols []string) ([]ProtoCountersStat, error) {
+	return ProtoCountersWithContext(context.Background(), protocols)
+}
+
+func ProtoCountersWithContext(ctx context.Context, protocols []string) ([]ProtoCountersStat, error) {
+	if len(protocols) == 0 {
+		protocols = netProtocols
+	}
+
+	stats := make([]ProtoCountersStat, 0, len(protocols))
+	protos := make(map[string]bool, len(protocols))
+	for _, p := range protocols {
+		protos[p] = true
+	}
+
+	filename := common.HostProc("net/snmp")
+	lines, err := common.ReadLines(filename)
+	if err != nil {
+		return nil, err
+	}
+
+	linecount := len(lines)
+	for i := 0; i < linecount; i++ {
+		line := lines[i]
+		r := strings.IndexRune(line, ':')
+		if r == -1 {
+			return nil, errors.New(filename + " is not fomatted correctly, expected ':'.")
+		}
+		proto := strings.ToLower(line[:r])
+		if !protos[proto] {
+			// skip protocol and data line
+			i++
+			continue
+		}
+
+		// Read header line
+		statNames := strings.Split(line[r+2:], " ")
+
+		// Read data line
+		i++
+		statValues := strings.Split(lines[i][r+2:], " ")
+		if len(statNames) != len(statValues) {
+			return nil, errors.New(filename + " is not fomatted correctly, expected same number of columns.")
+		}
+		stat := ProtoCountersStat{
+			Protocol: proto,
+			Stats:    make(map[string]int64, len(statNames)),
+		}
+		for j := range statNames {
+			value, err := strconv.ParseInt(statValues[j], 10, 64)
+			if err != nil {
+				return nil, err
+			}
+			stat.Stats[statNames[j]] = value
+		}
+		stats = append(stats, stat)
+	}
+	return stats, nil
+}
+
+// NetFilterCounters returns iptables conntrack statistics
+// the currently in use conntrack count and the max.
+// If the file does not exist or is invalid it will return nil.
+func FilterCounters() ([]FilterStat, error) {
+	return FilterCountersWithContext(context.Background())
+}
+
+func FilterCountersWithContext(ctx context.Context) ([]FilterStat, error) {
+	countfile := common.HostProc("sys/net/netfilter/nf_conntrack_count")
+	maxfile := common.HostProc("sys/net/netfilter/nf_conntrack_max")
+
+	count, err := common.ReadInts(countfile)
+
+	if err != nil {
+		return nil, err
+	}
+	stats := make([]FilterStat, 0, 1)
+
+	max, err := common.ReadInts(maxfile)
+	if err != nil {
+		return nil, err
+	}
+
+	payload := FilterStat{
+		ConnTrackCount: count[0],
+		ConnTrackMax:   max[0],
+	}
+
+	stats = append(stats, payload)
+	return stats, nil
+}
+
+// http://students.mimuw.edu.pl/lxr/source/include/net/tcp_states.h
+var TCPStatuses = map[string]string{
+	"01": "ESTABLISHED",
+	"02": "SYN_SENT",
+	"03": "SYN_RECV",
+	"04": "FIN_WAIT1",
+	"05": "FIN_WAIT2",
+	"06": "TIME_WAIT",
+	"07": "CLOSE",
+	"08": "CLOSE_WAIT",
+	"09": "LAST_ACK",
+	"0A": "LISTEN",
+	"0B": "CLOSING",
+}
+
+type netConnectionKindType struct {
+	family   uint32
+	sockType uint32
+	filename string
+}
+
+var kindTCP4 = netConnectionKindType{
+	family:   syscall.AF_INET,
+	sockType: syscall.SOCK_STREAM,
+	filename: "tcp",
+}
+var kindTCP6 = netConnectionKindType{
+	family:   syscall.AF_INET6,
+	sockType: syscall.SOCK_STREAM,
+	filename: "tcp6",
+}
+var kindUDP4 = netConnectionKindType{
+	family:   syscall.AF_INET,
+	sockType: syscall.SOCK_DGRAM,
+	filename: "udp",
+}
+var kindUDP6 = netConnectionKindType{
+	family:   syscall.AF_INET6,
+	sockType: syscall.SOCK_DGRAM,
+	filename: "udp6",
+}
+var kindUNIX = netConnectionKindType{
+	family:   syscall.AF_UNIX,
+	filename: "unix",
+}
+
+var netConnectionKindMap = map[string][]netConnectionKindType{
+	"all":   {kindTCP4, kindTCP6, kindUDP4, kindUDP6, kindUNIX},
+	"tcp":   {kindTCP4, kindTCP6},
+	"tcp4":  {kindTCP4},
+	"tcp6":  {kindTCP6},
+	"udp":   {kindUDP4, kindUDP6},
+	"udp4":  {kindUDP4},
+	"udp6":  {kindUDP6},
+	"unix":  {kindUNIX},
+	"inet":  {kindTCP4, kindTCP6, kindUDP4, kindUDP6},
+	"inet4": {kindTCP4, kindUDP4},
+	"inet6": {kindTCP6, kindUDP6},
+}
+
+type inodeMap struct {
+	pid int32
+	fd  uint32
+}
+
+type connTmp struct {
+	fd       uint32
+	family   uint32
+	sockType uint32
+	laddr    Addr
+	raddr    Addr
+	status   string
+	pid      int32
+	boundPid int32
+	path     string
+}
+
+// Return a list of network connections opened.
+func Connections(kind string) ([]ConnectionStat, error) {
+	return ConnectionsWithContext(context.Background(), kind)
+}
+
+func ConnectionsWithContext(ctx context.Context, kind string) ([]ConnectionStat, error) {
+	return ConnectionsPid(kind, 0)
+}
+
+// Return a list of network connections opened returning at most `max`
+// connections for each running process.
+func ConnectionsMax(kind string, max int) ([]ConnectionStat, error) {
+	return ConnectionsMaxWithContext(context.Background(), kind, max)
+}
+
+func ConnectionsMaxWithContext(ctx context.Context, kind string, max int) ([]ConnectionStat, error) {
+	return ConnectionsPidMax(kind, 0, max)
+}
+
+// Return a list of network connections opened by a process.
+func ConnectionsPid(kind string, pid int32) ([]ConnectionStat, error) {
+	return ConnectionsPidWithContext(context.Background(), kind, pid)
+}
+
+func ConnectionsPidWithContext(ctx context.Context, kind string, pid int32) ([]ConnectionStat, error) {
+	tmap, ok := netConnectionKindMap[kind]
+	if !ok {
+		return nil, fmt.Errorf("invalid kind, %s", kind)
+	}
+	root := common.HostProc()
+	var err error
+	var inodes map[string][]inodeMap
+	if pid == 0 {
+		inodes, err = getProcInodesAll(root, 0)
+	} else {
+		inodes, err = getProcInodes(root, pid, 0)
+		if len(inodes) == 0 {
+			// no connection for the pid
+			return []ConnectionStat{}, nil
+		}
+	}
+	if err != nil {
+		return nil, fmt.Errorf("cound not get pid(s), %d: %s", pid, err)
+	}
+	return statsFromInodes(root, pid, tmap, inodes)
+}
+
+// Return up to `max` network connections opened by a process.
+func ConnectionsPidMax(kind string, pid int32, max int) ([]ConnectionStat, error) {
+	return ConnectionsPidMaxWithContext(context.Background(), kind, pid, max)
+}
+
+func ConnectionsPidMaxWithContext(ctx context.Context, kind string, pid int32, max int) ([]ConnectionStat, error) {
+	tmap, ok := netConnectionKindMap[kind]
+	if !ok {
+		return nil, fmt.Errorf("invalid kind, %s", kind)
+	}
+	root := common.HostProc()
+	var err error
+	var inodes map[string][]inodeMap
+	if pid == 0 {
+		inodes, err = getProcInodesAll(root, max)
+	} else {
+		inodes, err = getProcInodes(root, pid, max)
+		if len(inodes) == 0 {
+			// no connection for the pid
+			return []ConnectionStat{}, nil
+		}
+	}
+	if err != nil {
+		return nil, fmt.Errorf("cound not get pid(s), %d", pid)
+	}
+	return statsFromInodes(root, pid, tmap, inodes)
+}
+
+func statsFromInodes(root string, pid int32, tmap []netConnectionKindType, inodes map[string][]inodeMap) ([]ConnectionStat, error) {
+	dupCheckMap := make(map[string]struct{})
+	var ret []ConnectionStat
+
+	var err error
+	for _, t := range tmap {
+		var path string
+		var connKey string
+		var ls []connTmp
+		path = fmt.Sprintf("%s/net/%s", root, t.filename)
+		switch t.family {
+		case syscall.AF_INET:
+			fallthrough
+		case syscall.AF_INET6:
+			ls, err = processInet(path, t, inodes, pid)
+		case syscall.AF_UNIX:
+			ls, err = processUnix(path, t, inodes, pid)
+		}
+		if err != nil {
+			return nil, err
+		}
+		for _, c := range ls {
+			// Build TCP key to id the connection uniquely
+			// socket type, src ip, src port, dst ip, dst port and state should be enough
+			// to prevent duplications.
+			connKey = fmt.Sprintf("%d-%s:%d-%s:%d-%s", c.sockType, c.laddr.IP, c.laddr.Port, c.raddr.IP, c.raddr.Port, c.status)
+			if _, ok := dupCheckMap[connKey]; ok {
+				continue
+			}
+
+			conn := ConnectionStat{
+				Fd:     c.fd,
+				Family: c.family,
+				Type:   c.sockType,
+				Laddr:  c.laddr,
+				Raddr:  c.raddr,
+				Status: c.status,
+				Pid:    c.pid,
+			}
+			if c.pid == 0 {
+				conn.Pid = c.boundPid
+			} else {
+				conn.Pid = c.pid
+			}
+
+			// fetch process owner Real, effective, saved set, and filesystem UIDs
+			proc := process{Pid: conn.Pid}
+			conn.Uids, _ = proc.getUids()
+
+			ret = append(ret, conn)
+			dupCheckMap[connKey] = struct{}{}
+		}
+
+	}
+
+	return ret, nil
+}
+
+// getProcInodes returnes fd of the pid.
+func getProcInodes(root string, pid int32, max int) (map[string][]inodeMap, error) {
+	ret := make(map[string][]inodeMap)
+
+	dir := fmt.Sprintf("%s/%d/fd", root, pid)
+	f, err := os.Open(dir)
+	if err != nil {
+		return ret, err
+	}
+	defer f.Close()
+	files, err := f.Readdir(max)
+	if err != nil {
+		return ret, err
+	}
+	for _, fd := range files {
+		inodePath := fmt.Sprintf("%s/%d/fd/%s", root, pid, fd.Name())
+
+		inode, err := os.Readlink(inodePath)
+		if err != nil {
+			continue
+		}
+		if !strings.HasPrefix(inode, "socket:[") {
+			continue
+		}
+		// the process is using a socket
+		l := len(inode)
+		inode = inode[8 : l-1]
+		_, ok := ret[inode]
+		if !ok {
+			ret[inode] = make([]inodeMap, 0)
+		}
+		fd, err := strconv.Atoi(fd.Name())
+		if err != nil {
+			continue
+		}
+
+		i := inodeMap{
+			pid: pid,
+			fd:  uint32(fd),
+		}
+		ret[inode] = append(ret[inode], i)
+	}
+	return ret, nil
+}
+
+// Pids retunres all pids.
+// Note: this is a copy of process_linux.Pids()
+// FIXME: Import process occures import cycle.
+// move to common made other platform breaking. Need consider.
+func Pids() ([]int32, error) {
+	return PidsWithContext(context.Background())
+}
+
+func PidsWithContext(ctx context.Context) ([]int32, error) {
+	var ret []int32
+
+	d, err := os.Open(common.HostProc())
+	if err != nil {
+		return nil, err
+	}
+	defer d.Close()
+
+	fnames, err := d.Readdirnames(-1)
+	if err != nil {
+		return nil, err
+	}
+	for _, fname := range fnames {
+		pid, err := strconv.ParseInt(fname, 10, 32)
+		if err != nil {
+			// if not numeric name, just skip
+			continue
+		}
+		ret = append(ret, int32(pid))
+	}
+
+	return ret, nil
+}
+
+// Note: the following is based off process_linux structs and methods
+// we need these to fetch the owner of a process ID
+// FIXME: Import process occures import cycle.
+// see remarks on pids()
+type process struct {
+	Pid  int32 `json:"pid"`
+	uids []int32
+}
+
+// Uids returns user ids of the process as a slice of the int
+func (p *process) getUids() ([]int32, error) {
+	err := p.fillFromStatus()
+	if err != nil {
+		return []int32{}, err
+	}
+	return p.uids, nil
+}
+
+// Get status from /proc/(pid)/status
+func (p *process) fillFromStatus() error {
+	pid := p.Pid
+	statPath := common.HostProc(strconv.Itoa(int(pid)), "status")
+	contents, err := ioutil.ReadFile(statPath)
+	if err != nil {
+		return err
+	}
+	lines := strings.Split(string(contents), "\n")
+	for _, line := range lines {
+		tabParts := strings.SplitN(line, "\t", 2)
+		if len(tabParts) < 2 {
+			continue
+		}
+		value := tabParts[1]
+		switch strings.TrimRight(tabParts[0], ":") {
+		case "Uid":
+			p.uids = make([]int32, 0, 4)
+			for _, i := range strings.Split(value, "\t") {
+				v, err := strconv.ParseInt(i, 10, 32)
+				if err != nil {
+					return err
+				}
+				p.uids = append(p.uids, int32(v))
+			}
+		}
+	}
+	return nil
+}
+
+func getProcInodesAll(root string, max int) (map[string][]inodeMap, error) {
+	pids, err := Pids()
+	if err != nil {
+		return nil, err
+	}
+	ret := make(map[string][]inodeMap)
+
+	for _, pid := range pids {
+		t, err := getProcInodes(root, pid, max)
+		if err != nil {
+			// skip if permission error or no longer exists
+			if os.IsPermission(err) || os.IsNotExist(err) {
+				continue
+			}
+			return ret, err
+		}
+		if len(t) == 0 {
+			continue
+		}
+		// TODO: update ret.
+		ret = updateMap(ret, t)
+	}
+	return ret, nil
+}
+
+// decodeAddress decode addresse represents addr in proc/net/*
+// ex:
+// "0500000A:0016" -> "10.0.0.5", 22
+// "0085002452100113070057A13F025401:0035" -> "2400:8500:1301:1052:a157:7:154:23f", 53
+func decodeAddress(family uint32, src string) (Addr, error) {
+	t := strings.Split(src, ":")
+	if len(t) != 2 {
+		return Addr{}, fmt.Errorf("does not contain port, %s", src)
+	}
+	addr := t[0]
+	port, err := strconv.ParseInt("0x"+t[1], 0, 64)
+	if err != nil {
+		return Addr{}, fmt.Errorf("invalid port, %s", src)
+	}
+	decoded, err := hex.DecodeString(addr)
+	if err != nil {
+		return Addr{}, fmt.Errorf("decode error, %s", err)
+	}
+	var ip net.IP
+	// Assumes this is little_endian
+	if family == syscall.AF_INET {
+		ip = net.IP(Reverse(decoded))
+	} else { // IPv6
+		ip, err = parseIPv6HexString(decoded)
+		if err != nil {
+			return Addr{}, err
+		}
+	}
+	return Addr{
+		IP:   ip.String(),
+		Port: uint32(port),
+	}, nil
+}
+
+// Reverse reverses array of bytes.
+func Reverse(s []byte) []byte {
+	return ReverseWithContext(context.Background(), s)
+}
+
+func ReverseWithContext(ctx context.Context, s []byte) []byte {
+	for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 {
+		s[i], s[j] = s[j], s[i]
+	}
+	return s
+}
+
+// parseIPv6HexString parse array of bytes to IPv6 string
+func parseIPv6HexString(src []byte) (net.IP, error) {
+	if len(src) != 16 {
+		return nil, fmt.Errorf("invalid IPv6 string")
+	}
+
+	buf := make([]byte, 0, 16)
+	for i := 0; i < len(src); i += 4 {
+		r := Reverse(src[i : i+4])
+		buf = append(buf, r...)
+	}
+	return net.IP(buf), nil
+}
+
+func processInet(file string, kind netConnectionKindType, inodes map[string][]inodeMap, filterPid int32) ([]connTmp, error) {
+
+	if strings.HasSuffix(file, "6") && !common.PathExists(file) {
+		// IPv6 not supported, return empty.
+		return []connTmp{}, nil
+	}
+
+	// Read the contents of the /proc file with a single read sys call.
+	// This minimizes duplicates in the returned connections
+	// For more info:
+	// https://github.com/shirou/gopsutil/pull/361
+	contents, err := ioutil.ReadFile(file)
+	if err != nil {
+		return nil, err
+	}
+
+	lines := bytes.Split(contents, []byte("\n"))
+
+	var ret []connTmp
+	// skip first line
+	for _, line := range lines[1:] {
+		l := strings.Fields(string(line))
+		if len(l) < 10 {
+			continue
+		}
+		laddr := l[1]
+		raddr := l[2]
+		status := l[3]
+		inode := l[9]
+		pid := int32(0)
+		fd := uint32(0)
+		i, exists := inodes[inode]
+		if exists {
+			pid = i[0].pid
+			fd = i[0].fd
+		}
+		if filterPid > 0 && filterPid != pid {
+			continue
+		}
+		if kind.sockType == syscall.SOCK_STREAM {
+			status = TCPStatuses[status]
+		} else {
+			status = "NONE"
+		}
+		la, err := decodeAddress(kind.family, laddr)
+		if err != nil {
+			continue
+		}
+		ra, err := decodeAddress(kind.family, raddr)
+		if err != nil {
+			continue
+		}
+
+		ret = append(ret, connTmp{
+			fd:       fd,
+			family:   kind.family,
+			sockType: kind.sockType,
+			laddr:    la,
+			raddr:    ra,
+			status:   status,
+			pid:      pid,
+		})
+	}
+
+	return ret, nil
+}
+
+func processUnix(file string, kind netConnectionKindType, inodes map[string][]inodeMap, filterPid int32) ([]connTmp, error) {
+	// Read the contents of the /proc file with a single read sys call.
+	// This minimizes duplicates in the returned connections
+	// For more info:
+	// https://github.com/shirou/gopsutil/pull/361
+	contents, err := ioutil.ReadFile(file)
+	if err != nil {
+		return nil, err
+	}
+
+	lines := bytes.Split(contents, []byte("\n"))
+
+	var ret []connTmp
+	// skip first line
+	for _, line := range lines[1:] {
+		tokens := strings.Fields(string(line))
+		if len(tokens) < 6 {
+			continue
+		}
+		st, err := strconv.Atoi(tokens[4])
+		if err != nil {
+			return nil, err
+		}
+
+		inode := tokens[6]
+
+		var pairs []inodeMap
+		pairs, exists := inodes[inode]
+		if !exists {
+			pairs = []inodeMap{
+				{},
+			}
+		}
+		for _, pair := range pairs {
+			if filterPid > 0 && filterPid != pair.pid {
+				continue
+			}
+			var path string
+			if len(tokens) == 8 {
+				path = tokens[len(tokens)-1]
+			}
+			ret = append(ret, connTmp{
+				fd:       pair.fd,
+				family:   kind.family,
+				sockType: uint32(st),
+				laddr: Addr{
+					IP: path,
+				},
+				pid:    pair.pid,
+				status: "NONE",
+				path:   path,
+			})
+		}
+	}
+
+	return ret, nil
+}
+
+func updateMap(src map[string][]inodeMap, add map[string][]inodeMap) map[string][]inodeMap {
+	for key, value := range add {
+		a, exists := src[key]
+		if !exists {
+			src[key] = value
+			continue
+		}
+		src[key] = append(a, value...)
+	}
+	return src
+}

vendor/github.com/shirou/gopsutil/net/net_openbsd.go

@@ -0,0 +1,312 @@
+// +build openbsd
+
+package net
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os/exec"
+	"regexp"
+	"strconv"
+	"strings"
+	"syscall"
+
+	"github.com/shirou/gopsutil/internal/common"
+)
+
+var portMatch = regexp.MustCompile(`(.*)\.(\d+)$`)
+
+func ParseNetstat(output string, mode string,
+	iocs map[string]IOCountersStat) error {
+	lines := strings.Split(output, "\n")
+
+	exists := make([]string, 0, len(lines)-1)
+
+	columns := 6
+	if mode == "ind" {
+		columns = 10
+	}
+	for _, line := range lines {
+		values := strings.Fields(line)
+		if len(values) < 1 || values[0] == "Name" {
+			continue
+		}
+		if common.StringsHas(exists, values[0]) {
+			// skip if already get
+			continue
+		}
+
+		if len(values) < columns {
+			continue
+		}
+		base := 1
+		// sometimes Address is ommitted
+		if len(values) < columns {
+			base = 0
+		}
+
+		parsed := make([]uint64, 0, 8)
+		var vv []string
+		if mode == "inb" {
+			vv = []string{
+				values[base+3], // BytesRecv
+				values[base+4], // BytesSent
+			}
+		} else {
+			vv = []string{
+				values[base+3], // Ipkts
+				values[base+4], // Ierrs
+				values[base+5], // Opkts
+				values[base+6], // Oerrs
+				values[base+8], // Drops
+			}
+		}
+		for _, target := range vv {
+			if target == "-" {
+				parsed = append(parsed, 0)
+				continue
+			}
+
+			t, err := strconv.ParseUint(target, 10, 64)
+			if err != nil {
+				return err
+			}
+			parsed = append(parsed, t)
+		}
+		exists = append(exists, values[0])
+
+		n, present := iocs[values[0]]
+		if !present {
+			n = IOCountersStat{Name: values[0]}
+		}
+		if mode == "inb" {
+			n.BytesRecv = parsed[0]
+			n.BytesSent = parsed[1]
+		} else {
+			n.PacketsRecv = parsed[0]
+			n.Errin = parsed[1]
+			n.PacketsSent = parsed[2]
+			n.Errout = parsed[3]
+			n.Dropin = parsed[4]
+			n.Dropout = parsed[4]
+		}
+
+		iocs[n.Name] = n
+	}
+	return nil
+}
+
+func IOCounters(pernic bool) ([]IOCountersStat, error) {
+	return IOCountersWithContext(context.Background(), pernic)
+}
+
+func IOCountersWithContext(ctx context.Context, pernic bool) ([]IOCountersStat, error) {
+	netstat, err := exec.LookPath("netstat")
+	if err != nil {
+		return nil, err
+	}
+	out, err := invoke.CommandWithContext(ctx, netstat, "-inb")
+	if err != nil {
+		return nil, err
+	}
+	out2, err := invoke.CommandWithContext(ctx, netstat, "-ind")
+	if err != nil {
+		return nil, err
+	}
+	iocs := make(map[string]IOCountersStat)
+
+	lines := strings.Split(string(out), "\n")
+	ret := make([]IOCountersStat, 0, len(lines)-1)
+
+	err = ParseNetstat(string(out), "inb", iocs)
+	if err != nil {
+		return nil, err
+	}
+	err = ParseNetstat(string(out2), "ind", iocs)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, ioc := range iocs {
+		ret = append(ret, ioc)
+	}
+
+	if pernic == false {
+		return getIOCountersAll(ret)
+	}
+
+	return ret, nil
+}
+
+// NetIOCountersByFile is an method which is added just a compatibility for linux.
+func IOCountersByFile(pernic bool, filename string) ([]IOCountersStat, error) {
+	return IOCountersByFileWithContext(context.Background(), pernic, filename)
+}
+
+func IOCountersByFileWithContext(ctx context.Context, pernic bool, filename string) ([]IOCountersStat, error) {
+	return IOCounters(pernic)
+}
+
+func FilterCounters() ([]FilterStat, error) {
+	return FilterCountersWithContext(context.Background())
+}
+
+func FilterCountersWithContext(ctx context.Context) ([]FilterStat, error) {
+	return nil, errors.New("NetFilterCounters not implemented for openbsd")
+}
+
+// NetProtoCounters returns network statistics for the entire system
+// If protocols is empty then all protocols are returned, otherwise
+// just the protocols in the list are returned.
+// Not Implemented for OpenBSD
+func ProtoCounters(protocols []string) ([]ProtoCountersStat, error) {
+	return ProtoCountersWithContext(context.Background(), protocols)
+}
+
+func ProtoCountersWithContext(ctx context.Context, protocols []string) ([]ProtoCountersStat, error) {
+	return nil, errors.New("NetProtoCounters not implemented for openbsd")
+}
+
+func parseNetstatLine(line string) (ConnectionStat, error) {
+	f := strings.Fields(line)
+	if len(f) < 5 {
+		return ConnectionStat{}, fmt.Errorf("wrong line,%s", line)
+	}
+
+	var netType, netFamily uint32
+	switch f[0] {
+	case "tcp":
+		netType = syscall.SOCK_STREAM
+		netFamily = syscall.AF_INET
+	case "udp":
+		netType = syscall.SOCK_DGRAM
+		netFamily = syscall.AF_INET
+	case "tcp6":
+		netType = syscall.SOCK_STREAM
+		netFamily = syscall.AF_INET6
+	case "udp6":
+		netType = syscall.SOCK_DGRAM
+		netFamily = syscall.AF_INET6
+	default:
+		return ConnectionStat{}, fmt.Errorf("unknown type, %s", f[0])
+	}
+
+	laddr, raddr, err := parseNetstatAddr(f[3], f[4], netFamily)
+	if err != nil {
+		return ConnectionStat{}, fmt.Errorf("failed to parse netaddr, %s %s", f[3], f[4])
+	}
+
+	n := ConnectionStat{
+		Fd:     uint32(0), // not supported
+		Family: uint32(netFamily),
+		Type:   uint32(netType),
+		Laddr:  laddr,
+		Raddr:  raddr,
+		Pid:    int32(0), // not supported
+	}
+	if len(f) == 6 {
+		n.Status = f[5]
+	}
+
+	return n, nil
+}
+
+func parseNetstatAddr(local string, remote string, family uint32) (laddr Addr, raddr Addr, err error) {
+	parse := func(l string) (Addr, error) {
+		matches := portMatch.FindStringSubmatch(l)
+		if matches == nil {
+			return Addr{}, fmt.Errorf("wrong addr, %s", l)
+		}
+		host := matches[1]
+		port := matches[2]
+		if host == "*" {
+			switch family {
+			case syscall.AF_INET:
+				host = "0.0.0.0"
+			case syscall.AF_INET6:
+				host = "::"
+			default:
+				return Addr{}, fmt.Errorf("unknown family, %d", family)
+			}
+		}
+		lport, err := strconv.Atoi(port)
+		if err != nil {
+			return Addr{}, err
+		}
+		return Addr{IP: host, Port: uint32(lport)}, nil
+	}
+
+	laddr, err = parse(local)
+	if remote != "*.*" { // remote addr exists
+		raddr, err = parse(remote)
+		if err != nil {
+			return laddr, raddr, err
+		}
+	}
+
+	return laddr, raddr, err
+}
+
+// Return a list of network connections opened.
+func Connections(kind string) ([]ConnectionStat, error) {
+	return ConnectionsWithContext(context.Background(), kind)
+}
+
+func ConnectionsWithContext(ctx context.Context, kind string) ([]ConnectionStat, error) {
+	var ret []ConnectionStat
+
+	args := []string{"-na"}
+	switch strings.ToLower(kind) {
+	default:
+		fallthrough
+	case "":
+		fallthrough
+	case "all":
+		fallthrough
+	case "inet":
+		// nothing to add
+	case "inet4":
+		args = append(args, "-finet")
+	case "inet6":
+		args = append(args, "-finet6")
+	case "tcp":
+		args = append(args, "-ptcp")
+	case "tcp4":
+		args = append(args, "-ptcp", "-finet")
+	case "tcp6":
+		args = append(args, "-ptcp", "-finet6")
+	case "udp":
+		args = append(args, "-pudp")
+	case "udp4":
+		args = append(args, "-pudp", "-finet")
+	case "udp6":
+		args = append(args, "-pudp", "-finet6")
+	case "unix":
+		return ret, common.ErrNotImplementedError
+	}
+
+	netstat, err := exec.LookPath("netstat")
+	if err != nil {
+		return nil, err
+	}
+	out, err := invoke.CommandWithContext(ctx, netstat, args...)
+
+	if err != nil {
+		return nil, err
+	}
+	lines := strings.Split(string(out), "\n")
+	for _, line := range lines {
+		if !(strings.HasPrefix(line, "tcp") || strings.HasPrefix(line, "udp")) {
+			continue
+		}
+		n, err := parseNetstatLine(line)
+		if err != nil {
+			continue
+		}
+
+		ret = append(ret, n)
+	}
+
+	return ret, nil
+}

vendor/github.com/shirou/gopsutil/net/net_unix.go

@@ -0,0 +1,96 @@
+// +build freebsd darwin
+
+package net
+
+import (
+	"context"
+	"strings"
+
+	"github.com/shirou/gopsutil/internal/common"
+)
+
+// Return a list of network connections opened.
+func Connections(kind string) ([]ConnectionStat, error) {
+	return ConnectionsWithContext(context.Background(), kind)
+}
+
+func ConnectionsWithContext(ctx context.Context, kind string) ([]ConnectionStat, error) {
+	return ConnectionsPid(kind, 0)
+}
+
+// Return a list of network connections opened returning at most `max`
+// connections for each running process.
+func ConnectionsMax(kind string, max int) ([]ConnectionStat, error) {
+	return ConnectionsMaxWithContext(context.Background(), kind, max)
+}
+
+func ConnectionsMaxWithContext(ctx context.Context, kind string, max int) ([]ConnectionStat, error) {
+	return []ConnectionStat{}, common.ErrNotImplementedError
+}
+
+// Return a list of network connections opened by a process.
+func ConnectionsPid(kind string, pid int32) ([]ConnectionStat, error) {
+	return ConnectionsPidWithContext(context.Background(), kind, pid)
+}
+
+func ConnectionsPidWithContext(ctx context.Context, kind string, pid int32) ([]ConnectionStat, error) {
+	var ret []ConnectionStat
+
+	args := []string{"-i"}
+	switch strings.ToLower(kind) {
+	default:
+		fallthrough
+	case "":
+		fallthrough
+	case "all":
+		fallthrough
+	case "inet":
+		args = append(args, "tcp", "-i", "udp")
+	case "inet4":
+		args = append(args, "4")
+	case "inet6":
+		args = append(args, "6")
+	case "tcp":
+		args = append(args, "tcp")
+	case "tcp4":
+		args = append(args, "4tcp")
+	case "tcp6":
+		args = append(args, "6tcp")
+	case "udp":
+		args = append(args, "udp")
+	case "udp4":
+		args = append(args, "6udp")
+	case "udp6":
+		args = append(args, "6udp")
+	case "unix":
+		args = []string{"-U"}
+	}
+
+	r, err := common.CallLsofWithContext(ctx, invoke, pid, args...)
+	if err != nil {
+		return nil, err
+	}
+	for _, rr := range r {
+		if strings.HasPrefix(rr, "COMMAND") {
+			continue
+		}
+		n, err := parseNetLine(rr)
+		if err != nil {
+
+			continue
+		}
+
+		ret = append(ret, n)
+	}
+
+	return ret, nil
+}
+
+// Return up to `max` network connections opened by a process.
+func ConnectionsPidMax(kind string, pid int32, max int) ([]ConnectionStat, error) {
+	return ConnectionsPidMaxWithContext(context.Background(), kind, pid, max)
+}
+
+func ConnectionsPidMaxWithContext(ctx context.Context, kind string, pid int32, max int) ([]ConnectionStat, error) {
+	return []ConnectionStat{}, common.ErrNotImplementedError
+}

vendor/github.com/shirou/gopsutil/net/net_windows.go

@@ -0,0 +1,120 @@
+// +build windows
+
+package net
+
+import (
+	"context"
+	"errors"
+	"net"
+	"os"
+
+	"github.com/shirou/gopsutil/internal/common"
+	"golang.org/x/sys/windows"
+)
+
+var (
+	modiphlpapi             = windows.NewLazyDLL("iphlpapi.dll")
+	procGetExtendedTCPTable = modiphlpapi.NewProc("GetExtendedTcpTable")
+	procGetExtendedUDPTable = modiphlpapi.NewProc("GetExtendedUdpTable")
+)
+
+const (
+	TCPTableBasicListener = iota
+	TCPTableBasicConnections
+	TCPTableBasicAll
+	TCPTableOwnerPIDListener
+	TCPTableOwnerPIDConnections
+	TCPTableOwnerPIDAll
+	TCPTableOwnerModuleListener
+	TCPTableOwnerModuleConnections
+	TCPTableOwnerModuleAll
+)
+
+func IOCounters(pernic bool) ([]IOCountersStat, error) {
+	return IOCountersWithContext(context.Background(), pernic)
+}
+
+func IOCountersWithContext(ctx context.Context, pernic bool) ([]IOCountersStat, error) {
+	ifs, err := net.Interfaces()
+	if err != nil {
+		return nil, err
+	}
+	var ret []IOCountersStat
+
+	for _, ifi := range ifs {
+		c := IOCountersStat{
+			Name: ifi.Name,
+		}
+
+		row := windows.MibIfRow{Index: uint32(ifi.Index)}
+		e := windows.GetIfEntry(&row)
+		if e != nil {
+			return nil, os.NewSyscallError("GetIfEntry", e)
+		}
+		c.BytesSent = uint64(row.OutOctets)
+		c.BytesRecv = uint64(row.InOctets)
+		c.PacketsSent = uint64(row.OutUcastPkts)
+		c.PacketsRecv = uint64(row.InUcastPkts)
+		c.Errin = uint64(row.InErrors)
+		c.Errout = uint64(row.OutErrors)
+		c.Dropin = uint64(row.InDiscards)
+		c.Dropout = uint64(row.OutDiscards)
+
+		ret = append(ret, c)
+	}
+
+	if pernic == false {
+		return getIOCountersAll(ret)
+	}
+	return ret, nil
+}
+
+// NetIOCountersByFile is an method which is added just a compatibility for linux.
+func IOCountersByFile(pernic bool, filename string) ([]IOCountersStat, error) {
+	return IOCountersByFileWithContext(context.Background(), pernic, filename)
+}
+
+func IOCountersByFileWithContext(ctx context.Context, pernic bool, filename string) ([]IOCountersStat, error) {
+	return IOCounters(pernic)
+}
+
+// Return a list of network connections opened by a process
+func Connections(kind string) ([]ConnectionStat, error) {
+	return ConnectionsWithContext(context.Background(), kind)
+}
+
+func ConnectionsWithContext(ctx context.Context, kind string) ([]ConnectionStat, error) {
+	var ret []ConnectionStat
+
+	return ret, common.ErrNotImplementedError
+}
+
+// Return a list of network connections opened returning at most `max`
+// connections for each running process.
+func ConnectionsMax(kind string, max int) ([]ConnectionStat, error) {
+	return ConnectionsMaxWithContext(context.Background(), kind, max)
+}
+
+func ConnectionsMaxWithContext(ctx context.Context, kind string, max int) ([]ConnectionStat, error) {
+	return []ConnectionStat{}, common.ErrNotImplementedError
+}
+
+func FilterCounters() ([]FilterStat, error) {
+	return FilterCountersWithContext(context.Background())
+}
+
+func FilterCountersWithContext(ctx context.Context) ([]FilterStat, error) {
+	return nil, errors.New("NetFilterCounters not implemented for windows")
+}
+
+// NetProtoCounters returns network statistics for the entire system
+// If protocols is empty then all protocols are returned, otherwise
+// just the protocols in the list are returned.
+// Not Implemented for Windows
+func ProtoCounters(protocols []string) ([]ProtoCountersStat, error) {
+	return ProtoCountersWithContext(context.Background(), protocols)
+}
+
+func ProtoCountersWithContext(ctx context.Context, protocols []string) ([]ProtoCountersStat, error) {
+	return nil, errors.New("NetProtoCounters not implemented for windows")
+}

vendor/github.com/shirou/gopsutil/process/BUILD.bazel

@@ -0,0 +1,89 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "process.go",
+        "process_darwin.go",
+        "process_darwin_386.go",
+        "process_darwin_amd64.go",
+        "process_fallback.go",
+        "process_freebsd.go",
+        "process_freebsd_386.go",
+        "process_freebsd_amd64.go",
+        "process_freebsd_arm.go",
+        "process_linux.go",
+        "process_openbsd.go",
+        "process_openbsd_amd64.go",
+        "process_posix.go",
+        "process_windows.go",
+        "process_windows_386.go",
+        "process_windows_amd64.go",
+    ],
+    cgo = True,
+    importmap = "go-common/vendor/github.com/shirou/gopsutil/process",
+    importpath = "github.com/shirou/gopsutil/process",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//vendor/github.com/shirou/gopsutil/cpu:go_default_library",
+        "//vendor/github.com/shirou/gopsutil/internal/common:go_default_library",
+        "//vendor/github.com/shirou/gopsutil/mem:go_default_library",
+    ] + select({
+        "@io_bazel_rules_go//go/platform:android": [
+            "//vendor/github.com/shirou/gopsutil/net:go_default_library",
+        ],
+        "@io_bazel_rules_go//go/platform:darwin": [
+            "//vendor/github.com/shirou/gopsutil/net:go_default_library",
+            "//vendor/golang.org/x/sys/unix:go_default_library",
+        ],
+        "@io_bazel_rules_go//go/platform:dragonfly": [
+            "//vendor/github.com/shirou/gopsutil/net:go_default_library",
+        ],
+        "@io_bazel_rules_go//go/platform:freebsd": [
+            "//vendor/github.com/shirou/gopsutil/net:go_default_library",
+            "//vendor/golang.org/x/sys/unix:go_default_library",
+        ],
+        "@io_bazel_rules_go//go/platform:linux": [
+            "//vendor/github.com/shirou/gopsutil/host:go_default_library",
+            "//vendor/github.com/shirou/gopsutil/net:go_default_library",
+            "//vendor/golang.org/x/sys/unix:go_default_library",
+        ],
+        "@io_bazel_rules_go//go/platform:nacl": [
+            "//vendor/github.com/shirou/gopsutil/net:go_default_library",
+        ],
+        "@io_bazel_rules_go//go/platform:netbsd": [
+            "//vendor/github.com/shirou/gopsutil/net:go_default_library",
+        ],
+        "@io_bazel_rules_go//go/platform:openbsd": [
+            "//vendor/github.com/shirou/gopsutil/net:go_default_library",
+            "//vendor/golang.org/x/sys/unix:go_default_library",
+        ],
+        "@io_bazel_rules_go//go/platform:plan9": [
+            "//vendor/github.com/shirou/gopsutil/net:go_default_library",
+        ],
+        "@io_bazel_rules_go//go/platform:solaris": [
+            "//vendor/github.com/shirou/gopsutil/net:go_default_library",
+        ],
+        "@io_bazel_rules_go//go/platform:windows": [
+            "//vendor/github.com/StackExchange/wmi:go_default_library",
+            "//vendor/github.com/shirou/gopsutil/net:go_default_library",
+            "//vendor/github.com/shirou/w32:go_default_library",
+            "//vendor/golang.org/x/sys/windows:go_default_library",
+        ],
+        "//conditions:default": [],
+    }),
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

vendor/github.com/shirou/gopsutil/process/process.go

@@ -0,0 +1,241 @@
+package process
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"runtime"
+	"time"
+
+	"github.com/shirou/gopsutil/cpu"
+	"github.com/shirou/gopsutil/internal/common"
+	"github.com/shirou/gopsutil/mem"
+)
+
+var (
+	invoke          common.Invoker = common.Invoke{}
+	ErrorNoChildren                = errors.New("process does not have children")
+)
+
+type Process struct {
+	Pid            int32 `json:"pid"`
+	name           string
+	status         string
+	parent         int32
+	numCtxSwitches *NumCtxSwitchesStat
+	uids           []int32
+	gids           []int32
+	numThreads     int32
+	memInfo        *MemoryInfoStat
+	sigInfo        *SignalInfoStat
+
+	lastCPUTimes *cpu.TimesStat
+	lastCPUTime  time.Time
+
+	tgid int32
+}
+
+type OpenFilesStat struct {
+	Path string `json:"path"`
+	Fd   uint64 `json:"fd"`
+}
+
+type MemoryInfoStat struct {
+	RSS    uint64 `json:"rss"`    // bytes
+	VMS    uint64 `json:"vms"`    // bytes
+	Data   uint64 `json:"data"`   // bytes
+	Stack  uint64 `json:"stack"`  // bytes
+	Locked uint64 `json:"locked"` // bytes
+	Swap   uint64 `json:"swap"`   // bytes
+}
+
+type SignalInfoStat struct {
+	PendingProcess uint64 `json:"pending_process"`
+	PendingThread  uint64 `json:"pending_thread"`
+	Blocked        uint64 `json:"blocked"`
+	Ignored        uint64 `json:"ignored"`
+	Caught         uint64 `json:"caught"`
+}
+
+type RlimitStat struct {
+	Resource int32  `json:"resource"`
+	Soft     int32  `json:"soft"` //TODO too small. needs to be uint64
+	Hard     int32  `json:"hard"` //TODO too small. needs to be uint64
+	Used     uint64 `json:"used"`
+}
+
+type IOCountersStat struct {
+	ReadCount  uint64 `json:"readCount"`
+	WriteCount uint64 `json:"writeCount"`
+	ReadBytes  uint64 `json:"readBytes"`
+	WriteBytes uint64 `json:"writeBytes"`
+}
+
+type NumCtxSwitchesStat struct {
+	Voluntary   int64 `json:"voluntary"`
+	Involuntary int64 `json:"involuntary"`
+}
+
+// Resource limit constants are from /usr/include/x86_64-linux-gnu/bits/resource.h
+// from libc6-dev package in Ubuntu 16.10
+const (
+	RLIMIT_CPU        int32 = 0
+	RLIMIT_FSIZE      int32 = 1
+	RLIMIT_DATA       int32 = 2
+	RLIMIT_STACK      int32 = 3
+	RLIMIT_CORE       int32 = 4
+	RLIMIT_RSS        int32 = 5
+	RLIMIT_NPROC      int32 = 6
+	RLIMIT_NOFILE     int32 = 7
+	RLIMIT_MEMLOCK    int32 = 8
+	RLIMIT_AS         int32 = 9
+	RLIMIT_LOCKS      int32 = 10
+	RLIMIT_SIGPENDING int32 = 11
+	RLIMIT_MSGQUEUE   int32 = 12
+	RLIMIT_NICE       int32 = 13
+	RLIMIT_RTPRIO     int32 = 14
+	RLIMIT_RTTIME     int32 = 15
+)
+
+func (p Process) String() string {
+	s, _ := json.Marshal(p)
+	return string(s)
+}
+
+func (o OpenFilesStat) String() string {
+	s, _ := json.Marshal(o)
+	return string(s)
+}
+
+func (m MemoryInfoStat) String() string {
+	s, _ := json.Marshal(m)
+	return string(s)
+}
+
+func (r RlimitStat) String() string {
+	s, _ := json.Marshal(r)
+	return string(s)
+}
+
+func (i IOCountersStat) String() string {
+	s, _ := json.Marshal(i)
+	return string(s)
+}
+
+func (p NumCtxSwitchesStat) String() string {
+	s, _ := json.Marshal(p)
+	return string(s)
+}
+
+func PidExists(pid int32) (bool, error) {
+	return PidExistsWithContext(context.Background(), pid)
+}
+
+func PidExistsWithContext(ctx context.Context, pid int32) (bool, error) {
+	pids, err := Pids()
+	if err != nil {
+		return false, err
+	}
+
+	for _, i := range pids {
+		if i == pid {
+			return true, err
+		}
+	}
+
+	return false, err
+}
+
+// If interval is 0, return difference from last call(non-blocking).
+// If interval > 0, wait interval sec and return diffrence between start and end.
+func (p *Process) Percent(interval time.Duration) (float64, error) {
+	return p.PercentWithContext(context.Background(), interval)
+}
+
+func (p *Process) PercentWithContext(ctx context.Context, interval time.Duration) (float64, error) {
+	cpuTimes, err := p.Times()
+	if err != nil {
+		return 0, err
+	}
+	now := time.Now()
+
+	if interval > 0 {
+		p.lastCPUTimes = cpuTimes
+		p.lastCPUTime = now
+		time.Sleep(interval)
+		cpuTimes, err = p.Times()
+		now = time.Now()
+		if err != nil {
+			return 0, err
+		}
+	} else {
+		if p.lastCPUTimes == nil {
+			// invoked first time
+			p.lastCPUTimes = cpuTimes
+			p.lastCPUTime = now
+			return 0, nil
+		}
+	}
+
+	numcpu := runtime.NumCPU()
+	delta := (now.Sub(p.lastCPUTime).Seconds()) * float64(numcpu)
+	ret := calculatePercent(p.lastCPUTimes, cpuTimes, delta, numcpu)
+	p.lastCPUTimes = cpuTimes
+	p.lastCPUTime = now
+	return ret, nil
+}
+
+func calculatePercent(t1, t2 *cpu.TimesStat, delta float64, numcpu int) float64 {
+	if delta == 0 {
+		return 0
+	}
+	delta_proc := t2.Total() - t1.Total()
+	overall_percent := ((delta_proc / delta) * 100) * float64(numcpu)
+	return overall_percent
+}
+
+// MemoryPercent returns how many percent of the total RAM this process uses
+func (p *Process) MemoryPercent() (float32, error) {
+	return p.MemoryPercentWithContext(context.Background())
+}
+
+func (p *Process) MemoryPercentWithContext(ctx context.Context) (float32, error) {
+	machineMemory, err := mem.VirtualMemory()
+	if err != nil {
+		return 0, err
+	}
+	total := machineMemory.Total
+
+	processMemory, err := p.MemoryInfo()
+	if err != nil {
+		return 0, err
+	}
+	used := processMemory.RSS
+
+	return (100 * float32(used) / float32(total)), nil
+}
+
+// CPU_Percent returns how many percent of the CPU time this process uses
+func (p *Process) CPUPercent() (float64, error) {
+	return p.CPUPercentWithContext(context.Background())
+}
+
+func (p *Process) CPUPercentWithContext(ctx context.Context) (float64, error) {
+	crt_time, err := p.CreateTime()
+	if err != nil {
+		return 0, err
+	}
+
+	cput, err := p.Times()
+	if err != nil {
+		return 0, err
+	}
+
+	created := time.Unix(0, crt_time*int64(time.Millisecond))
+	totalTime := time.Since(created).Seconds()
+	if totalTime <= 0 {
+		return 0, nil
+	}
+
+	return 100 * cput.Total() / totalTime, nil
+}

vendor/github.com/shirou/gopsutil/process/process_darwin.go

@@ -0,0 +1,647 @@
+// +build darwin
+
+package process
+
+import (
+	"bytes"
+	"context"
+	"encoding/binary"
+	"fmt"
+	"os/exec"
+	"strconv"
+	"strings"
+	"time"
+	"unsafe"
+
+	"github.com/shirou/gopsutil/cpu"
+	"github.com/shirou/gopsutil/internal/common"
+	"github.com/shirou/gopsutil/net"
+	"golang.org/x/sys/unix"
+)
+
+// copied from sys/sysctl.h
+const (
+	CTLKern          = 1  // "high kernel": proc, limits
+	KernProc         = 14 // struct: process entries
+	KernProcPID      = 1  // by process id
+	KernProcProc     = 8  // only return procs
+	KernProcAll      = 0  // everything
+	KernProcPathname = 12 // path to executable
+)
+
+const (
+	ClockTicks = 100 // C.sysconf(C._SC_CLK_TCK)
+)
+
+type _Ctype_struct___0 struct {
+	Pad uint64
+}
+
+// MemoryInfoExStat is different between OSes
+type MemoryInfoExStat struct {
+}
+
+type MemoryMapsStat struct {
+}
+
+func Pids() ([]int32, error) {
+	return PidsWithContext(context.Background())
+}
+
+func PidsWithContext(ctx context.Context) ([]int32, error) {
+	var ret []int32
+
+	pids, err := callPsWithContext(ctx, "pid", 0, false)
+	if err != nil {
+		return ret, err
+	}
+
+	for _, pid := range pids {
+		v, err := strconv.Atoi(pid[0])
+		if err != nil {
+			return ret, err
+		}
+		ret = append(ret, int32(v))
+	}
+
+	return ret, nil
+}
+
+func (p *Process) Ppid() (int32, error) {
+	return p.PpidWithContext(context.Background())
+}
+
+func (p *Process) PpidWithContext(ctx context.Context) (int32, error) {
+	r, err := callPsWithContext(ctx, "ppid", p.Pid, false)
+	if err != nil {
+		return 0, err
+	}
+
+	v, err := strconv.Atoi(r[0][0])
+	if err != nil {
+		return 0, err
+	}
+
+	return int32(v), err
+}
+func (p *Process) Name() (string, error) {
+	return p.NameWithContext(context.Background())
+}
+
+func (p *Process) NameWithContext(ctx context.Context) (string, error) {
+	k, err := p.getKProc()
+	if err != nil {
+		return "", err
+	}
+
+	return common.IntToString(k.Proc.P_comm[:]), nil
+}
+func (p *Process) Tgid() (int32, error) {
+	return 0, common.ErrNotImplementedError
+}
+func (p *Process) Exe() (string, error) {
+	return p.ExeWithContext(context.Background())
+}
+
+func (p *Process) ExeWithContext(ctx context.Context) (string, error) {
+	lsof_bin, err := exec.LookPath("lsof")
+	if err != nil {
+		return "", err
+	}
+
+	awk_bin, err := exec.LookPath("awk")
+	if err != nil {
+		return "", err
+	}
+
+	sed_bin, err := exec.LookPath("sed")
+	if err != nil {
+		return "", err
+	}
+
+	lsof := exec.CommandContext(ctx, lsof_bin, "-p", strconv.Itoa(int(p.Pid)), "-Fpfn")
+	awk := exec.CommandContext(ctx, awk_bin, "NR==5{print}")
+	sed := exec.CommandContext(ctx, sed_bin, "s/n\\//\\//")
+
+	output, _, err := common.Pipeline(lsof, awk, sed)
+
+	if err != nil {
+		return "", err
+	}
+
+	ret := strings.TrimSpace(string(output))
+
+	return ret, nil
+}
+
+// Cmdline returns the command line arguments of the process as a string with
+// each argument separated by 0x20 ascii character.
+func (p *Process) Cmdline() (string, error) {
+	return p.CmdlineWithContext(context.Background())
+}
+
+func (p *Process) CmdlineWithContext(ctx context.Context) (string, error) {
+	r, err := callPsWithContext(ctx, "command", p.Pid, false)
+	if err != nil {
+		return "", err
+	}
+	return strings.Join(r[0], " "), err
+}
+
+// CmdlineSlice returns the command line arguments of the process as a slice with each
+// element being an argument. Because of current deficiencies in the way that the command
+// line arguments are found, single arguments that have spaces in the will actually be
+// reported as two separate items. In order to do something better CGO would be needed
+// to use the native darwin functions.
+func (p *Process) CmdlineSlice() ([]string, error) {
+	return p.CmdlineSliceWithContext(context.Background())
+}
+
+func (p *Process) CmdlineSliceWithContext(ctx context.Context) ([]string, error) {
+	r, err := callPsWithContext(ctx, "command", p.Pid, false)
+	if err != nil {
+		return nil, err
+	}
+	return r[0], err
+}
+func (p *Process) CreateTime() (int64, error) {
+	return p.CreateTimeWithContext(context.Background())
+}
+
+func (p *Process) CreateTimeWithContext(ctx context.Context) (int64, error) {
+	r, err := callPsWithContext(ctx, "etime", p.Pid, false)
+	if err != nil {
+		return 0, err
+	}
+
+	elapsedSegments := strings.Split(strings.Replace(r[0][0], "-", ":", 1), ":")
+	var elapsedDurations []time.Duration
+	for i := len(elapsedSegments) - 1; i >= 0; i-- {
+		p, err := strconv.ParseInt(elapsedSegments[i], 10, 0)
+		if err != nil {
+			return 0, err
+		}
+		elapsedDurations = append(elapsedDurations, time.Duration(p))
+	}
+
+	var elapsed = time.Duration(elapsedDurations[0]) * time.Second
+	if len(elapsedDurations) > 1 {
+		elapsed += time.Duration(elapsedDurations[1]) * time.Minute
+	}
+	if len(elapsedDurations) > 2 {
+		elapsed += time.Duration(elapsedDurations[2]) * time.Hour
+	}
+	if len(elapsedDurations) > 3 {
+		elapsed += time.Duration(elapsedDurations[3]) * time.Hour * 24
+	}
+
+	start := time.Now().Add(-elapsed)
+	return start.Unix() * 1000, nil
+}
+func (p *Process) Cwd() (string, error) {
+	return p.CwdWithContext(context.Background())
+}
+
+func (p *Process) CwdWithContext(ctx context.Context) (string, error) {
+	return "", common.ErrNotImplementedError
+}
+func (p *Process) Parent() (*Process, error) {
+	return p.ParentWithContext(context.Background())
+}
+
+func (p *Process) ParentWithContext(ctx context.Context) (*Process, error) {
+	rr, err := common.CallLsofWithContext(ctx, invoke, p.Pid, "-FR")
+	if err != nil {
+		return nil, err
+	}
+	for _, r := range rr {
+		if strings.HasPrefix(r, "p") { // skip if process
+			continue
+		}
+		l := string(r)
+		v, err := strconv.Atoi(strings.Replace(l, "R", "", 1))
+		if err != nil {
+			return nil, err
+		}
+		return NewProcess(int32(v))
+	}
+	return nil, fmt.Errorf("could not find parent line")
+}
+func (p *Process) Status() (string, error) {
+	return p.StatusWithContext(context.Background())
+}
+
+func (p *Process) StatusWithContext(ctx context.Context) (string, error) {
+	r, err := callPsWithContext(ctx, "state", p.Pid, false)
+	if err != nil {
+		return "", err
+	}
+
+	return r[0][0], err
+}
+func (p *Process) Uids() ([]int32, error) {
+	return p.UidsWithContext(context.Background())
+}
+
+func (p *Process) UidsWithContext(ctx context.Context) ([]int32, error) {
+	k, err := p.getKProc()
+	if err != nil {
+		return nil, err
+	}
+
+	// See: http://unix.superglobalmegacorp.com/Net2/newsrc/sys/ucred.h.html
+	userEffectiveUID := int32(k.Eproc.Ucred.UID)
+
+	return []int32{userEffectiveUID}, nil
+}
+func (p *Process) Gids() ([]int32, error) {
+	return p.GidsWithContext(context.Background())
+}
+
+func (p *Process) GidsWithContext(ctx context.Context) ([]int32, error) {
+	k, err := p.getKProc()
+	if err != nil {
+		return nil, err
+	}
+
+	gids := make([]int32, 0, 3)
+	gids = append(gids, int32(k.Eproc.Pcred.P_rgid), int32(k.Eproc.Ucred.Ngroups), int32(k.Eproc.Pcred.P_svgid))
+
+	return gids, nil
+}
+func (p *Process) Terminal() (string, error) {
+	return p.TerminalWithContext(context.Background())
+}
+
+func (p *Process) TerminalWithContext(ctx context.Context) (string, error) {
+	return "", common.ErrNotImplementedError
+	/*
+		k, err := p.getKProc()
+		if err != nil {
+			return "", err
+		}
+
+		ttyNr := uint64(k.Eproc.Tdev)
+		termmap, err := getTerminalMap()
+		if err != nil {
+			return "", err
+		}
+
+		return termmap[ttyNr], nil
+	*/
+}
+func (p *Process) Nice() (int32, error) {
+	return p.NiceWithContext(context.Background())
+}
+
+func (p *Process) NiceWithContext(ctx context.Context) (int32, error) {
+	k, err := p.getKProc()
+	if err != nil {
+		return 0, err
+	}
+	return int32(k.Proc.P_nice), nil
+}
+func (p *Process) IOnice() (int32, error) {
+	return p.IOniceWithContext(context.Background())
+}
+
+func (p *Process) IOniceWithContext(ctx context.Context) (int32, error) {
+	return 0, common.ErrNotImplementedError
+}
+func (p *Process) Rlimit() ([]RlimitStat, error) {
+	return p.RlimitWithContext(context.Background())
+}
+
+func (p *Process) RlimitWithContext(ctx context.Context) ([]RlimitStat, error) {
+	var rlimit []RlimitStat
+	return rlimit, common.ErrNotImplementedError
+}
+func (p *Process) RlimitUsage(gatherUsed bool) ([]RlimitStat, error) {
+	return p.RlimitUsageWithContext(context.Background(), gatherUsed)
+}
+
+func (p *Process) RlimitUsageWithContext(ctx context.Context, gatherUsed bool) ([]RlimitStat, error) {
+	var rlimit []RlimitStat
+	return rlimit, common.ErrNotImplementedError
+}
+func (p *Process) IOCounters() (*IOCountersStat, error) {
+	return p.IOCountersWithContext(context.Background())
+}
+
+func (p *Process) IOCountersWithContext(ctx context.Context) (*IOCountersStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+func (p *Process) NumCtxSwitches() (*NumCtxSwitchesStat, error) {
+	return p.NumCtxSwitchesWithContext(context.Background())
+}
+
+func (p *Process) NumCtxSwitchesWithContext(ctx context.Context) (*NumCtxSwitchesStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+func (p *Process) NumFDs() (int32, error) {
+	return p.NumFDsWithContext(context.Background())
+}
+
+func (p *Process) NumFDsWithContext(ctx context.Context) (int32, error) {
+	return 0, common.ErrNotImplementedError
+}
+func (p *Process) NumThreads() (int32, error) {
+	return p.NumThreadsWithContext(context.Background())
+}
+
+func (p *Process) NumThreadsWithContext(ctx context.Context) (int32, error) {
+	r, err := callPsWithContext(ctx, "utime,stime", p.Pid, true)
+	if err != nil {
+		return 0, err
+	}
+	return int32(len(r)), nil
+}
+func (p *Process) Threads() (map[int32]*cpu.TimesStat, error) {
+	return p.ThreadsWithContext(context.Background())
+}
+
+func (p *Process) ThreadsWithContext(ctx context.Context) (map[int32]*cpu.TimesStat, error) {
+	ret := make(map[int32]*cpu.TimesStat)
+	return ret, common.ErrNotImplementedError
+}
+
+func convertCPUTimes(s string) (ret float64, err error) {
+	var t int
+	var _tmp string
+	if strings.Contains(s, ":") {
+		_t := strings.Split(s, ":")
+		hour, err := strconv.Atoi(_t[0])
+		if err != nil {
+			return ret, err
+		}
+		t += hour * 60 * 100
+		_tmp = _t[1]
+	} else {
+		_tmp = s
+	}
+
+	_t := strings.Split(_tmp, ".")
+	if err != nil {
+		return ret, err
+	}
+	h, err := strconv.Atoi(_t[0])
+	t += h * 100
+	h, err = strconv.Atoi(_t[1])
+	t += h
+	return float64(t) / ClockTicks, nil
+}
+func (p *Process) Times() (*cpu.TimesStat, error) {
+	return p.TimesWithContext(context.Background())
+}
+
+func (p *Process) TimesWithContext(ctx context.Context) (*cpu.TimesStat, error) {
+	r, err := callPsWithContext(ctx, "utime,stime", p.Pid, false)
+
+	if err != nil {
+		return nil, err
+	}
+
+	utime, err := convertCPUTimes(r[0][0])
+	if err != nil {
+		return nil, err
+	}
+	stime, err := convertCPUTimes(r[0][1])
+	if err != nil {
+		return nil, err
+	}
+
+	ret := &cpu.TimesStat{
+		CPU:    "cpu",
+		User:   utime,
+		System: stime,
+	}
+	return ret, nil
+}
+func (p *Process) CPUAffinity() ([]int32, error) {
+	return p.CPUAffinityWithContext(context.Background())
+}
+
+func (p *Process) CPUAffinityWithContext(ctx context.Context) ([]int32, error) {
+	return nil, common.ErrNotImplementedError
+}
+func (p *Process) MemoryInfo() (*MemoryInfoStat, error) {
+	return p.MemoryInfoWithContext(context.Background())
+}
+
+func (p *Process) MemoryInfoWithContext(ctx context.Context) (*MemoryInfoStat, error) {
+	r, err := callPsWithContext(ctx, "rss,vsize,pagein", p.Pid, false)
+	if err != nil {
+		return nil, err
+	}
+	rss, err := strconv.Atoi(r[0][0])
+	if err != nil {
+		return nil, err
+	}
+	vms, err := strconv.Atoi(r[0][1])
+	if err != nil {
+		return nil, err
+	}
+	pagein, err := strconv.Atoi(r[0][2])
+	if err != nil {
+		return nil, err
+	}
+
+	ret := &MemoryInfoStat{
+		RSS:  uint64(rss) * 1024,
+		VMS:  uint64(vms) * 1024,
+		Swap: uint64(pagein),
+	}
+
+	return ret, nil
+}
+func (p *Process) MemoryInfoEx() (*MemoryInfoExStat, error) {
+	return p.MemoryInfoExWithContext(context.Background())
+}
+
+func (p *Process) MemoryInfoExWithContext(ctx context.Context) (*MemoryInfoExStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+
+func (p *Process) Children() ([]*Process, error) {
+	return p.ChildrenWithContext(context.Background())
+}
+
+func (p *Process) ChildrenWithContext(ctx context.Context) ([]*Process, error) {
+	pids, err := common.CallPgrepWithContext(ctx, invoke, p.Pid)
+	if err != nil {
+		return nil, err
+	}
+	ret := make([]*Process, 0, len(pids))
+	for _, pid := range pids {
+		np, err := NewProcess(pid)
+		if err != nil {
+			return nil, err
+		}
+		ret = append(ret, np)
+	}
+	return ret, nil
+}
+
+func (p *Process) OpenFiles() ([]OpenFilesStat, error) {
+	return p.OpenFilesWithContext(context.Background())
+}
+
+func (p *Process) OpenFilesWithContext(ctx context.Context) ([]OpenFilesStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+
+func (p *Process) Connections() ([]net.ConnectionStat, error) {
+	return p.ConnectionsWithContext(context.Background())
+}
+
+func (p *Process) ConnectionsWithContext(ctx context.Context) ([]net.ConnectionStat, error) {
+	return net.ConnectionsPid("all", p.Pid)
+}
+
+func (p *Process) NetIOCounters(pernic bool) ([]net.IOCountersStat, error) {
+	return p.NetIOCountersWithContext(context.Background(), pernic)
+}
+
+func (p *Process) NetIOCountersWithContext(ctx context.Context, pernic bool) ([]net.IOCountersStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+
+func (p *Process) IsRunning() (bool, error) {
+	return p.IsRunningWithContext(context.Background())
+}
+
+func (p *Process) IsRunningWithContext(ctx context.Context) (bool, error) {
+	return true, common.ErrNotImplementedError
+}
+func (p *Process) MemoryMaps(grouped bool) (*[]MemoryMapsStat, error) {
+	return p.MemoryMapsWithContext(context.Background(), grouped)
+}
+
+func (p *Process) MemoryMapsWithContext(ctx context.Context, grouped bool) (*[]MemoryMapsStat, error) {
+	var ret []MemoryMapsStat
+	return &ret, common.ErrNotImplementedError
+}
+
+func Processes() ([]*Process, error) {
+	return ProcessesWithContext(context.Background())
+}
+
+func ProcessesWithContext(ctx context.Context) ([]*Process, error) {
+	results := []*Process{}
+
+	mib := []int32{CTLKern, KernProc, KernProcAll, 0}
+	buf, length, err := common.CallSyscall(mib)
+	if err != nil {
+		return results, err
+	}
+
+	// get kinfo_proc size
+	k := KinfoProc{}
+	procinfoLen := int(unsafe.Sizeof(k))
+	count := int(length / uint64(procinfoLen))
+
+	// parse buf to procs
+	for i := 0; i < count; i++ {
+		b := buf[i*procinfoLen : i*procinfoLen+procinfoLen]
+		k, err := parseKinfoProc(b)
+		if err != nil {
+			continue
+		}
+		p, err := NewProcess(int32(k.Proc.P_pid))
+		if err != nil {
+			continue
+		}
+		results = append(results, p)
+	}
+
+	return results, nil
+}
+
+func parseKinfoProc(buf []byte) (KinfoProc, error) {
+	var k KinfoProc
+	br := bytes.NewReader(buf)
+
+	err := common.Read(br, binary.LittleEndian, &k)
+	if err != nil {
+		return k, err
+	}
+
+	return k, nil
+}
+
+// Returns a proc as defined here:
+// http://unix.superglobalmegacorp.com/Net2/newsrc/sys/kinfo_proc.h.html
+func (p *Process) getKProc() (*KinfoProc, error) {
+	return p.getKProcWithContext(context.Background())
+}
+
+func (p *Process) getKProcWithContext(ctx context.Context) (*KinfoProc, error) {
+	mib := []int32{CTLKern, KernProc, KernProcPID, p.Pid}
+	procK := KinfoProc{}
+	length := uint64(unsafe.Sizeof(procK))
+	buf := make([]byte, length)
+	_, _, syserr := unix.Syscall6(
+		unix.SYS___SYSCTL,
+		uintptr(unsafe.Pointer(&mib[0])),
+		uintptr(len(mib)),
+		uintptr(unsafe.Pointer(&buf[0])),
+		uintptr(unsafe.Pointer(&length)),
+		0,
+		0)
+	if syserr != 0 {
+		return nil, syserr
+	}
+	k, err := parseKinfoProc(buf)
+	if err != nil {
+		return nil, err
+	}
+
+	return &k, nil
+}
+
+func NewProcess(pid int32) (*Process, error) {
+	p := &Process{Pid: pid}
+
+	return p, nil
+}
+
+// call ps command.
+// Return value deletes Header line(you must not input wrong arg).
+// And splited by Space. Caller have responsibility to manage.
+// If passed arg pid is 0, get information from all process.
+func callPsWithContext(ctx context.Context, arg string, pid int32, threadOption bool) ([][]string, error) {
+	bin, err := exec.LookPath("ps")
+	if err != nil {
+		return [][]string{}, err
+	}
+
+	var cmd []string
+	if pid == 0 { // will get from all processes.
+		cmd = []string{"-ax", "-o", arg}
+	} else if threadOption {
+		cmd = []string{"-x", "-o", arg, "-M", "-p", strconv.Itoa(int(pid))}
+	} else {
+		cmd = []string{"-x", "-o", arg, "-p", strconv.Itoa(int(pid))}
+	}
+	out, err := invoke.CommandWithContext(ctx, bin, cmd...)
+	if err != nil {
+		return [][]string{}, err
+	}
+	lines := strings.Split(string(out), "\n")
+
+	var ret [][]string
+	for _, l := range lines[1:] {
+		var lr []string
+		for _, r := range strings.Split(l, " ") {
+			if r == "" {
+				continue
+			}
+			lr = append(lr, strings.TrimSpace(r))
+		}
+		if len(lr) != 0 {
+			ret = append(ret, lr)
+		}
+	}
+
+	return ret, nil
+}

vendor/github.com/shirou/gopsutil/process/process_darwin_386.go

@@ -0,0 +1,234 @@
+// Created by cgo -godefs - DO NOT EDIT
+// cgo -godefs types_darwin.go
+
+package process
+
+const (
+	sizeofPtr      = 0x8
+	sizeofShort    = 0x2
+	sizeofInt      = 0x4
+	sizeofLong     = 0x8
+	sizeofLongLong = 0x8
+)
+
+type (
+	_C_short     int16
+	_C_int       int32
+	_C_long      int64
+	_C_long_long int64
+)
+
+type Timespec struct {
+	Sec  int64
+	Nsec int64
+}
+
+type Timeval struct {
+	Sec       int64
+	Usec      int32
+	Pad_cgo_0 [4]byte
+}
+
+type Rusage struct {
+	Utime    Timeval
+	Stime    Timeval
+	Maxrss   int64
+	Ixrss    int64
+	Idrss    int64
+	Isrss    int64
+	Minflt   int64
+	Majflt   int64
+	Nswap    int64
+	Inblock  int64
+	Oublock  int64
+	Msgsnd   int64
+	Msgrcv   int64
+	Nsignals int64
+	Nvcsw    int64
+	Nivcsw   int64
+}
+
+type Rlimit struct {
+	Cur uint64
+	Max uint64
+}
+
+type UGid_t uint32
+
+type KinfoProc struct {
+	Proc  ExternProc
+	Eproc Eproc
+}
+
+type Eproc struct {
+	Paddr     *uint64
+	Sess      *Session
+	Pcred     Upcred
+	Ucred     Uucred
+	Pad_cgo_0 [4]byte
+	Vm        Vmspace
+	Ppid      int32
+	Pgid      int32
+	Jobc      int16
+	Pad_cgo_1 [2]byte
+	Tdev      int32
+	Tpgid     int32
+	Pad_cgo_2 [4]byte
+	Tsess     *Session
+	Wmesg     [8]int8
+	Xsize     int32
+	Xrssize   int16
+	Xccount   int16
+	Xswrss    int16
+	Pad_cgo_3 [2]byte
+	Flag      int32
+	Login     [12]int8
+	Spare     [4]int32
+	Pad_cgo_4 [4]byte
+}
+
+type Proc struct{}
+
+type Session struct{}
+
+type ucred struct {
+	Link  _Ctype_struct___0
+	Ref   uint64
+	Posix Posix_cred
+	Label *Label
+	Audit Au_session
+}
+
+type Uucred struct {
+	Ref       int32
+	UID       uint32
+	Ngroups   int16
+	Pad_cgo_0 [2]byte
+	Groups    [16]uint32
+}
+
+type Upcred struct {
+	Pc_lock   [72]int8
+	Pc_ucred  *ucred
+	P_ruid    uint32
+	P_svuid   uint32
+	P_rgid    uint32
+	P_svgid   uint32
+	P_refcnt  int32
+	Pad_cgo_0 [4]byte
+}
+
+type Vmspace struct {
+	Dummy     int32
+	Pad_cgo_0 [4]byte
+	Dummy2    *int8
+	Dummy3    [5]int32
+	Pad_cgo_1 [4]byte
+	Dummy4    [3]*int8
+}
+
+type Sigacts struct{}
+
+type ExternProc struct {
+	P_un        [16]byte
+	P_vmspace   uint64
+	P_sigacts   uint64
+	Pad_cgo_0   [3]byte
+	P_flag      int32
+	P_stat      int8
+	P_pid       int32
+	P_oppid     int32
+	P_dupfd     int32
+	Pad_cgo_1   [4]byte
+	User_stack  uint64
+	Exit_thread uint64
+	P_debugger  int32
+	Sigwait     int32
+	P_estcpu    uint32
+	P_cpticks   int32
+	P_pctcpu    uint32
+	Pad_cgo_2   [4]byte
+	P_wchan     uint64
+	P_wmesg     uint64
+	P_swtime    uint32
+	P_slptime   uint32
+	P_realtimer Itimerval
+	P_rtime     Timeval
+	P_uticks    uint64
+	P_sticks    uint64
+	P_iticks    uint64
+	P_traceflag int32
+	Pad_cgo_3   [4]byte
+	P_tracep    uint64
+	P_siglist   int32
+	Pad_cgo_4   [4]byte
+	P_textvp    uint64
+	P_holdcnt   int32
+	P_sigmask   uint32
+	P_sigignore uint32
+	P_sigcatch  uint32
+	P_priority  uint8
+	P_usrpri    uint8
+	P_nice      int8
+	P_comm      [17]int8
+	Pad_cgo_5   [4]byte
+	P_pgrp      uint64
+	P_addr      uint64
+	P_xstat     uint16
+	P_acflag    uint16
+	Pad_cgo_6   [4]byte
+	P_ru        uint64
+}
+
+type Itimerval struct {
+	Interval Timeval
+	Value    Timeval
+}
+
+type Vnode struct{}
+
+type Pgrp struct{}
+
+type UserStruct struct{}
+
+type Au_session struct {
+	Aia_p *AuditinfoAddr
+	Mask  AuMask
+}
+
+type Posix_cred struct {
+	UID       uint32
+	Ruid      uint32
+	Svuid     uint32
+	Ngroups   int16
+	Pad_cgo_0 [2]byte
+	Groups    [16]uint32
+	Rgid      uint32
+	Svgid     uint32
+	Gmuid     uint32
+	Flags     int32
+}
+
+type Label struct{}
+
+type AuditinfoAddr struct {
+	Auid   uint32
+	Mask   AuMask
+	Termid AuTidAddr
+	Asid   int32
+	Flags  uint64
+}
+type AuMask struct {
+	Success uint32
+	Failure uint32
+}
+type AuTidAddr struct {
+	Port int32
+	Type uint32
+	Addr [4]uint32
+}
+
+type UcredQueue struct {
+	Next *ucred
+	Prev **ucred
+}

vendor/github.com/shirou/gopsutil/process/process_darwin_amd64.go

@@ -0,0 +1,234 @@
+// Created by cgo -godefs - DO NOT EDIT
+// cgo -godefs types_darwin.go
+
+package process
+
+const (
+	sizeofPtr      = 0x8
+	sizeofShort    = 0x2
+	sizeofInt      = 0x4
+	sizeofLong     = 0x8
+	sizeofLongLong = 0x8
+)
+
+type (
+	_C_short     int16
+	_C_int       int32
+	_C_long      int64
+	_C_long_long int64
+)
+
+type Timespec struct {
+	Sec  int64
+	Nsec int64
+}
+
+type Timeval struct {
+	Sec       int64
+	Usec      int32
+	Pad_cgo_0 [4]byte
+}
+
+type Rusage struct {
+	Utime    Timeval
+	Stime    Timeval
+	Maxrss   int64
+	Ixrss    int64
+	Idrss    int64
+	Isrss    int64
+	Minflt   int64
+	Majflt   int64
+	Nswap    int64
+	Inblock  int64
+	Oublock  int64
+	Msgsnd   int64
+	Msgrcv   int64
+	Nsignals int64
+	Nvcsw    int64
+	Nivcsw   int64
+}
+
+type Rlimit struct {
+	Cur uint64
+	Max uint64
+}
+
+type UGid_t uint32
+
+type KinfoProc struct {
+	Proc  ExternProc
+	Eproc Eproc
+}
+
+type Eproc struct {
+	Paddr     *uint64
+	Sess      *Session
+	Pcred     Upcred
+	Ucred     Uucred
+	Pad_cgo_0 [4]byte
+	Vm        Vmspace
+	Ppid      int32
+	Pgid      int32
+	Jobc      int16
+	Pad_cgo_1 [2]byte
+	Tdev      int32
+	Tpgid     int32
+	Pad_cgo_2 [4]byte
+	Tsess     *Session
+	Wmesg     [8]int8
+	Xsize     int32
+	Xrssize   int16
+	Xccount   int16
+	Xswrss    int16
+	Pad_cgo_3 [2]byte
+	Flag      int32
+	Login     [12]int8
+	Spare     [4]int32
+	Pad_cgo_4 [4]byte
+}
+
+type Proc struct{}
+
+type Session struct{}
+
+type ucred struct {
+	Link  _Ctype_struct___0
+	Ref   uint64
+	Posix Posix_cred
+	Label *Label
+	Audit Au_session
+}
+
+type Uucred struct {
+	Ref       int32
+	UID       uint32
+	Ngroups   int16
+	Pad_cgo_0 [2]byte
+	Groups    [16]uint32
+}
+
+type Upcred struct {
+	Pc_lock   [72]int8
+	Pc_ucred  *ucred
+	P_ruid    uint32
+	P_svuid   uint32
+	P_rgid    uint32
+	P_svgid   uint32
+	P_refcnt  int32
+	Pad_cgo_0 [4]byte
+}
+
+type Vmspace struct {
+	Dummy     int32
+	Pad_cgo_0 [4]byte
+	Dummy2    *int8
+	Dummy3    [5]int32
+	Pad_cgo_1 [4]byte
+	Dummy4    [3]*int8
+}
+
+type Sigacts struct{}
+
+type ExternProc struct {
+	P_un        [16]byte
+	P_vmspace   uint64
+	P_sigacts   uint64
+	Pad_cgo_0   [3]byte
+	P_flag      int32
+	P_stat      int8
+	P_pid       int32
+	P_oppid     int32
+	P_dupfd     int32
+	Pad_cgo_1   [4]byte
+	User_stack  uint64
+	Exit_thread uint64
+	P_debugger  int32
+	Sigwait     int32
+	P_estcpu    uint32
+	P_cpticks   int32
+	P_pctcpu    uint32
+	Pad_cgo_2   [4]byte
+	P_wchan     uint64
+	P_wmesg     uint64
+	P_swtime    uint32
+	P_slptime   uint32
+	P_realtimer Itimerval
+	P_rtime     Timeval
+	P_uticks    uint64
+	P_sticks    uint64
+	P_iticks    uint64
+	P_traceflag int32
+	Pad_cgo_3   [4]byte
+	P_tracep    uint64
+	P_siglist   int32
+	Pad_cgo_4   [4]byte
+	P_textvp    uint64
+	P_holdcnt   int32
+	P_sigmask   uint32
+	P_sigignore uint32
+	P_sigcatch  uint32
+	P_priority  uint8
+	P_usrpri    uint8
+	P_nice      int8
+	P_comm      [17]int8
+	Pad_cgo_5   [4]byte
+	P_pgrp      uint64
+	P_addr      uint64
+	P_xstat     uint16
+	P_acflag    uint16
+	Pad_cgo_6   [4]byte
+	P_ru        uint64
+}
+
+type Itimerval struct {
+	Interval Timeval
+	Value    Timeval
+}
+
+type Vnode struct{}
+
+type Pgrp struct{}
+
+type UserStruct struct{}
+
+type Au_session struct {
+	Aia_p *AuditinfoAddr
+	Mask  AuMask
+}
+
+type Posix_cred struct {
+	UID       uint32
+	Ruid      uint32
+	Svuid     uint32
+	Ngroups   int16
+	Pad_cgo_0 [2]byte
+	Groups    [16]uint32
+	Rgid      uint32
+	Svgid     uint32
+	Gmuid     uint32
+	Flags     int32
+}
+
+type Label struct{}
+
+type AuditinfoAddr struct {
+	Auid   uint32
+	Mask   AuMask
+	Termid AuTidAddr
+	Asid   int32
+	Flags  uint64
+}
+type AuMask struct {
+	Success uint32
+	Failure uint32
+}
+type AuTidAddr struct {
+	Port int32
+	Type uint32
+	Addr [4]uint32
+}
+
+type UcredQueue struct {
+	Next *ucred
+	Prev **ucred
+}

vendor/github.com/shirou/gopsutil/process/process_fallback.go

@@ -0,0 +1,312 @@
+// +build !darwin,!linux,!freebsd,!openbsd,!windows
+
+package process
+
+import (
+	"context"
+	"syscall"
+
+	"github.com/shirou/gopsutil/cpu"
+	"github.com/shirou/gopsutil/internal/common"
+	"github.com/shirou/gopsutil/net"
+)
+
+type MemoryMapsStat struct {
+	Path         string `json:"path"`
+	Rss          uint64 `json:"rss"`
+	Size         uint64 `json:"size"`
+	Pss          uint64 `json:"pss"`
+	SharedClean  uint64 `json:"sharedClean"`
+	SharedDirty  uint64 `json:"sharedDirty"`
+	PrivateClean uint64 `json:"privateClean"`
+	PrivateDirty uint64 `json:"privateDirty"`
+	Referenced   uint64 `json:"referenced"`
+	Anonymous    uint64 `json:"anonymous"`
+	Swap         uint64 `json:"swap"`
+}
+
+type MemoryInfoExStat struct {
+}
+
+func Pids() ([]int32, error) {
+	return PidsWithContext(context.Background())
+}
+
+func PidsWithContext(ctx context.Context) ([]int32, error) {
+	return []int32{}, common.ErrNotImplementedError
+}
+
+func Processes() ([]*Process, error) {
+	return nil, common.ErrNotImplementedError
+}
+
+func ProcessesWithContext(ctx context.Context) ([]*Process, error) {
+	return nil, common.ErrNotImplementedError
+}
+
+func NewProcess(pid int32) (*Process, error) {
+	return nil, common.ErrNotImplementedError
+}
+
+func (p *Process) Ppid() (int32, error) {
+	return p.PpidWithContext(context.Background())
+}
+
+func (p *Process) PpidWithContext(ctx context.Context) (int32, error) {
+	return 0, common.ErrNotImplementedError
+}
+func (p *Process) Name() (string, error) {
+	return p.NameWithContext(context.Background())
+}
+
+func (p *Process) NameWithContext(ctx context.Context) (string, error) {
+	return "", common.ErrNotImplementedError
+}
+func (p *Process) Tgid() (int32, error) {
+	return 0, common.ErrNotImplementedError
+}
+func (p *Process) Exe() (string, error) {
+	return p.ExeWithContext(context.Background())
+}
+
+func (p *Process) ExeWithContext(ctx context.Context) (string, error) {
+	return "", common.ErrNotImplementedError
+}
+func (p *Process) Cmdline() (string, error) {
+	return p.CmdlineWithContext(context.Background())
+}
+
+func (p *Process) CmdlineWithContext(ctx context.Context) (string, error) {
+	return "", common.ErrNotImplementedError
+}
+func (p *Process) CmdlineSlice() ([]string, error) {
+	return p.CmdlineSliceWithContext(context.Background())
+}
+
+func (p *Process) CmdlineSliceWithContext(ctx context.Context) ([]string, error) {
+	return []string{}, common.ErrNotImplementedError
+}
+func (p *Process) CreateTime() (int64, error) {
+	return p.CreateTimeWithContext(context.Background())
+}
+
+func (p *Process) CreateTimeWithContext(ctx context.Context) (int64, error) {
+	return 0, common.ErrNotImplementedError
+}
+func (p *Process) Cwd() (string, error) {
+	return p.CwdWithContext(context.Background())
+}
+
+func (p *Process) CwdWithContext(ctx context.Context) (string, error) {
+	return "", common.ErrNotImplementedError
+}
+func (p *Process) Parent() (*Process, error) {
+	return p.ParentWithContext(context.Background())
+}
+
+func (p *Process) ParentWithContext(ctx context.Context) (*Process, error) {
+	return nil, common.ErrNotImplementedError
+}
+func (p *Process) Status() (string, error) {
+	return p.StatusWithContext(context.Background())
+}
+
+func (p *Process) StatusWithContext(ctx context.Context) (string, error) {
+	return "", common.ErrNotImplementedError
+}
+func (p *Process) Uids() ([]int32, error) {
+	return p.UidsWithContext(context.Background())
+}
+
+func (p *Process) UidsWithContext(ctx context.Context) ([]int32, error) {
+	return []int32{}, common.ErrNotImplementedError
+}
+func (p *Process) Gids() ([]int32, error) {
+	return p.GidsWithContext(context.Background())
+}
+
+func (p *Process) GidsWithContext(ctx context.Context) ([]int32, error) {
+	return []int32{}, common.ErrNotImplementedError
+}
+func (p *Process) Terminal() (string, error) {
+	return p.TerminalWithContext(context.Background())
+}
+
+func (p *Process) TerminalWithContext(ctx context.Context) (string, error) {
+	return "", common.ErrNotImplementedError
+}
+func (p *Process) Nice() (int32, error) {
+	return p.NiceWithContext(context.Background())
+}
+
+func (p *Process) NiceWithContext(ctx context.Context) (int32, error) {
+	return 0, common.ErrNotImplementedError
+}
+func (p *Process) IOnice() (int32, error) {
+	return p.IOniceWithContext(context.Background())
+}
+
+func (p *Process) IOniceWithContext(ctx context.Context) (int32, error) {
+	return 0, common.ErrNotImplementedError
+}
+func (p *Process) Rlimit() ([]RlimitStat, error) {
+	return p.RlimitWithContext(context.Background())
+}
+
+func (p *Process) RlimitWithContext(ctx context.Context) ([]RlimitStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+func (p *Process) RlimitUsage(gatherUsed bool) ([]RlimitStat, error) {
+	return p.RlimitUsageWithContext(context.Background(), gatherUsed)
+}
+
+func (p *Process) RlimitUsageWithContext(ctx context.Context, gatherUsed bool) ([]RlimitStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+func (p *Process) IOCounters() (*IOCountersStat, error) {
+	return p.IOCountersWithContext(context.Background())
+}
+
+func (p *Process) IOCountersWithContext(ctx context.Context) (*IOCountersStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+func (p *Process) NumCtxSwitches() (*NumCtxSwitchesStat, error) {
+	return p.NumCtxSwitchesWithContext(context.Background())
+}
+
+func (p *Process) NumCtxSwitchesWithContext(ctx context.Context) (*NumCtxSwitchesStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+func (p *Process) NumFDs() (int32, error) {
+	return p.NumFDsWithContext(context.Background())
+}
+
+func (p *Process) NumFDsWithContext(ctx context.Context) (int32, error) {
+	return 0, common.ErrNotImplementedError
+}
+func (p *Process) NumThreads() (int32, error) {
+	return p.NumThreadsWithContext(context.Background())
+}
+
+func (p *Process) NumThreadsWithContext(ctx context.Context) (int32, error) {
+	return 0, common.ErrNotImplementedError
+}
+func (p *Process) Threads() (map[int32]*cpu.TimesStat, error) {
+	return p.ThreadsWithContext(context.Background())
+}
+
+func (p *Process) ThreadsWithContext(ctx context.Context) (map[int32]*cpu.TimesStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+func (p *Process) Times() (*cpu.TimesStat, error) {
+	return p.TimesWithContext(context.Background())
+}
+
+func (p *Process) TimesWithContext(ctx context.Context) (*cpu.TimesStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+func (p *Process) CPUAffinity() ([]int32, error) {
+	return p.CPUAffinityWithContext(context.Background())
+}
+
+func (p *Process) CPUAffinityWithContext(ctx context.Context) ([]int32, error) {
+	return nil, common.ErrNotImplementedError
+}
+func (p *Process) MemoryInfo() (*MemoryInfoStat, error) {
+	return p.MemoryInfoWithContext(context.Background())
+}
+
+func (p *Process) MemoryInfoWithContext(ctx context.Context) (*MemoryInfoStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+func (p *Process) MemoryInfoEx() (*MemoryInfoExStat, error) {
+	return p.MemoryInfoExWithContext(context.Background())
+}
+
+func (p *Process) MemoryInfoExWithContext(ctx context.Context) (*MemoryInfoExStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+func (p *Process) Children() ([]*Process, error) {
+	return p.ChildrenWithContext(context.Background())
+}
+
+func (p *Process) ChildrenWithContext(ctx context.Context) ([]*Process, error) {
+	return nil, common.ErrNotImplementedError
+}
+func (p *Process) OpenFiles() ([]OpenFilesStat, error) {
+	return p.OpenFilesWithContext(context.Background())
+}
+
+func (p *Process) OpenFilesWithContext(ctx context.Context) ([]OpenFilesStat, error) {
+	return []OpenFilesStat{}, common.ErrNotImplementedError
+}
+func (p *Process) Connections() ([]net.ConnectionStat, error) {
+	return p.ConnectionsWithContext(context.Background())
+}
+
+func (p *Process) ConnectionsWithContext(ctx context.Context) ([]net.ConnectionStat, error) {
+	return []net.ConnectionStat{}, common.ErrNotImplementedError
+}
+func (p *Process) NetIOCounters(pernic bool) ([]net.IOCountersStat, error) {
+	return p.NetIOCountersWithContext(context.Background(), pernic)
+}
+
+func (p *Process) NetIOCountersWithContext(ctx context.Context, pernic bool) ([]net.IOCountersStat, error) {
+	return []net.IOCountersStat{}, common.ErrNotImplementedError
+}
+func (p *Process) IsRunning() (bool, error) {
+	return p.IsRunningWithContext(context.Background())
+}
+
+func (p *Process) IsRunningWithContext(ctx context.Context) (bool, error) {
+	return true, common.ErrNotImplementedError
+}
+func (p *Process) MemoryMaps(grouped bool) (*[]MemoryMapsStat, error) {
+	return p.MemoryMapsWithContext(context.Background(), grouped)
+}
+
+func (p *Process) MemoryMapsWithContext(ctx context.Context, grouped bool) (*[]MemoryMapsStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+func (p *Process) SendSignal(sig syscall.Signal) error {
+	return p.SendSignalWithContext(context.Background(), sig)
+}
+
+func (p *Process) SendSignalWithContext(ctx context.Context, sig syscall.Signal) error {
+	return common.ErrNotImplementedError
+}
+func (p *Process) Suspend() error {
+	return p.SuspendWithContext(context.Background())
+}
+
+func (p *Process) SuspendWithContext(ctx context.Context) error {
+	return common.ErrNotImplementedError
+}
+func (p *Process) Resume() error {
+	return p.ResumeWithContext(context.Background())
+}
+
+func (p *Process) ResumeWithContext(ctx context.Context) error {
+	return common.ErrNotImplementedError
+}
+func (p *Process) Terminate() error {
+	return p.TerminateWithContext(context.Background())
+}
+
+func (p *Process) TerminateWithContext(ctx context.Context) error {
+	return common.ErrNotImplementedError
+}
+func (p *Process) Kill() error {
+	return p.KillWithContext(context.Background())
+}
+
+func (p *Process) KillWithContext(ctx context.Context) error {
+	return common.ErrNotImplementedError
+}
+func (p *Process) Username() (string, error) {
+	return p.UsernameWithContext(context.Background())
+}
+
+func (p *Process) UsernameWithContext(ctx context.Context) (string, error) {
+	return "", common.ErrNotImplementedError
+}

vendor/github.com/shirou/gopsutil/process/process_freebsd.go

@@ -0,0 +1,480 @@
+// +build freebsd
+
+package process
+
+import (
+	"bytes"
+	"context"
+	"encoding/binary"
+	"strings"
+
+	cpu "github.com/shirou/gopsutil/cpu"
+	"github.com/shirou/gopsutil/internal/common"
+	net "github.com/shirou/gopsutil/net"
+	"golang.org/x/sys/unix"
+)
+
+// MemoryInfoExStat is different between OSes
+type MemoryInfoExStat struct {
+}
+
+type MemoryMapsStat struct {
+}
+
+func Pids() ([]int32, error) {
+	return PidsWithContext(context.Background())
+}
+
+func PidsWithContext(ctx context.Context) ([]int32, error) {
+	var ret []int32
+	procs, err := Processes()
+	if err != nil {
+		return ret, nil
+	}
+
+	for _, p := range procs {
+		ret = append(ret, p.Pid)
+	}
+
+	return ret, nil
+}
+
+func (p *Process) Ppid() (int32, error) {
+	return p.PpidWithContext(context.Background())
+}
+
+func (p *Process) PpidWithContext(ctx context.Context) (int32, error) {
+	k, err := p.getKProc()
+	if err != nil {
+		return 0, err
+	}
+
+	return k.Ppid, nil
+}
+func (p *Process) Name() (string, error) {
+	return p.NameWithContext(context.Background())
+}
+
+func (p *Process) NameWithContext(ctx context.Context) (string, error) {
+	k, err := p.getKProc()
+	if err != nil {
+		return "", err
+	}
+
+	return common.IntToString(k.Comm[:]), nil
+}
+func (p *Process) Tgid() (int32, error) {
+	return 0, common.ErrNotImplementedError
+}
+func (p *Process) Exe() (string, error) {
+	return p.ExeWithContext(context.Background())
+}
+
+func (p *Process) ExeWithContext(ctx context.Context) (string, error) {
+	return "", common.ErrNotImplementedError
+}
+
+func (p *Process) Cmdline() (string, error) {
+	return p.CmdlineWithContext(context.Background())
+}
+
+func (p *Process) CmdlineWithContext(ctx context.Context) (string, error) {
+	mib := []int32{CTLKern, KernProc, KernProcArgs, p.Pid}
+	buf, _, err := common.CallSyscall(mib)
+	if err != nil {
+		return "", err
+	}
+	ret := strings.FieldsFunc(string(buf), func(r rune) bool {
+		if r == '\u0000' {
+			return true
+		}
+		return false
+	})
+
+	return strings.Join(ret, " "), nil
+}
+
+func (p *Process) CmdlineSlice() ([]string, error) {
+	return p.CmdlineSliceWithContext(context.Background())
+}
+
+func (p *Process) CmdlineSliceWithContext(ctx context.Context) ([]string, error) {
+	mib := []int32{CTLKern, KernProc, KernProcArgs, p.Pid}
+	buf, _, err := common.CallSyscall(mib)
+	if err != nil {
+		return nil, err
+	}
+	if len(buf) == 0 {
+		return nil, nil
+	}
+	if buf[len(buf)-1] == 0 {
+		buf = buf[:len(buf)-1]
+	}
+	parts := bytes.Split(buf, []byte{0})
+	var strParts []string
+	for _, p := range parts {
+		strParts = append(strParts, string(p))
+	}
+
+	return strParts, nil
+}
+func (p *Process) CreateTime() (int64, error) {
+	return p.CreateTimeWithContext(context.Background())
+}
+
+func (p *Process) CreateTimeWithContext(ctx context.Context) (int64, error) {
+	return 0, common.ErrNotImplementedError
+}
+func (p *Process) Cwd() (string, error) {
+	return p.CwdWithContext(context.Background())
+}
+
+func (p *Process) CwdWithContext(ctx context.Context) (string, error) {
+	return "", common.ErrNotImplementedError
+}
+func (p *Process) Parent() (*Process, error) {
+	return p.ParentWithContext(context.Background())
+}
+
+func (p *Process) ParentWithContext(ctx context.Context) (*Process, error) {
+	return p, common.ErrNotImplementedError
+}
+func (p *Process) Status() (string, error) {
+	return p.StatusWithContext(context.Background())
+}
+
+func (p *Process) StatusWithContext(ctx context.Context) (string, error) {
+	k, err := p.getKProc()
+	if err != nil {
+		return "", err
+	}
+	var s string
+	switch k.Stat {
+	case SIDL:
+		s = "I"
+	case SRUN:
+		s = "R"
+	case SSLEEP:
+		s = "S"
+	case SSTOP:
+		s = "T"
+	case SZOMB:
+		s = "Z"
+	case SWAIT:
+		s = "W"
+	case SLOCK:
+		s = "L"
+	}
+
+	return s, nil
+}
+func (p *Process) Uids() ([]int32, error) {
+	return p.UidsWithContext(context.Background())
+}
+
+func (p *Process) UidsWithContext(ctx context.Context) ([]int32, error) {
+	k, err := p.getKProc()
+	if err != nil {
+		return nil, err
+	}
+
+	uids := make([]int32, 0, 3)
+
+	uids = append(uids, int32(k.Ruid), int32(k.Uid), int32(k.Svuid))
+
+	return uids, nil
+}
+func (p *Process) Gids() ([]int32, error) {
+	return p.GidsWithContext(context.Background())
+}
+
+func (p *Process) GidsWithContext(ctx context.Context) ([]int32, error) {
+	k, err := p.getKProc()
+	if err != nil {
+		return nil, err
+	}
+
+	gids := make([]int32, 0, 3)
+	gids = append(gids, int32(k.Rgid), int32(k.Ngroups), int32(k.Svgid))
+
+	return gids, nil
+}
+func (p *Process) Terminal() (string, error) {
+	return p.TerminalWithContext(context.Background())
+}
+
+func (p *Process) TerminalWithContext(ctx context.Context) (string, error) {
+	k, err := p.getKProc()
+	if err != nil {
+		return "", err
+	}
+
+	ttyNr := uint64(k.Tdev)
+
+	termmap, err := getTerminalMap()
+	if err != nil {
+		return "", err
+	}
+
+	return termmap[ttyNr], nil
+}
+func (p *Process) Nice() (int32, error) {
+	return p.NiceWithContext(context.Background())
+}
+
+func (p *Process) NiceWithContext(ctx context.Context) (int32, error) {
+	k, err := p.getKProc()
+	if err != nil {
+		return 0, err
+	}
+	return int32(k.Nice), nil
+}
+func (p *Process) IOnice() (int32, error) {
+	return p.IOniceWithContext(context.Background())
+}
+
+func (p *Process) IOniceWithContext(ctx context.Context) (int32, error) {
+	return 0, common.ErrNotImplementedError
+}
+func (p *Process) Rlimit() ([]RlimitStat, error) {
+	return p.RlimitWithContext(context.Background())
+}
+
+func (p *Process) RlimitWithContext(ctx context.Context) ([]RlimitStat, error) {
+	var rlimit []RlimitStat
+	return rlimit, common.ErrNotImplementedError
+}
+func (p *Process) RlimitUsage(gatherUsed bool) ([]RlimitStat, error) {
+	return p.RlimitUsageWithContext(context.Background(), gatherUsed)
+}
+
+func (p *Process) RlimitUsageWithContext(ctx context.Context, gatherUsed bool) ([]RlimitStat, error) {
+	var rlimit []RlimitStat
+	return rlimit, common.ErrNotImplementedError
+}
+func (p *Process) IOCounters() (*IOCountersStat, error) {
+	return p.IOCountersWithContext(context.Background())
+}
+
+func (p *Process) IOCountersWithContext(ctx context.Context) (*IOCountersStat, error) {
+	k, err := p.getKProc()
+	if err != nil {
+		return nil, err
+	}
+	return &IOCountersStat{
+		ReadCount:  uint64(k.Rusage.Inblock),
+		WriteCount: uint64(k.Rusage.Oublock),
+	}, nil
+}
+func (p *Process) NumCtxSwitches() (*NumCtxSwitchesStat, error) {
+	return p.NumCtxSwitchesWithContext(context.Background())
+}
+
+func (p *Process) NumCtxSwitchesWithContext(ctx context.Context) (*NumCtxSwitchesStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+func (p *Process) NumFDs() (int32, error) {
+	return p.NumFDsWithContext(context.Background())
+}
+
+func (p *Process) NumFDsWithContext(ctx context.Context) (int32, error) {
+	return 0, common.ErrNotImplementedError
+}
+func (p *Process) NumThreads() (int32, error) {
+	return p.NumThreadsWithContext(context.Background())
+}
+
+func (p *Process) NumThreadsWithContext(ctx context.Context) (int32, error) {
+	k, err := p.getKProc()
+	if err != nil {
+		return 0, err
+	}
+
+	return k.Numthreads, nil
+}
+func (p *Process) Threads() (map[int32]*cpu.TimesStat, error) {
+	return p.ThreadsWithContext(context.Background())
+}
+
+func (p *Process) ThreadsWithContext(ctx context.Context) (map[int32]*cpu.TimesStat, error) {
+	ret := make(map[int32]*cpu.TimesStat)
+	return ret, common.ErrNotImplementedError
+}
+func (p *Process) Times() (*cpu.TimesStat, error) {
+	return p.TimesWithContext(context.Background())
+}
+
+func (p *Process) TimesWithContext(ctx context.Context) (*cpu.TimesStat, error) {
+	k, err := p.getKProc()
+	if err != nil {
+		return nil, err
+	}
+	return &cpu.TimesStat{
+		CPU:    "cpu",
+		User:   float64(k.Rusage.Utime.Sec) + float64(k.Rusage.Utime.Usec)/1000000,
+		System: float64(k.Rusage.Stime.Sec) + float64(k.Rusage.Stime.Usec)/1000000,
+	}, nil
+}
+func (p *Process) CPUAffinity() ([]int32, error) {
+	return p.CPUAffinityWithContext(context.Background())
+}
+
+func (p *Process) CPUAffinityWithContext(ctx context.Context) ([]int32, error) {
+	return nil, common.ErrNotImplementedError
+}
+func (p *Process) MemoryInfo() (*MemoryInfoStat, error) {
+	return p.MemoryInfoWithContext(context.Background())
+}
+
+func (p *Process) MemoryInfoWithContext(ctx context.Context) (*MemoryInfoStat, error) {
+	k, err := p.getKProc()
+	if err != nil {
+		return nil, err
+	}
+	v, err := unix.Sysctl("vm.stats.vm.v_page_size")
+	if err != nil {
+		return nil, err
+	}
+	pageSize := common.LittleEndian.Uint16([]byte(v))
+
+	return &MemoryInfoStat{
+		RSS: uint64(k.Rssize) * uint64(pageSize),
+		VMS: uint64(k.Size),
+	}, nil
+}
+func (p *Process) MemoryInfoEx() (*MemoryInfoExStat, error) {
+	return p.MemoryInfoExWithContext(context.Background())
+}
+
+func (p *Process) MemoryInfoExWithContext(ctx context.Context) (*MemoryInfoExStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+
+func (p *Process) Children() ([]*Process, error) {
+	return p.ChildrenWithContext(context.Background())
+}
+
+func (p *Process) ChildrenWithContext(ctx context.Context) ([]*Process, error) {
+	pids, err := common.CallPgrepWithContext(ctx, invoke, p.Pid)
+	if err != nil {
+		return nil, err
+	}
+	ret := make([]*Process, 0, len(pids))
+	for _, pid := range pids {
+		np, err := NewProcess(pid)
+		if err != nil {
+			return nil, err
+		}
+		ret = append(ret, np)
+	}
+	return ret, nil
+}
+
+func (p *Process) OpenFiles() ([]OpenFilesStat, error) {
+	return p.OpenFilesWithContext(context.Background())
+}
+
+func (p *Process) OpenFilesWithContext(ctx context.Context) ([]OpenFilesStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+
+func (p *Process) Connections() ([]net.ConnectionStat, error) {
+	return p.ConnectionsWithContext(context.Background())
+}
+
+func (p *Process) ConnectionsWithContext(ctx context.Context) ([]net.ConnectionStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+
+func (p *Process) NetIOCounters(pernic bool) ([]net.IOCountersStat, error) {
+	return p.NetIOCountersWithContext(context.Background(), pernic)
+}
+
+func (p *Process) NetIOCountersWithContext(ctx context.Context, pernic bool) ([]net.IOCountersStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+
+func (p *Process) IsRunning() (bool, error) {
+	return p.IsRunningWithContext(context.Background())
+}
+
+func (p *Process) IsRunningWithContext(ctx context.Context) (bool, error) {
+	return true, common.ErrNotImplementedError
+}
+func (p *Process) MemoryMaps(grouped bool) (*[]MemoryMapsStat, error) {
+	return p.MemoryMapsWithContext(context.Background(), grouped)
+}
+
+func (p *Process) MemoryMapsWithContext(ctx context.Context, grouped bool) (*[]MemoryMapsStat, error) {
+	var ret []MemoryMapsStat
+	return &ret, common.ErrNotImplementedError
+}
+
+func Processes() ([]*Process, error) {
+	return ProcessesWithContext(context.Background())
+}
+
+func ProcessesWithContext(ctx context.Context) ([]*Process, error) {
+	results := []*Process{}
+
+	mib := []int32{CTLKern, KernProc, KernProcProc, 0}
+	buf, length, err := common.CallSyscall(mib)
+	if err != nil {
+		return results, err
+	}
+
+	// get kinfo_proc size
+	count := int(length / uint64(sizeOfKinfoProc))
+
+	// parse buf to procs
+	for i := 0; i < count; i++ {
+		b := buf[i*sizeOfKinfoProc : (i+1)*sizeOfKinfoProc]
+		k, err := parseKinfoProc(b)
+		if err != nil {
+			continue
+		}
+		p, err := NewProcess(int32(k.Pid))
+		if err != nil {
+			continue
+		}
+
+		results = append(results, p)
+	}
+
+	return results, nil
+}
+
+func parseKinfoProc(buf []byte) (KinfoProc, error) {
+	var k KinfoProc
+	br := bytes.NewReader(buf)
+	err := common.Read(br, binary.LittleEndian, &k)
+	return k, err
+}
+
+func (p *Process) getKProc() (*KinfoProc, error) {
+	return p.getKProcWithContext(context.Background())
+}
+
+func (p *Process) getKProcWithContext(ctx context.Context) (*KinfoProc, error) {
+	mib := []int32{CTLKern, KernProc, KernProcPID, p.Pid}
+
+	buf, length, err := common.CallSyscall(mib)
+	if err != nil {
+		return nil, err
+	}
+	if length != sizeOfKinfoProc {
+		return nil, err
+	}
+
+	k, err := parseKinfoProc(buf)
+	if err != nil {
+		return nil, err
+	}
+	return &k, nil
+}
+
+func NewProcess(pid int32) (*Process, error) {
+	p := &Process{Pid: pid}
+
+	return p, nil
+}

vendor/github.com/shirou/gopsutil/process/process_freebsd_386.go

@@ -0,0 +1,192 @@
+// Created by cgo -godefs - DO NOT EDIT
+// cgo -godefs types_freebsd.go
+
+package process
+
+const (
+	CTLKern          = 1
+	KernProc         = 14
+	KernProcPID      = 1
+	KernProcProc     = 8
+	KernProcPathname = 12
+	KernProcArgs     = 7
+)
+
+const (
+	sizeofPtr      = 0x4
+	sizeofShort    = 0x2
+	sizeofInt      = 0x4
+	sizeofLong     = 0x4
+	sizeofLongLong = 0x8
+)
+
+const (
+	sizeOfKinfoVmentry = 0x488
+	sizeOfKinfoProc    = 0x300
+)
+
+const (
+	SIDL   = 1
+	SRUN   = 2
+	SSLEEP = 3
+	SSTOP  = 4
+	SZOMB  = 5
+	SWAIT  = 6
+	SLOCK  = 7
+)
+
+type (
+	_C_short     int16
+	_C_int       int32
+	_C_long      int32
+	_C_long_long int64
+)
+
+type Timespec struct {
+	Sec  int32
+	Nsec int32
+}
+
+type Timeval struct {
+	Sec  int32
+	Usec int32
+}
+
+type Rusage struct {
+	Utime    Timeval
+	Stime    Timeval
+	Maxrss   int32
+	Ixrss    int32
+	Idrss    int32
+	Isrss    int32
+	Minflt   int32
+	Majflt   int32
+	Nswap    int32
+	Inblock  int32
+	Oublock  int32
+	Msgsnd   int32
+	Msgrcv   int32
+	Nsignals int32
+	Nvcsw    int32
+	Nivcsw   int32
+}
+
+type Rlimit struct {
+	Cur int64
+	Max int64
+}
+
+type KinfoProc struct {
+	Structsize   int32
+	Layout       int32
+	Args         int32 /* pargs */
+	Paddr        int32 /* proc */
+	Addr         int32 /* user */
+	Tracep       int32 /* vnode */
+	Textvp       int32 /* vnode */
+	Fd           int32 /* filedesc */
+	Vmspace      int32 /* vmspace */
+	Wchan        int32
+	Pid          int32
+	Ppid         int32
+	Pgid         int32
+	Tpgid        int32
+	Sid          int32
+	Tsid         int32
+	Jobc         int16
+	Spare_short1 int16
+	Tdev         uint32
+	Siglist      [16]byte /* sigset */
+	Sigmask      [16]byte /* sigset */
+	Sigignore    [16]byte /* sigset */
+	Sigcatch     [16]byte /* sigset */
+	Uid          uint32
+	Ruid         uint32
+	Svuid        uint32
+	Rgid         uint32
+	Svgid        uint32
+	Ngroups      int16
+	Spare_short2 int16
+	Groups       [16]uint32
+	Size         uint32
+	Rssize       int32
+	Swrss        int32
+	Tsize        int32
+	Dsize        int32
+	Ssize        int32
+	Xstat        uint16
+	Acflag       uint16
+	Pctcpu       uint32
+	Estcpu       uint32
+	Slptime      uint32
+	Swtime       uint32
+	Cow          uint32
+	Runtime      uint64
+	Start        Timeval
+	Childtime    Timeval
+	Flag         int32
+	Kiflag       int32
+	Traceflag    int32
+	Stat         int8
+	Nice         int8
+	Lock         int8
+	Rqindex      int8
+	Oncpu        uint8
+	Lastcpu      uint8
+	Tdname       [17]int8
+	Wmesg        [9]int8
+	Login        [18]int8
+	Lockname     [9]int8
+	Comm         [20]int8
+	Emul         [17]int8
+	Loginclass   [18]int8
+	Sparestrings [50]int8
+	Spareints    [7]int32
+	Flag2        int32
+	Fibnum       int32
+	Cr_flags     uint32
+	Jid          int32
+	Numthreads   int32
+	Tid          int32
+	Pri          Priority
+	Rusage       Rusage
+	Rusage_ch    Rusage
+	Pcb          int32 /* pcb */
+	Kstack       int32
+	Udata        int32
+	Tdaddr       int32 /* thread */
+	Spareptrs    [6]int32
+	Sparelongs   [12]int32
+	Sflag        int32
+	Tdflags      int32
+}
+
+type Priority struct {
+	Class  uint8
+	Level  uint8
+	Native uint8
+	User   uint8
+}
+
+type KinfoVmentry struct {
+	Structsize       int32
+	Type             int32
+	Start            uint64
+	End              uint64
+	Offset           uint64
+	Vn_fileid        uint64
+	Vn_fsid          uint32
+	Flags            int32
+	Resident         int32
+	Private_resident int32
+	Protection       int32
+	Ref_count        int32
+	Shadow_count     int32
+	Vn_type          int32
+	Vn_size          uint64
+	Vn_rdev          uint32
+	Vn_mode          uint16
+	Status           uint16
+	X_kve_ispare     [12]int32
+	Path             [1024]int8
+}

vendor/github.com/shirou/gopsutil/process/process_freebsd_amd64.go

@@ -0,0 +1,192 @@
+// Created by cgo -godefs - DO NOT EDIT
+// cgo -godefs types_freebsd.go
+
+package process
+
+const (
+	CTLKern          = 1
+	KernProc         = 14
+	KernProcPID      = 1
+	KernProcProc     = 8
+	KernProcPathname = 12
+	KernProcArgs     = 7
+)
+
+const (
+	sizeofPtr      = 0x8
+	sizeofShort    = 0x2
+	sizeofInt      = 0x4
+	sizeofLong     = 0x8
+	sizeofLongLong = 0x8
+)
+
+const (
+	sizeOfKinfoVmentry = 0x488
+	sizeOfKinfoProc    = 0x440
+)
+
+const (
+	SIDL   = 1
+	SRUN   = 2
+	SSLEEP = 3
+	SSTOP  = 4
+	SZOMB  = 5
+	SWAIT  = 6
+	SLOCK  = 7
+)
+
+type (
+	_C_short     int16
+	_C_int       int32
+	_C_long      int64
+	_C_long_long int64
+)
+
+type Timespec struct {
+	Sec  int64
+	Nsec int64
+}
+
+type Timeval struct {
+	Sec  int64
+	Usec int64
+}
+
+type Rusage struct {
+	Utime    Timeval
+	Stime    Timeval
+	Maxrss   int64
+	Ixrss    int64
+	Idrss    int64
+	Isrss    int64
+	Minflt   int64
+	Majflt   int64
+	Nswap    int64
+	Inblock  int64
+	Oublock  int64
+	Msgsnd   int64
+	Msgrcv   int64
+	Nsignals int64
+	Nvcsw    int64
+	Nivcsw   int64
+}
+
+type Rlimit struct {
+	Cur int64
+	Max int64
+}
+
+type KinfoProc struct {
+	Structsize   int32
+	Layout       int32
+	Args         int64 /* pargs */
+	Paddr        int64 /* proc */
+	Addr         int64 /* user */
+	Tracep       int64 /* vnode */
+	Textvp       int64 /* vnode */
+	Fd           int64 /* filedesc */
+	Vmspace      int64 /* vmspace */
+	Wchan        int64
+	Pid          int32
+	Ppid         int32
+	Pgid         int32
+	Tpgid        int32
+	Sid          int32
+	Tsid         int32
+	Jobc         int16
+	Spare_short1 int16
+	Tdev         uint32
+	Siglist      [16]byte /* sigset */
+	Sigmask      [16]byte /* sigset */
+	Sigignore    [16]byte /* sigset */
+	Sigcatch     [16]byte /* sigset */
+	Uid          uint32
+	Ruid         uint32
+	Svuid        uint32
+	Rgid         uint32
+	Svgid        uint32
+	Ngroups      int16
+	Spare_short2 int16
+	Groups       [16]uint32
+	Size         uint64
+	Rssize       int64
+	Swrss        int64
+	Tsize        int64
+	Dsize        int64
+	Ssize        int64
+	Xstat        uint16
+	Acflag       uint16
+	Pctcpu       uint32
+	Estcpu       uint32
+	Slptime      uint32
+	Swtime       uint32
+	Cow          uint32
+	Runtime      uint64
+	Start        Timeval
+	Childtime    Timeval
+	Flag         int64
+	Kiflag       int64
+	Traceflag    int32
+	Stat         int8
+	Nice         int8
+	Lock         int8
+	Rqindex      int8
+	Oncpu        uint8
+	Lastcpu      uint8
+	Tdname       [17]int8
+	Wmesg        [9]int8
+	Login        [18]int8
+	Lockname     [9]int8
+	Comm         [20]int8
+	Emul         [17]int8
+	Loginclass   [18]int8
+	Sparestrings [50]int8
+	Spareints    [7]int32
+	Flag2        int32
+	Fibnum       int32
+	Cr_flags     uint32
+	Jid          int32
+	Numthreads   int32
+	Tid          int32
+	Pri          Priority
+	Rusage       Rusage
+	Rusage_ch    Rusage
+	Pcb          int64 /* pcb */
+	Kstack       int64
+	Udata        int64
+	Tdaddr       int64 /* thread */
+	Spareptrs    [6]int64
+	Sparelongs   [12]int64
+	Sflag        int64
+	Tdflags      int64
+}
+
+type Priority struct {
+	Class  uint8
+	Level  uint8
+	Native uint8
+	User   uint8
+}
+
+type KinfoVmentry struct {
+	Structsize       int32
+	Type             int32
+	Start            uint64
+	End              uint64
+	Offset           uint64
+	Vn_fileid        uint64
+	Vn_fsid          uint32
+	Flags            int32
+	Resident         int32
+	Private_resident int32
+	Protection       int32
+	Ref_count        int32
+	Shadow_count     int32
+	Vn_type          int32
+	Vn_size          uint64
+	Vn_rdev          uint32
+	Vn_mode          uint16
+	Status           uint16
+	X_kve_ispare     [12]int32
+	Path             [1024]int8
+}

vendor/github.com/shirou/gopsutil/process/process_freebsd_arm.go

@@ -0,0 +1,192 @@
+// Created by cgo -godefs - DO NOT EDIT
+// cgo -godefs types_freebsd.go
+
+package process
+
+const (
+	CTLKern          = 1
+	KernProc         = 14
+	KernProcPID      = 1
+	KernProcProc     = 8
+	KernProcPathname = 12
+	KernProcArgs     = 7
+)
+
+const (
+	sizeofPtr      = 0x4
+	sizeofShort    = 0x2
+	sizeofInt      = 0x4
+	sizeofLong     = 0x4
+	sizeofLongLong = 0x8
+)
+
+const (
+	sizeOfKinfoVmentry = 0x488
+	sizeOfKinfoProc    = 0x440
+)
+
+const (
+	SIDL   = 1
+	SRUN   = 2
+	SSLEEP = 3
+	SSTOP  = 4
+	SZOMB  = 5
+	SWAIT  = 6
+	SLOCK  = 7
+)
+
+type (
+	_C_short     int16
+	_C_int       int32
+	_C_long      int32
+	_C_long_long int64
+)
+
+type Timespec struct {
+	Sec  int64
+	Nsec int64
+}
+
+type Timeval struct {
+	Sec  int64
+	Usec int64
+}
+
+type Rusage struct {
+	Utime    Timeval
+	Stime    Timeval
+	Maxrss   int32
+	Ixrss    int32
+	Idrss    int32
+	Isrss    int32
+	Minflt   int32
+	Majflt   int32
+	Nswap    int32
+	Inblock  int32
+	Oublock  int32
+	Msgsnd   int32
+	Msgrcv   int32
+	Nsignals int32
+	Nvcsw    int32
+	Nivcsw   int32
+}
+
+type Rlimit struct {
+	Cur int32
+	Max int32
+}
+
+type KinfoProc struct {
+	Structsize   int32
+	Layout       int32
+	Args         int32 /* pargs */
+	Paddr        int32 /* proc */
+	Addr         int32 /* user */
+	Tracep       int32 /* vnode */
+	Textvp       int32 /* vnode */
+	Fd           int32 /* filedesc */
+	Vmspace      int32 /* vmspace */
+	Wchan        int32
+	Pid          int32
+	Ppid         int32
+	Pgid         int32
+	Tpgid        int32
+	Sid          int32
+	Tsid         int32
+	Jobc         int16
+	Spare_short1 int16
+	Tdev         uint32
+	Siglist      [16]byte /* sigset */
+	Sigmask      [16]byte /* sigset */
+	Sigignore    [16]byte /* sigset */
+	Sigcatch     [16]byte /* sigset */
+	Uid          uint32
+	Ruid         uint32
+	Svuid        uint32
+	Rgid         uint32
+	Svgid        uint32
+	Ngroups      int16
+	Spare_short2 int16
+	Groups       [16]uint32
+	Size         uint32
+	Rssize       int32
+	Swrss        int32
+	Tsize        int32
+	Dsize        int32
+	Ssize        int32
+	Xstat        uint16
+	Acflag       uint16
+	Pctcpu       uint32
+	Estcpu       uint32
+	Slptime      uint32
+	Swtime       uint32
+	Cow          uint32
+	Runtime      uint64
+	Start        Timeval
+	Childtime    Timeval
+	Flag         int32
+	Kiflag       int32
+	Traceflag    int32
+	Stat         int8
+	Nice         int8
+	Lock         int8
+	Rqindex      int8
+	Oncpu        uint8
+	Lastcpu      uint8
+	Tdname       [17]int8
+	Wmesg        [9]int8
+	Login        [18]int8
+	Lockname     [9]int8
+	Comm         [20]int8
+	Emul         [17]int8
+	Loginclass   [18]int8
+	Sparestrings [50]int8
+	Spareints    [4]int32
+	Flag2        int32
+	Fibnum       int32
+	Cr_flags     uint32
+	Jid          int32
+	Numthreads   int32
+	Tid          int32
+	Pri          Priority
+	Rusage       Rusage
+	Rusage_ch    Rusage
+	Pcb          int32 /* pcb */
+	Kstack       int32
+	Udata        int32
+	Tdaddr       int32 /* thread */
+	Spareptrs    [6]int64
+	Sparelongs   [12]int64
+	Sflag        int64
+	Tdflags      int64
+}
+
+type Priority struct {
+	Class  uint8
+	Level  uint8
+	Native uint8
+	User   uint8
+}
+
+type KinfoVmentry struct {
+	Structsize       int32
+	Type             int32
+	Start            uint64
+	End              uint64
+	Offset           uint64
+	Vn_fileid        uint64
+	Vn_fsid          uint32
+	Flags            int32
+	Resident         int32
+	Private_resident int32
+	Protection       int32
+	Ref_count        int32
+	Shadow_count     int32
+	Vn_type          int32
+	Vn_size          uint64
+	Vn_rdev          uint32
+	Vn_mode          uint16
+	Status           uint16
+	X_kve_ispare     [12]int32
+	Path             [1024]int8
+}

vendor/github.com/shirou/gopsutil/process/process_openbsd.go

@@ -0,0 +1,510 @@
+// +build openbsd
+
+package process
+
+import (
+	"C"
+	"bytes"
+	"context"
+	"encoding/binary"
+	"strings"
+	"unsafe"
+
+	cpu "github.com/shirou/gopsutil/cpu"
+	"github.com/shirou/gopsutil/internal/common"
+	mem "github.com/shirou/gopsutil/mem"
+	net "github.com/shirou/gopsutil/net"
+	"golang.org/x/sys/unix"
+)
+
+// MemoryInfoExStat is different between OSes
+type MemoryInfoExStat struct {
+}
+
+type MemoryMapsStat struct {
+}
+
+func Pids() ([]int32, error) {
+	return PidsWithContext(context.Background())
+}
+
+func PidsWithContext(ctx context.Context) ([]int32, error) {
+	var ret []int32
+	procs, err := Processes()
+	if err != nil {
+		return ret, nil
+	}
+
+	for _, p := range procs {
+		ret = append(ret, p.Pid)
+	}
+
+	return ret, nil
+}
+
+func (p *Process) Ppid() (int32, error) {
+	return p.PpidWithContext(context.Background())
+}
+
+func (p *Process) PpidWithContext(ctx context.Context) (int32, error) {
+	k, err := p.getKProc()
+	if err != nil {
+		return 0, err
+	}
+
+	return k.Ppid, nil
+}
+func (p *Process) Name() (string, error) {
+	return p.NameWithContext(context.Background())
+}
+
+func (p *Process) NameWithContext(ctx context.Context) (string, error) {
+	k, err := p.getKProc()
+	if err != nil {
+		return "", err
+	}
+
+	return common.IntToString(k.Comm[:]), nil
+}
+func (p *Process) Tgid() (int32, error) {
+	return 0, common.ErrNotImplementedError
+}
+func (p *Process) Exe() (string, error) {
+	return p.ExeWithContext(context.Background())
+}
+
+func (p *Process) ExeWithContext(ctx context.Context) (string, error) {
+	return "", common.ErrNotImplementedError
+}
+
+func (p *Process) CmdlineSlice() ([]string, error) {
+	return p.CmdlineSliceWithContext(context.Background())
+}
+
+func (p *Process) CmdlineSliceWithContext(ctx context.Context) ([]string, error) {
+	mib := []int32{CTLKern, KernProcArgs, p.Pid, KernProcArgv}
+	buf, _, err := common.CallSyscall(mib)
+
+	if err != nil {
+		return nil, err
+	}
+
+	argc := 0
+	argvp := unsafe.Pointer(&buf[0])
+	argv := *(**C.char)(unsafe.Pointer(argvp))
+	size := unsafe.Sizeof(argv)
+	var strParts []string
+
+	for argv != nil {
+		strParts = append(strParts, C.GoString(argv))
+
+		argc++
+		argv = *(**C.char)(unsafe.Pointer(uintptr(argvp) + uintptr(argc)*size))
+	}
+	return strParts, nil
+}
+
+func (p *Process) Cmdline() (string, error) {
+	return p.CmdlineWithContext(context.Background())
+}
+
+func (p *Process) CmdlineWithContext(ctx context.Context) (string, error) {
+	argv, err := p.CmdlineSlice()
+	if err != nil {
+		return "", err
+	}
+	return strings.Join(argv, " "), nil
+}
+
+func (p *Process) CreateTime() (int64, error) {
+	return p.CreateTimeWithContext(context.Background())
+}
+
+func (p *Process) CreateTimeWithContext(ctx context.Context) (int64, error) {
+	return 0, common.ErrNotImplementedError
+}
+func (p *Process) Cwd() (string, error) {
+	return p.CwdWithContext(context.Background())
+}
+
+func (p *Process) CwdWithContext(ctx context.Context) (string, error) {
+	return "", common.ErrNotImplementedError
+}
+func (p *Process) Parent() (*Process, error) {
+	return p.ParentWithContext(context.Background())
+}
+
+func (p *Process) ParentWithContext(ctx context.Context) (*Process, error) {
+	return p, common.ErrNotImplementedError
+}
+func (p *Process) Status() (string, error) {
+	return p.StatusWithContext(context.Background())
+}
+
+func (p *Process) StatusWithContext(ctx context.Context) (string, error) {
+	k, err := p.getKProc()
+	if err != nil {
+		return "", err
+	}
+	var s string
+	switch k.Stat {
+	case SIDL:
+	case SRUN:
+	case SONPROC:
+		s = "R"
+	case SSLEEP:
+		s = "S"
+	case SSTOP:
+		s = "T"
+	case SDEAD:
+		s = "Z"
+	}
+
+	return s, nil
+}
+func (p *Process) Uids() ([]int32, error) {
+	return p.UidsWithContext(context.Background())
+}
+
+func (p *Process) UidsWithContext(ctx context.Context) ([]int32, error) {
+	k, err := p.getKProc()
+	if err != nil {
+		return nil, err
+	}
+
+	uids := make([]int32, 0, 3)
+
+	uids = append(uids, int32(k.Ruid), int32(k.Uid), int32(k.Svuid))
+
+	return uids, nil
+}
+func (p *Process) Gids() ([]int32, error) {
+	return p.GidsWithContext(context.Background())
+}
+
+func (p *Process) GidsWithContext(ctx context.Context) ([]int32, error) {
+	k, err := p.getKProc()
+	if err != nil {
+		return nil, err
+	}
+
+	gids := make([]int32, 0, 3)
+	gids = append(gids, int32(k.Rgid), int32(k.Ngroups), int32(k.Svgid))
+
+	return gids, nil
+}
+func (p *Process) Terminal() (string, error) {
+	return p.TerminalWithContext(context.Background())
+}
+
+func (p *Process) TerminalWithContext(ctx context.Context) (string, error) {
+	k, err := p.getKProc()
+	if err != nil {
+		return "", err
+	}
+
+	ttyNr := uint64(k.Tdev)
+
+	termmap, err := getTerminalMap()
+	if err != nil {
+		return "", err
+	}
+
+	return termmap[ttyNr], nil
+}
+func (p *Process) Nice() (int32, error) {
+	return p.NiceWithContext(context.Background())
+}
+
+func (p *Process) NiceWithContext(ctx context.Context) (int32, error) {
+	k, err := p.getKProc()
+	if err != nil {
+		return 0, err
+	}
+	return int32(k.Nice), nil
+}
+func (p *Process) IOnice() (int32, error) {
+	return p.IOniceWithContext(context.Background())
+}
+
+func (p *Process) IOniceWithContext(ctx context.Context) (int32, error) {
+	return 0, common.ErrNotImplementedError
+}
+func (p *Process) Rlimit() ([]RlimitStat, error) {
+	return p.RlimitWithContext(context.Background())
+}
+
+func (p *Process) RlimitWithContext(ctx context.Context) ([]RlimitStat, error) {
+	var rlimit []RlimitStat
+	return rlimit, common.ErrNotImplementedError
+}
+func (p *Process) RlimitUsage(gatherUsed bool) ([]RlimitStat, error) {
+	return p.RlimitUsageWithContext(context.Background(), gatherUsed)
+}
+
+func (p *Process) RlimitUsageWithContext(ctx context.Context, gatherUsed bool) ([]RlimitStat, error) {
+	var rlimit []RlimitStat
+	return rlimit, common.ErrNotImplementedError
+}
+func (p *Process) IOCounters() (*IOCountersStat, error) {
+	return p.IOCountersWithContext(context.Background())
+}
+
+func (p *Process) IOCountersWithContext(ctx context.Context) (*IOCountersStat, error) {
+	k, err := p.getKProc()
+	if err != nil {
+		return nil, err
+	}
+	return &IOCountersStat{
+		ReadCount:  uint64(k.Uru_inblock),
+		WriteCount: uint64(k.Uru_oublock),
+	}, nil
+}
+func (p *Process) NumCtxSwitches() (*NumCtxSwitchesStat, error) {
+	return p.NumCtxSwitchesWithContext(context.Background())
+}
+
+func (p *Process) NumCtxSwitchesWithContext(ctx context.Context) (*NumCtxSwitchesStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+func (p *Process) NumFDs() (int32, error) {
+	return p.NumFDsWithContext(context.Background())
+}
+
+func (p *Process) NumFDsWithContext(ctx context.Context) (int32, error) {
+	return 0, common.ErrNotImplementedError
+}
+func (p *Process) NumThreads() (int32, error) {
+	return p.NumThreadsWithContext(context.Background())
+}
+
+func (p *Process) NumThreadsWithContext(ctx context.Context) (int32, error) {
+	/* not supported, just return 1 */
+	return 1, nil
+}
+func (p *Process) Threads() (map[int32]*cpu.TimesStat, error) {
+	return p.ThreadsWithContext(context.Background())
+}
+
+func (p *Process) ThreadsWithContext(ctx context.Context) (map[int32]*cpu.TimesStat, error) {
+	ret := make(map[int32]*cpu.TimesStat)
+	return ret, common.ErrNotImplementedError
+}
+func (p *Process) Times() (*cpu.TimesStat, error) {
+	return p.TimesWithContext(context.Background())
+}
+
+func (p *Process) TimesWithContext(ctx context.Context) (*cpu.TimesStat, error) {
+	k, err := p.getKProc()
+	if err != nil {
+		return nil, err
+	}
+	return &cpu.TimesStat{
+		CPU:    "cpu",
+		User:   float64(k.Uutime_sec) + float64(k.Uutime_usec)/1000000,
+		System: float64(k.Ustime_sec) + float64(k.Ustime_usec)/1000000,
+	}, nil
+}
+func (p *Process) CPUAffinity() ([]int32, error) {
+	return p.CPUAffinityWithContext(context.Background())
+}
+
+func (p *Process) CPUAffinityWithContext(ctx context.Context) ([]int32, error) {
+	return nil, common.ErrNotImplementedError
+}
+func (p *Process) MemoryInfo() (*MemoryInfoStat, error) {
+	return p.MemoryInfoWithContext(context.Background())
+}
+
+func (p *Process) MemoryInfoWithContext(ctx context.Context) (*MemoryInfoStat, error) {
+	k, err := p.getKProc()
+	if err != nil {
+		return nil, err
+	}
+	pageSize, err := mem.GetPageSize()
+	if err != nil {
+		return nil, err
+	}
+
+	return &MemoryInfoStat{
+		RSS: uint64(k.Vm_rssize) * pageSize,
+		VMS: uint64(k.Vm_tsize) + uint64(k.Vm_dsize) +
+			uint64(k.Vm_ssize),
+	}, nil
+}
+func (p *Process) MemoryInfoEx() (*MemoryInfoExStat, error) {
+	return p.MemoryInfoExWithContext(context.Background())
+}
+
+func (p *Process) MemoryInfoExWithContext(ctx context.Context) (*MemoryInfoExStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+
+func (p *Process) Children() ([]*Process, error) {
+	return p.ChildrenWithContext(context.Background())
+}
+
+func (p *Process) ChildrenWithContext(ctx context.Context) ([]*Process, error) {
+	pids, err := common.CallPgrepWithContext(ctx, invoke, p.Pid)
+	if err != nil {
+		return nil, err
+	}
+	ret := make([]*Process, 0, len(pids))
+	for _, pid := range pids {
+		np, err := NewProcess(pid)
+		if err != nil {
+			return nil, err
+		}
+		ret = append(ret, np)
+	}
+	return ret, nil
+}
+
+func (p *Process) OpenFiles() ([]OpenFilesStat, error) {
+	return p.OpenFilesWithContext(context.Background())
+}
+
+func (p *Process) OpenFilesWithContext(ctx context.Context) ([]OpenFilesStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+
+func (p *Process) Connections() ([]net.ConnectionStat, error) {
+	return p.ConnectionsWithContext(context.Background())
+}
+
+func (p *Process) ConnectionsWithContext(ctx context.Context) ([]net.ConnectionStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+
+func (p *Process) NetIOCounters(pernic bool) ([]net.IOCountersStat, error) {
+	return p.NetIOCountersWithContext(context.Background(), pernic)
+}
+
+func (p *Process) NetIOCountersWithContext(ctx context.Context, pernic bool) ([]net.IOCountersStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+
+func (p *Process) IsRunning() (bool, error) {
+	return p.IsRunningWithContext(context.Background())
+}
+
+func (p *Process) IsRunningWithContext(ctx context.Context) (bool, error) {
+	return true, common.ErrNotImplementedError
+}
+func (p *Process) MemoryMaps(grouped bool) (*[]MemoryMapsStat, error) {
+	return p.MemoryMapsWithContext(context.Background(), grouped)
+}
+
+func (p *Process) MemoryMapsWithContext(ctx context.Context, grouped bool) (*[]MemoryMapsStat, error) {
+	var ret []MemoryMapsStat
+	return &ret, common.ErrNotImplementedError
+}
+
+func Processes() ([]*Process, error) {
+	return ProcessesWithContext(context.Background())
+}
+
+func ProcessesWithContext(ctx context.Context) ([]*Process, error) {
+	results := []*Process{}
+
+	buf, length, err := CallKernProcSyscall(KernProcAll, 0)
+
+	if err != nil {
+		return results, err
+	}
+
+	// get kinfo_proc size
+	count := int(length / uint64(sizeOfKinfoProc))
+
+	// parse buf to procs
+	for i := 0; i < count; i++ {
+		b := buf[i*sizeOfKinfoProc : (i+1)*sizeOfKinfoProc]
+		k, err := parseKinfoProc(b)
+		if err != nil {
+			continue
+		}
+		p, err := NewProcess(int32(k.Pid))
+		if err != nil {
+			continue
+		}
+
+		results = append(results, p)
+	}
+
+	return results, nil
+}
+
+func parseKinfoProc(buf []byte) (KinfoProc, error) {
+	var k KinfoProc
+	br := bytes.NewReader(buf)
+	err := common.Read(br, binary.LittleEndian, &k)
+	return k, err
+}
+
+func (p *Process) getKProc() (*KinfoProc, error) {
+	return p.getKProcWithContext(context.Background())
+}
+
+func (p *Process) getKProcWithContext(ctx context.Context) (*KinfoProc, error) {
+	buf, length, err := CallKernProcSyscall(KernProcPID, p.Pid)
+	if err != nil {
+		return nil, err
+	}
+	if length != sizeOfKinfoProc {
+		return nil, err
+	}
+
+	k, err := parseKinfoProc(buf)
+	if err != nil {
+		return nil, err
+	}
+	return &k, nil
+}
+
+func NewProcess(pid int32) (*Process, error) {
+	p := &Process{Pid: pid}
+
+	return p, nil
+}
+
+func CallKernProcSyscall(op int32, arg int32) ([]byte, uint64, error) {
+	return CallKernProcSyscallWithContext(context.Background(), op, arg)
+}
+
+func CallKernProcSyscallWithContext(ctx context.Context, op int32, arg int32) ([]byte, uint64, error) {
+	mib := []int32{CTLKern, KernProc, op, arg, sizeOfKinfoProc, 0}
+	mibptr := unsafe.Pointer(&mib[0])
+	miblen := uint64(len(mib))
+	length := uint64(0)
+	_, _, err := unix.Syscall6(
+		unix.SYS___SYSCTL,
+		uintptr(mibptr),
+		uintptr(miblen),
+		0,
+		uintptr(unsafe.Pointer(&length)),
+		0,
+		0)
+	if err != 0 {
+		return nil, length, err
+	}
+
+	count := int32(length / uint64(sizeOfKinfoProc))
+	mib = []int32{CTLKern, KernProc, op, arg, sizeOfKinfoProc, count}
+	mibptr = unsafe.Pointer(&mib[0])
+	miblen = uint64(len(mib))
+	// get proc info itself
+	buf := make([]byte, length)
+	_, _, err = unix.Syscall6(
+		unix.SYS___SYSCTL,
+		uintptr(mibptr),
+		uintptr(miblen),
+		uintptr(unsafe.Pointer(&buf[0])),
+		uintptr(unsafe.Pointer(&length)),
+		0,
+		0)
+	if err != 0 {
+		return buf, length, err
+	}
+
+	return buf, length, nil
+}