Merge pull request #480 from shirou/feature/add_context_support

Add WithContext functions.

Makefile

@@ -17,10 +17,10 @@ build_test:  ## test only buildable
 	GOOS=freebsd go test ./... | $(BUILD_FAIL_PATTERN)
 #	GOOS=openbsd go test ./... | $(BUILD_FAIL_PATTERN)
 	CGO_ENABLED=0 GOOS=darwin go test ./... | $(BUILD_FAIL_PATTERN)
-	CGO_ENABLED=1 GOOS=darwin go test ./... | $(BUILD_FAIL_PATTERN)
 	GOOS=windows go test ./... | $(BUILD_FAIL_PATTERN)
 	# Operating systems supported for building only (not implemented error if used)
 	GOOS=solaris go test ./... | $(BUILD_FAIL_PATTERN)
 #	GOOS=dragonfly go test ./... | $(BUILD_FAIL_PATTERN)
 	GOOS=netbsd go test ./... | $(BUILD_FAIL_PATTERN)
+	CGO_ENABLED=1 GOOS=darwin go test ./... | $(BUILD_FAIL_PATTERN)
 	@echo 'Successfully built on all known operating systems'

cpu/cpu.go

@@ -1,6 +1,7 @@
 package cpu
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"runtime"
@@ -64,6 +65,10 @@ func init() {
 }
 
 func Counts(logical bool) (int, error) {
+	return CountsWithContext(context.Background(), logical)
+}
+
+func CountsWithContext(ctx context.Context, logical bool) (int, error) {
 	return runtime.NumCPU(), nil
 }
 
@@ -137,6 +142,10 @@ func calculateAllBusy(t1, t2 []TimesStat) ([]float64, error) {
 // 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)
 	}

cpu/cpu_darwin.go

@@ -3,6 +3,7 @@
 package cpu
 
 import (
+	"context"
 	"os/exec"
 	"strconv"
 	"strings"
@@ -22,6 +23,10 @@ const (
 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()
 	}
@@ -31,6 +36,10 @@ func Times(percpu bool) ([]TimesStat, error) {
 
 // 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 {

cpu/cpu_fallback.go

@@ -3,13 +3,23 @@
 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
 }

cpu/cpu_freebsd.go

@@ -1,6 +1,7 @@
 package cpu
 
 import (
+	"context"
 	"fmt"
 	"os/exec"
 	"reflect"
@@ -50,6 +51,10 @@ func timeStat(name string, t *cpuTimes) *TimesStat {
 }
 
 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 {
@@ -87,6 +92,10 @@ func Times(percpu bool) ([]TimesStat, error) {
 // 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)

cpu/cpu_linux.go

@@ -3,6 +3,7 @@
 package cpu
 
 import (
+	"context"
 	"errors"
 	"fmt"
 	"os/exec"
@@ -30,6 +31,10 @@ func init() {
 }
 
 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 {
@@ -104,6 +109,10 @@ func finishCPUInfo(c *InfoStat) error {
 // 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)
 

cpu/cpu_openbsd.go

@@ -4,6 +4,7 @@ package cpu
 
 import (
 	"bytes"
+	"context"
 	"encoding/binary"
 	"fmt"
 	"os/exec"
@@ -49,6 +50,10 @@ func init() {
 }
 
 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
@@ -96,6 +101,10 @@ func Times(percpu bool) ([]TimesStat, error) {
 
 // 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{}

cpu/cpu_solaris.go

@@ -1,6 +1,7 @@
 package cpu
 
 import (
+	"context"
 	"errors"
 	"fmt"
 	"os/exec"
@@ -30,10 +31,18 @@ func init() {
 }
 
 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)

cpu/cpu_windows.go

@@ -46,6 +46,10 @@ type Win32_PerfFormattedData_PerfOS_System struct {
 
 // 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()
 	}
@@ -79,6 +83,10 @@ func Times(percpu bool) ([]TimesStat, error) {
 }
 
 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, "")
@@ -114,6 +122,10 @@ func Info() ([]InfoStat, error) {
 // 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, "")
@@ -126,6 +138,10 @@ func PerfInfo() ([]Win32_PerfFormattedData_Counters_ProcessorInformation, error)
 // 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, "")
 	ctx, cancel := context.WithTimeout(context.Background(), common.Timeout)

disk/disk_darwin.go

@@ -3,6 +3,7 @@
 package disk
 
 import (
+	"context"
 	"path"
 	"unsafe"
 
@@ -11,6 +12,10 @@ import (
 )
 
 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)
@@ -88,6 +93,10 @@ func Partitions(all bool) ([]PartitionStat, error) {
 }
 
 func Getfsstat(buf []Statfs_t, flags int) (n int, err error) {
+	return GetfsstatWithContext(context.Background(), buf, flags)
+}
+
+func GetfsstatWithContext(ctx context.Context, buf []Statfs_t, flags int) (n int, err error) {
 	var _p0 unsafe.Pointer
 	var bufsize uintptr
 	if len(buf) > 0 {

disk/disk_darwin_cgo.go

@@ -26,6 +26,7 @@ typedef struct
 import "C"
 
 import (
+	"context"
 	"errors"
 	"strings"
 	"unsafe"
@@ -34,6 +35,10 @@ import (
 )
 
 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")
 	}

disk/disk_darwin_nocgo.go

@@ -3,8 +3,16 @@
 
 package disk
 
-import "github.com/shirou/gopsutil/internal/common"
+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
 }

disk/disk_fallback.go

@@ -2,16 +2,32 @@
 
 package disk
 
-import "github.com/shirou/gopsutil/internal/common"
+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
 }

disk/disk_freebsd.go

@@ -4,6 +4,7 @@ package disk
 
 import (
 	"bytes"
+	"context"
 	"encoding/binary"
 	"path"
 	"strconv"
@@ -15,6 +16,10 @@ import (
 )
 
 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
@@ -96,6 +101,10 @@ func Partitions(all bool) ([]PartitionStat, error) {
 }
 
 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)
@@ -150,6 +159,10 @@ func (b Bintime) Compute() float64 {
 // 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 {

disk/disk_linux.go

@@ -3,6 +3,7 @@
 package disk
 
 import (
+	"context"
 	"fmt"
 	"os/exec"
 	"path/filepath"
@@ -217,6 +218,10 @@ var fsTypeMap = map[int64]string{
 // 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 {
@@ -273,6 +278,10 @@ func getFileSystems() ([]string, error) {
 }
 
 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 {
@@ -369,6 +378,10 @@ func IOCounters(names ...string) (map[string]IOCountersStat, error) {
 // 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 {
 	n := fmt.Sprintf("--name=%s", name)
 	udevadm, err := exec.LookPath("/sbin/udevadm")
 	if err != nil {

disk/disk_openbsd.go

@@ -4,6 +4,7 @@ package disk
 
 import (
 	"bytes"
+	"context"
 	"encoding/binary"
 	"path"
 	"unsafe"
@@ -13,6 +14,10 @@ import (
 )
 
 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
@@ -64,6 +69,10 @@ func Partitions(all bool) ([]PartitionStat, error) {
 }
 
 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")
@@ -106,6 +115,10 @@ func IOCounters(names ...string) (map[string]IOCountersStat, error) {
 // 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 {
@@ -133,6 +146,10 @@ func parseDiskstats(buf []byte) (Diskstats, error) {
 }
 
 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 {

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
+}

disk/disk_unix.go

@@ -2,12 +2,20 @@
 
 package disk
 
-import "golang.org/x/sys/unix"
+import (
+	"context"
+
+	"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 {

disk/disk_windows.go

@@ -36,6 +36,10 @@ type Win32_PerfFormattedData struct {
 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)
@@ -64,6 +68,10 @@ func Usage(path string) (*UsageStat, error) {
 }
 
 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(
@@ -129,6 +137,10 @@ func Partitions(all bool) ([]PartitionStat, error) {
 }
 
 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
 

docker/docker_linux.go

@@ -3,6 +3,7 @@
 package docker
 
 import (
+	"context"
 	"fmt"
 	"os"
 	"os/exec"
@@ -17,6 +18,10 @@ import (
 // GetDockerStat returns a list of Docker basic stats.
 // This requires certain permission.
 func GetDockerStat() ([]CgroupDockerStat, error) {
+	return GetDockerStatWithContext(context.Background())
+}
+
+func GetDockerStatWithContext(ctx context.Context) ([]CgroupDockerStat, error) {
 	path, err := exec.LookPath("docker")
 	if err != nil {
 		return nil, ErrDockerNotAvailable
@@ -54,6 +59,10 @@ func GetDockerStat() ([]CgroupDockerStat, error) {
 // GetDockerIDList returnes a list of DockerID.
 // This requires certain permission.
 func GetDockerIDList() ([]string, error) {
+	return GetDockerIDListWithContext(context.Background())
+}
+
+func GetDockerIDListWithContext(ctx context.Context) ([]string, error) {
 	path, err := exec.LookPath("docker")
 	if err != nil {
 		return nil, ErrDockerNotAvailable
@@ -81,6 +90,10 @@ func GetDockerIDList() ([]string, error) {
 // If you use container via systemd.slice, you could use
 // containerID = docker-<container id>.scope and base=/sys/fs/cgroup/cpuacct/system.slice/
 func CgroupCPU(containerID string, base string) (*cpu.TimesStat, error) {
+	return CgroupCPUWithContext(context.Background(), containerID, base)
+}
+
+func CgroupCPUWithContext(ctx context.Context, containerID string, base string) (*cpu.TimesStat, error) {
 	statfile := getCgroupFilePath(containerID, base, "cpuacct", "cpuacct.stat")
 	lines, err := common.ReadLines(statfile)
 	if err != nil {
@@ -111,10 +124,18 @@ func CgroupCPU(containerID string, base string) (*cpu.TimesStat, error) {
 }
 
 func CgroupCPUDocker(containerid string) (*cpu.TimesStat, error) {
+	return CgroupCPUDockerWithContext(context.Background(), containerid)
+}
+
+func CgroupCPUDockerWithContext(ctx context.Context, containerid string) (*cpu.TimesStat, error) {
 	return CgroupCPU(containerid, common.HostSys("fs/cgroup/cpuacct/docker"))
 }
 
 func CgroupMem(containerID string, base string) (*CgroupMemStat, error) {
+	return CgroupMemWithContext(context.Background(), containerID, base)
+}
+
+func CgroupMemWithContext(ctx context.Context, containerID string, base string) (*CgroupMemStat, error) {
 	statfile := getCgroupFilePath(containerID, base, "memory", "memory.stat")
 
 	// empty containerID means all cgroup
@@ -211,6 +232,10 @@ func CgroupMem(containerID string, base string) (*CgroupMemStat, error) {
 }
 
 func CgroupMemDocker(containerID string) (*CgroupMemStat, error) {
+	return CgroupMemDockerWithContext(context.Background(), containerID)
+}
+
+func CgroupMemDockerWithContext(ctx context.Context, containerID string) (*CgroupMemStat, error) {
 	return CgroupMem(containerID, common.HostSys("fs/cgroup/memory/docker"))
 }
 

docker/docker_notlinux.go

@@ -3,6 +3,7 @@
 package docker
 
 import (
+	"context"
 	"github.com/shirou/gopsutil/cpu"
 	"github.com/shirou/gopsutil/internal/common"
 )
@@ -10,12 +11,20 @@ import (
 // GetDockerStat returns a list of Docker basic stats.
 // This requires certain permission.
 func GetDockerStat() ([]CgroupDockerStat, error) {
+	return GetDockerStatWithContext(context.Background())
+}
+
+func GetDockerStatWithContext(ctx context.Context) ([]CgroupDockerStat, error) {
 	return nil, ErrDockerNotAvailable
 }
 
 // GetDockerIDList returnes a list of DockerID.
 // This requires certain permission.
 func GetDockerIDList() ([]string, error) {
+	return GetDockerIDListWithContext(context.Background())
+}
+
+func GetDockerIDListWithContext(ctx context.Context) ([]string, error) {
 	return nil, ErrDockerNotAvailable
 }
 
@@ -24,17 +33,33 @@ func GetDockerIDList() ([]string, error) {
 // If you use container via systemd.slice, you could use
 // containerid = docker-<container id>.scope and base=/sys/fs/cgroup/cpuacct/system.slice/
 func CgroupCPU(containerid string, base string) (*cpu.TimesStat, error) {
+	return CgroupCPUWithContext(context.Background(), containerid, base)
+}
+
+func CgroupCPUWithContext(ctx context.Context, containerid string, base string) (*cpu.TimesStat, error) {
 	return nil, ErrCgroupNotAvailable
 }
 
 func CgroupCPUDocker(containerid string) (*cpu.TimesStat, error) {
+	return CgroupCPUDockerWithContext(context.Background(), containerid)
+}
+
+func CgroupCPUDockerWithContext(ctx context.Context, containerid string) (*cpu.TimesStat, error) {
 	return CgroupCPU(containerid, common.HostSys("fs/cgroup/cpuacct/docker"))
 }
 
 func CgroupMem(containerid string, base string) (*CgroupMemStat, error) {
+	return CgroupMemWithContext(context.Background(), containerid, base)
+}
+
+func CgroupMemWithContext(ctx context.Context, containerid string, base string) (*CgroupMemStat, error) {
 	return nil, ErrCgroupNotAvailable
 }
 
 func CgroupMemDocker(containerid string) (*CgroupMemStat, error) {
+	return CgroupMemDockerWithContext(context.Background(), containerid)
+}
+
+func CgroupMemDockerWithContext(ctx context.Context, containerid string) (*CgroupMemStat, error) {
 	return CgroupMem(containerid, common.HostSys("fs/cgroup/memory/docker"))
 }

host/host_darwin.go

@@ -4,6 +4,7 @@ package host
 
 import (
 	"bytes"
+	"context"
 	"encoding/binary"
 	"io/ioutil"
 	"os"
@@ -23,6 +24,10 @@ import (
 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",
@@ -77,6 +82,10 @@ func Info() (*InfoStat, error) {
 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
@@ -102,6 +111,10 @@ func uptime(boot uint64) uint64 {
 }
 
 func Uptime() (uint64, error) {
+	return UptimeWithContext(context.Background())
+}
+
+func UptimeWithContext(ctx context.Context) (uint64, error) {
 	boot, err := BootTime()
 	if err != nil {
 		return 0, err
@@ -110,6 +123,10 @@ func Uptime() (uint64, error) {
 }
 
 func Users() ([]UserStat, error) {
+	return UsersWithContext(context.Background())
+}
+
+func UsersWithContext(ctx context.Context) ([]UserStat, error) {
 	utmpfile := "/var/run/utmpx"
 	var ret []UserStat
 
@@ -154,6 +171,10 @@ func Users() ([]UserStat, error) {
 }
 
 func PlatformInformation() (string, string, string, error) {
+	return PlatformInformationWithContext(context.Background())
+}
+
+func PlatformInformationWithContext(ctx context.Context) (string, string, string, error) {
 	platform := ""
 	family := ""
 	pver := ""
@@ -181,10 +202,18 @@ func PlatformInformation() (string, string, string, error) {
 }
 
 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
 }

host/host_darwin_cgo.go

@@ -6,8 +6,13 @@ package host
 // #cgo LDFLAGS: -framework IOKit
 // #include "include/smc.c"
 import "C"
+import "context"
 
 func SensorsTemperatures() ([]TemperatureStat, error) {
+	return SensorsTemperaturesWithContext(context.Background())
+}
+
+func SensorsTemperaturesWithContext(ctx context.Context) ([]TemperatureStat, error) {
 	temperatureKeys := []string{
 		C.AMBIENT_AIR_0,
 		C.AMBIENT_AIR_1,

host/host_darwin_nocgo.go

@@ -3,8 +3,16 @@
 
 package host
 
-import "github.com/shirou/gopsutil/internal/common"
+import (
+	"context"
+
+	"github.com/shirou/gopsutil/internal/common"
+)
 
 func SensorsTemperatures() ([]TemperatureStat, error) {
+	return SensorsTemperaturesWithContext(context.Background())
+}
+
+func SensorsTemperaturesWithContext(ctx context.Context) ([]TemperatureStat, error) {
 	return []TemperatureStat{}, common.ErrNotImplementedError
 }

host/host_fallback.go

@@ -2,28 +2,56 @@
 
 package host
 
-import "github.com/shirou/gopsutil/internal/common"
+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
 }

host/host_freebsd.go

@@ -4,6 +4,7 @@ package host
 
 import (
 	"bytes"
+	"context"
 	"encoding/binary"
 	"io/ioutil"
 	"os"
@@ -27,6 +28,10 @@ const (
 )
 
 func Info() (*InfoStat, error) {
+	return InfoWithContext(context.Background())
+}
+
+func InfoWithContext(ctx context.Context) (*InfoStat, error) {
 	ret := &InfoStat{
 		OS:             runtime.GOOS,
 		PlatformFamily: "freebsd",
@@ -74,6 +79,10 @@ func Info() (*InfoStat, error) {
 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
@@ -94,6 +103,10 @@ func uptime(boot uint64) uint64 {
 }
 
 func Uptime() (uint64, error) {
+	return UptimeWithContext(context.Background())
+}
+
+func UptimeWithContext(ctx context.Context) (uint64, error) {
 	boot, err := BootTime()
 	if err != nil {
 		return 0, err
@@ -102,6 +115,10 @@ func Uptime() (uint64, error) {
 }
 
 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
@@ -147,6 +164,10 @@ func Users() ([]UserStat, error) {
 }
 
 func PlatformInformation() (string, string, string, error) {
+	return PlatformInformationWithContext(context.Background())
+}
+
+func PlatformInformationWithContext(ctx context.Context) (string, string, string, error) {
 	platform := ""
 	family := ""
 	version := ""
@@ -169,6 +190,10 @@ func PlatformInformation() (string, string, string, error) {
 }
 
 func Virtualization() (string, string, error) {
+	return VirtualizationWithContext(context.Background())
+}
+
+func VirtualizationWithContext(ctx context.Context) (string, string, error) {
 	return "", "", common.ErrNotImplementedError
 }
 
@@ -212,10 +237,18 @@ func getUsersFromUtmp(utmpfile string) ([]UserStat, error) {
 }
 
 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
 }

host/host_linux.go

@@ -4,6 +4,7 @@ package host
 
 import (
 	"bytes"
+	"context"
 	"encoding/binary"
 	"fmt"
 	"io/ioutil"
@@ -31,6 +32,10 @@ type LSB struct {
 const USER_PROCESS = 7
 
 func Info() (*InfoStat, error) {
+	return InfoWithContext(context.Background())
+}
+
+func InfoWithContext(ctx context.Context) (*InfoStat, error) {
 	ret := &InfoStat{
 		OS: runtime.GOOS,
 	}
@@ -91,6 +96,10 @@ 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
@@ -135,6 +144,10 @@ func uptime(boot uint64) uint64 {
 }
 
 func Uptime() (uint64, error) {
+	return UptimeWithContext(context.Background())
+}
+
+func UptimeWithContext(ctx context.Context) (uint64, error) {
 	boot, err := BootTime()
 	if err != nil {
 		return 0, err
@@ -143,6 +156,10 @@ func Uptime() (uint64, error) {
 }
 
 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)
@@ -260,6 +277,10 @@ func getLSB() (*LSB, error) {
 }
 
 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 {
@@ -382,6 +403,10 @@ func PlatformInformation() (platform string, family string, version string, err
 }
 
 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)
@@ -441,6 +466,10 @@ func getSusePlatform(contents []string) string {
 }
 
 func Virtualization() (string, string, error) {
+	return VirtualizationWithContext(context.Background())
+}
+
+func VirtualizationWithContext(ctx context.Context) (string, string, error) {
 	var system string
 	var role string
 
@@ -544,6 +573,10 @@ func Virtualization() (string, string, error) {
 }
 
 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 {

host/host_openbsd.go

@@ -4,6 +4,7 @@ package host
 
 import (
 	"bytes"
+	"context"
 	"encoding/binary"
 	"io/ioutil"
 	"os"
@@ -25,6 +26,10 @@ const (
 )
 
 func Info() (*InfoStat, error) {
+	return InfoWithContext(context.Background())
+}
+
+func InfoWithContext(ctx context.Context) (*InfoStat, error) {
 	ret := &InfoStat{
 		OS:             runtime.GOOS,
 		PlatformFamily: "openbsd",
@@ -62,6 +67,10 @@ func Info() (*InfoStat, error) {
 }
 
 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
@@ -80,6 +89,10 @@ func uptime(boot uint64) uint64 {
 }
 
 func Uptime() (uint64, error) {
+	return UptimeWithContext(context.Background())
+}
+
+func UptimeWithContext(ctx context.Context) (uint64, error) {
 	boot, err := BootTime()
 	if err != nil {
 		return 0, err
@@ -88,6 +101,10 @@ func Uptime() (uint64, error) {
 }
 
 func PlatformInformation() (string, string, string, error) {
+	return PlatformInformationWithContext(context.Background())
+}
+
+func PlatformInformationWithContext(ctx context.Context) (string, string, string, error) {
 	platform := ""
 	family := ""
 	version := ""
@@ -110,10 +127,18 @@ func PlatformInformation() (string, string, string, error) {
 }
 
 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)
@@ -153,10 +178,18 @@ func Users() ([]UserStat, error) {
 }
 
 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
 }

host/host_solaris.go

@@ -3,6 +3,7 @@ package host
 import (
 	"bufio"
 	"bytes"
+	"context"
 	"fmt"
 	"io/ioutil"
 	"os"
@@ -17,6 +18,10 @@ import (
 )
 
 func Info() (*InfoStat, error) {
+	return InfoWithContext(context.Background())
+}
+
+func InfoWithContext(ctx context.Context) (*InfoStat, error) {
 	result := &InfoStat{
 		OS: runtime.GOOS,
 	}
@@ -142,6 +147,10 @@ func Info() (*InfoStat, error) {
 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
@@ -161,6 +170,10 @@ func BootTime() (uint64, error) {
 }
 
 func Uptime() (uint64, error) {
+	return UptimeWithContext(context.Background())
+}
+
+func UptimeWithContext(ctx context.Context) (uint64, error) {
 	bootTime, err := BootTime()
 	if err != nil {
 		return 0, err
@@ -173,18 +186,34 @@ func uptimeSince(since uint64) uint64 {
 }
 
 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 {

host/host_windows.go

@@ -32,6 +32,10 @@ type Win32_OperatingSystem struct {
 }
 
 func Info() (*InfoStat, error) {
+	return InfoWithContext(context.Background())
+}
+
+func InfoWithContext(ctx context.Context) (*InfoStat, error) {
 	ret := &InfoStat{
 		OS: runtime.GOOS,
 	}
@@ -108,6 +112,10 @@ func getMachineGuid() (string, error) {
 }
 
 func GetOSInfo() (Win32_OperatingSystem, error) {
+	return GetOSInfoWithContext(context.Background())
+}
+
+func GetOSInfoWithContext(ctx context.Context) (Win32_OperatingSystem, error) {
 	var dst []Win32_OperatingSystem
 	q := wmi.CreateQuery(&dst, "")
 	ctx, cancel := context.WithTimeout(context.Background(), common.Timeout)
@@ -123,6 +131,10 @@ func GetOSInfo() (Win32_OperatingSystem, error) {
 }
 
 func Uptime() (uint64, error) {
+	return UptimeWithContext(context.Background())
+}
+
+func UptimeWithContext(ctx context.Context) (uint64, error) {
 	if osInfo == nil {
 		_, err := GetOSInfo()
 		if err != nil {
@@ -142,6 +154,10 @@ func bootTime(up uint64) uint64 {
 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
@@ -156,6 +172,10 @@ func BootTime() (uint64, error) {
 }
 
 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) {
 	if osInfo == nil {
 		_, err = GetOSInfo()
 		if err != nil {
@@ -183,20 +203,36 @@ func PlatformInformation() (platform string, family string, version string, err
 }
 
 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) {
 	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) {
 	_, _, version, err := PlatformInformation()
 	return version, err
 }

load/load_bsd.go

@@ -3,6 +3,7 @@
 package load
 
 import (
+	"context"
 	"os/exec"
 	"strings"
 	"unsafe"
@@ -11,6 +12,10 @@ import (
 )
 
 func Avg() (*AvgStat, error) {
+	return AvgWithContext(context.Background())
+}
+
+func AvgWithContext(ctx context.Context) (*AvgStat, error) {
 	// This SysctlRaw method borrowed from
 	// https://github.com/prometheus/node_exporter/blob/master/collector/loadavg_freebsd.go
 	type loadavg struct {
@@ -36,6 +41,10 @@ func Avg() (*AvgStat, error) {
 // darwin use ps command to get process running/blocked count.
 // Almost same as Darwin implementation, but state is different.
 func Misc() (*MiscStat, error) {
+	return MiscWithContext(context.Background())
+}
+
+func MiscWithContext(ctx context.Context) (*MiscStat, error) {
 	bin, err := exec.LookPath("ps")
 	if err != nil {
 		return nil, err

load/load_darwin.go

@@ -3,6 +3,7 @@
 package load
 
 import (
+	"context"
 	"os/exec"
 	"strconv"
 	"strings"
@@ -11,6 +12,10 @@ import (
 )
 
 func Avg() (*AvgStat, error) {
+	return AvgWithContext(context.Background())
+}
+
+func AvgWithContext(ctx context.Context) (*AvgStat, error) {
 	values, err := common.DoSysctrl("vm.loadavg")
 	if err != nil {
 		return nil, err
@@ -43,6 +48,10 @@ func Avg() (*AvgStat, error) {
 // Almost same as FreeBSD implementation, but state is different.
 // U means 'Uninterruptible Sleep'.
 func Misc() (*MiscStat, error) {
+	return MiscWithContext(context.Background())
+}
+
+func MiscWithContext(ctx context.Context) (*MiscStat, error) {
 	bin, err := exec.LookPath("ps")
 	if err != nil {
 		return nil, err

load/load_fallback.go

@@ -2,12 +2,24 @@
 
 package load
 
-import "github.com/shirou/gopsutil/internal/common"
+import (
+	"context"
+
+	"github.com/shirou/gopsutil/internal/common"
+)
 
 func Avg() (*AvgStat, error) {
+	return AvgWithContext(context.Background())
+}
+
+func AvgWithContext(ctx context.Context) (*AvgStat, error) {
 	return nil, common.ErrNotImplementedError
 }
 
 func Misc() (*MiscStat, error) {
+	return MiscWithContext(context.Background())
+}
+
+func MiscWithContext(ctx context.Context) (*MiscStat, error) {
 	return nil, common.ErrNotImplementedError
 }

load/load_linux.go

@@ -3,6 +3,7 @@
 package load
 
 import (
+	"context"
 	"io/ioutil"
 	"strconv"
 	"strings"
@@ -11,6 +12,10 @@ import (
 )
 
 func Avg() (*AvgStat, error) {
+	return AvgWithContext(context.Background())
+}
+
+func AvgWithContext(ctx context.Context) (*AvgStat, error) {
 	filename := common.HostProc("loadavg")
 	line, err := ioutil.ReadFile(filename)
 	if err != nil {
@@ -44,6 +49,10 @@ func Avg() (*AvgStat, error) {
 // Misc returnes miscellaneous host-wide statistics.
 // Note: the name should be changed near future.
 func Misc() (*MiscStat, error) {
+	return MiscWithContext(context.Background())
+}
+
+func MiscWithContext(ctx context.Context) (*MiscStat, error) {
 	filename := common.HostProc("stat")
 	out, err := ioutil.ReadFile(filename)
 	if err != nil {

load/load_windows.go

@@ -3,16 +3,26 @@
 package load
 
 import (
+	"context"
+
 	"github.com/shirou/gopsutil/internal/common"
 )
 
 func Avg() (*AvgStat, error) {
+	return AvgWithContext(context.Background())
+}
+
+func AvgWithContext(ctx context.Context) (*AvgStat, error) {
 	ret := AvgStat{}
 
 	return &ret, common.ErrNotImplementedError
 }
 
 func Misc() (*MiscStat, error) {
+	return MiscWithContext(context.Background())
+}
+
+func MiscWithContext(ctx context.Context) (*MiscStat, error) {
 	ret := MiscStat{}
 
 	return &ret, common.ErrNotImplementedError

mem/mem_darwin.go

@@ -3,6 +3,7 @@
 package mem
 
 import (
+	"context"
 	"encoding/binary"
 	"strconv"
 	"strings"
@@ -28,6 +29,10 @@ func getHwMemsize() (uint64, error) {
 
 // SwapMemory returns swapinfo.
 func SwapMemory() (*SwapMemoryStat, error) {
+	return SwapMemoryWithContext(context.Background())
+}
+
+func SwapMemoryWithContext(ctx context.Context) (*SwapMemoryStat, error) {
 	var ret *SwapMemoryStat
 
 	swapUsage, err := common.DoSysctrl("vm.swapusage")

mem/mem_darwin_cgo.go

@@ -9,6 +9,7 @@ package mem
 import "C"
 
 import (
+	"context"
 	"fmt"
 	"unsafe"
 
@@ -17,6 +18,10 @@ import (
 
 // 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
 

mem/mem_darwin_nocgo.go

@@ -4,6 +4,7 @@
 package mem
 
 import (
+	"context"
 	"os/exec"
 	"strconv"
 	"strings"
@@ -68,6 +69,10 @@ func parseVMStat(out string, vms *VirtualMemoryStat) error {
 
 // VirtualMemory returns VirtualmemoryStat.
 func VirtualMemory() (*VirtualMemoryStat, error) {
+	return VirtualMemoryWithContext(context.Background())
+}
+
+func VirtualMemoryWithContext(ctx context.Context) (*VirtualMemoryStat, error) {
 	ret := &VirtualMemoryStat{}
 
 	total, err := getHwMemsize()

mem/mem_fallback.go

@@ -2,12 +2,24 @@
 
 package mem
 
-import "github.com/shirou/gopsutil/internal/common"
+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
 }

mem/mem_freebsd.go

@@ -3,6 +3,7 @@
 package mem
 
 import (
+	"context"
 	"errors"
 	"os/exec"
 	"strconv"
@@ -12,6 +13,10 @@ import (
 )
 
 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
@@ -66,6 +71,10 @@ func VirtualMemory() (*VirtualMemoryStat, error) {
 // Return swapinfo
 // FreeBSD can have multiple swap devices. but use only first device
 func SwapMemory() (*SwapMemoryStat, error) {
+	return SwapMemoryWithContext(context.Background())
+}
+
+func SwapMemoryWithContext(ctx context.Context) (*SwapMemoryStat, error) {
 	swapinfo, err := exec.LookPath("swapinfo")
 	if err != nil {
 		return nil, err

mem/mem_linux.go

@@ -3,6 +3,7 @@
 package mem
 
 import (
+	"context"
 	"strconv"
 	"strings"
 
@@ -11,6 +12,10 @@ import (
 )
 
 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+)
@@ -72,6 +77,10 @@ func VirtualMemory() (*VirtualMemoryStat, error) {
 }
 
 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 {

mem/mem_openbsd.go

@@ -4,14 +4,20 @@ package mem
 
 import (
 	"bytes"
+	"context"
 	"encoding/binary"
 	"errors"
 	"fmt"
-	"github.com/shirou/gopsutil/internal/common"
 	"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 {
@@ -30,6 +36,10 @@ func GetPageSize() (uint64, error) {
 }
 
 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 {
@@ -80,6 +90,10 @@ func VirtualMemory() (*VirtualMemoryStat, error) {
 
 // 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

mem/mem_solaris.go

@@ -1,6 +1,7 @@
 package mem
 
 import (
+	"context"
 	"errors"
 	"fmt"
 	"os/exec"
@@ -14,6 +15,10 @@ import (
 // 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()
@@ -39,6 +44,10 @@ func VirtualMemory() (*VirtualMemoryStat, error) {
 }
 
 func SwapMemory() (*SwapMemoryStat, error) {
+	return SwapMemoryWithContext(context.Background())
+}
+
+func SwapMemoryWithContext(ctx context.Context) (*SwapMemoryStat, error) {
 	return nil, common.ErrNotImplementedError
 }
 

mem/mem_windows.go

@@ -3,6 +3,7 @@
 package mem
 
 import (
+	"context"
 	"unsafe"
 
 	"github.com/shirou/gopsutil/internal/common"
@@ -11,7 +12,7 @@ import (
 
 var (
 	procGlobalMemoryStatusEx = common.Modkernel32.NewProc("GlobalMemoryStatusEx")
-	procGetPerformanceInfo = common.ModPsapi.NewProc("GetPerformanceInfo")
+	procGetPerformanceInfo   = common.ModPsapi.NewProc("GetPerformanceInfo")
 )
 
 type memoryStatusEx struct {
@@ -27,6 +28,10 @@ type memoryStatusEx struct {
 }
 
 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)))
@@ -45,23 +50,27 @@ func VirtualMemory() (*VirtualMemoryStat, error) {
 }
 
 type performanceInformation struct {
-	cb				uint32
-	commitTotal		uint64
-	commitLimit		uint64
-	commitPeak		uint64
-	physicalTotal	uint64
+	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
+	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))
@@ -72,12 +81,11 @@ func SwapMemory() (*SwapMemoryStat, error) {
 	used := perfInfo.commitTotal * perfInfo.pageSize
 	free := tot - used
 	ret := &SwapMemoryStat{
-		Total: tot,
-		Used: used,
-		Free: free,
-		UsedPercent: float64(used/tot),
+		Total:       tot,
+		Used:        used,
+		Free:        free,
+		UsedPercent: float64(used / tot),
 	}
 
 	return ret, nil
 }
-

net/net.go

@@ -1,6 +1,7 @@
 package net
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"net"
@@ -111,6 +112,10 @@ func (n InterfaceAddr) String() string {
 }
 
 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

net/net_darwin.go

@@ -3,6 +3,7 @@
 package net
 
 import (
+	"context"
 	"errors"
 	"fmt"
 	"os/exec"
@@ -164,6 +165,10 @@ func (min mapInterfaceNameUsage) notTruncated() []string {
 // 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
@@ -251,10 +256,18 @@ func IOCounters(pernic bool) ([]IOCountersStat, error) {
 
 // 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")
 }
 
@@ -263,5 +276,9 @@ func FilterCounters() ([]FilterStat, error) {
 // 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")
 }

net/net_fallback.go

@@ -2,24 +2,48 @@
 
 package net
 
-import "github.com/shirou/gopsutil/internal/common"
+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
 }

net/net_freebsd.go

@@ -3,6 +3,7 @@
 package net
 
 import (
+	"context"
 	"errors"
 	"os/exec"
 	"strconv"
@@ -12,6 +13,10 @@ import (
 )
 
 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
@@ -92,10 +97,18 @@ func IOCounters(pernic bool) ([]IOCountersStat, error) {
 
 // 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")
 }
 
@@ -104,5 +117,9 @@ func FilterCounters() ([]FilterStat, error) {
 // 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")
 }

net/net_linux.go

@@ -4,6 +4,7 @@ package net
 
 import (
 	"bytes"
+	"context"
 	"encoding/hex"
 	"errors"
 	"fmt"
@@ -23,11 +24,19 @@ import (
 // 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
@@ -132,6 +141,10 @@ var netProtocols = []string{
 // 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
 	}
@@ -191,6 +204,10 @@ func ProtoCounters(protocols []string) ([]ProtoCountersStat, error) {
 // 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")
 
@@ -294,17 +311,29 @@ type connTmp struct {
 
 // 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)
@@ -329,6 +358,10 @@ func ConnectionsPid(kind string, pid int32) ([]ConnectionStat, error) {
 
 // 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)
@@ -459,6 +492,10 @@ func getProcInodes(root string, pid int32, max int) (map[string][]inodeMap, erro
 // 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())
@@ -592,6 +629,10 @@ func decodeAddress(family uint32, src string) (Addr, error) {
 
 // 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]
 	}

net/net_openbsd.go

@@ -3,6 +3,7 @@
 package net
 
 import (
+	"context"
 	"errors"
 	"fmt"
 	"os/exec"
@@ -97,6 +98,10 @@ func ParseNetstat(output string, mode string,
 }
 
 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
@@ -136,10 +141,18 @@ func IOCounters(pernic bool) ([]IOCountersStat, error) {
 
 // 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")
 }
 
@@ -148,6 +161,10 @@ func FilterCounters() ([]FilterStat, error) {
 // 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")
 }
 
@@ -233,6 +250,10 @@ func parseNetstatAddr(local string, remote string, family uint32) (laddr Addr, r
 
 // 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"}

net/net_unix.go

@@ -3,6 +3,7 @@
 package net
 
 import (
+	"context"
 	"strings"
 
 	"github.com/shirou/gopsutil/internal/common"
@@ -10,17 +11,29 @@ import (
 
 // 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"}
@@ -75,5 +88,9 @@ func ConnectionsPid(kind string, pid int32) ([]ConnectionStat, error) {
 
 // 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
 }

net/net_windows.go

@@ -3,6 +3,7 @@
 package net
 
 import (
+	"context"
 	"errors"
 	"net"
 	"os"
@@ -30,6 +31,10 @@ const (
 )
 
 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
@@ -66,11 +71,19 @@ func IOCounters(pernic bool) ([]IOCountersStat, error) {
 
 // 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
@@ -79,10 +92,18 @@ func Connections(kind string) ([]ConnectionStat, error) {
 // 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")
 }
 
@@ -91,5 +112,9 @@ func FilterCounters() ([]FilterStat, error) {
 // 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")
 }

process/process.go

@@ -1,6 +1,7 @@
 package process
 
 import (
+	"context"
 	"encoding/json"
 	"runtime"
 	"time"
@@ -127,6 +128,10 @@ func (p NumCtxSwitchesStat) String() string {
 }
 
 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
@@ -144,6 +149,10 @@ func PidExists(pid int32) (bool, error) {
 // 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
@@ -187,6 +196,10 @@ func calculatePercent(t1, t2 *cpu.TimesStat, delta float64, numcpu int) float64
 
 // 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
@@ -204,6 +217,10 @@ func (p *Process) MemoryPercent() (float32, error) {
 
 // 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

process/process_darwin.go

@@ -4,6 +4,7 @@ package process
 
 import (
 	"bytes"
+	"context"
 	"encoding/binary"
 	"fmt"
 	"os/exec"
@@ -44,6 +45,10 @@ type MemoryMapsStat struct {
 }
 
 func Pids() ([]int32, error) {
+	return PidsWithContext(context.Background())
+}
+
+func PidsWithContext(ctx context.Context) ([]int32, error) {
 	var ret []int32
 
 	pids, err := callPs("pid", 0, false)
@@ -63,6 +68,10 @@ func Pids() ([]int32, error) {
 }
 
 func (p *Process) Ppid() (int32, error) {
+	return p.PpidWithContext(context.Background())
+}
+
+func (p *Process) PpidWithContext(ctx context.Context) (int32, error) {
 	r, err := callPs("ppid", p.Pid, false)
 	if err != nil {
 		return 0, err
@@ -76,6 +85,10 @@ func (p *Process) Ppid() (int32, error) {
 	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
@@ -87,6 +100,10 @@ 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
@@ -120,6 +137,10 @@ func (p *Process) Exe() (string, error) {
 // 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 := callPs("command", p.Pid, false)
 	if err != nil {
 		return "", err
@@ -133,6 +154,10 @@ func (p *Process) Cmdline() (string, error) {
 // 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 := callPs("command", p.Pid, false)
 	if err != nil {
 		return nil, err
@@ -140,6 +165,10 @@ func (p *Process) CmdlineSlice() ([]string, error) {
 	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 := callPs("etime", p.Pid, false)
 	if err != nil {
 		return 0, err
@@ -170,9 +199,17 @@ func (p *Process) CreateTime() (int64, error) {
 	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.CallLsof(invoke, p.Pid, "-FR")
 	if err != nil {
 		return nil, err
@@ -191,6 +228,10 @@ func (p *Process) Parent() (*Process, error) {
 	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 := callPs("state", p.Pid, false)
 	if err != nil {
 		return "", err
@@ -199,6 +240,10 @@ func (p *Process) Status() (string, error) {
 	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
@@ -210,6 +255,10 @@ func (p *Process) Uids() ([]int32, error) {
 	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
@@ -221,6 +270,10 @@ func (p *Process) Gids() ([]int32, error) {
 	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()
@@ -238,6 +291,10 @@ func (p *Process) Terminal() (string, error) {
 	*/
 }
 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
@@ -245,26 +302,54 @@ func (p *Process) Nice() (int32, error) {
 	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(_ bool) ([]RlimitStat, error) {
+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 := callPs("utime,stime", p.Pid, true)
 	if err != nil {
 		return 0, err
@@ -272,6 +357,10 @@ func (p *Process) NumThreads() (int32, error) {
 	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
 }
@@ -302,6 +391,10 @@ func convertCPUTimes(s string) (ret float64, err error) {
 	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 := callPs("utime,stime", p.Pid, false)
 
 	if err != nil {
@@ -325,9 +418,17 @@ func (p *Process) Times() (*cpu.TimesStat, error) {
 	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 := callPs("rss,vsize,pagein", p.Pid, false)
 	if err != nil {
 		return nil, err
@@ -354,10 +455,18 @@ func (p *Process) MemoryInfo() (*MemoryInfoStat, error) {
 	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.CallPgrep(invoke, p.Pid)
 	if err != nil {
 		return nil, err
@@ -374,21 +483,41 @@ func (p *Process) Children() ([]*Process, error) {
 }
 
 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
 }
@@ -439,6 +568,10 @@ func parseKinfoProc(buf []byte) (KinfoProc, error) {
 // 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))

process/process_fallback.go

@@ -3,6 +3,7 @@
 package process
 
 import (
+	"context"
 	"syscall"
 
 	"github.com/shirou/gopsutil/cpu"
@@ -28,6 +29,10 @@ type MemoryInfoExStat struct {
 }
 
 func Pids() ([]int32, error) {
+	return PidsWithContext(context.Background())
+}
+
+func PidsWithContext(ctx context.Context) ([]int32, error) {
 	return []int32{}, common.ErrNotImplementedError
 }
 
@@ -36,116 +41,264 @@ func NewProcess(pid int32) (*Process, error) {
 }
 
 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(_ bool) ([]RlimitStat, error) {
+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
 }

process/process_freebsd.go

@@ -4,6 +4,7 @@ package process
 
 import (
 	"bytes"
+	"context"
 	"encoding/binary"
 	"strings"
 
@@ -21,6 +22,10 @@ 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 {
@@ -35,6 +40,10 @@ func Pids() ([]int32, error) {
 }
 
 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
@@ -43,6 +52,10 @@ func (p *Process) Ppid() (int32, error) {
 	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
@@ -54,10 +67,18 @@ 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 {
@@ -74,6 +95,10 @@ func (p *Process) Cmdline() (string, error) {
 }
 
 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 {
@@ -94,15 +119,31 @@ func (p *Process) CmdlineSlice() ([]string, error) {
 	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
@@ -128,6 +169,10 @@ func (p *Process) Status() (string, error) {
 	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
@@ -140,6 +185,10 @@ func (p *Process) Uids() ([]int32, error) {
 	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
@@ -151,6 +200,10 @@ func (p *Process) Gids() ([]int32, error) {
 	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
@@ -166,6 +219,10 @@ func (p *Process) Terminal() (string, error) {
 	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
@@ -173,17 +230,33 @@ func (p *Process) Nice() (int32, error) {
 	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(_ bool) ([]RlimitStat, error) {
+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
@@ -194,12 +267,24 @@ func (p *Process) IOCounters() (*IOCountersStat, error) {
 	}, 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
@@ -208,10 +293,18 @@ func (p *Process) NumThreads() (int32, error) {
 	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
@@ -223,9 +316,17 @@ func (p *Process) Times() (*cpu.TimesStat, error) {
 	}, 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
@@ -242,10 +343,18 @@ func (p *Process) MemoryInfo() (*MemoryInfoStat, error) {
 	}, 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.CallPgrep(invoke, p.Pid)
 	if err != nil {
 		return nil, err
@@ -262,21 +371,41 @@ func (p *Process) Children() ([]*Process, error) {
 }
 
 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
 }
@@ -319,6 +448,10 @@ func parseKinfoProc(buf []byte) (KinfoProc, error) {
 }
 
 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)

process/process_linux.go

@@ -5,6 +5,7 @@ package process
 import (
 	"bufio"
 	"bytes"
+	"context"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -83,6 +84,10 @@ func NewProcess(pid int32) (*Process, error) {
 
 // Ppid returns Parent Process ID of the process.
 func (p *Process) Ppid() (int32, error) {
+	return p.PpidWithContext(context.Background())
+}
+
+func (p *Process) PpidWithContext(ctx context.Context) (int32, error) {
 	_, ppid, _, _, _, _, err := p.fillFromStat()
 	if err != nil {
 		return -1, err
@@ -92,6 +97,10 @@ func (p *Process) Ppid() (int32, error) {
 
 // Name returns name of the process.
 func (p *Process) Name() (string, error) {
+	return p.NameWithContext(context.Background())
+}
+
+func (p *Process) NameWithContext(ctx context.Context) (string, error) {
 	if p.name == "" {
 		if err := p.fillFromStatus(); err != nil {
 			return "", err
@@ -112,23 +121,39 @@ func (p *Process) Tgid() (int32, error) {
 
 // Exe returns executable path of the process.
 func (p *Process) Exe() (string, error) {
+	return p.ExeWithContext(context.Background())
+}
+
+func (p *Process) ExeWithContext(ctx context.Context) (string, error) {
 	return p.fillFromExe()
 }
 
 // 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) {
 	return p.fillFromCmdline()
 }
 
 // CmdlineSlice returns the command line arguments of the process as a slice with each
 // element being an argument.
 func (p *Process) CmdlineSlice() ([]string, error) {
+	return p.CmdlineSliceWithContext(context.Background())
+}
+
+func (p *Process) CmdlineSliceWithContext(ctx context.Context) ([]string, error) {
 	return p.fillSliceFromCmdline()
 }
 
 // CreateTime returns created time of the process in milliseconds since the epoch, in UTC.
 func (p *Process) CreateTime() (int64, error) {
+	return p.CreateTimeWithContext(context.Background())
+}
+
+func (p *Process) CreateTimeWithContext(ctx context.Context) (int64, error) {
 	_, _, _, createTime, _, _, err := p.fillFromStat()
 	if err != nil {
 		return 0, err
@@ -138,11 +163,19 @@ func (p *Process) CreateTime() (int64, error) {
 
 // Cwd returns current working directory of the process.
 func (p *Process) Cwd() (string, error) {
+	return p.CwdWithContext(context.Background())
+}
+
+func (p *Process) CwdWithContext(ctx context.Context) (string, error) {
 	return p.fillFromCwd()
 }
 
 // Parent returns parent Process of the process.
 func (p *Process) Parent() (*Process, error) {
+	return p.ParentWithContext(context.Background())
+}
+
+func (p *Process) ParentWithContext(ctx context.Context) (*Process, error) {
 	err := p.fillFromStatus()
 	if err != nil {
 		return nil, err
@@ -159,6 +192,10 @@ func (p *Process) Parent() (*Process, error) {
 // Z: Zombie W: Wait L: Lock
 // The charactor is same within all supported platforms.
 func (p *Process) Status() (string, error) {
+	return p.StatusWithContext(context.Background())
+}
+
+func (p *Process) StatusWithContext(ctx context.Context) (string, error) {
 	err := p.fillFromStatus()
 	if err != nil {
 		return "", err
@@ -168,6 +205,10 @@ func (p *Process) Status() (string, error) {
 
 // Uids returns user ids of the process as a slice of the int
 func (p *Process) Uids() ([]int32, error) {
+	return p.UidsWithContext(context.Background())
+}
+
+func (p *Process) UidsWithContext(ctx context.Context) ([]int32, error) {
 	err := p.fillFromStatus()
 	if err != nil {
 		return []int32{}, err
@@ -177,6 +218,10 @@ func (p *Process) Uids() ([]int32, error) {
 
 // Gids returns group ids of the process as a slice of the int
 func (p *Process) Gids() ([]int32, error) {
+	return p.GidsWithContext(context.Background())
+}
+
+func (p *Process) GidsWithContext(ctx context.Context) ([]int32, error) {
 	err := p.fillFromStatus()
 	if err != nil {
 		return []int32{}, err
@@ -186,6 +231,10 @@ func (p *Process) Gids() ([]int32, error) {
 
 // Terminal returns a terminal which is associated with the process.
 func (p *Process) Terminal() (string, error) {
+	return p.TerminalWithContext(context.Background())
+}
+
+func (p *Process) TerminalWithContext(ctx context.Context) (string, error) {
 	terminal, _, _, _, _, _, err := p.fillFromStat()
 	if err != nil {
 		return "", err
@@ -196,6 +245,10 @@ func (p *Process) Terminal() (string, error) {
 // Nice returns a nice value (priority).
 // Notice: gopsutil can not set nice value.
 func (p *Process) Nice() (int32, error) {
+	return p.NiceWithContext(context.Background())
+}
+
+func (p *Process) NiceWithContext(ctx context.Context) (int32, error) {
 	_, _, _, _, _, nice, err := p.fillFromStat()
 	if err != nil {
 		return 0, err
@@ -205,11 +258,19 @@ func (p *Process) Nice() (int32, error) {
 
 // IOnice returns process I/O nice value (priority).
 func (p *Process) IOnice() (int32, error) {
+	return p.IOniceWithContext(context.Background())
+}
+
+func (p *Process) IOniceWithContext(ctx context.Context) (int32, error) {
 	return 0, common.ErrNotImplementedError
 }
 
 // Rlimit returns Resource Limits.
 func (p *Process) Rlimit() ([]RlimitStat, error) {
+	return p.RlimitWithContext(context.Background())
+}
+
+func (p *Process) RlimitWithContext(ctx context.Context) ([]RlimitStat, error) {
 	return p.RlimitUsage(false)
 }
 
@@ -217,6 +278,10 @@ func (p *Process) Rlimit() ([]RlimitStat, error) {
 // If gatherUsed is true, the currently used value will be gathered and added
 // to the resulting RlimitStat.
 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) {
 	rlimits, err := p.fillFromLimits()
 	if !gatherUsed || err != nil {
 		return rlimits, err
@@ -273,11 +338,19 @@ func (p *Process) RlimitUsage(gatherUsed bool) ([]RlimitStat, error) {
 
 // IOCounters returns IO Counters.
 func (p *Process) IOCounters() (*IOCountersStat, error) {
+	return p.IOCountersWithContext(context.Background())
+}
+
+func (p *Process) IOCountersWithContext(ctx context.Context) (*IOCountersStat, error) {
 	return p.fillFromIO()
 }
 
 // NumCtxSwitches returns the number of the context switches of the process.
 func (p *Process) NumCtxSwitches() (*NumCtxSwitchesStat, error) {
+	return p.NumCtxSwitchesWithContext(context.Background())
+}
+
+func (p *Process) NumCtxSwitchesWithContext(ctx context.Context) (*NumCtxSwitchesStat, error) {
 	err := p.fillFromStatus()
 	if err != nil {
 		return nil, err
@@ -287,12 +360,20 @@ func (p *Process) NumCtxSwitches() (*NumCtxSwitchesStat, error) {
 
 // NumFDs returns the number of File Descriptors used by the process.
 func (p *Process) NumFDs() (int32, error) {
+	return p.NumFDsWithContext(context.Background())
+}
+
+func (p *Process) NumFDsWithContext(ctx context.Context) (int32, error) {
 	_, fnames, err := p.fillFromfdList()
 	return int32(len(fnames)), err
 }
 
 // NumThreads returns the number of threads used by the process.
 func (p *Process) NumThreads() (int32, error) {
+	return p.NumThreadsWithContext(context.Background())
+}
+
+func (p *Process) NumThreadsWithContext(ctx context.Context) (int32, error) {
 	err := p.fillFromStatus()
 	if err != nil {
 		return 0, err
@@ -301,6 +382,10 @@ func (p *Process) NumThreads() (int32, error) {
 }
 
 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)
 	taskPath := common.HostProc(strconv.Itoa(int(p.Pid)), "task")
 
@@ -322,6 +407,10 @@ func (p *Process) Threads() (map[int32]*cpu.TimesStat, error) {
 
 // Times returns CPU times of the process.
 func (p *Process) Times() (*cpu.TimesStat, error) {
+	return p.TimesWithContext(context.Background())
+}
+
+func (p *Process) TimesWithContext(ctx context.Context) (*cpu.TimesStat, error) {
 	_, _, cpuTimes, _, _, _, err := p.fillFromStat()
 	if err != nil {
 		return nil, err
@@ -333,11 +422,19 @@ func (p *Process) Times() (*cpu.TimesStat, error) {
 //
 // Notice: Not implemented yet.
 func (p *Process) CPUAffinity() ([]int32, error) {
+	return p.CPUAffinityWithContext(context.Background())
+}
+
+func (p *Process) CPUAffinityWithContext(ctx context.Context) ([]int32, error) {
 	return nil, common.ErrNotImplementedError
 }
 
 // MemoryInfo returns platform in-dependend memory information, such as RSS, VMS and Swap
 func (p *Process) MemoryInfo() (*MemoryInfoStat, error) {
+	return p.MemoryInfoWithContext(context.Background())
+}
+
+func (p *Process) MemoryInfoWithContext(ctx context.Context) (*MemoryInfoStat, error) {
 	meminfo, _, err := p.fillFromStatm()
 	if err != nil {
 		return nil, err
@@ -347,6 +444,10 @@ func (p *Process) MemoryInfo() (*MemoryInfoStat, error) {
 
 // MemoryInfoEx returns platform dependend memory information.
 func (p *Process) MemoryInfoEx() (*MemoryInfoExStat, error) {
+	return p.MemoryInfoExWithContext(context.Background())
+}
+
+func (p *Process) MemoryInfoExWithContext(ctx context.Context) (*MemoryInfoExStat, error) {
 	_, memInfoEx, err := p.fillFromStatm()
 	if err != nil {
 		return nil, err
@@ -356,6 +457,10 @@ func (p *Process) MemoryInfoEx() (*MemoryInfoExStat, error) {
 
 // Children returns a slice of Process of the process.
 func (p *Process) Children() ([]*Process, error) {
+	return p.ChildrenWithContext(context.Background())
+}
+
+func (p *Process) ChildrenWithContext(ctx context.Context) ([]*Process, error) {
 	pids, err := common.CallPgrep(invoke, p.Pid)
 	if err != nil {
 		if pids == nil || len(pids) == 0 {
@@ -377,6 +482,10 @@ func (p *Process) Children() ([]*Process, error) {
 // OpenFiles returns a slice of OpenFilesStat opend by the process.
 // OpenFilesStat includes a file path and file descriptor.
 func (p *Process) OpenFiles() ([]OpenFilesStat, error) {
+	return p.OpenFilesWithContext(context.Background())
+}
+
+func (p *Process) OpenFilesWithContext(ctx context.Context) ([]OpenFilesStat, error) {
 	_, ofs, err := p.fillFromfd()
 	if err != nil {
 		return nil, err
@@ -392,11 +501,19 @@ func (p *Process) OpenFiles() ([]OpenFilesStat, error) {
 // Connections returns a slice of net.ConnectionStat used by the process.
 // This returns all kind of the connection. This measn TCP, UDP or UNIX.
 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)
 }
 
 // NetIOCounters returns NetIOCounters of the process.
 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) {
 	filename := common.HostProc(strconv.Itoa(int(p.Pid)), "net/dev")
 	return net.IOCountersByFile(pernic, filename)
 }
@@ -404,11 +521,19 @@ func (p *Process) NetIOCounters(pernic bool) ([]net.IOCountersStat, error) {
 // IsRunning returns whether the process is running or not.
 // Not implemented yet.
 func (p *Process) IsRunning() (bool, error) {
+	return p.IsRunningWithContext(context.Background())
+}
+
+func (p *Process) IsRunningWithContext(ctx context.Context) (bool, error) {
 	return true, common.ErrNotImplementedError
 }
 
 // MemoryMaps get memory maps from /proc/(pid)/smaps
 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) {
 	pid := p.Pid
 	var ret []MemoryMapsStat
 	smapsPath := common.HostProc(strconv.Itoa(int(pid)), "smaps")
@@ -503,6 +628,10 @@ func limitToInt(val string) (int32, error) {
 
 // Get num_fds from /proc/(pid)/limits
 func (p *Process) fillFromLimits() ([]RlimitStat, error) {
+	return p.fillFromLimitsWithContext(context.Background())
+}
+
+func (p *Process) fillFromLimitsWithContext(ctx context.Context) ([]RlimitStat, error) {
 	pid := p.Pid
 	limitsFile := common.HostProc(strconv.Itoa(int(pid)), "limits")
 	d, err := os.Open(limitsFile)
@@ -596,6 +725,10 @@ func (p *Process) fillFromLimits() ([]RlimitStat, error) {
 
 // Get list of /proc/(pid)/fd files
 func (p *Process) fillFromfdList() (string, []string, error) {
+	return p.fillFromfdListWithContext(context.Background())
+}
+
+func (p *Process) fillFromfdListWithContext(ctx context.Context) (string, []string, error) {
 	pid := p.Pid
 	statPath := common.HostProc(strconv.Itoa(int(pid)), "fd")
 	d, err := os.Open(statPath)
@@ -609,6 +742,10 @@ func (p *Process) fillFromfdList() (string, []string, error) {
 
 // Get num_fds from /proc/(pid)/fd
 func (p *Process) fillFromfd() (int32, []*OpenFilesStat, error) {
+	return p.fillFromfdWithContext(context.Background())
+}
+
+func (p *Process) fillFromfdWithContext(ctx context.Context) (int32, []*OpenFilesStat, error) {
 	statPath, fnames, err := p.fillFromfdList()
 	if err != nil {
 		return 0, nil, err
@@ -638,6 +775,10 @@ func (p *Process) fillFromfd() (int32, []*OpenFilesStat, error) {
 
 // Get cwd from /proc/(pid)/cwd
 func (p *Process) fillFromCwd() (string, error) {
+	return p.fillFromCwdWithContext(context.Background())
+}
+
+func (p *Process) fillFromCwdWithContext(ctx context.Context) (string, error) {
 	pid := p.Pid
 	cwdPath := common.HostProc(strconv.Itoa(int(pid)), "cwd")
 	cwd, err := os.Readlink(cwdPath)
@@ -649,6 +790,10 @@ func (p *Process) fillFromCwd() (string, error) {
 
 // Get exe from /proc/(pid)/exe
 func (p *Process) fillFromExe() (string, error) {
+	return p.fillFromExeWithContext(context.Background())
+}
+
+func (p *Process) fillFromExeWithContext(ctx context.Context) (string, error) {
 	pid := p.Pid
 	exePath := common.HostProc(strconv.Itoa(int(pid)), "exe")
 	exe, err := os.Readlink(exePath)
@@ -660,6 +805,10 @@ func (p *Process) fillFromExe() (string, error) {
 
 // Get cmdline from /proc/(pid)/cmdline
 func (p *Process) fillFromCmdline() (string, error) {
+	return p.fillFromCmdlineWithContext(context.Background())
+}
+
+func (p *Process) fillFromCmdlineWithContext(ctx context.Context) (string, error) {
 	pid := p.Pid
 	cmdPath := common.HostProc(strconv.Itoa(int(pid)), "cmdline")
 	cmdline, err := ioutil.ReadFile(cmdPath)
@@ -677,6 +826,10 @@ func (p *Process) fillFromCmdline() (string, error) {
 }
 
 func (p *Process) fillSliceFromCmdline() ([]string, error) {
+	return p.fillSliceFromCmdlineWithContext(context.Background())
+}
+
+func (p *Process) fillSliceFromCmdlineWithContext(ctx context.Context) ([]string, error) {
 	pid := p.Pid
 	cmdPath := common.HostProc(strconv.Itoa(int(pid)), "cmdline")
 	cmdline, err := ioutil.ReadFile(cmdPath)
@@ -700,6 +853,10 @@ func (p *Process) fillSliceFromCmdline() ([]string, error) {
 
 // Get IO status from /proc/(pid)/io
 func (p *Process) fillFromIO() (*IOCountersStat, error) {
+	return p.fillFromIOWithContext(context.Background())
+}
+
+func (p *Process) fillFromIOWithContext(ctx context.Context) (*IOCountersStat, error) {
 	pid := p.Pid
 	ioPath := common.HostProc(strconv.Itoa(int(pid)), "io")
 	ioline, err := ioutil.ReadFile(ioPath)
@@ -739,6 +896,10 @@ func (p *Process) fillFromIO() (*IOCountersStat, error) {
 
 // Get memory info from /proc/(pid)/statm
 func (p *Process) fillFromStatm() (*MemoryInfoStat, *MemoryInfoExStat, error) {
+	return p.fillFromStatmWithContext(context.Background())
+}
+
+func (p *Process) fillFromStatmWithContext(ctx context.Context) (*MemoryInfoStat, *MemoryInfoExStat, error) {
 	pid := p.Pid
 	memPath := common.HostProc(strconv.Itoa(int(pid)), "statm")
 	contents, err := ioutil.ReadFile(memPath)
@@ -791,6 +952,10 @@ func (p *Process) fillFromStatm() (*MemoryInfoStat, *MemoryInfoExStat, error) {
 
 // Get various status from /proc/(pid)/status
 func (p *Process) fillFromStatus() error {
+	return p.fillFromStatusWithContext(context.Background())
+}
+
+func (p *Process) fillFromStatusWithContext(ctx context.Context) error {
 	pid := p.Pid
 	statPath := common.HostProc(strconv.Itoa(int(pid)), "status")
 	contents, err := ioutil.ReadFile(statPath)
@@ -951,6 +1116,10 @@ func (p *Process) fillFromStatus() error {
 }
 
 func (p *Process) fillFromTIDStat(tid int32) (string, int32, *cpu.TimesStat, int64, uint32, int32, error) {
+	return p.fillFromTIDStatWithContext(context.Background(), tid)
+}
+
+func (p *Process) fillFromTIDStatWithContext(ctx context.Context, tid int32) (string, int32, *cpu.TimesStat, int64, uint32, int32, error) {
 	pid := p.Pid
 	var statPath string
 
@@ -1025,11 +1194,19 @@ func (p *Process) fillFromTIDStat(tid int32) (string, int32, *cpu.TimesStat, int
 }
 
 func (p *Process) fillFromStat() (string, int32, *cpu.TimesStat, int64, uint32, int32, error) {
+	return p.fillFromStatWithContext(context.Background())
+}
+
+func (p *Process) fillFromStatWithContext(ctx context.Context) (string, int32, *cpu.TimesStat, int64, uint32, int32, error) {
 	return p.fillFromTIDStat(-1)
 }
 
 // Pids returns a slice of process ID list which are running now.
 func Pids() ([]int32, error) {
+	return PidsWithContext(context.Background())
+}
+
+func PidsWithContext(ctx context.Context) ([]int32, error) {
 	return readPidsFromDir(common.HostProc())
 }
 

process/process_openbsd.go

@@ -15,6 +15,7 @@ import (
 	net "github.com/shirou/gopsutil/net"
 	"golang.org/x/sys/unix"
 )
+import "context"
 
 // MemoryInfoExStat is different between OSes
 type MemoryInfoExStat struct {
@@ -24,6 +25,10 @@ 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 {
@@ -38,6 +43,10 @@ func Pids() ([]int32, error) {
 }
 
 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
@@ -46,6 +55,10 @@ func (p *Process) Ppid() (int32, error) {
 	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
@@ -57,10 +70,18 @@ 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)
 
@@ -84,6 +105,10 @@ func (p *Process) CmdlineSlice() ([]string, error) {
 }
 
 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
@@ -92,15 +117,31 @@ func (p *Process) Cmdline() (string, error) {
 }
 
 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
@@ -122,6 +163,10 @@ func (p *Process) Status() (string, error) {
 	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
@@ -134,6 +179,10 @@ func (p *Process) Uids() ([]int32, error) {
 	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
@@ -145,6 +194,10 @@ func (p *Process) Gids() ([]int32, error) {
 	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
@@ -160,6 +213,10 @@ func (p *Process) Terminal() (string, error) {
 	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
@@ -167,17 +224,33 @@ func (p *Process) Nice() (int32, error) {
 	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(_ bool) ([]RlimitStat, error) {
+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
@@ -188,20 +261,40 @@ func (p *Process) IOCounters() (*IOCountersStat, error) {
 	}, 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
@@ -213,9 +306,17 @@ func (p *Process) Times() (*cpu.TimesStat, error) {
 	}, 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
@@ -232,10 +333,18 @@ func (p *Process) MemoryInfo() (*MemoryInfoStat, error) {
 	}, 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.CallPgrep(invoke, p.Pid)
 	if err != nil {
 		return nil, err
@@ -252,21 +361,41 @@ func (p *Process) Children() ([]*Process, error) {
 }
 
 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
 }
@@ -309,6 +438,10 @@ func parseKinfoProc(buf []byte) (KinfoProc, error) {
 }
 
 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
@@ -331,6 +464,10 @@ func NewProcess(pid int32) (*Process, error) {
 }
 
 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))

process/process_posix.go

@@ -3,6 +3,7 @@
 package process
 
 import (
+	"context"
 	"os"
 	"os/user"
 	"path/filepath"
@@ -65,6 +66,10 @@ func getTerminalMap() (map[uint64]string, error) {
 // SendSignal sends a unix.Signal to the process.
 // Currently, SIGSTOP, SIGCONT, SIGTERM and SIGKILL are supported.
 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 {
 	process, err := os.FindProcess(int(p.Pid))
 	if err != nil {
 		return err
@@ -80,26 +85,46 @@ func (p *Process) SendSignal(sig syscall.Signal) error {
 
 // Suspend sends SIGSTOP to the process.
 func (p *Process) Suspend() error {
+	return p.SuspendWithContext(context.Background())
+}
+
+func (p *Process) SuspendWithContext(ctx context.Context) error {
 	return p.SendSignal(unix.SIGSTOP)
 }
 
 // Resume sends SIGCONT to the process.
 func (p *Process) Resume() error {
+	return p.ResumeWithContext(context.Background())
+}
+
+func (p *Process) ResumeWithContext(ctx context.Context) error {
 	return p.SendSignal(unix.SIGCONT)
 }
 
 // Terminate sends SIGTERM to the process.
 func (p *Process) Terminate() error {
+	return p.TerminateWithContext(context.Background())
+}
+
+func (p *Process) TerminateWithContext(ctx context.Context) error {
 	return p.SendSignal(unix.SIGTERM)
 }
 
 // Kill sends SIGKILL to the process.
 func (p *Process) Kill() error {
+	return p.KillWithContext(context.Background())
+}
+
+func (p *Process) KillWithContext(ctx context.Context) error {
 	return p.SendSignal(unix.SIGKILL)
 }
 
 // Username returns a username of the process.
 func (p *Process) Username() (string, error) {
+	return p.UsernameWithContext(context.Background())
+}
+
+func (p *Process) UsernameWithContext(ctx context.Context) (string, error) {
 	uids, err := p.Uids()
 	if err != nil {
 		return "", err

process/process_windows.go

@@ -95,6 +95,10 @@ func init() {
 }
 
 func Pids() ([]int32, error) {
+	return PidsWithContext(context.Background())
+}
+
+func PidsWithContext(ctx context.Context) ([]int32, error) {
 	// inspired by https://gist.github.com/henkman/3083408
 	// and https://github.com/giampaolo/psutil/blob/1c3a15f637521ba5c0031283da39c733fda53e4c/psutil/arch/windows/process_info.c#L315-L329
 	var ret []int32
@@ -121,6 +125,10 @@ func Pids() ([]int32, error) {
 }
 
 func (p *Process) Ppid() (int32, error) {
+	return p.PpidWithContext(context.Background())
+}
+
+func (p *Process) PpidWithContext(ctx context.Context) (int32, error) {
 	ppid, _, _, err := getFromSnapProcess(p.Pid)
 	if err != nil {
 		return 0, err
@@ -129,6 +137,10 @@ func (p *Process) Ppid() (int32, error) {
 }
 
 func GetWin32Proc(pid int32) ([]Win32_Process, error) {
+	return GetWin32ProcWithContext(context.Background(), pid)
+}
+
+func GetWin32ProcWithContext(ctx context.Context, pid int32) ([]Win32_Process, error) {
 	var dst []Win32_Process
 	query := fmt.Sprintf("WHERE ProcessId = %d", pid)
 	q := wmi.CreateQuery(&dst, query)
@@ -147,6 +159,10 @@ func GetWin32Proc(pid int32) ([]Win32_Process, error) {
 }
 
 func (p *Process) Name() (string, error) {
+	return p.NameWithContext(context.Background())
+}
+
+func (p *Process) NameWithContext(ctx context.Context) (string, error) {
 	_, _, name, err := getFromSnapProcess(p.Pid)
 	if err != nil {
 		return "", fmt.Errorf("could not get Name: %s", err)
@@ -159,6 +175,10 @@ func (p *Process) Tgid() (int32, error) {
 }
 
 func (p *Process) Exe() (string, error) {
+	return p.ExeWithContext(context.Background())
+}
+
+func (p *Process) ExeWithContext(ctx context.Context) (string, error) {
 	dst, err := GetWin32Proc(p.Pid)
 	if err != nil {
 		return "", fmt.Errorf("could not get ExecutablePath: %s", err)
@@ -167,6 +187,10 @@ func (p *Process) Exe() (string, error) {
 }
 
 func (p *Process) Cmdline() (string, error) {
+	return p.CmdlineWithContext(context.Background())
+}
+
+func (p *Process) CmdlineWithContext(ctx context.Context) (string, error) {
 	dst, err := GetWin32Proc(p.Pid)
 	if err != nil {
 		return "", fmt.Errorf("could not get CommandLine: %s", err)
@@ -178,6 +202,10 @@ func (p *Process) Cmdline() (string, error) {
 // element being an argument. This merely returns the CommandLine informations passed
 // to the process split on the 0x20 ASCII character.
 func (p *Process) CmdlineSlice() ([]string, error) {
+	return p.CmdlineSliceWithContext(context.Background())
+}
+
+func (p *Process) CmdlineSliceWithContext(ctx context.Context) ([]string, error) {
 	cmdline, err := p.Cmdline()
 	if err != nil {
 		return nil, err
@@ -186,6 +214,10 @@ func (p *Process) CmdlineSlice() ([]string, error) {
 }
 
 func (p *Process) CreateTime() (int64, error) {
+	return p.CreateTimeWithContext(context.Background())
+}
+
+func (p *Process) CreateTimeWithContext(ctx context.Context) (int64, error) {
 	ru, err := getRusage(p.Pid)
 	if err != nil {
 		return 0, fmt.Errorf("could not get CreationDate: %s", err)
@@ -195,9 +227,17 @@ func (p *Process) CreateTime() (int64, error) {
 }
 
 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) {
 	dst, err := GetWin32Proc(p.Pid)
 	if err != nil {
 		return nil, fmt.Errorf("could not get ParentProcessID: %s", err)
@@ -206,9 +246,17 @@ func (p *Process) Parent() (*Process, error) {
 	return NewProcess(int32(dst[0].ParentProcessID))
 }
 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) Username() (string, error) {
+	return p.UsernameWithContext(context.Background())
+}
+
+func (p *Process) UsernameWithContext(ctx context.Context) (string, error) {
 	pid := p.Pid
 	// 0x1000 is PROCESS_QUERY_LIMITED_INFORMATION
 	c, err := syscall.OpenProcess(0x1000, false, uint32(pid))
@@ -230,20 +278,36 @@ func (p *Process) Username() (string, error) {
 }
 
 func (p *Process) Uids() ([]int32, error) {
+	return p.UidsWithContext(context.Background())
+}
+
+func (p *Process) UidsWithContext(ctx context.Context) ([]int32, error) {
 	var uids []int32
 
 	return uids, common.ErrNotImplementedError
 }
 func (p *Process) Gids() ([]int32, error) {
+	return p.GidsWithContext(context.Background())
+}
+
+func (p *Process) GidsWithContext(ctx context.Context) ([]int32, error) {
 	var gids []int32
 	return gids, 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
 }
 
 // Nice returnes priority in Windows
 func (p *Process) Nice() (int32, error) {
+	return p.NiceWithContext(context.Background())
+}
+
+func (p *Process) NiceWithContext(ctx context.Context) (int32, error) {
 	dst, err := GetWin32Proc(p.Pid)
 	if err != nil {
 		return 0, fmt.Errorf("could not get Priority: %s", err)
@@ -251,20 +315,36 @@ func (p *Process) Nice() (int32, error) {
 	return int32(dst[0].Priority), 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(_ bool) ([]RlimitStat, error) {
+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) {
 	dst, err := GetWin32Proc(p.Pid)
 	if err != nil || len(dst) == 0 {
 		return nil, fmt.Errorf("could not get Win32Proc: %s", err)
@@ -279,12 +359,24 @@ func (p *Process) IOCounters() (*IOCountersStat, error) {
 	return ret, 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) {
 	dst, err := GetWin32Proc(p.Pid)
 	if err != nil {
 		return 0, fmt.Errorf("could not get ThreadCount: %s", err)
@@ -292,10 +384,18 @@ func (p *Process) NumThreads() (int32, error) {
 	return int32(dst[0].ThreadCount), 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) {
 	sysTimes, err := getProcessCPUTimes(p.Pid)
 	if err != nil {
 		return nil, err
@@ -319,9 +419,17 @@ func (p *Process) Times() (*cpu.TimesStat, error) {
 	}, 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) {
 	mem, err := getMemoryInfo(p.Pid)
 	if err != nil {
 		return nil, err
@@ -335,10 +443,18 @@ func (p *Process) MemoryInfo() (*MemoryInfoStat, error) {
 	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) {
 	var dst []Win32_Process
 	query := wmi.CreateQuery(&dst, fmt.Sprintf("Where ParentProcessId = %d", p.Pid))
 	ctx, cancel := context.WithTimeout(context.Background(), common.Timeout)
@@ -361,22 +477,42 @@ func (p *Process) Children() ([]*Process, error) {
 }
 
 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
 }
@@ -388,17 +524,33 @@ func NewProcess(pid int32) (*Process, error) {
 }
 
 func (p *Process) SendSignal(sig windows.Signal) error {
+	return p.SendSignalWithContext(context.Background(), sig)
+}
+
+func (p *Process) SendSignalWithContext(ctx context.Context, sig windows.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 {
 	// PROCESS_TERMINATE = 0x0001
 	proc := w32.OpenProcess(0x0001, false, uint32(p.Pid))
 	ret := w32.TerminateProcess(proc, 0)
@@ -412,6 +564,10 @@ func (p *Process) Terminate() error {
 }
 
 func (p *Process) Kill() error {
+	return p.KillWithContext(context.Background())
+}
+
+func (p *Process) KillWithContext(ctx context.Context) error {
 	process := os.Process{Pid: int(p.Pid)}
 	return process.Kill()
 }