Add support for OpenBSD/amd64

This code is based on the FreeBSD version
and implements roughly the same feature set.

Makefile

@@ -15,12 +15,12 @@ build_test:  ## test only buildable
 	# Supported operating systems
 	GOOS=linux go test ./... | $(BUILD_FAIL_PATTERN)
 	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=dragonfly go test ./... | $(BUILD_FAIL_PATTERN)
 	GOOS=netbsd go test ./... | $(BUILD_FAIL_PATTERN)
-	GOOS=openbsd go test ./... | $(BUILD_FAIL_PATTERN)
 	GOOS=solaris go test ./... | $(BUILD_FAIL_PATTERN)
 	@echo 'Successfully built on all known operating systems'

cpu/cpu_fallback.go

@@ -1,4 +1,4 @@
-// +build !darwin,!linux,!freebsd,!windows
+// +build !darwin,!linux,!freebsd,!openbsd,!windows
 
 package cpu
 

cpu/cpu_openbsd.go

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

disk/disk_fallback.go

@@ -1,4 +1,4 @@
-// +build !darwin,!linux,!freebsd,!windows
+// +build !darwin,!linux,!freebsd,!openbsd,!windows
 
 package disk
 

disk/disk_openbsd.go

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

disk/disk_openbsd_amd64.go

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

disk/types_openbsd.go

@@ -0,0 +1,70 @@
+// +build ignore
+// Hand writing: _Ctype_struct___0
+
+/*
+Input to cgo -godefs.
+*/
+
+package disk
+
+/*
+#include <sys/types.h>
+#include <sys/disk.h>
+#include <sys/mount.h>
+
+enum {
+	sizeofPtr = sizeof(void*),
+};
+
+*/
+import "C"
+
+// Machine characteristics; for internal use.
+
+const (
+	sizeofPtr        = C.sizeofPtr
+	sizeofShort      = C.sizeof_short
+	sizeofInt        = C.sizeof_int
+	sizeofLong       = C.sizeof_long
+	sizeofLongLong   = C.sizeof_longlong
+	sizeofLongDouble = C.sizeof_longlong
+
+	DEVSTAT_NO_DATA = 0x00
+	DEVSTAT_READ    = 0x01
+	DEVSTAT_WRITE   = 0x02
+	DEVSTAT_FREE    = 0x03
+
+	// from sys/mount.h
+	MNT_RDONLY      = 0x00000001 /* read only filesystem */
+	MNT_SYNCHRONOUS = 0x00000002 /* filesystem written synchronously */
+	MNT_NOEXEC      = 0x00000004 /* can't exec from filesystem */
+	MNT_NOSUID      = 0x00000008 /* don't honor setuid bits on fs */
+	MNT_NODEV       = 0x00000010 /* don't interpret special files */
+	MNT_ASYNC       = 0x00000040 /* filesystem written asynchronously */
+
+	MNT_WAIT    = 1 /* synchronously wait for I/O to complete */
+	MNT_NOWAIT  = 2 /* start all I/O, but do not wait for it */
+	MNT_LAZY    = 3 /* push data not written by filesystem syncer */
+)
+
+const (
+	sizeOfDiskstats = C.sizeof_struct_diskstats
+)
+
+// Basic types
+
+type (
+	_C_short       C.short
+	_C_int         C.int
+	_C_long        C.long
+	_C_long_long   C.longlong
+	_C_long_double C.longlong
+)
+
+type Statfs C.struct_statfs
+type Diskstats C.struct_diskstats
+type Fsid C.fsid_t
+type Timeval C.struct_timeval
+
+type Diskstat C.struct_diskstat
+type Bintime C.struct_bintime

host/host_fallback.go

@@ -1,4 +1,4 @@
-// +build !darwin,!linux,!freebsd,!windows
+// +build !darwin,!linux,!freebsd,!openbsd,!windows
 
 package host
 

host/host_openbsd.go

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

host/host_openbsd_amd64.go

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

host/types_openbsd.go

@@ -0,0 +1,43 @@
+// +build ignore
+
+/*
+Input to cgo -godefs.
+*/
+
+package host
+
+/*
+#define KERNEL
+#include <sys/types.h>
+#include <sys/time.h>
+#include <utmp.h>
+
+enum {
+	sizeofPtr = sizeof(void*),
+};
+
+*/
+import "C"
+
+// Machine characteristics; for internal use.
+
+const (
+	sizeofPtr      = C.sizeofPtr
+	sizeofShort    = C.sizeof_short
+	sizeofInt      = C.sizeof_int
+	sizeofLong     = C.sizeof_long
+	sizeofLongLong = C.sizeof_longlong
+	sizeOfUtmp    = C.sizeof_struct_utmp
+)
+
+// Basic types
+
+type (
+	_C_short     C.short
+	_C_int       C.int
+	_C_long      C.long
+	_C_long_long C.longlong
+)
+
+type Utmp C.struct_utmp
+type Timeval C.struct_timeval

internal/common/common_freebsd.go

@@ -1,4 +1,4 @@
-// +build freebsd
+// +build freebsd openbsd
 
 package common
 

internal/common/common_openbsd.go

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

internal/common/common_unix.go

@@ -1,4 +1,4 @@
-// +build linux freebsd darwin
+// +build linux freebsd darwin openbsd
 
 package common
 

load/load_fallback.go

@@ -1,4 +1,4 @@
-// +build !darwin,!linux,!freebsd,!windows
+// +build !darwin,!linux,!freebsd,!openbsd,!windows
 
 package load
 

load/load_openbsd.go

@@ -0,0 +1,65 @@
+// +build openbsd
+
+package load
+
+import (
+	"os/exec"
+	"strconv"
+	"strings"
+
+	"github.com/shirou/gopsutil/internal/common"
+)
+
+func Avg() (*AvgStat, error) {
+	values, err := common.DoSysctrl("vm.loadavg")
+	if err != nil {
+		return nil, err
+	}
+
+	load1, err := strconv.ParseFloat(values[0], 64)
+	if err != nil {
+		return nil, err
+	}
+	load5, err := strconv.ParseFloat(values[1], 64)
+	if err != nil {
+		return nil, err
+	}
+	load15, err := strconv.ParseFloat(values[2], 64)
+	if err != nil {
+		return nil, err
+	}
+
+	ret := &AvgStat{
+		Load1:  float64(load1),
+		Load5:  float64(load5),
+		Load15: float64(load15),
+	}
+
+	return ret, nil
+}
+
+// Misc returnes miscellaneous host-wide statistics.
+// darwin use ps command to get process running/blocked count.
+// Almost same as Darwin implementation, but state is different.
+func Misc() (*MiscStat, error) {
+	bin, err := exec.LookPath("ps")
+	if err != nil {
+		return nil, err
+	}
+	out, err := invoke.Command(bin, "axo", "state")
+	if err != nil {
+		return nil, err
+	}
+	lines := strings.Split(string(out), "\n")
+
+	ret := MiscStat{}
+	for _, l := range lines {
+		if strings.Contains(l, "R") {
+			ret.ProcsRunning++
+		} else if strings.Contains(l, "D") {
+			ret.ProcsBlocked++
+		}
+	}
+
+	return &ret, nil
+}

mem/mem_fallback.go

@@ -1,4 +1,4 @@
-// +build !darwin,!linux,!freebsd,!windows
+// +build !darwin,!linux,!freebsd,!openbsd,!windows
 
 package mem
 

mem/mem_openbsd.go

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

mem/mem_openbsd_amd64.go

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

mem/types_openbsd.go

@@ -0,0 +1,37 @@
+// +build ignore
+
+/*
+Input to cgo -godefs.
+*/
+
+
+package mem
+
+/*
+#include <sys/types.h>
+#include <sys/mount.h>
+#include <sys/sysctl.h>
+#include <uvm/uvmexp.h>
+
+*/
+import "C"
+
+// Machine characteristics; for internal use.
+
+const (
+	CTLVm		= 2
+	CTLVfs		= 10
+	VmUvmexp	= 4  // get uvmexp
+	VfsGeneric	= 0
+	VfsBcacheStat	= 3
+)
+
+const (
+	sizeOfUvmexp = C.sizeof_struct_uvmexp
+	sizeOfBcachestats = C.sizeof_struct_bcachestats
+)
+
+
+type Uvmexp C.struct_uvmexp
+type Bcachestats C.struct_bcachestats
+

net/net_fallback.go

@@ -1,4 +1,4 @@
-// +build !darwin,!linux,!freebsd,!windows
+// +build !darwin,!linux,!freebsd,!openbsd,!windows
 
 package net
 

net/net_openbsd.go

@@ -0,0 +1,153 @@
+// +build openbsd
+
+package net
+
+import (
+	"errors"
+	"os/exec"
+	"strconv"
+	"strings"
+
+	"github.com/shirou/gopsutil/internal/common"
+)
+
+func ParseNetstat(output string, mode string,
+	iocs map[string]IOCountersStat) (error) {
+	lines := strings.Split(output, "\n")
+
+	exists := make([]string, 0, len(lines)-1)
+
+	columns := 6
+	if mode == "ind" {
+		columns = 10
+	}
+	for _, line := range lines {
+		values := strings.Fields(line)
+		if len(values) < 1 || values[0] == "Name" {
+			continue
+		}
+		if common.StringsHas(exists, values[0]) {
+			// skip if already get
+			continue
+		}
+
+		if len(values) < columns {
+			continue
+		}
+		base := 1
+		// sometimes Address is ommitted
+		if len(values) < columns {
+			base = 0
+		}
+
+		parsed := make([]uint64, 0, 8)
+		var vv []string
+		if mode == "inb" {
+			vv = []string{
+				values[base+3],  // BytesRecv
+				values[base+4],  // BytesSent
+			}
+		} else {
+			vv = []string{
+				values[base+3],  // Ipkts
+				values[base+4],  // Ierrs
+				values[base+5],  // Opkts
+				values[base+6],  // Oerrs
+				values[base+8],  // Drops
+			}
+		}
+		for _, target := range vv {
+			if target == "-" {
+				parsed = append(parsed, 0)
+				continue
+			}
+
+			t, err := strconv.ParseUint(target, 10, 64)
+			if err != nil {
+				return err
+			}
+			parsed = append(parsed, t)
+		}
+		exists = append(exists, values[0])
+
+		n, present := iocs[values[0]]
+		if !present {
+			n = IOCountersStat{Name : values[0]}
+		}
+		if mode == "inb" {
+			n.BytesRecv = parsed[0]
+			n.BytesSent = parsed[1]
+		} else {
+			n.PacketsRecv = parsed[0]
+			n.Errin       = parsed[1]
+			n.PacketsSent = parsed[2]
+			n.Errout      = parsed[3]
+			n.Dropin      = parsed[4]
+			n.Dropout     = parsed[4]
+		}
+
+		iocs[n.Name] = n
+	}
+	return nil
+}
+
+func IOCounters(pernic bool) ([]IOCountersStat, error) {
+	netstat, err := exec.LookPath("/usr/bin/netstat")
+	if err != nil {
+		return nil, err
+	}
+	out, err := invoke.Command(netstat, "-inb")
+	if err != nil {
+		return nil, err
+	}
+	out2, err := invoke.Command(netstat, "-ind")
+	if err != nil {
+		return nil, err
+	}
+	iocs := make(map[string]IOCountersStat)
+
+	lines := strings.Split(string(out), "\n")
+	ret := make([]IOCountersStat, 0, len(lines)-1)
+
+	err = ParseNetstat(string(out), "inb", iocs)
+	if err != nil {
+		return nil, err
+	}
+	err = ParseNetstat(string(out2), "ind", iocs)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, ioc := range iocs {
+		ret = append(ret, ioc)
+	}
+
+	if pernic == false {
+		return getIOCountersAll(ret)
+	}
+
+	return ret, nil
+}
+
+// NetIOCountersByFile is an method which is added just a compatibility for linux.
+func IOCountersByFile(pernic bool, filename string) ([]IOCountersStat, error) {
+	return IOCounters(pernic)
+}
+
+func FilterCounters() ([]FilterStat, error) {
+	return nil, errors.New("NetFilterCounters not implemented for openbsd")
+}
+
+// NetProtoCounters returns network statistics for the entire system
+// If protocols is empty then all protocols are returned, otherwise
+// just the protocols in the list are returned.
+// Not Implemented for OpenBSD
+func ProtoCounters(protocols []string) ([]ProtoCountersStat, error) {
+	return nil, errors.New("NetProtoCounters not implemented for openbsd")
+}
+
+// Return a list of network connections opened.
+// Not Implemented for OpenBSD
+func Connections(kind string) ([]ConnectionStat, error) {
+	return nil, errors.New("Connections not implemented for openbsd")
+}

process/process_fallback.go

@@ -1,4 +1,4 @@
-// +build !darwin,!linux,!freebsd,!windows
+// +build !darwin,!linux,!freebsd,!openbsd,!windows
 
 package process
 

process/process_openbsd.go

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

process/process_openbsd_amd64.go

@@ -0,0 +1,200 @@
+// Created by cgo -godefs - DO NOT EDIT
+// cgo -godefs types_openbsd.go
+
+package process
+
+const (
+	CTLKern			= 1
+	KernProc		= 66
+	KernProcAll		= 0
+	KernProcPID		= 1
+	KernProcProc		= 8
+	KernProcPathname	= 12
+	KernProcArgs		= 55
+	KernProcArgv		= 1
+	KernProcEnv		= 3
+)
+
+const (
+	ArgMax = 256 * 1024
+)
+
+const (
+	sizeofPtr	= 0x8
+	sizeofShort	= 0x2
+	sizeofInt	= 0x4
+	sizeofLong	= 0x8
+	sizeofLongLong	= 0x8
+)
+
+const (
+	sizeOfKinfoVmentry	= 0x50
+	sizeOfKinfoProc		= 0x268
+)
+
+const (
+	SIDL	= 1
+	SRUN	= 2
+	SSLEEP	= 3
+	SSTOP	= 4
+	SZOMB	= 5
+	SDEAD	= 6
+	SONPROC	= 7
+)
+
+type (
+	_C_short	int16
+	_C_int		int32
+	_C_long		int64
+	_C_long_long	int64
+)
+
+type Timespec struct {
+	Sec	int64
+	Nsec	int64
+}
+
+type Timeval struct {
+	Sec	int64
+	Usec	int64
+}
+
+type Rusage struct {
+	Utime		Timeval
+	Stime		Timeval
+	Maxrss		int64
+	Ixrss		int64
+	Idrss		int64
+	Isrss		int64
+	Minflt		int64
+	Majflt		int64
+	Nswap		int64
+	Inblock		int64
+	Oublock		int64
+	Msgsnd		int64
+	Msgrcv		int64
+	Nsignals	int64
+	Nvcsw		int64
+	Nivcsw		int64
+}
+
+type Rlimit struct {
+	Cur	uint64
+	Max	uint64
+}
+
+type KinfoProc struct {
+	Forw		uint64
+	Back		uint64
+	Paddr		uint64
+	Addr		uint64
+	Fd		uint64
+	Stats		uint64
+	Limit		uint64
+	Vmspace		uint64
+	Sigacts		uint64
+	Sess		uint64
+	Tsess		uint64
+	Ru		uint64
+	Eflag		int32
+	Exitsig		int32
+	Flag		int32
+	Pid		int32
+	Ppid		int32
+	Sid		int32
+	X_pgid		int32
+	Tpgid		int32
+	Uid		uint32
+	Ruid		uint32
+	Gid		uint32
+	Rgid		uint32
+	Groups		[16]uint32
+	Ngroups		int16
+	Jobc		int16
+	Tdev		uint32
+	Estcpu		uint32
+	Rtime_sec	uint32
+	Rtime_usec	uint32
+	Cpticks		int32
+	Pctcpu		uint32
+	Swtime		uint32
+	Slptime		uint32
+	Schedflags	int32
+	Uticks		uint64
+	Sticks		uint64
+	Iticks		uint64
+	Tracep		uint64
+	Traceflag	int32
+	Holdcnt		int32
+	Siglist		int32
+	Sigmask		uint32
+	Sigignore	uint32
+	Sigcatch	uint32
+	Stat		int8
+	Priority	uint8
+	Usrpri		uint8
+	Nice		uint8
+	Xstat		uint16
+	Acflag		uint16
+	Comm		[24]int8
+	Wmesg		[8]int8
+	Wchan		uint64
+	Login		[32]int8
+	Vm_rssize	int32
+	Vm_tsize	int32
+	Vm_dsize	int32
+	Vm_ssize	int32
+	Uvalid		int64
+	Ustart_sec	uint64
+	Ustart_usec	uint32
+	Uutime_sec	uint32
+	Uutime_usec	uint32
+	Ustime_sec	uint32
+	Ustime_usec	uint32
+	Pad_cgo_0	[4]byte
+	Uru_maxrss	uint64
+	Uru_ixrss	uint64
+	Uru_idrss	uint64
+	Uru_isrss	uint64
+	Uru_minflt	uint64
+	Uru_majflt	uint64
+	Uru_nswap	uint64
+	Uru_inblock	uint64
+	Uru_oublock	uint64
+	Uru_msgsnd	uint64
+	Uru_msgrcv	uint64
+	Uru_nsignals	uint64
+	Uru_nvcsw	uint64
+	Uru_nivcsw	uint64
+	Uctime_sec	uint32
+	Uctime_usec	uint32
+	Psflags		int32
+	Spare		int32
+	Svuid		uint32
+	Svgid		uint32
+	Emul		[8]int8
+	Rlim_rss_cur	uint64
+	Cpuid		uint64
+	Vm_map_size	uint64
+	Tid		int32
+	Rtableid	uint32
+}
+
+type Priority struct{}
+
+type KinfoVmentry struct {
+	Start		uint64
+	End		uint64
+	Guard		uint64
+	Fspace		uint64
+	Fspace_augment	uint64
+	Offset		uint64
+	Wired_count	int32
+	Etype		int32
+	Protection	int32
+	Max_protection	int32
+	Advice		int32
+	Inheritance	int32
+	Flags		uint8
+	Pad_cgo_0	[7]byte
+}

process/process_posix.go

@@ -1,4 +1,4 @@
-// +build linux freebsd darwin
+// +build linux freebsd openbsd darwin
 
 package process
 
@@ -6,6 +6,7 @@ import (
 	"os"
 	"os/exec"
 	"os/user"
+	"path/filepath"
 	"strconv"
 	"strings"
 	"syscall"
@@ -31,15 +32,22 @@ func getTerminalMap() (map[uint64]string, error) {
 		}
 	}
 
+	var ptsnames []string
 	ptsd, err := os.Open("/dev/pts")
 	if err != nil {
-		return nil, err
+		ptsnames, _ = filepath.Glob("/dev/ttyp*")
+		if ptsnames == nil {
+			return nil, err
+		}
 	}
-	defer ptsd.Close()
+	if ptsnames == nil {
-
+		defer ptsd.Close()
-	ptsnames, err := ptsd.Readdirnames(-1)
+		ptsnames, err = ptsd.Readdirnames(-1)
-	for _, ptsname := range ptsnames {
+		for _, ptsname := range ptsnames {
-		termfiles = append(termfiles, "/dev/pts/"+ptsname)
+			termfiles = append(termfiles, "/dev/pts/"+ptsname)
+		}
+	} else {
+		termfiles = ptsnames
 	}
 
 	for _, name := range termfiles {

process/types_openbsd.go

@@ -0,0 +1,104 @@
+// +build ignore
+
+// We still need editing by hands.
+// go tool cgo -godefs types_openbsd.go | sed 's/\*int64/int64/' | sed 's/\*byte/int64/'  > process_openbsd_amd64.go
+
+/*
+Input to cgo -godefs.
+*/
+
+// +godefs map struct_pargs int64 /* pargs */
+// +godefs map struct_proc int64 /* proc */
+// +godefs map struct_user int64 /* user */
+// +godefs map struct_vnode int64 /* vnode */
+// +godefs map struct_vnode int64 /* vnode */
+// +godefs map struct_filedesc int64 /* filedesc */
+// +godefs map struct_vmspace int64 /* vmspace */
+// +godefs map struct_pcb int64 /* pcb */
+// +godefs map struct_thread int64 /* thread */
+// +godefs map struct___sigset [16]byte /* sigset */
+
+package process
+
+/*
+#include <sys/types.h>
+#include <sys/sysctl.h>
+#include <sys/user.h>
+
+enum {
+	sizeofPtr = sizeof(void*),
+};
+
+
+*/
+import "C"
+
+// Machine characteristics; for internal use.
+
+const (
+	CTLKern          = 1  // "high kernel": proc, limits
+	KernProc         = 66 // struct: process entries
+	KernProcAll      = 0
+	KernProcPID      = 1  // by process id
+	KernProcProc     = 8  // only return procs
+	KernProcPathname = 12 // path to executable
+	KernProcArgs     = 55  // get/set arguments/proctitle
+	KernProcArgv	 = 1
+	KernProcEnv	 = 3
+)
+
+const (
+	ArgMax	=	256 * 1024 // sys/syslimits.h:#define  ARG_MAX
+)
+
+
+const (
+	sizeofPtr      = C.sizeofPtr
+	sizeofShort    = C.sizeof_short
+	sizeofInt      = C.sizeof_int
+	sizeofLong     = C.sizeof_long
+	sizeofLongLong = C.sizeof_longlong
+)
+
+const (
+	sizeOfKinfoVmentry = C.sizeof_struct_kinfo_vmentry
+	sizeOfKinfoProc    = C.sizeof_struct_kinfo_proc
+)
+
+// from sys/proc.h
+const (
+	SIDL   = 1 /* Process being created by fork. */
+	SRUN   = 2 /* Currently runnable. */
+	SSLEEP = 3 /* Sleeping on an address. */
+	SSTOP  = 4 /* Process debugging or suspension. */
+	SZOMB  = 5 /* Awaiting collection by parent. */
+	SDEAD  = 6 /* Thread is almost gone */
+	SONPROC = 7 /* Thread is currently on a CPU. */
+)
+
+// Basic types
+
+type (
+	_C_short     C.short
+	_C_int       C.int
+	_C_long      C.long
+	_C_long_long C.longlong
+)
+
+// Time
+
+type Timespec C.struct_timespec
+
+type Timeval C.struct_timeval
+
+// Processes
+
+type Rusage C.struct_rusage
+
+type Rlimit C.struct_rlimit
+
+type KinfoProc C.struct_kinfo_proc
+
+type Priority C.struct_priority
+
+type KinfoVmentry C.struct_kinfo_vmentry