Add v16.7.2

vendor/github.com/power-devops/perfstat/LICENSE

@@ -0,0 +1,23 @@
+MIT License
+
+Copyright (c) 2020 Power DevOps
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+

vendor/github.com/power-devops/perfstat/c_helpers.c

@@ -0,0 +1,159 @@
+#include "c_helpers.h"
+
+GETFUNC(cpu)
+GETFUNC(disk)
+GETFUNC(diskadapter)
+GETFUNC(diskpath)
+GETFUNC(fcstat)
+GETFUNC(logicalvolume)
+GETFUNC(memory_page)
+GETFUNC(netadapter)
+GETFUNC(netbuffer)
+GETFUNC(netinterface)
+GETFUNC(pagingspace)
+GETFUNC(process)
+GETFUNC(thread)
+GETFUNC(volumegroup)
+
+double get_partition_mhz(perfstat_partition_config_t pinfo) {
+	return pinfo.processorMHz;
+}
+
+char *get_ps_hostname(perfstat_pagingspace_t *ps) {
+	return ps->u.nfs_paging.hostname;
+}
+
+char *get_ps_filename(perfstat_pagingspace_t *ps) {
+	return ps->u.nfs_paging.filename;
+}
+
+char *get_ps_vgname(perfstat_pagingspace_t *ps) {
+	return ps->u.lv_paging.vgname;
+}
+
+time_t boottime()
+{
+        register struct utmpx *utmp;
+
+	setutxent();
+        while ( (utmp = getutxent()) != NULL ) {
+                if (utmp->ut_type == BOOT_TIME) {
+                        return utmp->ut_tv.tv_sec;
+                }
+        }
+	endutxent();
+        return -1;
+}
+
+struct fsinfo *get_filesystem_stat(struct fsinfo *fs_all, int n) {
+	if (!fs_all) return NULL;
+	return &(fs_all[n]);
+}
+
+int get_mounts(struct vmount **vmountpp) {
+        int size;
+        struct vmount *vm;
+        int nmounts;
+
+        size = BUFSIZ;
+
+        while (1) {
+                if ((vm = (struct vmount *)malloc((size_t)size)) == NULL) {
+                        perror("malloc failed");
+                        exit(-1);
+                }
+                if ((nmounts = mntctl(MCTL_QUERY, size, (caddr_t)vm)) > 0) {
+                        *vmountpp = vm;
+                        return nmounts;
+                } else if (nmounts == 0) {
+                        size = *(int *)vm;
+                        free((void *)vm);
+                } else {
+                        free((void *)vm);
+                        return -1;
+                }
+        }
+}
+
+void fill_fsinfo(struct statfs statbuf, struct fsinfo *fs) {
+        fsblkcnt_t freeblks, totblks, usedblks;
+        fsblkcnt_t tinodes, ninodes, ifree;
+        uint    cfactor;
+
+        if (statbuf.f_blocks == -1) {
+                fs->totalblks = 0;
+                fs->freeblks = 0;
+                fs->totalinodes = 0;
+                fs->freeinodes = 0;
+                return;
+        }
+
+        cfactor = statbuf.f_bsize / 512;
+        fs->freeblks = statbuf.f_bavail * cfactor;
+        fs->totalblks = statbuf.f_blocks * cfactor;
+
+        fs->freeinodes = statbuf.f_ffree;
+        fs->totalinodes = statbuf.f_files;
+
+        if (fs->freeblks < 0)
+                fs->freeblks = 0;
+}
+
+int getfsinfo(char *fsname, char *devname, char *host, char *options, int flags, int fstype, struct fsinfo *fs) {
+        struct statfs statbuf;
+	int devname_size = strlen(devname);
+	int fsname_size = strlen(fsname);
+        char buf[BUFSIZ];
+        char *p;
+
+        if (fs == NULL) {
+                return 1;
+        }
+
+        for (p = strtok(options, ","); p != NULL; p = strtok(NULL, ","))
+                if (strcmp(p, "ignore") == 0)
+                        return 0;
+
+        if (*host != 0 && strcmp(host, "-") != 0) {
+                sprintf(buf, "%s:%s", host, devname);
+                devname = buf;
+        }
+        fs->devname = (char *)calloc(devname_size+1, 1);
+        fs->fsname = (char *)calloc(fsname_size+1, 1);
+        strncpy(fs->devname, devname, devname_size);
+        strncpy(fs->fsname, fsname, fsname_size);
+	fs->flags = flags;
+	fs->fstype = fstype;
+
+        if (statfs(fsname,&statbuf) < 0) {
+                return 1;
+        }
+
+        fill_fsinfo(statbuf, fs);
+        return 0;
+}
+
+struct fsinfo *get_all_fs(int *rc) {
+        struct vmount *mnt;
+        struct fsinfo *fs_all;
+        int nmounts;
+
+        *rc = -1;
+        if ((nmounts = get_mounts(&mnt)) <= 0) {
+                perror("Can't get mount table info");
+                return NULL;
+        }
+
+        fs_all = (struct fsinfo *)calloc(sizeof(struct fsinfo), nmounts);
+        while ((*rc)++, nmounts--) {
+                getfsinfo(vmt2dataptr(mnt, VMT_STUB),
+                          vmt2dataptr(mnt, VMT_OBJECT),
+                          vmt2dataptr(mnt, VMT_HOST),
+                          vmt2dataptr(mnt, VMT_ARGS),
+			  mnt->vmt_flags,
+			  mnt->vmt_gfstype,
+                          &fs_all[*rc]);
+                mnt = (struct vmount *)((char *)mnt + mnt->vmt_length);
+        }
+        return fs_all;
+}

vendor/github.com/power-devops/perfstat/c_helpers.h

@@ -0,0 +1,58 @@
+#ifndef C_HELPERS_H
+#define C_HELPERS_H
+
+#include <sys/types.h>
+#include <sys/mntctl.h>
+#include <sys/vmount.h>
+#include <sys/statfs.h>
+#include <libperfstat.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <utmpx.h>
+
+#define GETFUNC(TYPE) perfstat_##TYPE##_t *get_##TYPE##_stat(perfstat_##TYPE##_t *b, int n) { \
+        if (!b) return NULL; \
+        return &(b[n]); \
+}
+
+#define GETFUNC_EXT(TYPE) extern perfstat_##TYPE##_t *get_##TYPE##_stat(perfstat_##TYPE##_t *, int);
+
+GETFUNC_EXT(cpu)
+GETFUNC_EXT(disk)
+GETFUNC_EXT(diskadapter)
+GETFUNC_EXT(diskpath)
+GETFUNC_EXT(fcstat)
+GETFUNC_EXT(logicalvolume)
+GETFUNC_EXT(memory_page)
+GETFUNC_EXT(netadapter)
+GETFUNC_EXT(netbuffer)
+GETFUNC_EXT(netinterface)
+GETFUNC_EXT(pagingspace)
+GETFUNC_EXT(process)
+GETFUNC_EXT(thread)
+GETFUNC_EXT(volumegroup)
+
+struct fsinfo {
+        char *devname;
+        char *fsname;
+	int flags;
+	int fstype;
+        unsigned long totalblks;
+        unsigned long freeblks;
+        unsigned long totalinodes;
+        unsigned long freeinodes;
+};
+
+extern double get_partition_mhz(perfstat_partition_config_t);
+extern char *get_ps_hostname(perfstat_pagingspace_t *);
+extern char *get_ps_filename(perfstat_pagingspace_t *);
+extern char *get_ps_vgname(perfstat_pagingspace_t *);
+extern time_t boottime();
+struct fsinfo *get_filesystem_stat(struct fsinfo *, int);
+int get_mounts(struct vmount **);
+void fill_statfs(struct statfs, struct fsinfo *);
+int getfsinfo(char *, char *, char *, char *, int, int, struct fsinfo *);
+struct fsinfo *get_all_fs(int *);
+
+#endif

vendor/github.com/power-devops/perfstat/config.go

@@ -0,0 +1,18 @@
+// +build aix
+
+package perfstat
+
+/*
+#cgo LDFLAGS: -lperfstat
+
+#include <libperfstat.h>
+*/
+import "C"
+
+func EnableLVMStat() {
+	C.perfstat_config(C.PERFSTAT_ENABLE|C.PERFSTAT_LV|C.PERFSTAT_VG, nil)
+}
+
+func DisableLVMStat() {
+	C.perfstat_config(C.PERFSTAT_DISABLE|C.PERFSTAT_LV|C.PERFSTAT_VG, nil)
+}

vendor/github.com/power-devops/perfstat/cpustat.go

@@ -0,0 +1,138 @@
+// +build aix
+
+package perfstat
+
+/*
+#cgo LDFLAGS: -lperfstat
+
+#include <libperfstat.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "c_helpers.h"
+*/
+import "C"
+
+import (
+	"fmt"
+	"runtime"
+	"time"
+	"unsafe"
+)
+
+var old_cpu_total_stat *C.perfstat_cpu_total_t
+
+func init() {
+	old_cpu_total_stat = (*C.perfstat_cpu_total_t)(C.malloc(C.sizeof_perfstat_cpu_total_t))
+	C.perfstat_cpu_total(nil, old_cpu_total_stat, C.sizeof_perfstat_cpu_total_t, 1)
+}
+
+func CpuStat() ([]CPU, error) {
+	var cpustat *C.perfstat_cpu_t
+	var cpu C.perfstat_id_t
+
+	ncpu := runtime.NumCPU()
+
+	cpustat_len := C.sizeof_perfstat_cpu_t * C.ulong(ncpu)
+	cpustat = (*C.perfstat_cpu_t)(C.malloc(cpustat_len))
+	defer C.free(unsafe.Pointer(cpustat))
+	C.strcpy(&cpu.name[0], C.CString(C.FIRST_CPU))
+	r := C.perfstat_cpu(&cpu, cpustat, C.sizeof_perfstat_cpu_t, C.int(ncpu))
+	if r <= 0 {
+		return nil, fmt.Errorf("error perfstat_cpu()")
+	}
+	c := make([]CPU, r)
+	for i := 0; i < int(r); i++ {
+		n := C.get_cpu_stat(cpustat, C.int(i))
+		if n != nil {
+			c[i] = perfstatcpu2cpu(n)
+		}
+	}
+	return c, nil
+}
+
+func CpuTotalStat() (*CPUTotal, error) {
+	var cpustat *C.perfstat_cpu_total_t
+
+	cpustat = (*C.perfstat_cpu_total_t)(C.malloc(C.sizeof_perfstat_cpu_total_t))
+	defer C.free(unsafe.Pointer(cpustat))
+	r := C.perfstat_cpu_total(nil, cpustat, C.sizeof_perfstat_cpu_total_t, 1)
+	if r <= 0 {
+		return nil, fmt.Errorf("error perfstat_cpu_total()")
+	}
+	c := perfstatcputotal2cputotal(cpustat)
+	return &c, nil
+}
+
+func CpuUtilStat(intvl time.Duration) (*CPUUtil, error) {
+	var cpuutil *C.perfstat_cpu_util_t
+	var newt *C.perfstat_cpu_total_t
+	var oldt *C.perfstat_cpu_total_t
+	var data C.perfstat_rawdata_t
+
+	oldt = (*C.perfstat_cpu_total_t)(C.malloc(C.sizeof_perfstat_cpu_total_t))
+	newt = (*C.perfstat_cpu_total_t)(C.malloc(C.sizeof_perfstat_cpu_total_t))
+	cpuutil = (*C.perfstat_cpu_util_t)(C.malloc(C.sizeof_perfstat_cpu_util_t))
+	defer C.free(unsafe.Pointer(oldt))
+	defer C.free(unsafe.Pointer(newt))
+	defer C.free(unsafe.Pointer(cpuutil))
+
+	r := C.perfstat_cpu_total(nil, oldt, C.sizeof_perfstat_cpu_total_t, 1)
+	if r <= 0 {
+		return nil, fmt.Errorf("error perfstat_cpu_total()")
+	}
+
+	time.Sleep(intvl)
+
+	r = C.perfstat_cpu_total(nil, newt, C.sizeof_perfstat_cpu_total_t, 1)
+	if r <= 0 {
+		return nil, fmt.Errorf("error perfstat_cpu_total()")
+	}
+
+	data._type = C.UTIL_CPU_TOTAL
+	data.curstat = unsafe.Pointer(newt)
+	data.prevstat = unsafe.Pointer(oldt)
+	data.sizeof_data = C.sizeof_perfstat_cpu_total_t
+	data.cur_elems = 1
+	data.prev_elems = 1
+
+	r = C.perfstat_cpu_util(&data, cpuutil, C.sizeof_perfstat_cpu_util_t, 1)
+	if r <= 0 {
+		return nil, fmt.Errorf("error perfstat_cpu_util()")
+	}
+	u := perfstatcpuutil2cpuutil(cpuutil)
+	return &u, nil
+}
+
+func CpuUtilTotalStat() (*CPUUtil, error) {
+	var cpuutil *C.perfstat_cpu_util_t
+	var new_cpu_total_stat *C.perfstat_cpu_total_t
+	var data C.perfstat_rawdata_t
+
+	new_cpu_total_stat = (*C.perfstat_cpu_total_t)(C.malloc(C.sizeof_perfstat_cpu_total_t))
+	cpuutil = (*C.perfstat_cpu_util_t)(C.malloc(C.sizeof_perfstat_cpu_util_t))
+	defer C.free(unsafe.Pointer(cpuutil))
+
+	r := C.perfstat_cpu_total(nil, new_cpu_total_stat, C.sizeof_perfstat_cpu_total_t, 1)
+	if r <= 0 {
+		C.free(unsafe.Pointer(new_cpu_total_stat))
+		return nil, fmt.Errorf("error perfstat_cpu_total()")
+	}
+
+	data._type = C.UTIL_CPU_TOTAL
+	data.curstat = unsafe.Pointer(new_cpu_total_stat)
+	data.prevstat = unsafe.Pointer(old_cpu_total_stat)
+	data.sizeof_data = C.sizeof_perfstat_cpu_total_t
+	data.cur_elems = 1
+	data.prev_elems = 1
+
+	r = C.perfstat_cpu_util(&data, cpuutil, C.sizeof_perfstat_cpu_util_t, 1)
+	C.free(unsafe.Pointer(old_cpu_total_stat))
+	old_cpu_total_stat = new_cpu_total_stat
+	if r <= 0 {
+		return nil, fmt.Errorf("error perfstat_cpu_util()")
+	}
+	u := perfstatcpuutil2cpuutil(cpuutil)
+	return &u, nil
+}
+

vendor/github.com/power-devops/perfstat/diskstat.go

@@ -0,0 +1,137 @@
+// +build aix
+
+package perfstat
+
+/*
+#cgo LDFLAGS: -lperfstat
+
+#include <libperfstat.h>
+#include <string.h>
+#include <stdlib.h>
+#include "c_helpers.h"
+*/
+import "C"
+
+import (
+	"fmt"
+	"unsafe"
+)
+
+func DiskTotalStat() (*DiskTotal, error) {
+	var disk C.perfstat_disk_total_t
+
+	rc := C.perfstat_disk_total(nil, &disk, C.sizeof_perfstat_disk_total_t, 1)
+	if rc != 1 {
+		return nil, fmt.Errorf("perfstat_disk_total() error")
+	}
+	d := perfstatdisktotal2disktotal(disk)
+	return &d, nil
+}
+
+func DiskAdapterStat() ([]DiskAdapter, error) {
+	var adapter *C.perfstat_diskadapter_t
+	var adptname C.perfstat_id_t
+
+	numadpt := C.perfstat_diskadapter(nil, nil, C.sizeof_perfstat_diskadapter_t, 0)
+	if numadpt <= 0 {
+		return nil, fmt.Errorf("perfstat_diskadapter() error")
+	}
+
+	adapter_len := C.sizeof_perfstat_diskadapter_t * C.ulong(numadpt)
+	adapter = (*C.perfstat_diskadapter_t)(C.malloc(adapter_len))
+	defer C.free(unsafe.Pointer(adapter))
+	C.strcpy(&adptname.name[0], C.CString(C.FIRST_DISKADAPTER))
+	r := C.perfstat_diskadapter(&adptname, adapter, C.sizeof_perfstat_diskadapter_t, numadpt)
+	if r < 0 {
+		return nil, fmt.Errorf("perfstat_diskadapter() error")
+	}
+	da := make([]DiskAdapter, r)
+	for i := 0; i < int(r); i++ {
+		d := C.get_diskadapter_stat(adapter, C.int(i))
+		if d != nil {
+			da[i] = perfstatdiskadapter2diskadapter(d)
+		}
+	}
+	return da, nil
+}
+
+func DiskStat() ([]Disk, error) {
+	var disk *C.perfstat_disk_t
+	var diskname C.perfstat_id_t
+
+	numdisk := C.perfstat_disk(nil, nil, C.sizeof_perfstat_disk_t, 0)
+	if numdisk <= 0 {
+		return nil, fmt.Errorf("perfstat_disk() error")
+	}
+
+	disk_len := C.sizeof_perfstat_disk_t * C.ulong(numdisk)
+	disk = (*C.perfstat_disk_t)(C.malloc(disk_len))
+	defer C.free(unsafe.Pointer(disk))
+	C.strcpy(&diskname.name[0], C.CString(C.FIRST_DISK))
+	r := C.perfstat_disk(&diskname, disk, C.sizeof_perfstat_disk_t, numdisk)
+	if r < 0 {
+		return nil, fmt.Errorf("perfstat_disk() error")
+	}
+	d := make([]Disk, r)
+	for i := 0; i < int(r); i++ {
+		ds := C.get_disk_stat(disk, C.int(i))
+		if ds != nil {
+			d[i] = perfstatdisk2disk(ds)
+		}
+	}
+	return d, nil
+}
+
+func DiskPathStat() ([]DiskPath, error) {
+	var diskpath *C.perfstat_diskpath_t
+	var pathname C.perfstat_id_t
+
+	numpaths := C.perfstat_diskpath(nil, nil, C.sizeof_perfstat_diskpath_t, 0)
+	if numpaths <= 0 {
+		return nil, fmt.Errorf("perfstat_diskpath() error")
+	}
+
+	path_len := C.sizeof_perfstat_diskpath_t * C.ulong(numpaths)
+	diskpath = (*C.perfstat_diskpath_t)(C.malloc(path_len))
+	defer C.free(unsafe.Pointer(diskpath))
+	C.strcpy(&pathname.name[0], C.CString(C.FIRST_DISKPATH))
+	r := C.perfstat_diskpath(&pathname, diskpath, C.sizeof_perfstat_diskpath_t, numpaths)
+	if r < 0 {
+		return nil, fmt.Errorf("perfstat_diskpath() error")
+	}
+	d := make([]DiskPath, r)
+	for i := 0; i < int(r); i++ {
+		p := C.get_diskpath_stat(diskpath, C.int(i))
+		if p != nil {
+			d[i] = perfstatdiskpath2diskpath(p)
+		}
+	}
+	return d, nil
+}
+
+func FCAdapterStat() ([]FCAdapter, error) {
+	var fcstat *C.perfstat_fcstat_t
+	var fcname C.perfstat_id_t
+
+	numadpt := C.perfstat_fcstat(nil, nil, C.sizeof_perfstat_fcstat_t, 0)
+	if numadpt <= 0 {
+		return nil, fmt.Errorf("perfstat_fcstat() error")
+	}
+
+	fcstat_len := C.sizeof_perfstat_fcstat_t * C.ulong(numadpt)
+	fcstat = (*C.perfstat_fcstat_t)(C.malloc(fcstat_len))
+	defer C.free(unsafe.Pointer(fcstat))
+	C.strcpy(&fcname.name[0], C.CString(C.FIRST_NETINTERFACE))
+	r := C.perfstat_fcstat(&fcname, fcstat, C.sizeof_perfstat_fcstat_t, numadpt)
+	if r < 0 {
+		return nil, fmt.Errorf("perfstat_fcstat() error")
+	}
+	fca := make([]FCAdapter, r)
+	for i := 0; i < int(r); i++ {
+		f := C.get_fcstat_stat(fcstat, C.int(i))
+		if f != nil {
+			fca[i] = perfstatfcstat2fcadapter(f)
+		}
+	}
+	return fca, nil
+}

vendor/github.com/power-devops/perfstat/doc.go

@@ -0,0 +1,315 @@
+// +build !aix
+
+// Copyright 2020 Power-Devops.com. All rights reserved.
+// Use of this source code is governed by the license
+// that can be found in the LICENSE file.
+/*
+Package perfstat is Go interface to IBM AIX libperfstat.
+To use it you need AIX with installed bos.perf.libperfstat. You can check, if is installed using the following command:
+
+	$ lslpp -L bos.perf.perfstat
+
+The package is written using Go 1.14.7 and AIX 7.2 TL5. It should work with earlier TLs of AIX 7.2, but I
+can't guarantee that perfstat structures in the TLs have all the same fields as the structures in AIX 7.2 TL5.
+
+For documentation of perfstat on AIX and using it in programs refer to the official IBM documentation:
+https://www.ibm.com/support/knowledgecenter/ssw_aix_72/performancetools/idprftools_perfstat.html
+*/
+package perfstat
+
+import (
+	"fmt"
+	"time"
+)
+
+// EnableLVMStat() switches on LVM (logical volumes and volume groups) performance statistics.
+// With this enabled you can use fields KBReads, KBWrites, and IOCnt
+// in LogicalVolume and VolumeGroup data types.
+func EnableLVMStat() {}
+
+// DisableLVMStat() switchess of LVM (logical volumes and volume groups) performance statistics.
+// This is the default state. In this case LogicalVolume and VolumeGroup data types are
+// populated with informations about LVM structures, but performance statistics fields
+// (KBReads, KBWrites, IOCnt) are empty.
+func DisableLVMStat() {}
+
+// CpuStat() returns array of CPU structures with information about
+// logical CPUs on the system.
+// IBM documentation:
+//   * https://www.ibm.com/support/knowledgecenter/ssw_aix_72/performancetools/idprftools_perfstat_int_cpu.html
+//   * https://www.ibm.com/support/knowledgecenter/en/ssw_aix_72/p_bostechref/perfstat_cpu.html
+func CpuStat() ([]CPU, error) {
+	return nil, fmt.Errorf("not implemented")
+}
+
+// CpuTotalStat() returns general information about CPUs on the system.
+// IBM documentation:
+//   * https://www.ibm.com/support/knowledgecenter/ssw_aix_72/performancetools/idprftools_perfstat_glob_cpu.html
+//   * https://www.ibm.com/support/knowledgecenter/en/ssw_aix_72/p_bostechref/perfstat_cputot.html
+func CpuTotalStat() (*CPUTotal, error) {
+	return nil, fmt.Errorf("not implemented")
+}
+
+// CpuUtilStat() calculates CPU utilization.
+// IBM documentation:
+//   * https://www.ibm.com/support/knowledgecenter/ssw_aix_72/performancetools/idprftools_perfstat_cpu_util.html
+//   * https://www.ibm.com/support/knowledgecenter/en/ssw_aix_72/p_bostechref/perfstat_cpu_util.html
+func CpuUtilStat(intvl time.Duration) (*CPUUtil, error) {
+	return nil, fmt.Errorf("not implemented")
+}
+
+func DiskTotalStat() (*DiskTotal, error) {
+	return nil, fmt.Errorf("not implemented")
+}
+
+func DiskAdapterStat() ([]DiskAdapter, error) {
+	return nil, fmt.Errorf("not implemented")
+}
+
+func DiskStat() ([]Disk, error) {
+	return nil, fmt.Errorf("not implemented")
+}
+
+func DiskPathStat() ([]DiskPath, error) {
+	return nil, fmt.Errorf("not implemented")
+}
+
+func FCAdapterStat() ([]FCAdapter, error) {
+	return nil, fmt.Errorf("not implemented")
+}
+
+func PartitionStat() (*PartitionConfig, error) {
+	return nil, fmt.Errorf("not implemented")
+}
+
+func LogicalVolumeStat() ([]LogicalVolume, error) {
+	return nil, fmt.Errorf("not implemented")
+}
+
+func VolumeGroupStat() ([]VolumeGroup, error) {
+	return nil, fmt.Errorf("not implemented")
+}
+
+func MemoryTotalStat() (*MemoryTotal, error) {
+	return nil, fmt.Errorf("not implemented")
+}
+
+func MemoryPageStat() ([]MemoryPage, error) {
+	return nil, fmt.Errorf("not implemented")
+}
+
+func PagingSpaceStat() ([]PagingSpace, error) {
+	return nil, fmt.Errorf("not implemented")
+}
+
+func NetIfaceTotalStat() (*NetIfaceTotal, error) {
+	return nil, fmt.Errorf("not implemented")
+}
+
+func NetBufferStat() ([]NetBuffer, error) {
+	return nil, fmt.Errorf("not implemented")
+}
+
+func NetIfaceStat() ([]NetIface, error) {
+	return nil, fmt.Errorf("not implemented")
+}
+
+func NetAdapterStat() ([]NetAdapter, error) {
+	return nil, fmt.Errorf("not implemented")
+}
+
+func ProcessStat() ([]Process, error) {
+	return nil, fmt.Errorf("not implemented")
+}
+
+func ThreadStat() ([]Thread, error) {
+	return nil, fmt.Errorf("not implemented")
+}
+
+func Sysconf(name int32) (int64, error) {
+	return 0, fmt.Errorf("not implemented")
+}
+
+func GetCPUImplementation() string {
+	return ""
+}
+
+func POWER9OrNewer() bool {
+	return false
+}
+
+func POWER9() bool {
+	return false
+}
+
+func POWER8OrNewer() bool {
+	return false
+}
+
+func POWER8() bool {
+	return false
+}
+
+func POWER7OrNewer() bool {
+	return false
+}
+
+func POWER7() bool {
+	return false
+}
+
+func HasTransactionalMemory() bool {
+	return false
+}
+
+func Is64Bit() bool {
+	return false
+}
+
+func IsSMP() bool {
+	return false
+}
+
+func HasVMX() bool {
+	return false
+}
+
+func HasVSX() bool {
+	return false
+}
+
+func HasDFP() bool {
+	return false
+}
+
+func HasNxGzip() bool {
+	return false
+}
+
+func PksCapable() bool {
+	return false
+}
+
+func PksEnabled() bool {
+	return false
+}
+
+func CPUMode() string {
+	return ""
+}
+
+func KernelBits() int {
+	return 0
+}
+
+func IsLPAR() bool {
+	return false
+}
+
+func CpuAddCapable() bool {
+	return false
+}
+
+func CpuRemoveCapable() bool {
+	return false
+}
+
+func MemoryAddCapable() bool {
+	return false
+}
+
+func MemoryRemoveCapable() bool {
+	return false
+}
+
+func DLparCapable() bool {
+	return false
+}
+
+func IsNUMA() bool {
+	return false
+}
+
+func KernelKeys() bool {
+	return false
+}
+
+func RecoveryMode() bool {
+	return false
+}
+
+func EnhancedAffinity() bool {
+	return false
+}
+
+func VTpmEnabled() bool {
+	return false
+}
+
+func IsVIOS() bool {
+	return false
+}
+
+func MLSEnabled() bool {
+	return false
+}
+
+func SPLparCapable() bool {
+	return false
+}
+
+func SPLparEnabled() bool {
+	return false
+}
+
+func DedicatedLpar() bool {
+	return false
+}
+
+func SPLparCapped() bool {
+	return false
+}
+
+func SPLparDonating() bool {
+	return false
+}
+
+func SmtCapable() bool {
+	return false
+}
+
+func SmtEnabled() bool {
+	return false
+}
+
+func VrmCapable() bool {
+	return false
+}
+
+func VrmEnabled() bool {
+	return false
+}
+
+func AmeEnabled() bool {
+	return false
+}
+
+func EcoCapable() bool {
+	return false
+}
+
+func EcoEnabled() bool {
+	return false
+}
+
+func BootTime() (uint64, error) {
+	return 0, fmt.Errorf("Not implemented")
+}
+
+func UptimeSeconds() (uint64, error) {
+	return 0, fmt.Errorf("Not implemented")
+}
+
+func FileSystemStat() ([]FileSystem, error) {
+	return nil, fmt.Errorf("Not implemented")
+}

vendor/github.com/power-devops/perfstat/fsstat.go

@@ -0,0 +1,31 @@
+// +build aix
+
+package perfstat
+
+/*
+#include "c_helpers.h"
+*/
+import "C"
+
+import (
+	"fmt"
+)
+
+func FileSystemStat() ([]FileSystem, error) {
+	var fsinfo *C.struct_fsinfo
+	var nmounts C.int
+
+	fsinfo = C.get_all_fs(&nmounts)
+	if nmounts <= 0 {
+		return nil, fmt.Errorf("No mounts found")
+	}
+
+	fs := make([]FileSystem, nmounts)
+	for i := 0; i < int(nmounts); i++ {
+		f := C.get_filesystem_stat(fsinfo, C.int(i))
+		if f != nil {
+			fs[i] = fsinfo2filesystem(f)
+		}
+	}
+	return fs, nil
+}

vendor/github.com/power-devops/perfstat/go.mod

@@ -0,0 +1,5 @@
+module github.com/power-devops/perfstat
+
+go 1.14
+
+require golang.org/x/sys v0.0.0-20201204225414-ed752295db88

vendor/github.com/power-devops/perfstat/go.sum

@@ -0,0 +1,2 @@
+golang.org/x/sys v0.0.0-20201204225414-ed752295db88 h1:KmZPnMocC93w341XZp26yTJg8Za7lhb2KhkYmixoeso=
+golang.org/x/sys v0.0.0-20201204225414-ed752295db88/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=

vendor/github.com/power-devops/perfstat/helpers.go

@@ -0,0 +1,764 @@
+// +build aix
+
+package perfstat
+
+/*
+#cgo LDFLAGS: -lperfstat
+
+#include <libperfstat.h>
+#include <sys/proc.h>
+
+#include "c_helpers.h"
+*/
+import "C"
+
+func perfstatcpu2cpu(n *C.perfstat_cpu_t) CPU {
+	var c CPU
+	c.Name = C.GoString(&n.name[0])
+	c.User = int64(n.user)
+	c.Sys = int64(n.sys)
+	c.Idle = int64(n.idle)
+	c.Wait = int64(n.wait)
+	c.PSwitch = int64(n.pswitch)
+	c.Syscall = int64(n.syscall)
+	c.Sysread = int64(n.sysread)
+	c.Syswrite = int64(n.syswrite)
+	c.Sysfork = int64(n.sysfork)
+	c.Sysexec = int64(n.sysexec)
+	c.Readch = int64(n.readch)
+	c.Writech = int64(n.writech)
+	c.Bread = int64(n.bread)
+	c.Bwrite = int64(n.bwrite)
+	c.Lread = int64(n.lread)
+	c.Lwrite = int64(n.lwrite)
+	c.Phread = int64(n.phread)
+	c.Phwrite = int64(n.phwrite)
+	c.Iget = int64(n.iget)
+	c.Namei = int64(n.namei)
+	c.Dirblk = int64(n.dirblk)
+	c.Msg = int64(n.msg)
+	c.Sema = int64(n.sema)
+	c.MinFaults = int64(n.minfaults)
+	c.MajFaults = int64(n.majfaults)
+	c.PUser = int64(n.puser)
+	c.PSys = int64(n.psys)
+	c.PIdle = int64(n.pidle)
+	c.PWait = int64(n.pwait)
+	c.RedispSD0 = int64(n.redisp_sd0)
+	c.RedispSD1 = int64(n.redisp_sd1)
+	c.RedispSD2 = int64(n.redisp_sd2)
+	c.RedispSD3 = int64(n.redisp_sd3)
+	c.RedispSD4 = int64(n.redisp_sd4)
+	c.RedispSD5 = int64(n.redisp_sd5)
+	c.MigrationPush = int64(n.migration_push)
+	c.MigrationS3grq = int64(n.migration_S3grq)
+	c.MigrationS3pul = int64(n.migration_S3pul)
+	c.InvolCSwitch = int64(n.invol_cswitch)
+	c.VolCSwitch = int64(n.vol_cswitch)
+	c.RunQueue = int64(n.runque)
+	c.Bound = int64(n.bound)
+	c.DecrIntrs = int64(n.decrintrs)
+	c.MpcRIntrs = int64(n.mpcrintrs)
+	c.MpcSIntrs = int64(n.mpcsintrs)
+	c.SoftIntrs = int64(n.softintrs)
+	c.DevIntrs = int64(n.devintrs)
+	c.PhantIntrs = int64(n.phantintrs)
+	c.IdleDonatedPurr = int64(n.idle_donated_purr)
+	c.IdleDonatedSpurr = int64(n.idle_donated_spurr)
+	c.BusyDonatedPurr = int64(n.busy_donated_purr)
+	c.BusyDonatedSpurr = int64(n.busy_donated_spurr)
+	c.IdleStolenPurr = int64(n.idle_stolen_purr)
+	c.IdleStolenSpurr = int64(n.idle_stolen_spurr)
+	c.BusyStolenPurr = int64(n.busy_stolen_purr)
+	c.BusyStolenSpurr = int64(n.busy_stolen_spurr)
+	c.Hpi = int64(n.hpi)
+	c.Hpit = int64(n.hpit)
+	c.PUserSpurr = int64(n.puser_spurr)
+	c.PSysSpurr = int64(n.psys_spurr)
+	c.PIdleSpurr = int64(n.pidle_spurr)
+	c.PWaitSpurr = int64(n.pwait_spurr)
+	c.SpurrFlag = int32(n.spurrflag)
+	c.LocalDispatch = int64(n.localdispatch)
+	c.NearDispatch = int64(n.neardispatch)
+	c.FarDispatch = int64(n.fardispatch)
+	c.CSwitches = int64(n.cswitches)
+	c.Version = int64(n.version)
+	c.TbLast = int64(n.tb_last)
+	c.State = int(n.state)
+	c.VtbLast = int64(n.vtb_last)
+	c.ICountLast = int64(n.icount_last)
+	return c
+}
+
+func perfstatcputotal2cputotal(n *C.perfstat_cpu_total_t) CPUTotal {
+	var c CPUTotal
+	c.NCpus = int(n.ncpus)
+	c.NCpusCfg = int(n.ncpus_cfg)
+	c.Description = C.GoString(&n.description[0])
+	c.ProcessorHz = int64(n.processorHZ)
+	c.User = int64(n.user)
+	c.Sys = int64(n.sys)
+	c.Idle = int64(n.idle)
+	c.Wait = int64(n.wait)
+	c.PSwitch = int64(n.pswitch)
+	c.Syscall = int64(n.syscall)
+	c.Sysread = int64(n.sysread)
+	c.Syswrite = int64(n.syswrite)
+	c.Sysfork = int64(n.sysfork)
+	c.Sysexec = int64(n.sysexec)
+	c.Readch = int64(n.readch)
+	c.Writech = int64(n.writech)
+	c.DevIntrs = int64(n.devintrs)
+	c.SoftIntrs = int64(n.softintrs)
+	c.Lbolt = int64(n.lbolt)
+	c.LoadAvg1 = (float32(n.loadavg[0]) / (1 << C.SBITS))
+	c.LoadAvg5 = (float32(n.loadavg[1]) / (1 << C.SBITS))
+	c.LoadAvg15 = (float32(n.loadavg[2]) / (1 << C.SBITS))
+	c.RunQueue = int64(n.runque)
+	c.SwpQueue = int64(n.swpque)
+	c.Bread = int64(n.bread)
+	c.Bwrite = int64(n.bwrite)
+	c.Lread = int64(n.lread)
+	c.Lwrite = int64(n.lwrite)
+	c.Phread = int64(n.phread)
+	c.Phwrite = int64(n.phwrite)
+	c.RunOcc = int64(n.runocc)
+	c.SwpOcc = int64(n.swpocc)
+	c.Iget = int64(n.iget)
+	c.Namei = int64(n.namei)
+	c.Dirblk = int64(n.dirblk)
+	c.Msg = int64(n.msg)
+	c.Sema = int64(n.sema)
+	c.RcvInt = int64(n.rcvint)
+	c.XmtInt = int64(n.xmtint)
+	c.MdmInt = int64(n.mdmint)
+	c.TtyRawInch = int64(n.tty_rawinch)
+	c.TtyCanInch = int64(n.tty_caninch)
+	c.TtyRawOutch = int64(n.tty_rawoutch)
+	c.Ksched = int64(n.ksched)
+	c.Koverf = int64(n.koverf)
+	c.Kexit = int64(n.kexit)
+	c.Rbread = int64(n.rbread)
+	c.Rcread = int64(n.rcread)
+	c.Rbwrt = int64(n.rbwrt)
+	c.Rcwrt = int64(n.rcwrt)
+	c.Traps = int64(n.traps)
+	c.NCpusHigh = int64(n.ncpus_high)
+	c.PUser = int64(n.puser)
+	c.PSys = int64(n.psys)
+	c.PIdle = int64(n.pidle)
+	c.PWait = int64(n.pwait)
+	c.DecrIntrs = int64(n.decrintrs)
+	c.MpcRIntrs = int64(n.mpcrintrs)
+	c.MpcSIntrs = int64(n.mpcsintrs)
+	c.PhantIntrs = int64(n.phantintrs)
+	c.IdleDonatedPurr = int64(n.idle_donated_purr)
+	c.IdleDonatedSpurr = int64(n.idle_donated_spurr)
+	c.BusyDonatedPurr = int64(n.busy_donated_purr)
+	c.BusyDonatedSpurr = int64(n.busy_donated_spurr)
+	c.IdleStolenPurr = int64(n.idle_stolen_purr)
+	c.IdleStolenSpurr = int64(n.idle_stolen_spurr)
+	c.BusyStolenPurr = int64(n.busy_stolen_purr)
+	c.BusyStolenSpurr = int64(n.busy_stolen_spurr)
+	c.IOWait = int32(n.iowait)
+	c.PhysIO = int32(n.physio)
+	c.TWait = int64(n.twait)
+	c.Hpi = int64(n.hpi)
+	c.Hpit = int64(n.hpit)
+	c.PUserSpurr = int64(n.puser_spurr)
+	c.PSysSpurr = int64(n.psys_spurr)
+	c.PIdleSpurr = int64(n.pidle_spurr)
+	c.PWaitSpurr = int64(n.pwait_spurr)
+	c.SpurrFlag = int(n.spurrflag)
+	c.Version = int64(n.version)
+	c.TbLast = int64(n.tb_last)
+	c.PurrCoalescing = int64(n.purr_coalescing)
+	c.SpurrCoalescing = int64(n.spurr_coalescing)
+	return c
+}
+
+func perfstatcpuutil2cpuutil(n *C.perfstat_cpu_util_t) CPUUtil {
+	var c CPUUtil
+
+	c.Version = int64(n.version)
+	c.CpuID = C.GoString(&n.cpu_id[0])
+	c.Entitlement = float32(n.entitlement)
+	c.UserPct = float32(n.user_pct)
+	c.KernPct = float32(n.kern_pct)
+	c.IdlePct = float32(n.idle_pct)
+	c.WaitPct = float32(n.wait_pct)
+	c.PhysicalBusy = float32(n.physical_busy)
+	c.PhysicalConsumed = float32(n.physical_consumed)
+	c.FreqPct = float32(n.freq_pct)
+	c.EntitlementPct = float32(n.entitlement_pct)
+	c.BusyPct = float32(n.busy_pct)
+	c.IdleDonatedPct = float32(n.idle_donated_pct)
+	c.BusyDonatedPct = float32(n.busy_donated_pct)
+	c.IdleStolenPct = float32(n.idle_stolen_pct)
+	c.BusyStolenPct = float32(n.busy_stolen_pct)
+	c.LUserPct = float32(n.l_user_pct)
+	c.LKernPct = float32(n.l_kern_pct)
+	c.LIdlePct = float32(n.l_idle_pct)
+	c.LWaitPct = float32(n.l_wait_pct)
+	c.DeltaTime = int64(n.delta_time)
+
+	return c
+}
+
+func perfstatdisktotal2disktotal(n C.perfstat_disk_total_t) DiskTotal {
+	var d DiskTotal
+
+	d.Number = int32(n.number)
+	d.Size = int64(n.size)
+	d.Free = int64(n.free)
+	d.XRate = int64(n.xrate)
+	d.Xfers = int64(n.xfers)
+	d.Wblks = int64(n.wblks)
+	d.Rblks = int64(n.rblks)
+	d.Time = int64(n.time)
+	d.Version = int64(n.version)
+	d.Rserv = int64(n.rserv)
+	d.MinRserv = int64(n.min_rserv)
+	d.MaxRserv = int64(n.max_rserv)
+	d.RTimeOut = int64(n.rtimeout)
+	d.RFailed = int64(n.rfailed)
+	d.Wserv = int64(n.wserv)
+	d.MinWserv = int64(n.min_wserv)
+	d.MaxWserv = int64(n.max_wserv)
+	d.WTimeOut = int64(n.wtimeout)
+	d.WFailed = int64(n.wfailed)
+	d.WqDepth = int64(n.wq_depth)
+	d.WqTime = int64(n.wq_time)
+	d.WqMinTime = int64(n.wq_min_time)
+	d.WqMaxTime = int64(n.wq_max_time)
+
+	return d
+}
+
+func perfstatdiskadapter2diskadapter(n *C.perfstat_diskadapter_t) DiskAdapter {
+	var d DiskAdapter
+
+	d.Name = C.GoString(&n.name[0])
+	d.Description = C.GoString(&n.description[0])
+	d.Number = int32(n.number)
+	d.Size = int64(n.size)
+	d.Free = int64(n.free)
+	d.XRate = int64(n.xrate)
+	d.Xfers = int64(n.xfers)
+	d.Rblks = int64(n.rblks)
+	d.Wblks = int64(n.wblks)
+	d.Time = int64(n.time)
+	d.Version = int64(n.version)
+	d.AdapterType = int64(n.adapter_type)
+	d.DkBSize = int64(n.dk_bsize)
+	d.DkRserv = int64(n.dk_rserv)
+	d.DkWserv = int64(n.dk_wserv)
+	d.MinRserv = int64(n.min_rserv)
+	d.MaxRserv = int64(n.max_rserv)
+	d.MinWserv = int64(n.min_wserv)
+	d.MaxWserv = int64(n.max_wserv)
+	d.WqDepth = int64(n.wq_depth)
+	d.WqSampled = int64(n.wq_sampled)
+	d.WqTime = int64(n.wq_time)
+	d.WqMinTime = int64(n.wq_min_time)
+	d.WqMaxTime = int64(n.wq_max_time)
+	d.QFull = int64(n.q_full)
+	d.QSampled = int64(n.q_sampled)
+
+	return d
+}
+
+func perfstatpartitionconfig2partitionconfig(n C.perfstat_partition_config_t) PartitionConfig {
+	var p PartitionConfig
+	p.Version = int64(n.version)
+	p.Name = C.GoString(&n.partitionname[0])
+	p.Node = C.GoString(&n.nodename[0])
+	p.Conf.SmtCapable = (n.conf[0] & (1 << 7)) > 0
+	p.Conf.SmtEnabled = (n.conf[0] & (1 << 6)) > 0
+	p.Conf.LparCapable = (n.conf[0] & (1 << 5)) > 0
+	p.Conf.LparEnabled = (n.conf[0] & (1 << 4)) > 0
+	p.Conf.SharedCapable = (n.conf[0] & (1 << 3)) > 0
+	p.Conf.SharedEnabled = (n.conf[0] & (1 << 2)) > 0
+	p.Conf.DLparCapable = (n.conf[0] & (1 << 1)) > 0
+	p.Conf.Capped = (n.conf[0] & (1 << 0)) > 0
+	p.Conf.Kernel64bit = (n.conf[1] & (1 << 7)) > 0
+	p.Conf.PoolUtilAuthority = (n.conf[1] & (1 << 6)) > 0
+	p.Conf.DonateCapable = (n.conf[1] & (1 << 5)) > 0
+	p.Conf.DonateEnabled = (n.conf[1] & (1 << 4)) > 0
+	p.Conf.AmsCapable = (n.conf[1] & (1 << 3)) > 0
+	p.Conf.AmsEnabled = (n.conf[1] & (1 << 2)) > 0
+	p.Conf.PowerSave = (n.conf[1] & (1 << 1)) > 0
+	p.Conf.AmeEnabled = (n.conf[1] & (1 << 0)) > 0
+	p.Conf.SharedExtended = (n.conf[2] & (1 << 7)) > 0
+	p.Number = int32(n.partitionnum)
+	p.GroupID = int32(n.groupid)
+	p.ProcessorFamily = C.GoString(&n.processorFamily[0])
+	p.ProcessorModel = C.GoString(&n.processorModel[0])
+	p.MachineID = C.GoString(&n.machineID[0])
+	p.ProcessorMhz = float64(C.get_partition_mhz(n))
+	p.NumProcessors.Online = int64(n.numProcessors.online)
+	p.NumProcessors.Max = int64(n.numProcessors.max)
+	p.NumProcessors.Min = int64(n.numProcessors.min)
+	p.NumProcessors.Desired = int64(n.numProcessors.desired)
+	p.OSName = C.GoString(&n.OSName[0])
+	p.OSVersion = C.GoString(&n.OSVersion[0])
+	p.OSBuild = C.GoString(&n.OSBuild[0])
+	p.LCpus = int32(n.lcpus)
+	p.SmtThreads = int32(n.smtthreads)
+	p.Drives = int32(n.drives)
+	p.NetworkAdapters = int32(n.nw_adapters)
+	p.CpuCap.Online = int64(n.cpucap.online)
+	p.CpuCap.Max = int64(n.cpucap.max)
+	p.CpuCap.Min = int64(n.cpucap.min)
+	p.CpuCap.Desired = int64(n.cpucap.desired)
+	p.Weightage = int32(n.cpucap_weightage)
+	p.EntCapacity = int32(n.entitled_proc_capacity)
+	p.VCpus.Online = int64(n.vcpus.online)
+	p.VCpus.Max = int64(n.vcpus.max)
+	p.VCpus.Min = int64(n.vcpus.min)
+	p.VCpus.Desired = int64(n.vcpus.desired)
+	p.PoolID = int32(n.processor_poolid)
+	p.ActiveCpusInPool = int32(n.activecpusinpool)
+	p.PoolWeightage = int32(n.cpupool_weightage)
+	p.SharedPCpu = int32(n.sharedpcpu)
+	p.MaxPoolCap = int32(n.maxpoolcap)
+	p.EntPoolCap = int32(n.entpoolcap)
+	p.Mem.Online = int64(n.mem.online)
+	p.Mem.Max = int64(n.mem.max)
+	p.Mem.Min = int64(n.mem.min)
+	p.Mem.Desired = int64(n.mem.desired)
+	p.MemWeightage = int32(n.mem_weightage)
+	p.TotalIOMemoryEntitlement = int64(n.totiomement)
+	p.MemPoolID = int32(n.mempoolid)
+	p.HyperPgSize = int64(n.hyperpgsize)
+	p.ExpMem.Online = int64(n.exp_mem.online)
+	p.ExpMem.Max = int64(n.exp_mem.max)
+	p.ExpMem.Min = int64(n.exp_mem.min)
+	p.ExpMem.Desired = int64(n.exp_mem.desired)
+	p.TargetMemExpFactor = int64(n.targetmemexpfactor)
+	p.TargetMemExpSize = int64(n.targetmemexpsize)
+	p.SubProcessorMode = int32(n.subprocessor_mode)
+	return p
+}
+
+func perfstatmemorytotal2memorytotal(n C.perfstat_memory_total_t) MemoryTotal {
+	var m MemoryTotal
+	m.VirtualTotal = int64(n.virt_total)
+	m.RealTotal = int64(n.real_total)
+	m.RealFree = int64(n.real_free)
+	m.RealPinned = int64(n.real_pinned)
+	m.RealInUse = int64(n.real_inuse)
+	m.BadPages = int64(n.pgbad)
+	m.PageFaults = int64(n.pgexct)
+	m.PageIn = int64(n.pgins)
+	m.PageOut = int64(n.pgouts)
+	m.PgSpIn = int64(n.pgspins)
+	m.PgSpOut = int64(n.pgspouts)
+	m.Scans = int64(n.scans)
+	m.Cycles = int64(n.cycles)
+	m.PgSteals = int64(n.pgsteals)
+	m.NumPerm = int64(n.numperm)
+	m.PgSpTotal = int64(n.pgsp_total)
+	m.PgSpFree = int64(n.pgsp_free)
+	m.PgSpRsvd = int64(n.pgsp_rsvd)
+	m.RealSystem = int64(n.real_system)
+	m.RealUser = int64(n.real_user)
+	m.RealProcess = int64(n.real_process)
+	m.VirtualActive = int64(n.virt_active)
+	m.IOME = int64(n.iome)
+	m.IOMU = int64(n.iomu)
+	m.IOHWM = int64(n.iohwm)
+	m.PMem = int64(n.pmem)
+	m.CompressedTotal = int64(n.comprsd_total)
+	m.CompressedWSegPg = int64(n.comprsd_wseg_pgs)
+	m.CPgIn = int64(n.cpgins)
+	m.CPgOut = int64(n.cpgouts)
+	m.TrueSize = int64(n.true_size)
+	m.ExpandedMemory = int64(n.expanded_memory)
+	m.CompressedWSegSize = int64(n.comprsd_wseg_size)
+	m.TargetCPoolSize = int64(n.target_cpool_size)
+	m.MaxCPoolSize = int64(n.max_cpool_size)
+	m.MinUCPoolSize = int64(n.min_ucpool_size)
+	m.CPoolSize = int64(n.cpool_size)
+	m.UCPoolSize = int64(n.ucpool_size)
+	m.CPoolInUse = int64(n.cpool_inuse)
+	m.UCPoolInUse = int64(n.ucpool_inuse)
+	m.Version = int64(n.version)
+	m.RealAvailable = int64(n.real_avail)
+	m.BytesCoalesced = int64(n.bytes_coalesced)
+	m.BytesCoalescedMemPool = int64(n.bytes_coalesced_mempool)
+
+	return m
+}
+
+func perfstatnetinterfacetotal2netifacetotal(n C.perfstat_netinterface_total_t) NetIfaceTotal {
+	var i NetIfaceTotal
+
+	i.Number = int32(n.number)
+	i.IPackets = int64(n.ipackets)
+	i.IBytes = int64(n.ibytes)
+	i.IErrors = int64(n.ierrors)
+	i.OPackets = int64(n.opackets)
+	i.OBytes = int64(n.obytes)
+	i.OErrors = int64(n.oerrors)
+	i.Collisions = int64(n.collisions)
+	i.XmitDrops = int64(n.xmitdrops)
+	i.Version = int64(n.version)
+
+	return i
+}
+
+func perfstatdisk2disk(n *C.perfstat_disk_t) Disk {
+	var d Disk
+
+	d.Name = C.GoString(&n.name[0])
+	d.Description = C.GoString(&n.description[0])
+	d.VGName = C.GoString(&n.vgname[0])
+	d.Size = int64(n.size)
+	d.Free = int64(n.free)
+	d.BSize = int64(n.bsize)
+	d.XRate = int64(n.xrate)
+	d.Xfers = int64(n.xfers)
+	d.Wblks = int64(n.wblks)
+	d.Rblks = int64(n.rblks)
+	d.QDepth = int64(n.qdepth)
+	d.Time = int64(n.time)
+	d.Adapter = C.GoString(&n.adapter[0])
+	d.PathsCount = int32(n.paths_count)
+	d.QFull = int64(n.q_full)
+	d.Rserv = int64(n.rserv)
+	d.RTimeOut = int64(n.rtimeout)
+	d.Rfailed = int64(n.rfailed)
+	d.MinRserv = int64(n.min_rserv)
+	d.MaxRserv = int64(n.max_rserv)
+	d.Wserv = int64(n.wserv)
+	d.WTimeOut = int64(n.wtimeout)
+	d.Wfailed = int64(n.wfailed)
+	d.MinWserv = int64(n.min_wserv)
+	d.MaxWserv = int64(n.max_wserv)
+	d.WqDepth = int64(n.wq_depth)
+	d.WqSampled = int64(n.wq_sampled)
+	d.WqTime = int64(n.wq_time)
+	d.WqMinTime = int64(n.wq_min_time)
+	d.WqMaxTime = int64(n.wq_max_time)
+	d.QSampled = int64(n.q_sampled)
+	d.Version = int64(n.version)
+	d.PseudoDisk = (n.dk_type[0] & (1 << 7)) > 0
+	d.VTDisk = (n.dk_type[0] & (1 << 6)) > 0
+
+	return d
+}
+
+func perfstatdiskpath2diskpath(n *C.perfstat_diskpath_t) DiskPath {
+	var d DiskPath
+
+	d.Name = C.GoString(&n.name[0])
+	d.XRate = int64(n.xrate)
+	d.Xfers = int64(n.xfers)
+	d.Rblks = int64(n.rblks)
+	d.Wblks = int64(n.wblks)
+	d.Time = int64(n.time)
+	d.Adapter = C.GoString(&n.adapter[0])
+	d.QFull = int64(n.q_full)
+	d.Rserv = int64(n.rserv)
+	d.RTimeOut = int64(n.rtimeout)
+	d.Rfailed = int64(n.rfailed)
+	d.MinRserv = int64(n.min_rserv)
+	d.MaxRserv = int64(n.max_rserv)
+	d.Wserv = int64(n.wserv)
+	d.WTimeOut = int64(n.wtimeout)
+	d.Wfailed = int64(n.wfailed)
+	d.MinWserv = int64(n.min_wserv)
+	d.MaxWserv = int64(n.max_wserv)
+	d.WqDepth = int64(n.wq_depth)
+	d.WqSampled = int64(n.wq_sampled)
+	d.WqTime = int64(n.wq_time)
+	d.WqMinTime = int64(n.wq_min_time)
+	d.WqMaxTime = int64(n.wq_max_time)
+	d.QSampled = int64(n.q_sampled)
+	d.Version = int64(n.version)
+
+	return d
+}
+
+func perfstatfcstat2fcadapter(n *C.perfstat_fcstat_t) FCAdapter {
+	var f FCAdapter
+
+	f.Version = int64(n.version)
+	f.Name = C.GoString(&n.name[0])
+	f.State = int32(n.state)
+	f.InputRequests = int64(n.InputRequests)
+	f.OutputRequests = int64(n.OutputRequests)
+	f.InputBytes = int64(n.InputBytes)
+	f.OutputBytes = int64(n.OutputBytes)
+	f.EffMaxTransfer = int64(n.EffMaxTransfer)
+	f.NoDMAResourceCnt = int64(n.NoDMAResourceCnt)
+	f.NoCmdResourceCnt = int64(n.NoCmdResourceCnt)
+	f.AttentionType = int32(n.AttentionType)
+	f.SecondsSinceLastReset = int64(n.SecondsSinceLastReset)
+	f.TxFrames = int64(n.TxFrames)
+	f.TxWords = int64(n.TxWords)
+	f.RxFrames = int64(n.RxFrames)
+	f.RxWords = int64(n.RxWords)
+	f.LIPCount = int64(n.LIPCount)
+	f.NOSCount = int64(n.NOSCount)
+	f.ErrorFrames = int64(n.ErrorFrames)
+	f.DumpedFrames = int64(n.DumpedFrames)
+	f.LinkFailureCount = int64(n.LinkFailureCount)
+	f.LossofSyncCount = int64(n.LossofSyncCount)
+	f.LossofSignal = int64(n.LossofSignal)
+	f.PrimitiveSeqProtocolErrCount = int64(n.PrimitiveSeqProtocolErrCount)
+	f.InvalidTxWordCount = int64(n.InvalidTxWordCount)
+	f.InvalidCRCCount = int64(n.InvalidCRCCount)
+	f.PortFcId = int64(n.PortFcId)
+	f.PortSpeed = int64(n.PortSpeed)
+	f.PortType = C.GoString(&n.PortType[0])
+	f.PortWWN = int64(n.PortWWN)
+	f.PortSupportedSpeed = int64(n.PortSupportedSpeed)
+	f.AdapterType = int(n.adapter_type)
+	f.VfcName = C.GoString(&n.vfc_name[0])
+	f.ClientPartName = C.GoString(&n.client_part_name[0])
+
+	return f
+}
+
+func perfstatlogicalvolume2logicalvolume(n *C.perfstat_logicalvolume_t) LogicalVolume {
+	var l LogicalVolume
+
+	l.Name = C.GoString(&n.name[0])
+	l.VGName = C.GoString(&n.vgname[0])
+	l.OpenClose = int64(n.open_close)
+	l.State = int64(n.state)
+	l.MirrorPolicy = int64(n.mirror_policy)
+	l.MirrorWriteConsistency = int64(n.mirror_write_consistency)
+	l.WriteVerify = int64(n.write_verify)
+	l.PPsize = int64(n.ppsize)
+	l.LogicalPartitions = int64(n.logical_partitions)
+	l.Mirrors = int32(n.mirrors)
+	l.IOCnt = int64(n.iocnt)
+	l.KBReads = int64(n.kbreads)
+	l.KBWrites = int64(n.kbwrites)
+	l.Version = int64(n.version)
+
+	return l
+}
+
+func perfstatvolumegroup2volumegroup(n *C.perfstat_volumegroup_t) VolumeGroup {
+	var v VolumeGroup
+
+	v.Name = C.GoString(&n.name[0])
+	v.TotalDisks = int64(n.total_disks)
+	v.ActiveDisks = int64(n.active_disks)
+	v.TotalLogicalVolumes = int64(n.total_logical_volumes)
+	v.OpenedLogicalVolumes = int64(n.opened_logical_volumes)
+	v.IOCnt = int64(n.iocnt)
+	v.KBReads = int64(n.kbreads)
+	v.KBWrites = int64(n.kbwrites)
+	v.Version = int64(n.version)
+	v.VariedState = int(n.variedState)
+
+	return v
+}
+
+func perfstatmemorypage2memorypage(n *C.perfstat_memory_page_t) MemoryPage {
+	var m MemoryPage
+
+	m.PSize = int64(n.psize)
+	m.RealTotal = int64(n.real_total)
+	m.RealFree = int64(n.real_free)
+	m.RealPinned = int64(n.real_pinned)
+	m.RealInUse = int64(n.real_inuse)
+	m.PgExct = int64(n.pgexct)
+	m.PgIns = int64(n.pgins)
+	m.PgOuts = int64(n.pgouts)
+	m.PgSpIns = int64(n.pgspins)
+	m.PgSpOuts = int64(n.pgspouts)
+	m.Scans = int64(n.scans)
+	m.Cycles = int64(n.cycles)
+	m.PgSteals = int64(n.pgsteals)
+	m.NumPerm = int64(n.numperm)
+	m.NumPgSp = int64(n.numpgsp)
+	m.RealSystem = int64(n.real_system)
+	m.RealUser = int64(n.real_user)
+	m.RealProcess = int64(n.real_process)
+	m.VirtActive = int64(n.virt_active)
+	m.ComprsdTotal = int64(n.comprsd_total)
+	m.ComprsdWsegPgs = int64(n.comprsd_wseg_pgs)
+	m.CPgIns = int64(n.cpgins)
+	m.CPgOuts = int64(n.cpgouts)
+	m.CPoolInUse = int64(n.cpool_inuse)
+	m.UCPoolSize = int64(n.ucpool_size)
+	m.ComprsdWsegSize = int64(n.comprsd_wseg_size)
+	m.Version = int64(n.version)
+	m.RealAvail = int64(n.real_avail)
+
+	return m
+}
+
+func perfstatnetbuffer2netbuffer(n *C.perfstat_netbuffer_t) NetBuffer {
+	var b NetBuffer
+
+	b.Name = C.GoString(&n.name[0])
+	b.InUse = int64(n.inuse)
+	b.Calls = int64(n.calls)
+	b.Delayed = int64(n.delayed)
+	b.Free = int64(n.free)
+	b.Failed = int64(n.failed)
+	b.HighWatermark = int64(n.highwatermark)
+	b.Freed = int64(n.freed)
+	b.Version = int64(n.version)
+
+	return b
+}
+
+func perfstatnetinterface2netiface(n *C.perfstat_netinterface_t) NetIface {
+	var i NetIface
+
+	i.Name = C.GoString(&n.name[0])
+	i.Description = C.GoString(&n.description[0])
+	i.Type = uint8(n._type)
+	i.MTU = int64(n.mtu)
+	i.IPackets = int64(n.ipackets)
+	i.IBytes = int64(n.ibytes)
+	i.IErrors = int64(n.ierrors)
+	i.OPackets = int64(n.opackets)
+	i.OBytes = int64(n.obytes)
+	i.OErrors = int64(n.oerrors)
+	i.Collisions = int64(n.collisions)
+	i.Bitrate = int64(n.bitrate)
+	i.XmitDrops = int64(n.xmitdrops)
+	i.Version = int64(n.version)
+	i.IfIqDrops = int64(n.if_iqdrops)
+	i.IfArpDrops = int64(n.if_arpdrops)
+
+	return i
+}
+
+func perfstatnetadapter2netadapter(n *C.perfstat_netadapter_t) NetAdapter {
+	var i NetAdapter
+
+	i.Version = int64(n.version)
+	i.Name = C.GoString(&n.name[0])
+	i.TxPackets = int64(n.tx_packets)
+	i.TxBytes = int64(n.tx_bytes)
+	i.TxInterrupts = int64(n.tx_interrupts)
+	i.TxErrors = int64(n.tx_errors)
+	i.TxPacketsDropped = int64(n.tx_packets_dropped)
+	i.TxQueueSize = int64(n.tx_queue_size)
+	i.TxQueueLen = int64(n.tx_queue_len)
+	i.TxQueueOverflow = int64(n.tx_queue_overflow)
+	i.TxBroadcastPackets = int64(n.tx_broadcast_packets)
+	i.TxMulticastPackets = int64(n.tx_multicast_packets)
+	i.TxCarrierSense = int64(n.tx_carrier_sense)
+	i.TxDMAUnderrun = int64(n.tx_DMA_underrun)
+	i.TxLostCTSErrors = int64(n.tx_lost_CTS_errors)
+	i.TxMaxCollisionErrors = int64(n.tx_max_collision_errors)
+	i.TxLateCollisionErrors = int64(n.tx_late_collision_errors)
+	i.TxDeferred = int64(n.tx_deferred)
+	i.TxTimeoutErrors = int64(n.tx_timeout_errors)
+	i.TxSingleCollisionCount = int64(n.tx_single_collision_count)
+	i.TxMultipleCollisionCount = int64(n.tx_multiple_collision_count)
+	i.RxPackets = int64(n.rx_packets)
+	i.RxBytes = int64(n.rx_bytes)
+	i.RxInterrupts = int64(n.rx_interrupts)
+	i.RxErrors = int64(n.rx_errors)
+	i.RxPacketsDropped = int64(n.rx_packets_dropped)
+	i.RxBadPackets = int64(n.rx_bad_packets)
+	i.RxMulticastPackets = int64(n.rx_multicast_packets)
+	i.RxBroadcastPackets = int64(n.rx_broadcast_packets)
+	i.RxCRCErrors = int64(n.rx_CRC_errors)
+	i.RxDMAOverrun = int64(n.rx_DMA_overrun)
+	i.RxAlignmentErrors = int64(n.rx_alignment_errors)
+	i.RxNoResourceErrors = int64(n.rx_noresource_errors)
+	i.RxCollisionErrors = int64(n.rx_collision_errors)
+	i.RxPacketTooShortErrors = int64(n.rx_packet_tooshort_errors)
+	i.RxPacketTooLongErrors = int64(n.rx_packet_toolong_errors)
+	i.RxPacketDiscardedByAdapter = int64(n.rx_packets_discardedbyadapter)
+	i.AdapterType = int32(n.adapter_type)
+
+	return i
+}
+
+func perfstatpagingspace2pagingspace(n *C.perfstat_pagingspace_t) PagingSpace {
+	var i PagingSpace
+
+	i.Name = C.GoString(&n.name[0])
+	i.Type = uint8(n._type)
+	i.VGName = C.GoString(C.get_ps_vgname(n))
+	i.Hostname = C.GoString(C.get_ps_hostname(n))
+	i.Filename = C.GoString(C.get_ps_filename(n))
+	i.LPSize = int64(n.lp_size)
+	i.MBSize = int64(n.mb_size)
+	i.MBUsed = int64(n.mb_used)
+	i.IOPending = int64(n.io_pending)
+	i.Active = uint8(n.active)
+	i.Automatic = uint8(n.automatic)
+	i.Version = int64(n.version)
+
+	return i
+}
+
+func perfstatprocess2process(n *C.perfstat_process_t) Process {
+	var i Process
+
+	i.Version = int64(n.version)
+	i.PID = int64(n.pid)
+	i.ProcessName = C.GoString(&n.proc_name[0])
+	i.Priority = int32(n.proc_priority)
+	i.NumThreads = int64(n.num_threads)
+	i.UID = int64(n.proc_uid)
+	i.ClassID = int64(n.proc_classid)
+	i.Size = int64(n.proc_size)
+	i.RealMemData = int64(n.proc_real_mem_data)
+	i.RealMemText = int64(n.proc_real_mem_text)
+	i.VirtMemData = int64(n.proc_virt_mem_data)
+	i.VirtMemText = int64(n.proc_virt_mem_text)
+	i.SharedLibDataSize = int64(n.shared_lib_data_size)
+	i.HeapSize = int64(n.heap_size)
+	i.RealInUse = int64(n.real_inuse)
+	i.VirtInUse = int64(n.virt_inuse)
+	i.Pinned = int64(n.pinned)
+	i.PgSpInUse = int64(n.pgsp_inuse)
+	i.FilePages = int64(n.filepages)
+	i.RealInUseMap = int64(n.real_inuse_map)
+	i.VirtInUseMap = int64(n.virt_inuse_map)
+	i.PinnedInUseMap = int64(n.pinned_inuse_map)
+	i.UCpuTime = float64(n.ucpu_time)
+	i.SCpuTime = float64(n.scpu_time)
+	i.LastTimeBase = int64(n.last_timebase)
+	i.InBytes = int64(n.inBytes)
+	i.OutBytes = int64(n.outBytes)
+	i.InOps = int64(n.inOps)
+	i.OutOps = int64(n.outOps)
+
+	return i
+}
+
+func perfstatthread2thread(n *C.perfstat_thread_t) Thread {
+	var i Thread
+
+	i.TID = int64(n.tid)
+	i.PID = int64(n.pid)
+	i.CpuID = int64(n.cpuid)
+	i.UCpuTime = float64(n.ucpu_time)
+	i.SCpuTime = float64(n.scpu_time)
+	i.LastTimeBase = int64(n.last_timebase)
+	i.Version = int64(n.version)
+
+	return i
+}
+
+func fsinfo2filesystem(n *C.struct_fsinfo) FileSystem {
+	var i FileSystem
+
+	i.Device = C.GoString(n.devname)
+	i.MountPoint = C.GoString(n.fsname)
+	i.FSType = int(n.fstype)
+	i.Flags = uint(n.flags)
+	i.TotalBlocks = int64(n.totalblks)
+	i.FreeBlocks = int64(n.freeblks)
+	i.TotalInodes = int64(n.totalinodes)
+	i.FreeInodes = int64(n.freeinodes)
+
+	return i
+}

vendor/github.com/power-devops/perfstat/lparstat.go

@@ -0,0 +1,26 @@
+// +build aix
+
+package perfstat
+
+/*
+#cgo LDFLAGS: -lperfstat
+
+#include <libperfstat.h>
+*/
+import "C"
+
+import (
+	"fmt"
+)
+
+func PartitionStat() (*PartitionConfig, error) {
+	var part C.perfstat_partition_config_t
+
+	rc := C.perfstat_partition_config(nil, &part, C.sizeof_perfstat_partition_config_t, 1)
+	if rc != 1 {
+		return nil, fmt.Errorf("perfstat_partition_config() error")
+	}
+	p := perfstatpartitionconfig2partitionconfig(part)
+	return &p, nil
+
+}

vendor/github.com/power-devops/perfstat/lvmstat.go

@@ -0,0 +1,72 @@
+// +build aix
+
+package perfstat
+
+/*
+#cgo LDFLAGS: -lperfstat
+
+#include <libperfstat.h>
+#include <string.h>
+#include <stdlib.h>
+#include "c_helpers.h"
+*/
+import "C"
+
+import (
+	"fmt"
+	"unsafe"
+)
+
+func LogicalVolumeStat() ([]LogicalVolume, error) {
+	var lv *C.perfstat_logicalvolume_t
+	var lvname C.perfstat_id_t
+
+	numlvs := C.perfstat_logicalvolume(nil, nil, C.sizeof_perfstat_logicalvolume_t, 0)
+	if numlvs <= 0 {
+		return nil, fmt.Errorf("perfstat_logicalvolume() error")
+	}
+
+	lv_len := C.sizeof_perfstat_logicalvolume_t * C.ulong(numlvs)
+	lv = (*C.perfstat_logicalvolume_t)(C.malloc(lv_len))
+	defer C.free(unsafe.Pointer(lv))
+	C.strcpy(&lvname.name[0], C.CString(""))
+	r := C.perfstat_logicalvolume(&lvname, lv, C.sizeof_perfstat_logicalvolume_t, numlvs)
+	if r < 0 {
+		return nil, fmt.Errorf("perfstat_logicalvolume() error")
+	}
+	lvs := make([]LogicalVolume, r)
+	for i := 0; i < int(r); i++ {
+		l := C.get_logicalvolume_stat(lv, C.int(i))
+		if l != nil {
+			lvs[i] = perfstatlogicalvolume2logicalvolume(l)
+		}
+	}
+	return lvs, nil
+}
+
+func VolumeGroupStat() ([]VolumeGroup, error) {
+	var vg *C.perfstat_volumegroup_t
+	var vgname C.perfstat_id_t
+
+	numvgs := C.perfstat_volumegroup(nil, nil, C.sizeof_perfstat_volumegroup_t, 0)
+	if numvgs <= 0 {
+		return nil, fmt.Errorf("perfstat_volumegroup() error")
+	}
+
+	vg_len := C.sizeof_perfstat_volumegroup_t * C.ulong(numvgs)
+	vg = (*C.perfstat_volumegroup_t)(C.malloc(vg_len))
+	defer C.free(unsafe.Pointer(vg))
+	C.strcpy(&vgname.name[0], C.CString(""))
+	r := C.perfstat_volumegroup(&vgname, vg, C.sizeof_perfstat_volumegroup_t, numvgs)
+	if r < 0 {
+		return nil, fmt.Errorf("perfstat_volumegroup() error")
+	}
+	vgs := make([]VolumeGroup, r)
+	for i := 0; i < int(r); i++ {
+		v := C.get_volumegroup_stat(vg, C.int(i))
+		if v != nil {
+			vgs[i] = perfstatvolumegroup2volumegroup(v)
+		}
+	}
+	return vgs, nil
+}

vendor/github.com/power-devops/perfstat/memstat.go

@@ -0,0 +1,84 @@
+// +build aix
+
+package perfstat
+
+/*
+#cgo LDFLAGS: -lperfstat
+
+#include <libperfstat.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include "c_helpers.h"
+*/
+import "C"
+
+import (
+	"fmt"
+	"unsafe"
+)
+
+func MemoryTotalStat() (*MemoryTotal, error) {
+	var memory C.perfstat_memory_total_t
+
+	rc := C.perfstat_memory_total(nil, &memory, C.sizeof_perfstat_memory_total_t, 1)
+	if rc != 1 {
+		return nil, fmt.Errorf("perfstat_memory_total() error")
+	}
+	m := perfstatmemorytotal2memorytotal(memory)
+	return &m, nil
+}
+
+func MemoryPageStat() ([]MemoryPage, error) {
+	var mempage *C.perfstat_memory_page_t
+	var fps C.perfstat_psize_t
+
+	numps := C.perfstat_memory_page(nil, nil, C.sizeof_perfstat_memory_page_t, 0)
+	if numps < 1 {
+		return nil, fmt.Errorf("perfstat_memory_page() error")
+	}
+
+	mp_len := C.sizeof_perfstat_memory_page_t * C.ulong(numps)
+	mempage = (*C.perfstat_memory_page_t)(C.malloc(mp_len))
+	defer C.free(unsafe.Pointer(mempage))
+	fps.psize = C.FIRST_PSIZE
+	r := C.perfstat_memory_page(&fps, mempage, C.sizeof_perfstat_memory_page_t, numps)
+	if r < 1 {
+		return nil, fmt.Errorf("perfstat_memory_page() error")
+	}
+	ps := make([]MemoryPage, r)
+	for i := 0; i < int(r); i++ {
+		p := C.get_memory_page_stat(mempage, C.int(i))
+		if p != nil {
+			ps[i] = perfstatmemorypage2memorypage(p)
+		}
+	}
+	return ps, nil
+}
+
+func PagingSpaceStat() ([]PagingSpace, error) {
+	var pspace *C.perfstat_pagingspace_t
+	var fps C.perfstat_id_t
+
+	numps := C.perfstat_pagingspace(nil, nil, C.sizeof_perfstat_pagingspace_t, 0)
+	if numps <= 0 {
+		return nil, fmt.Errorf("perfstat_pagingspace() error")
+	}
+
+	ps_len := C.sizeof_perfstat_pagingspace_t * C.ulong(numps)
+	pspace = (*C.perfstat_pagingspace_t)(C.malloc(ps_len))
+	defer C.free(unsafe.Pointer(pspace))
+	C.strcpy(&fps.name[0], C.CString(C.FIRST_PAGINGSPACE))
+	r := C.perfstat_pagingspace(&fps, pspace, C.sizeof_perfstat_pagingspace_t, numps)
+	if r < 1 {
+		return nil, fmt.Errorf("perfstat_pagingspace() error")
+	}
+	ps := make([]PagingSpace, r)
+	for i := 0; i < int(r); i++ {
+		p := C.get_pagingspace_stat(pspace, C.int(i))
+		if p != nil {
+			ps[i] = perfstatpagingspace2pagingspace(p)
+		}
+	}
+	return ps, nil
+}

vendor/github.com/power-devops/perfstat/netstat.go

@@ -0,0 +1,117 @@
+// +build aix
+
+package perfstat
+
+/*
+#cgo LDFLAGS: -lperfstat
+
+#include <libperfstat.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include "c_helpers.h"
+*/
+import "C"
+
+import (
+	"fmt"
+	"unsafe"
+)
+
+func NetIfaceTotalStat() (*NetIfaceTotal, error) {
+	var nif C.perfstat_netinterface_total_t
+
+	rc := C.perfstat_netinterface_total(nil, &nif, C.sizeof_perfstat_netinterface_total_t, 1)
+	if rc != 1 {
+		return nil, fmt.Errorf("perfstat_netinterface_total() error")
+	}
+	n := perfstatnetinterfacetotal2netifacetotal(nif)
+	return &n, nil
+}
+
+func NetBufferStat() ([]NetBuffer, error) {
+	var nbuf *C.perfstat_netbuffer_t
+	var first C.perfstat_id_t
+
+	numbuf := C.perfstat_netbuffer(nil, nil, C.sizeof_perfstat_netbuffer_t, 0)
+	if numbuf < 1 {
+		return nil, fmt.Errorf("perfstat_netbuffer() error")
+	}
+
+	nblen := C.sizeof_perfstat_netbuffer_t * C.ulong(numbuf)
+	nbuf = (*C.perfstat_netbuffer_t)(C.malloc(nblen))
+	defer C.free(unsafe.Pointer(nbuf))
+	C.strcpy(&first.name[0], C.CString(C.FIRST_NETBUFFER))
+	r := C.perfstat_netbuffer(&first, nbuf, C.sizeof_perfstat_netbuffer_t, numbuf)
+	if r < 0 {
+		return nil, fmt.Errorf("perfstat_netbuffer() error")
+	}
+	nb := make([]NetBuffer, r)
+	for i := 0; i < int(r); i++ {
+		b := C.get_netbuffer_stat(nbuf, C.int(i))
+		if b != nil {
+			nb[i] = perfstatnetbuffer2netbuffer(b)
+		}
+	}
+	return nb, nil
+}
+
+func NetIfaceStat() ([]NetIface, error) {
+	var nif *C.perfstat_netinterface_t
+	var first C.perfstat_id_t
+
+	numif := C.perfstat_netinterface(nil, nil, C.sizeof_perfstat_netinterface_t, 0)
+	if numif < 0 {
+		return nil, fmt.Errorf("perfstat_netinterface() error")
+	}
+	if numif == 0 {
+		return []NetIface{}, fmt.Errorf("no network interfaces found")
+	}
+
+	iflen := C.sizeof_perfstat_netinterface_t * C.ulong(numif)
+	nif = (*C.perfstat_netinterface_t)(C.malloc(iflen))
+	defer C.free(unsafe.Pointer(nif))
+	C.strcpy(&first.name[0], C.CString(C.FIRST_NETINTERFACE))
+	r := C.perfstat_netinterface(&first, nif, C.sizeof_perfstat_netinterface_t, numif)
+	if r < 0 {
+		return nil, fmt.Errorf("perfstat_netinterface() error")
+	}
+	ifs := make([]NetIface, r)
+	for i := 0; i < int(r); i++ {
+		b := C.get_netinterface_stat(nif, C.int(i))
+		if b != nil {
+			ifs[i] = perfstatnetinterface2netiface(b)
+		}
+	}
+	return ifs, nil
+}
+
+func NetAdapterStat() ([]NetAdapter, error) {
+	var adapters *C.perfstat_netadapter_t
+	var first C.perfstat_id_t
+
+	numad := C.perfstat_netadapter(nil, nil, C.sizeof_perfstat_netadapter_t, 0)
+	if numad < 0 {
+		return nil, fmt.Errorf("perfstat_netadater() error")
+	}
+	if numad == 0 {
+		return []NetAdapter{}, fmt.Errorf("no network adapters found")
+	}
+
+	adplen := C.sizeof_perfstat_netadapter_t * C.ulong(numad)
+	adapters = (*C.perfstat_netadapter_t)(C.malloc(adplen))
+	defer C.free(unsafe.Pointer(adapters))
+	C.strcpy(&first.name[0], C.CString(C.FIRST_NETINTERFACE))
+	r := C.perfstat_netadapter(&first, adapters, C.sizeof_perfstat_netadapter_t, numad)
+	if r < 0 {
+		return nil, fmt.Errorf("perfstat_netadapter() error")
+	}
+	ads := make([]NetAdapter, r)
+	for i := 0; i < int(r); i++ {
+		b := C.get_netadapter_stat(adapters, C.int(i))
+		if b != nil {
+			ads[i] = perfstatnetadapter2netadapter(b)
+		}
+	}
+	return ads, nil
+}

vendor/github.com/power-devops/perfstat/procstat.go

@@ -0,0 +1,75 @@
+// +build aix
+
+package perfstat
+
+/*
+#cgo LDFLAGS: -lperfstat
+
+#include <libperfstat.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include "c_helpers.h"
+*/
+import "C"
+
+import (
+	"fmt"
+	"unsafe"
+)
+
+func ProcessStat() ([]Process, error) {
+	var proc *C.perfstat_process_t
+	var first C.perfstat_id_t
+
+	numproc := C.perfstat_process(nil, nil, C.sizeof_perfstat_process_t, 0)
+	if numproc < 1 {
+		return nil, fmt.Errorf("perfstat_process() error")
+	}
+
+	plen := C.sizeof_perfstat_process_t * C.ulong(numproc)
+	proc = (*C.perfstat_process_t)(C.malloc(plen))
+	defer C.free(unsafe.Pointer(proc))
+	C.strcpy(&first.name[0], C.CString(""))
+	r := C.perfstat_process(&first, proc, C.sizeof_perfstat_process_t, numproc)
+	if r < 0 {
+		return nil, fmt.Errorf("perfstat_process() error")
+	}
+
+	ps := make([]Process, r)
+	for i := 0; i < int(r); i++ {
+		p := C.get_process_stat(proc, C.int(i))
+		if p != nil {
+			ps[i] = perfstatprocess2process(p)
+		}
+	}
+	return ps, nil
+}
+
+func ThreadStat() ([]Thread, error) {
+	var thread *C.perfstat_thread_t
+	var first C.perfstat_id_t
+
+	numthr := C.perfstat_thread(nil, nil, C.sizeof_perfstat_thread_t, 0)
+	if numthr < 1 {
+		return nil, fmt.Errorf("perfstat_thread() error")
+	}
+
+	thlen := C.sizeof_perfstat_thread_t * C.ulong(numthr)
+	thread = (*C.perfstat_thread_t)(C.malloc(thlen))
+	defer C.free(unsafe.Pointer(thread))
+	C.strcpy(&first.name[0], C.CString(""))
+	r := C.perfstat_thread(&first, thread, C.sizeof_perfstat_thread_t, numthr)
+	if r < 0 {
+		return nil, fmt.Errorf("perfstat_thread() error")
+	}
+
+	th := make([]Thread, r)
+	for i := 0; i < int(r); i++ {
+		t := C.get_thread_stat(thread, C.int(i))
+		if t != nil {
+			th[i] = perfstatthread2thread(t)
+		}
+	}
+	return th, nil
+}

vendor/github.com/power-devops/perfstat/sysconf.go

@@ -0,0 +1,195 @@
+// +build aix
+
+package perfstat
+
+/*
+#include <unistd.h>
+*/
+import "C"
+
+import "fmt"
+
+const (
+	SC_ARG_MAX                      = 0
+	SC_CHILD_MAX                    = 1
+	SC_CLK_TCK                      = 2
+	SC_NGROUPS_MAX                  = 3
+	SC_OPEN_MAX                     = 4
+	SC_STREAM_MAX                   = 5
+	SC_TZNAME_MAX                   = 6
+	SC_JOB_CONTROL                  = 7
+	SC_SAVED_IDS                    = 8
+	SC_VERSION                      = 9
+	SC_POSIX_ARG_MAX                = 10
+	SC_POSIX_CHILD_MAX              = 11
+	SC_POSIX_LINK_MAX               = 12
+	SC_POSIX_MAX_CANON              = 13
+	SC_POSIX_MAX_INPUT              = 14
+	SC_POSIX_NAME_MAX               = 15
+	SC_POSIX_NGROUPS_MAX            = 16
+	SC_POSIX_OPEN_MAX               = 17
+	SC_POSIX_PATH_MAX               = 18
+	SC_POSIX_PIPE_BUF               = 19
+	SC_POSIX_SSIZE_MAX              = 20
+	SC_POSIX_STREAM_MAX             = 21
+	SC_POSIX_TZNAME_MAX             = 22
+	SC_BC_BASE_MAX                  = 23
+	SC_BC_DIM_MAX                   = 24
+	SC_BC_SCALE_MAX                 = 25
+	SC_BC_STRING_MAX                = 26
+	SC_EQUIV_CLASS_MAX              = 27
+	SC_EXPR_NEST_MAX                = 28
+	SC_LINE_MAX                     = 29
+	SC_RE_DUP_MAX                   = 30
+	SC_2_VERSION                    = 31
+	SC_2_C_DEV                      = 32
+	SC_2_FORT_DEV                   = 33
+	SC_2_FORT_RUN                   = 34
+	SC_2_LOCALEDEF                  = 35
+	SC_2_SW_DEV                     = 36
+	SC_POSIX2_BC_BASE_MAX           = 37
+	SC_POSIX2_BC_DIM_MAX            = 38
+	SC_POSIX2_BC_SCALE_MAX          = 39
+	SC_POSIX2_BC_STRING_MAX         = 40
+	SC_POSIX2_BC_EQUIV_CLASS_MAX    = 41
+	SC_POSIX2_BC_EXPR_NEST_MAX      = 42
+	SC_POSIX2_BC_LINE_MAX           = 43
+	SC_POSIX2_BC_RE_DUP_MAX         = 44
+	SC_PASS_MAX                     = 45
+	SC_XOPEN_VERSION                = 46
+	SC_ATEXIT_MAX                   = 47
+	SC_PAGE_SIZE                    = 48
+	SC_PAGESIZE                     = SC_PAGE_SIZE
+	SC_AES_OS_VERSION               = 49
+	SC_COLL_WEIGHTS_MAX             = 50
+	SC_2_C_WIND                     = 51
+	SC_2_C_VERSION                  = 52
+	SC_2_UPE                        = 53
+	SC_2_CHAR_TERM                  = 54
+	SC_XOPEN_SHM                    = 55
+	SC_XOPEN_CRYPT                  = 56
+	SC_XOPEN_ENH_I18N               = 57
+	SC_IOV_MAX                      = 58
+	SC_THREAD_SAFE_FUNCTIONS        = 59
+	SC_THREADS                      = 60
+	SC_THREAD_ATTR_STACKADDR        = 61
+	SC_THREAD_ATTR_STACKSIZE        = 62
+	SC_THREAD_FORKALL               = 63
+	SC_THREAD_PRIORITY_SCHEDULING   = 64
+	SC_THREAD_PRIO_INHERIT          = 65
+	SC_THREAD_PRIO_PROTECT          = 66
+	SC_THREAD_PROCESS_SHARED        = 67
+	SC_THREAD_KEYS_MAX              = 68
+	SC_THREAD_DATAKEYS_MAX          = SC_THREAD_KEYS_MAX
+	SC_THREAD_STACK_MIN             = 69
+	SC_THREAD_THREADS_MAX           = 70
+	SC_NPROCESSORS_CONF             = 71
+	SC_NPROCESSORS_ONLN             = 72
+	SC_XOPEN_UNIX                   = 73
+	SC_AIO_LISTIO_MAX               = 75
+	SC_AIO_MAX                      = 76
+	SC_AIO_PRIO_DELTA_MAX           = 77
+	SC_ASYNCHRONOUS_IO              = 78
+	SC_DELAYTIMER_MAX               = 79
+	SC_FSYNC                        = 80
+	SC_GETGR_R_SIZE_MAX             = 81
+	SC_GETPW_R_SIZE_MAX             = 82
+	SC_LOGIN_NAME_MAX               = 83
+	SC_MAPPED_FILES                 = 84
+	SC_MEMLOCK                      = 85
+	SC_MEMLOCK_RANGE                = 86
+	SC_MEMORY_PROTECTION            = 87
+	SC_MESSAGE_PASSING              = 88
+	SC_MQ_OPEN_MAX                  = 89
+	SC_MQ_PRIO_MAX                  = 90
+	SC_PRIORITIZED_IO               = 91
+	SC_PRIORITY_SCHEDULING          = 92
+	SC_REALTIME_SIGNALS             = 93
+	SC_RTSIG_MAX                    = 94
+	SC_SEMAPHORES                   = 95
+	SC_SEM_NSEMS_MAX                = 96
+	SC_SEM_VALUE_MAX                = 97
+	SC_SHARED_MEMORY_OBJECTS        = 98
+	SC_SIGQUEUE_MAX                 = 99
+	SC_SYNCHRONIZED_IO              = 100
+	SC_THREAD_DESTRUCTOR_ITERATIONS = 101
+	SC_TIMERS                       = 102
+	SC_TIMER_MAX                    = 103
+	SC_TTY_NAME_MAX                 = 104
+	SC_XBS5_ILP32_OFF32             = 105
+	SC_XBS5_ILP32_OFFBIG            = 106
+	SC_XBS5_LP64_OFF64              = 107
+	SC_XBS5_LPBIG_OFFBIG            = 108
+	SC_XOPEN_XCU_VERSION            = 109
+	SC_XOPEN_REALTIME               = 110
+	SC_XOPEN_REALTIME_THREADS       = 111
+	SC_XOPEN_LEGACY                 = 112
+	SC_REENTRANT_FUNCTIONS          = SC_THREAD_SAFE_FUNCTIONS
+	SC_PHYS_PAGES                   = 113
+	SC_AVPHYS_PAGES                 = 114
+	SC_LPAR_ENABLED                 = 115
+	SC_LARGE_PAGESIZE               = 116
+	SC_AIX_KERNEL_BITMODE           = 117
+	SC_AIX_REALMEM                  = 118
+	SC_AIX_HARDWARE_BITMODE         = 119
+	SC_AIX_MP_CAPABLE               = 120
+	SC_V6_ILP32_OFF32               = 121
+	SC_V6_ILP32_OFFBIG              = 122
+	SC_V6_LP64_OFF64                = 123
+	SC_V6_LPBIG_OFFBIG              = 124
+	SC_XOPEN_STREAMS                = 125
+	SC_HOST_NAME_MAX                = 126
+	SC_REGEXP                       = 127
+	SC_SHELL                        = 128
+	SC_SYMLOOP_MAX                  = 129
+	SC_ADVISORY_INFO                = 130
+	SC_FILE_LOCKING                 = 131
+	SC_2_PBS                        = 132
+	SC_2_PBS_ACCOUNTING             = 133
+	SC_2_PBS_CHECKPOINT             = 134
+	SC_2_PBS_LOCATE                 = 135
+	SC_2_PBS_MESSAGE                = 136
+	SC_2_PBS_TRACK                  = 137
+	SC_BARRIERS                     = 138
+	SC_CLOCK_SELECTION              = 139
+	SC_CPUTIME                      = 140
+	SC_MONOTONIC_CLOCK              = 141
+	SC_READER_WRITER_LOCKS          = 142
+	SC_SPAWN                        = 143
+	SC_SPIN_LOCKS                   = 144
+	SC_SPORADIC_SERVER              = 145
+	SC_THREAD_CPUTIME               = 146
+	SC_THREAD_SPORADIC_SERVER       = 147
+	SC_TIMEOUTS                     = 148
+	SC_TRACE                        = 149
+	SC_TRACE_EVENT_FILTER           = 150
+	SC_TRACE_INHERIT                = 151
+	SC_TRACE_LOG                    = 152
+	SC_TYPED_MEMORY_OBJECTS         = 153
+	SC_IPV6                         = 154
+	SC_RAW_SOCKETS                  = 155
+	SC_SS_REPL_MAX                  = 156
+	SC_TRACE_EVENT_NAME_MAX         = 157
+	SC_TRACE_NAME_MAX               = 158
+	SC_TRACE_SYS_MAX                = 159
+	SC_TRACE_USER_EVENT_MAX         = 160
+	SC_AIX_UKEYS                    = 161
+	SC_AIX_ENHANCED_AFFINITY        = 162
+	SC_V7_ILP32_OFF32               = 163
+	SC_V7_ILP32_OFFBIG              = 164
+	SC_V7_LP64_OFF64                = 165
+	SC_V7_LPBIG_OFFBIG              = 166
+	SC_THREAD_ROBUST_PRIO_INHERIT   = 167
+	SC_THREAD_ROBUST_PRIO_PROTECT   = 168
+	SC_XOPEN_UUCP                   = 169
+	SC_XOPEN_ARMOR                  = 170
+)
+
+func Sysconf(name int32) (int64, error) {
+	r := C.sysconf(C.int(name))
+	if r == -1 {
+		return 0, fmt.Errorf("sysconf error")
+	} else {
+		return int64(r), nil
+	}
+}

vendor/github.com/power-devops/perfstat/systemcfg.go

@@ -0,0 +1,635 @@
+// +build aix
+
+package perfstat
+
+import "golang.org/x/sys/unix"
+
+// function Getsystemcfg() is defined in golang.org/x/sys/unix
+// we define here just missing constants for the function and some helpers
+
+// Calls to getsystemcfg()
+const (
+	SC_ARCH         = 1  /* processor architecture */
+	SC_IMPL         = 2  /* processor implementation */
+	SC_VERS         = 3  /* processor version */
+	SC_WIDTH        = 4  /* width (32 || 64) */
+	SC_NCPUS        = 5  /* 1 = UP, n = n-way MP */
+	SC_L1C_ATTR     = 6  /* L1 cache attributes (bit flags) */
+	SC_L1C_ISZ      = 7  /* size of L1 instruction cache */
+	SC_L1C_DSZ      = 8  /* size of L1 data cache */
+	SC_L1C_ICA      = 9  /* L1 instruction cache associativity */
+	SC_L1C_DCA      = 10 /* L1 data cache associativity */
+	SC_L1C_IBS      = 11 /* L1 instruction cache block size */
+	SC_L1C_DBS      = 12 /* L1 data cache block size */
+	SC_L1C_ILS      = 13 /* L1 instruction cache line size */
+	SC_L1C_DLS      = 14 /* L1 data cache line size */
+	SC_L2C_SZ       = 15 /* size of L2 cache, 0 = No L2 cache */
+	SC_L2C_AS       = 16 /* L2 cache associativity */
+	SC_TLB_ATTR     = 17 /* TLB attributes (bit flags) */
+	SC_ITLB_SZ      = 18 /* entries in instruction TLB */
+	SC_DTLB_SZ      = 19 /* entries in data TLB */
+	SC_ITLB_ATT     = 20 /* instruction tlb associativity */
+	SC_DTLB_ATT     = 21 /* data tlb associativity */
+	SC_RESRV_SZ     = 22 /* size of reservation */
+	SC_PRI_LC       = 23 /* spin lock count in supevisor mode */
+	SC_PRO_LC       = 24 /* spin lock count in problem state */
+	SC_RTC_TYPE     = 25 /* RTC type */
+	SC_VIRT_AL      = 26 /* 1 if hardware aliasing is supported */
+	SC_CAC_CONG     = 27 /* number of page bits for cache synonym */
+	SC_MOD_ARCH     = 28 /* used by system for model determination */
+	SC_MOD_IMPL     = 29 /* used by system for model determination */
+	SC_XINT         = 30 /* used by system for time base conversion */
+	SC_XFRAC        = 31 /* used by system for time base conversion */
+	SC_KRN_ATTR     = 32 /* kernel attributes, see below */
+	SC_PHYSMEM      = 33 /* bytes of OS available memory */
+	SC_SLB_ATTR     = 34 /* SLB attributes */
+	SC_SLB_SZ       = 35 /* size of slb (0 = no slb) */
+	SC_ORIG_NCPUS   = 36 /* original number of CPUs */
+	SC_MAX_NCPUS    = 37 /* max cpus supported by this AIX image */
+	SC_MAX_REALADDR = 38 /* max supported real memory address +1 */
+	SC_ORIG_ENT_CAP = 39 /* configured entitled processor capacity at boot required by cross-partition LPAR tools. */
+	SC_ENT_CAP      = 40 /* entitled processor capacity */
+	SC_DISP_WHE     = 41 /* Dispatch wheel time period (TB units) */
+	SC_CAPINC       = 42 /* delta by which capacity can change */
+	SC_VCAPW        = 43 /* priority weight for idle capacity distribution */
+	SC_SPLP_STAT    = 44 /* State of SPLPAR enablement: 0x1 => 1=SPLPAR capable; 0=not, 0x2 => SPLPAR enabled 0=dedicated, 1=shared */
+	SC_SMT_STAT     = 45 /* State of SMT enablement: 0x1 = SMT Capable  0=no/1=yes, 0x2 = SMT Enabled  0=no/1=yes, 0x4 = SMT threads bound true 0=no/1=yes */
+	SC_SMT_TC       = 46 /* Number of SMT Threads per Physical CPU */
+	SC_VMX_VER      = 47 /* RPA defined VMX version: 0 = VMX not available or disabled, 1 = VMX capable, 2 = VMX and VSX capable */
+	SC_LMB_SZ       = 48 /* Size of an LMB on this system. */
+	SC_MAX_XCPU     = 49 /* Number of exclusive cpus on line */
+	SC_EC_LVL       = 50 /* Kernel error checking level */
+	SC_AME_STAT     = 51 /* AME status */
+	SC_ECO_STAT     = 52 /* extended cache options */
+	SC_DFP_STAT     = 53 /* RPA defined DFP version, 0=none/disabled */
+	SC_VRM_STAT     = 54 /* VRM Capable/enabled */
+	SC_PHYS_IMP     = 55 /* physical processor implementation */
+	SC_PHYS_VER     = 56 /* physical processor version */
+	SC_SPCM_STATUS  = 57
+	SC_SPCM_MAX     = 58
+	SC_TM_VER       = 59 /* Transaction Memory version, 0 - not capable */
+	SC_NX_CAP       = 60 /* NX GZIP capable */
+	SC_PKS_STATE    = 61 /* Platform KeyStore */
+)
+
+/* kernel attributes                        */
+/* bit          0/1 meaning                 */
+/* -----------------------------------------*/
+/* 31   32-bit kernel / 64-bit kernel       */
+/* 30   non-LPAR      / LPAR                */
+/* 29   old 64bit ABI / 64bit Large ABI     */
+/* 28   non-NUMA      / NUMA                */
+/* 27   UP            / MP                  */
+/* 26   no DR CPU add / DR CPU add support  */
+/* 25   no DR CPU rm  / DR CPU rm  support  */
+/* 24   no DR MEM add / DR MEM add support  */
+/* 23   no DR MEM rm  / DR MEM rm  support  */
+/* 22   kernel keys disabled / enabled      */
+/* 21   no recovery   / recovery enabled    */
+/* 20   non-MLS    / MLS enabled            */
+/* 19   enhanced affinity indicator         */
+/* 18   non-vTPM    / vTPM enabled          */
+/* 17   non-VIOS    / VIOS                  */
+
+// Values for architecture field
+const (
+	ARCH_POWER_RS = 0x0001 /* Power Classic architecture */
+	ARCH_POWER_PC = 0x0002 /* Power PC architecture */
+	ARCH_IA64     = 0x0003 /* Intel IA64 architecture */
+)
+
+// Values for implementation field for POWER_PC Architectures
+const (
+	IMPL_POWER_RS1     = 0x00001     /* RS1 class CPU */
+	IMPL_POWER_RSC     = 0x00002     /* RSC class CPU */
+	IMPL_POWER_RS2     = 0x00004     /* RS2 class CPU */
+	IMPL_POWER_601     = 0x00008     /* 601 class CPU */
+	IMPL_POWER_603     = 0x00020     /* 603 class CPU */
+	IMPL_POWER_604     = 0x00010     /* 604 class CPU */
+	IMPL_POWER_620     = 0x00040     /* 620 class CPU */
+	IMPL_POWER_630     = 0x00080     /* 630 class CPU */
+	IMPL_POWER_A35     = 0x00100     /* A35 class CPU */
+	IMPL_POWER_RS64II  = 0x0200      /* RS64-II class CPU */
+	IMPL_POWER_RS64III = 0x0400      /* RS64-III class CPU */
+	IMPL_POWER4        = 0x0800      /* 4 class CPU */
+	IMPL_POWER_RS64IV  = IMPL_POWER4 /* 4 class CPU */
+	IMPL_POWER_MPC7450 = 0x1000      /* MPC7450 class CPU */
+	IMPL_POWER5        = 0x2000      /* 5 class CPU */
+	IMPL_POWER6        = 0x4000      /* 6 class CPU */
+	IMPL_POWER7        = 0x8000      /* 7 class CPU */
+	IMPL_POWER8        = 0x10000     /* 8 class CPU */
+	IMPL_POWER9        = 0x20000     /* 9 class CPU */
+)
+
+// Values for implementation field for IA64 Architectures
+const (
+	IMPL_IA64_M1 = 0x0001 /* IA64 M1 class CPU (Itanium) */
+	IMPL_IA64_M2 = 0x0002 /* IA64 M2 class CPU */
+)
+
+// Values for the version field
+const (
+	PV_601        = 0x010001 /* Power PC 601 */
+	PV_601A       = 0x010002 /* Power PC 601 */
+	PV_603        = 0x060000 /* Power PC 603 */
+	PV_604        = 0x050000 /* Power PC 604 */
+	PV_620        = 0x070000 /* Power PC 620 */
+	PV_630        = 0x080000 /* Power PC 630 */
+	PV_A35        = 0x090000 /* Power PC A35 */
+	PV_RS64II     = 0x0A0000 /* Power PC RS64II */
+	PV_RS64III    = 0x0B0000 /* Power PC RS64III */
+	PV_4          = 0x0C0000 /* Power PC 4 */
+	PV_RS64IV     = PV_4     /* Power PC 4 */
+	PV_MPC7450    = 0x0D0000 /* Power PC MPC7450 */
+	PV_4_2        = 0x0E0000 /* Power PC 4 */
+	PV_4_3        = 0x0E0001 /* Power PC 4 */
+	PV_5          = 0x0F0000 /* Power PC 5 */
+	PV_5_2        = 0x0F0001 /* Power PC 5 */
+	PV_5_3        = 0x0F0002 /* Power PC 5 */
+	PV_6          = 0x100000 /* Power PC 6 */
+	PV_6_1        = 0x100001 /* Power PC 6 DD1.x */
+	PV_7          = 0x200000 /* Power PC 7 */
+	PV_8          = 0x300000 /* Power PC 8 */
+	PV_9          = 0x400000 /* Power PC 9 */
+	PV_5_Compat   = 0x0F8000 /* Power PC 5 */
+	PV_6_Compat   = 0x108000 /* Power PC 6 */
+	PV_7_Compat   = 0x208000 /* Power PC 7 */
+	PV_8_Compat   = 0x308000 /* Power PC 8 */
+	PV_9_Compat   = 0x408000 /* Power PC 9 */
+	PV_RESERVED_2 = 0x0A0000 /* source compatability */
+	PV_RESERVED_3 = 0x0B0000 /* source compatability */
+	PV_RS2        = 0x040000 /* Power RS2 */
+	PV_RS1        = 0x020000 /* Power RS1 */
+	PV_RSC        = 0x030000 /* Power RSC */
+	PV_M1         = 0x008000 /* Intel IA64 M1 */
+	PV_M2         = 0x008001 /* Intel IA64 M2 */
+)
+
+// Values for rtc_type
+const (
+	RTC_POWER    = 1 /* rtc as defined by Power Arch. */
+	RTC_POWER_PC = 2 /* rtc as defined by Power PC Arch. */
+	RTC_IA64     = 3 /* rtc as defined by IA64 Arch. */
+)
+
+const NX_GZIP_PRESENT = 0x00000001
+
+const (
+	PKS_STATE_CAPABLE = 1
+	PKS_STATE_ENABLED = 2
+)
+
+// Macros for identifying physical processor
+const (
+	PPI4_1 = 0x35
+	PPI4_2 = 0x38
+	PPI4_3 = 0x39
+	PPI4_4 = 0x3C
+	PPI4_5 = 0x44
+	PPI5_1 = 0x3A
+	PPI5_2 = 0x3B
+	PPI6_1 = 0x3E
+	PPI7_1 = 0x3F
+	PPI7_2 = 0x4A
+	PPI8_1 = 0x4B
+	PPI8_2 = 0x4D
+	PPI9   = 0x4E
+)
+
+// Macros for kernel attributes
+const (
+	KERN_TYPE            = 0x1
+	KERN_LPAR            = 0x2
+	KERN_64BIT_LARGE_ABI = 0x4
+	KERN_NUMA            = 0x8
+	KERN_UPMP            = 0x10
+	KERN_DR_CPU_ADD      = 0x20
+	KERN_DR_CPU_RM       = 0x40
+	KERN_DR_MEM_ADD      = 0x80
+	KERN_DR_MEM_RM       = 0x100
+	KERN_KKEY_ENABLED    = 0x200
+	KERN_RECOVERY        = 0x400
+	KERN_MLS             = 0x800
+	KERN_ENH_AFFINITY    = 0x1000
+	KERN_VTPM            = 0x2000
+	KERN_VIOS            = 0x4000
+)
+
+// macros for SPLPAR environment.
+const (
+	SPLPAR_CAPABLE        = 0x1
+	SPLPAR_ENABLED        = 0x2
+	SPLPAR_DONATE_CAPABLE = 0x4
+)
+
+// Macros for SMT status determination
+const (
+	SMT_CAPABLE = 0x1
+	SMT_ENABLE  = 0x2
+	SMT_BOUND   = 0x4
+	SMT_ORDER   = 0x8
+)
+
+// Macros for VRM status determination
+const (
+	VRM_CAPABLE  = 0x1
+	VRM_ENABLE   = 0x2
+	CMOX_CAPABLE = 0x4
+)
+
+// Macros for AME status determination
+const AME_ENABLE = 0x1
+
+// Macros for extended cache options
+const (
+	ECO_CAPABLE = 0x1
+	ECO_ENABLE  = 0x2
+)
+
+// These define blocks of values for model_arch and model_impl that are reserved for OEM use.
+const (
+	MODEL_ARCH_RSPC         = 2
+	MODEL_ARCH_CHRP         = 3
+	MODEL_ARCH_IA64         = 4
+	MODEL_ARCH_OEM_START    = 1024
+	MODEL_ARCH_OEM_END      = 2047
+	MODEL_IMPL_RS6K_UP_MCA  = 1
+	MODEL_IMPL_RS6K_SMP_MCA = 2
+	MODEL_IMPL_RSPC_UP_PCI  = 3
+	MODEL_IMPL_RSPC_SMP_PCI = 4
+	MODEL_IMPL_CHRP_UP_PCI  = 5
+	MODEL_IMPL_CHRP_SMP_PCI = 6
+	MODEL_IMPL_IA64_COM     = 7
+	MODEL_IMPL_IA64_SOFTSDV = 8
+	MODEL_IMPL_MAMBO_SIM    = 9
+	MODEL_IMPL_POWER_KVM    = 10
+	MODEL_IMPL_OEM_START    = 1024
+	MODEL_IMPL_OEM_END      = 2047
+)
+
+// example determining processor compatibilty mode on AIX:
+// impl := unix.Getsystemcfg(SC_IMPL)
+// if impl&IMPL_POWER8 != 0 {
+//     // we are running on POWER8
+// }
+// if impl&IMPL_POWER9 != 0 {
+//     // we are running on POWER9
+// }
+
+func GetCPUImplementation() string {
+	impl := unix.Getsystemcfg(SC_IMPL)
+	switch {
+	case impl&IMPL_POWER4 != 0:
+		return "POWER4"
+	case impl&IMPL_POWER5 != 0:
+		return "POWER5"
+	case impl&IMPL_POWER6 != 0:
+		return "POWER6"
+	case impl&IMPL_POWER7 != 0:
+		return "POWER7"
+	case impl&IMPL_POWER8 != 0:
+		return "POWER8"
+	case impl&IMPL_POWER9 != 0:
+		return "POWER9"
+	default:
+		return "Unknown"
+	}
+}
+
+func POWER9OrNewer() bool {
+	impl := unix.Getsystemcfg(SC_IMPL)
+	if impl&IMPL_POWER9 != 0 {
+		return true
+	}
+	return false
+}
+
+func POWER9() bool {
+	impl := unix.Getsystemcfg(SC_IMPL)
+	if impl&IMPL_POWER9 != 0 {
+		return true
+	}
+	return false
+}
+
+func POWER8OrNewer() bool {
+	impl := unix.Getsystemcfg(SC_IMPL)
+	if impl&IMPL_POWER9 != 0 || impl&IMPL_POWER8 != 0 {
+		return true
+	}
+	return false
+}
+
+func POWER8() bool {
+	impl := unix.Getsystemcfg(SC_IMPL)
+	if impl&IMPL_POWER8 != 0 {
+		return true
+	}
+	return false
+}
+
+func POWER7OrNewer() bool {
+	impl := unix.Getsystemcfg(SC_IMPL)
+	if impl&IMPL_POWER9 != 0 || impl&IMPL_POWER8 != 0 || impl&IMPL_POWER7 != 0 {
+		return true
+	}
+	return false
+}
+
+func POWER7() bool {
+	impl := unix.Getsystemcfg(SC_IMPL)
+	if impl&IMPL_POWER7 != 0 {
+		return true
+	}
+	return false
+}
+
+func HasTransactionalMemory() bool {
+	impl := unix.Getsystemcfg(SC_TM_VER)
+	if impl > 0 {
+		return true
+	}
+	return false
+}
+
+func Is64Bit() bool {
+	impl := unix.Getsystemcfg(SC_WIDTH)
+	if impl == 64 {
+		return true
+	}
+	return false
+}
+
+func IsSMP() bool {
+	impl := unix.Getsystemcfg(SC_NCPUS)
+	if impl > 1 {
+		return true
+	}
+	return false
+}
+
+func HasVMX() bool {
+	impl := unix.Getsystemcfg(SC_VMX_VER)
+	if impl > 0 {
+		return true
+	}
+	return false
+}
+
+func HasVSX() bool {
+	impl := unix.Getsystemcfg(SC_VMX_VER)
+	if impl > 1 {
+		return true
+	}
+	return false
+}
+
+func HasDFP() bool {
+	impl := unix.Getsystemcfg(SC_DFP_STAT)
+	if impl > 1 {
+		return true
+	}
+	return false
+}
+
+func HasNxGzip() bool {
+	impl := unix.Getsystemcfg(SC_NX_CAP)
+	if impl&NX_GZIP_PRESENT > 0 {
+		return true
+	}
+	return false
+}
+
+func PksCapable() bool {
+	impl := unix.Getsystemcfg(SC_PKS_STATE)
+	if impl&PKS_STATE_CAPABLE > 0 {
+		return true
+	}
+	return false
+}
+
+func PksEnabled() bool {
+	impl := unix.Getsystemcfg(SC_PKS_STATE)
+	if impl&PKS_STATE_ENABLED > 0 {
+		return true
+	}
+	return false
+}
+
+func CPUMode() string {
+	impl := unix.Getsystemcfg(SC_VERS)
+	switch impl {
+	case PV_9, PV_9_Compat:
+		return "POWER9"
+	case PV_8, PV_8_Compat:
+		return "POWER8"
+	case PV_7, PV_7_Compat:
+		return "POWER7"
+	default:
+		return "Unknown"
+	}
+}
+
+func KernelBits() int {
+	impl := unix.Getsystemcfg(SC_KRN_ATTR)
+	if impl&KERN_TYPE == KERN_TYPE {
+		return 64
+	}
+	return 32
+}
+
+func IsLPAR() bool {
+	impl := unix.Getsystemcfg(SC_KRN_ATTR)
+	if impl&KERN_LPAR == KERN_LPAR {
+		return true
+	}
+	return false
+}
+
+func CpuAddCapable() bool {
+	impl := unix.Getsystemcfg(SC_KRN_ATTR)
+	if impl&KERN_DR_CPU_ADD == KERN_DR_CPU_ADD {
+		return true
+	}
+	return false
+}
+
+func CpuRemoveCapable() bool {
+	impl := unix.Getsystemcfg(SC_KRN_ATTR)
+	if impl&KERN_DR_CPU_RM == KERN_DR_CPU_RM {
+		return true
+	}
+	return false
+}
+
+func MemoryAddCapable() bool {
+	impl := unix.Getsystemcfg(SC_KRN_ATTR)
+	if impl&KERN_DR_MEM_ADD == KERN_DR_MEM_ADD {
+		return true
+	}
+	return false
+}
+
+func MemoryRemoveCapable() bool {
+	impl := unix.Getsystemcfg(SC_KRN_ATTR)
+	if impl&KERN_DR_MEM_RM == KERN_DR_MEM_RM {
+		return true
+	}
+	return false
+}
+
+func DLparCapable() bool {
+	impl := unix.Getsystemcfg(SC_KRN_ATTR)
+	if impl&(KERN_DR_CPU_ADD|KERN_DR_CPU_RM|KERN_DR_MEM_ADD|KERN_DR_MEM_RM) > 0 {
+		return true
+	}
+	return false
+}
+
+func IsNUMA() bool {
+	impl := unix.Getsystemcfg(SC_KRN_ATTR)
+	if impl&KERN_NUMA > 0 {
+		return true
+	}
+	return false
+}
+
+func KernelKeys() bool {
+	impl := unix.Getsystemcfg(SC_KRN_ATTR)
+	if impl&KERN_KKEY_ENABLED > 0 {
+		return true
+	}
+	return false
+}
+
+func RecoveryMode() bool {
+	impl := unix.Getsystemcfg(SC_KRN_ATTR)
+	if impl&KERN_RECOVERY > 0 {
+		return true
+	}
+	return false
+}
+
+func EnhancedAffinity() bool {
+	impl := unix.Getsystemcfg(SC_KRN_ATTR)
+	if impl&KERN_ENH_AFFINITY > 0 {
+		return true
+	}
+	return false
+}
+
+func VTpmEnabled() bool {
+	impl := unix.Getsystemcfg(SC_KRN_ATTR)
+	if impl&KERN_VTPM > 0 {
+		return true
+	}
+	return false
+}
+
+func IsVIOS() bool {
+	impl := unix.Getsystemcfg(SC_KRN_ATTR)
+	if impl&KERN_VIOS > 0 {
+		return true
+	}
+	return false
+}
+
+func MLSEnabled() bool {
+	impl := unix.Getsystemcfg(SC_KRN_ATTR)
+	if impl&KERN_MLS > 0 {
+		return true
+	}
+	return false
+}
+
+func SPLparCapable() bool {
+	impl := unix.Getsystemcfg(SC_SPLP_STAT)
+	if impl&SPLPAR_CAPABLE > 0 {
+		return true
+	}
+	return false
+}
+
+func SPLparEnabled() bool {
+	impl := unix.Getsystemcfg(SC_SPLP_STAT)
+	if impl&SPLPAR_ENABLED > 0 {
+		return true
+	}
+	return false
+}
+
+func DedicatedLpar() bool {
+	return !SPLparEnabled()
+}
+
+func SPLparCapped() bool {
+	impl := unix.Getsystemcfg(SC_VCAPW)
+	if impl == 0 {
+		return true
+	}
+	return false
+}
+
+func SPLparDonating() bool {
+	impl := unix.Getsystemcfg(SC_SPLP_STAT)
+	if impl&SPLPAR_DONATE_CAPABLE > 0 {
+		return true
+	}
+	return false
+}
+
+func SmtCapable() bool {
+	impl := unix.Getsystemcfg(SC_SMT_STAT)
+	if impl&SMT_CAPABLE > 0 {
+		return true
+	}
+	return false
+}
+
+func SmtEnabled() bool {
+	impl := unix.Getsystemcfg(SC_SMT_STAT)
+	if impl&SMT_ENABLE > 0 {
+		return true
+	}
+	return false
+}
+
+func VrmCapable() bool {
+	impl := unix.Getsystemcfg(SC_VRM_STAT)
+	if impl&VRM_CAPABLE > 0 {
+		return true
+	}
+	return false
+}
+
+func VrmEnabled() bool {
+	impl := unix.Getsystemcfg(SC_VRM_STAT)
+	if impl&VRM_ENABLE > 0 {
+		return true
+	}
+	return false
+}
+
+func AmeEnabled() bool {
+	impl := unix.Getsystemcfg(SC_AME_STAT)
+	if impl&AME_ENABLE > 0 {
+		return true
+	}
+	return false
+}
+
+func EcoCapable() bool {
+	impl := unix.Getsystemcfg(SC_ECO_STAT)
+	if impl&ECO_CAPABLE > 0 {
+		return true
+	}
+	return false
+}
+
+func EcoEnabled() bool {
+	impl := unix.Getsystemcfg(SC_ECO_STAT)
+	if impl&ECO_ENABLE > 0 {
+		return true
+	}
+	return false
+}

vendor/github.com/power-devops/perfstat/types_cpu.go

@@ -0,0 +1,186 @@
+package perfstat
+
+type CPU struct {
+	Name             string /* logical processor name (cpu0, cpu1, ..) */
+	User             int64  /* raw number of clock ticks spent in user mode */
+	Sys              int64  /* raw number of clock ticks spent in system mode */
+	Idle             int64  /* raw number of clock ticks spent idle */
+	Wait             int64  /* raw number of clock ticks spent waiting for I/O */
+	PSwitch          int64  /* number of context switches (changes of currently running process) */
+	Syscall          int64  /* number of system calls executed */
+	Sysread          int64  /* number of read system calls executed */
+	Syswrite         int64  /* number of write system calls executed */
+	Sysfork          int64  /* number of fork system call executed */
+	Sysexec          int64  /* number of exec system call executed */
+	Readch           int64  /* number of characters tranferred with read system call */
+	Writech          int64  /* number of characters tranferred with write system call */
+	Bread            int64  /* number of block reads */
+	Bwrite           int64  /* number of block writes */
+	Lread            int64  /* number of logical read requests */
+	Lwrite           int64  /* number of logical write requests */
+	Phread           int64  /* number of physical reads (reads on raw device) */
+	Phwrite          int64  /* number of physical writes (writes on raw device) */
+	Iget             int64  /* number of inode lookups */
+	Namei            int64  /* number of vnode lookup from a path name */
+	Dirblk           int64  /* number of 512-byte block reads by the directory search routine to locate an entry for a file */
+	Msg              int64  /* number of IPC message operations */
+	Sema             int64  /* number of IPC semaphore operations  */
+	MinFaults        int64  /* number of page faults with no I/O */
+	MajFaults        int64  /* number of page faults with disk I/O */
+	PUser            int64  /* raw number of physical processor tics in user mode */
+	PSys             int64  /* raw number of physical processor tics in system mode */
+	PIdle            int64  /* raw number of physical processor tics idle */
+	PWait            int64  /* raw number of physical processor tics waiting for I/O */
+	RedispSD0        int64  /* number of thread redispatches within the scheduler affinity domain 0 */
+	RedispSD1        int64  /* number of thread redispatches within the scheduler affinity domain 1 */
+	RedispSD2        int64  /* number of thread redispatches within the scheduler affinity domain 2 */
+	RedispSD3        int64  /* number of thread redispatches within the scheduler affinity domain 3 */
+	RedispSD4        int64  /* number of thread redispatches within the scheduler affinity domain 4 */
+	RedispSD5        int64  /* number of thread redispatches within the scheduler affinity domain 5 */
+	MigrationPush    int64  /* number of thread migrations from the local runque to another queue due to starvation load balancing */
+	MigrationS3grq   int64  /* number of  thread migrations from the global runque to the local runque resulting in a move accross scheduling domain 3 */
+	MigrationS3pul   int64  /* number of  thread migrations from another processor's runque resulting in a move accross scheduling domain 3 */
+	InvolCSwitch     int64  /* number of  involuntary thread context switches */
+	VolCSwitch       int64  /* number of  voluntary thread context switches */
+	RunQueue         int64  /* number of  threads on the runque */
+	Bound            int64  /* number of  bound threads */
+	DecrIntrs        int64  /* number of decrementer tics interrupts */
+	MpcRIntrs        int64  /* number of mpc's received interrupts */
+	MpcSIntrs        int64  /* number of mpc's sent interrupts */
+	DevIntrs         int64  /* number of device interrupts */
+	SoftIntrs        int64  /* number of offlevel handlers called */
+	PhantIntrs       int64  /* number of phantom interrupts */
+	IdleDonatedPurr  int64  /* number of idle cycles donated by a dedicated partition enabled for donation */
+	IdleDonatedSpurr int64  /* number of idle spurr cycles donated by a dedicated partition enabled for donation */
+	BusyDonatedPurr  int64  /* number of busy cycles donated by a dedicated partition enabled for donation */
+	BusyDonatedSpurr int64  /* number of busy spurr cycles donated by a dedicated partition enabled for donation */
+	IdleStolenPurr   int64  /* number of idle cycles stolen by the hypervisor from a dedicated partition */
+	IdleStolenSpurr  int64  /* number of idle spurr cycles stolen by the hypervisor from a dedicated partition */
+	BusyStolenPurr   int64  /* number of busy cycles stolen by the hypervisor from a dedicated partition */
+	BusyStolenSpurr  int64  /* number of busy spurr cycles stolen by the hypervisor from a dedicated partition */
+	Hpi              int64  /* number of hypervisor page-ins */
+	Hpit             int64  /* Time spent in hypervisor page-ins (in nanoseconds)*/
+	PUserSpurr       int64  /* number of spurr cycles spent in user mode */
+	PSysSpurr        int64  /* number of spurr cycles spent in kernel mode */
+	PIdleSpurr       int64  /* number of spurr cycles spent in idle mode */
+	PWaitSpurr       int64  /* number of spurr cycles spent in wait mode */
+	SpurrFlag        int32  /* set if running in spurr mode */
+	LocalDispatch    int64  /* number of local thread dispatches on this logical CPU */
+	NearDispatch     int64  /* number of near thread dispatches on this logical CPU */
+	FarDispatch      int64  /* number of far thread dispatches on this logical CPU */
+	CSwitches        int64  /* Context switches */
+	Version          int64  /* version number (1, 2, etc.,) */
+	TbLast           int64  /* timebase counter */
+	State            int    /* Show whether the CPU is offline or online */
+	VtbLast          int64  /* Last virtual timebase read */
+	ICountLast       int64  /* Last instruction count read */
+}
+
+type CPUTotal struct {
+	NCpus            int     /* number of active logical processors */
+	NCpusCfg         int     /* number of configured processors */
+	Description      string  /* processor description (type/official name) */
+	ProcessorHz      int64   /* processor speed in Hz */
+	User             int64   /*  raw total number of clock ticks spent in user mode */
+	Sys              int64   /* raw total number of clock ticks spent in system mode */
+	Idle             int64   /* raw total number of clock ticks spent idle */
+	Wait             int64   /* raw total number of clock ticks spent waiting for I/O */
+	PSwitch          int64   /* number of process switches (change in currently running process) */
+	Syscall          int64   /* number of system calls executed */
+	Sysread          int64   /* number of read system calls executed */
+	Syswrite         int64   /* number of write system calls executed */
+	Sysfork          int64   /* number of forks system calls executed */
+	Sysexec          int64   /* number of execs system calls executed */
+	Readch           int64   /* number of characters tranferred with read system call */
+	Writech          int64   /* number of characters tranferred with write system call */
+	DevIntrs         int64   /* number of device interrupts */
+	SoftIntrs        int64   /* number of software interrupts */
+	Lbolt            int64   /* number of ticks since last reboot */
+	LoadAvg1         float32 /* times the average number of runnables processes during the last 1, 5 and 15 minutes.    */
+	LoadAvg5         float32 /* times the average number of runnables processes during the last 1, 5 and 15 minutes.    */
+	LoadAvg15        float32 /* times the average number of runnables processes during the last 1, 5 and 15 minutes.    */
+	RunQueue         int64   /* length of the run queue (processes ready) */
+	SwpQueue         int64   /* length of the swap queue (processes waiting to be paged in) */
+	Bread            int64   /* number of blocks read */
+	Bwrite           int64   /* number of blocks written */
+	Lread            int64   /* number of logical read requests */
+	Lwrite           int64   /* number of logical write requests */
+	Phread           int64   /* number of physical reads (reads on raw devices) */
+	Phwrite          int64   /* number of physical writes (writes on raw devices) */
+	RunOcc           int64   /* updated whenever runque is updated, i.e. the runqueue is occupied. This can be used to compute the simple average of ready processes  */
+	SwpOcc           int64   /* updated whenever swpque is updated. i.e. the swpqueue is occupied. This can be used to compute the simple average processes waiting to be paged in */
+	Iget             int64   /* number of inode lookups */
+	Namei            int64   /* number of vnode lookup from a path name */
+	Dirblk           int64   /* number of 512-byte block reads by the directory search routine to locate an entry for a file */
+	Msg              int64   /* number of IPC message operations */
+	Sema             int64   /* number of IPC semaphore operations */
+	RcvInt           int64   /* number of tty receive interrupts */
+	XmtInt           int64   /* number of tyy transmit interrupts */
+	MdmInt           int64   /* number of modem interrupts */
+	TtyRawInch       int64   /* number of raw input characters  */
+	TtyCanInch       int64   /* number of canonical input characters (always zero) */
+	TtyRawOutch      int64   /* number of raw output characters */
+	Ksched           int64   /* number of kernel processes created */
+	Koverf           int64   /* kernel process creation attempts where: -the user has forked to their maximum limit -the configuration limit of processes has been reached */
+	Kexit            int64   /* number of kernel processes that became zombies */
+	Rbread           int64   /* number of remote read requests */
+	Rcread           int64   /* number of cached remote reads */
+	Rbwrt            int64   /* number of remote writes */
+	Rcwrt            int64   /* number of cached remote writes */
+	Traps            int64   /* number of traps */
+	NCpusHigh        int64   /* index of highest processor online */
+	PUser            int64   /* raw number of physical processor tics in user mode */
+	PSys             int64   /* raw number of physical processor tics in system mode */
+	PIdle            int64   /* raw number of physical processor tics idle */
+	PWait            int64   /* raw number of physical processor tics waiting for I/O */
+	DecrIntrs        int64   /* number of decrementer tics interrupts */
+	MpcRIntrs        int64   /* number of mpc's received interrupts */
+	MpcSIntrs        int64   /* number of mpc's sent interrupts */
+	PhantIntrs       int64   /* number of phantom interrupts */
+	IdleDonatedPurr  int64   /* number of idle cycles donated by a dedicated partition enabled for donation */
+	IdleDonatedSpurr int64   /* number of idle spurr cycles donated by a dedicated partition enabled for donation */
+	BusyDonatedPurr  int64   /* number of busy cycles donated by a dedicated partition enabled for donation */
+	BusyDonatedSpurr int64   /* number of busy spurr cycles donated by a dedicated partition enabled for donation */
+	IdleStolenPurr   int64   /* number of idle cycles stolen by the hypervisor from a dedicated partition */
+	IdleStolenSpurr  int64   /* number of idle spurr cycles stolen by the hypervisor from a dedicated partition */
+	BusyStolenPurr   int64   /* number of busy cycles stolen by the hypervisor from a dedicated partition */
+	BusyStolenSpurr  int64   /* number of busy spurr cycles stolen by the hypervisor from a dedicated partition */
+	IOWait           int32   /* number of processes that are asleep waiting for buffered I/O */
+	PhysIO           int32   /* number of processes waiting for raw I/O */
+	TWait            int64   /* number of threads that are waiting for filesystem direct(cio) */
+	Hpi              int64   /* number of hypervisor page-ins */
+	Hpit             int64   /* Time spent in hypervisor page-ins (in nanoseconds) */
+	PUserSpurr       int64   /* number of spurr cycles spent in user mode */
+	PSysSpurr        int64   /* number of spurr cycles spent in kernel mode */
+	PIdleSpurr       int64   /* number of spurr cycles spent in idle mode */
+	PWaitSpurr       int64   /* number of spurr cycles spent in wait mode */
+	SpurrFlag        int     /* set if running in spurr mode */
+	Version          int64   /* version number (1, 2, etc.,) */
+	TbLast           int64   /*time base counter */
+	PurrCoalescing   int64   /* If the calling partition is authorized to see pool wide statistics then PURR cycles consumed to coalesce data else set to zero.*/
+	SpurrCoalescing  int64   /* If the calling partition is authorized to see pool wide statistics then SPURR cycles consumed to coalesce data else set to zero.  */
+}
+
+type CPUUtil struct {
+	Version          int64
+	CpuID            string  /* holds the id of the cpu */
+	Entitlement      float32 /* Partition's entitlement */
+	UserPct          float32 /* % of utilization in user mode */
+	KernPct          float32 /* % of utilization in kernel mode */
+	IdlePct          float32 /* % of utilization in idle mode */
+	WaitPct          float32 /* % of utilization in wait mode */
+	PhysicalBusy     float32 /* physical cpus busy */
+	PhysicalConsumed float32 /* total cpus consumed by the partition */
+	FreqPct          float32 /* Average freq% over the last interval */
+	EntitlementPct   float32 /* % of entitlement used */
+	BusyPct          float32 /* % of entitlement busy */
+	IdleDonatedPct   float32 /* % idle cycles donated */
+	BusyDonatedPct   float32 /* % of busy cycles donated */
+	IdleStolenPct    float32 /* % idle cycles stolen */
+	BusyStolenPct    float32 /* % busy cycles stolen */
+	LUserPct         float32 /* % of utilization in user mode, in terms of logical processor ticks */
+	LKernPct         float32 /* % of utilization in kernel mode, in terms of logical processor ticks*/
+	LIdlePct         float32 /* % of utilization in idle mode, in terms of logical processor ticks */
+	LWaitPct         float32 /* % of utilization in wait mode, in terms of logical processor ticks */
+	DeltaTime        int64   /*   delta time in milliseconds, for which utilization is evaluated */
+}

vendor/github.com/power-devops/perfstat/types_disk.go

@@ -0,0 +1,176 @@
+package perfstat
+
+type DiskTotal struct {
+	Number    int32 /* total number of disks */
+	Size      int64 /* total size of all disks (in MB) */
+	Free      int64 /* free portion of all disks (in MB) */
+	XRate     int64 /* __rxfers: total number of transfers from disk */
+	Xfers     int64 /* total number of transfers to/from disk */
+	Wblks     int64 /* 512 bytes blocks written to all disks */
+	Rblks     int64 /* 512 bytes blocks read from all disks */
+	Time      int64 /* amount of time disks are active */
+	Version   int64 /* version number (1, 2, etc.,) */
+	Rserv     int64 /* Average read or receive service time */
+	MinRserv  int64 /* min read or receive service time */
+	MaxRserv  int64 /* max read or receive service time */
+	RTimeOut  int64 /* number of read request timeouts */
+	RFailed   int64 /* number of failed read requests */
+	Wserv     int64 /* Average write or send service time */
+	MinWserv  int64 /* min write or send service time */
+	MaxWserv  int64 /* max write or send service time */
+	WTimeOut  int64 /* number of write request timeouts */
+	WFailed   int64 /* number of failed write requests */
+	WqDepth   int64 /* instantaneous wait queue depth (number of requests waiting to be sent to disk) */
+	WqTime    int64 /* accumulated wait queueing time */
+	WqMinTime int64 /* min wait queueing time */
+	WqMaxTime int64 /* max wait queueing time */
+}
+
+// Disk Adapter Types
+const (
+	DA_SCSI  = 0 /* 0 ==> SCSI, SAS, other legacy adapter types */
+	DA_VSCSI     /* 1 ==> Virtual SCSI/SAS Adapter */
+	DA_FCA       /* 2 ==> Fiber Channel Adapter */
+)
+
+type DiskAdapter struct {
+	Name        string /* name of the adapter (from ODM) */
+	Description string /* adapter description (from ODM) */
+	Number      int32  /* number of disks connected to adapter */
+	Size        int64  /* total size of all disks (in MB)  */
+	Free        int64  /* free portion of all disks (in MB)  */
+	XRate       int64  /* __rxfers: total number of reads via adapter */
+	Xfers       int64  /* total number of transfers via adapter */
+	Rblks       int64  /* 512 bytes blocks written via adapter */
+	Wblks       int64  /* 512 bytes blocks read via adapter  */
+	Time        int64  /* amount of time disks are active */
+	Version     int64  /* version number (1, 2, etc.,) */
+	AdapterType int64  /* 0 ==> SCSI, SAS, other legacy adapter types, 1 ==> Virtual SCSI/SAS Adapter, 2 ==> Fiber Channel Adapter */
+	DkBSize     int64  /* Number of Bytes in a block for this disk*/
+	DkRxfers    int64  /* Number of transfers from disk */
+	DkRserv     int64  /* read or receive service time */
+	DkWserv     int64  /* write or send service time */
+	MinRserv    int64  /* Minimum read service time */
+	MaxRserv    int64  /* Maximum read service time */
+	MinWserv    int64  /* Minimum Write service time */
+	MaxWserv    int64  /* Maximum write service time */
+	WqDepth     int64  /* driver wait queue depth */
+	WqSampled   int64  /* accumulated sampled dk_wq_depth */
+	WqTime      int64  /* accumulated wait queueing time */
+	WqMinTime   int64  /* minimum wait queueing time */
+	WqMaxTime   int64  /* maximum wait queueing time */
+	QFull       int64  /* "Service" queue full occurrence count (number of times the adapter/devices connected to the adapter is not accepting any more request) */
+	QSampled    int64  /* accumulated sampled */
+}
+
+type Disk struct {
+	Name        string /* name of the disk */
+	Description string /* disk description (from ODM) */
+	VGName      string /* volume group name (from ODM) */
+	Size        int64  /* size of the disk (in MB) */
+	Free        int64  /* free portion of the disk (in MB) */
+	BSize       int64  /* disk block size (in bytes) */
+	XRate       int64  /* number of transfers from disk */
+	Xfers       int64  /* number of transfers to/from disk */
+	Wblks       int64  /* number of blocks written to disk */
+	Rblks       int64  /* number of blocks read from disk */
+	QDepth      int64  /* instantaneous "service" queue depth (number of requests sent to disk and not completed yet) */
+	Time        int64  /* amount of time disk is active */
+	Adapter     string /* disk adapter name */
+	PathsCount  int32  /* number of paths to this disk */
+	QFull       int64  /* "service" queue full occurrence count (number of times the disk is not accepting any more request) */
+	Rserv       int64  /* read or receive service time */
+	RTimeOut    int64  /* number of read request timeouts */
+	Rfailed     int64  /* number of failed read requests */
+	MinRserv    int64  /* min read or receive service time */
+	MaxRserv    int64  /* max read or receive service time */
+	Wserv       int64  /* write or send service time */
+	WTimeOut    int64  /* number of write request timeouts */
+	Wfailed     int64  /* number of failed write requests */
+	MinWserv    int64  /* min write or send service time */
+	MaxWserv    int64  /* max write or send service time */
+	WqDepth     int64  /* instantaneous wait queue depth (number of requests waiting to be sent to disk) */
+	WqSampled   int64  /* accumulated sampled dk_wq_depth */
+	WqTime      int64  /* accumulated wait queueing time */
+	WqMinTime   int64  /* min wait queueing time */
+	WqMaxTime   int64  /* max wait queueing time */
+	QSampled    int64  /* accumulated sampled dk_q_depth */
+	Version     int64  /* version number (1, 2, etc.,) */
+	PseudoDisk  bool   /*Indicates whether pseudo or physical disk */
+	VTDisk      bool   /* 1- Virtual Target Disk, 0 - Others */
+}
+
+type DiskPath struct {
+	Name      string /* name of the path */
+	XRate     int64  /* __rxfers: number of reads via the path */
+	Xfers     int64  /* number of transfers via the path */
+	Rblks     int64  /* 512 bytes blocks written via the path */
+	Wblks     int64  /* 512 bytes blocks read via the path  */
+	Time      int64  /* amount of time disks are active */
+	Adapter   string /* disk adapter name (from ODM) */
+	QFull     int64  /* "service" queue full occurrence count (number of times the disk is not accepting any more request) */
+	Rserv     int64  /* read or receive service time */
+	RTimeOut  int64  /* number of read request timeouts */
+	Rfailed   int64  /* number of failed read requests */
+	MinRserv  int64  /* min read or receive service time */
+	MaxRserv  int64  /* max read or receive service time */
+	Wserv     int64  /* write or send service time */
+	WTimeOut  int64  /* number of write request timeouts */
+	Wfailed   int64  /* number of failed write requests */
+	MinWserv  int64  /* min write or send service time */
+	MaxWserv  int64  /* max write or send service time */
+	WqDepth   int64  /* instantaneous wait queue depth (number of requests waiting to be sent to disk) */
+	WqSampled int64  /* accumulated sampled dk_wq_depth */
+	WqTime    int64  /* accumulated wait queueing time */
+	WqMinTime int64  /* min wait queueing time */
+	WqMaxTime int64  /* max wait queueing time */
+	QSampled  int64  /* accumulated sampled dk_q_depth */
+	Version   int64  /* version number (1, 2, etc.,)   */
+}
+
+const (
+	FC_DOWN = 0 // FC Adapter state is DOWN
+	FC_UP   = 1 // FC Adapter state is UP
+)
+
+const (
+	FCT_FCHBA = 0 // FC type - real Fiber Channel Adapter
+	FCT_VFC   = 1 // FC type - virtual Fiber Channel
+)
+
+type FCAdapter struct {
+	Version                      int64  /* version number (1, 2, etc.,) */
+	Name                         string /* name of the adapter */
+	State                        int32  /* FC Adapter state  UP or DOWN */
+	InputRequests                int64  /* Number of Input Requests*/
+	OutputRequests               int64  /* Number of Output Requests */
+	InputBytes                   int64  /* Number of Input Bytes */
+	OutputBytes                  int64  /* Number of Output Bytes */
+	EffMaxTransfer               int64  /* Adapter's Effective Maximum  Transfer Value */
+	NoDMAResourceCnt             int64  /* Count of DMA failures due to no DMA Resource available */
+	NoCmdResourceCnt             int64  /* Count of failures to allocate a command due to no command resource available */
+	AttentionType                int32  /* Link up or down Indicator */
+	SecondsSinceLastReset        int64  /* Displays the seconds since last reset of the statistics on the adapter */
+	TxFrames                     int64  /* Number of frames transmitted */
+	TxWords                      int64  /* Fiber Channel Kbytes transmitted */
+	RxFrames                     int64  /* Number of Frames Received */
+	RxWords                      int64  /* Fiber Channel Kbytes Received */
+	LIPCount                     int64  /* Count of LIP (Loop Initialization Protocol) Events received in case we have FC-AL */
+	NOSCount                     int64  /* Count of NOS (Not_Operational) Events. This indicates a link failure state. */
+	ErrorFrames                  int64  /* Number of frames received with the CRC Error */
+	DumpedFrames                 int64  /* Number of lost frames */
+	LinkFailureCount             int64  /* Count of Link failures */
+	LossofSyncCount              int64  /* Count of loss of sync */
+	LossofSignal                 int64  /* Count of loss of Signal */
+	PrimitiveSeqProtocolErrCount int64  /* number of times a primitive sequence was in error */
+	InvalidTxWordCount           int64  /* Count of Invalid Transmission words received */
+	InvalidCRCCount              int64  /* Count of CRC Errors in a Received Frame */
+	PortFcId                     int64  /* SCSI Id of the adapter */
+	PortSpeed                    int64  /* Speed of Adapter in GBIT */
+	PortType                     string /* Type of connection. The Possible Values are Fabric, Private Loop, Point-to-Point, unknown */
+	PortWWN                      int64  /* World Wide Port name */
+	PortSupportedSpeed           int64  /* Supported Port Speed in GBIT */
+	AdapterType                  int    /* 0 - Fiber Chanel, 1 - Virtual Fiber Chanel Adapter */
+	VfcName                      string /* name of the Virtual Fiber Chanel(VFC) adapter */
+	ClientPartName               string /* name of the client partition */
+}

vendor/github.com/power-devops/perfstat/types_fs.go

@@ -0,0 +1,195 @@
+package perfstat
+
+import (
+	"strings"
+)
+
+type FileSystem struct {
+	Device      string /* name of the mounted device */
+	MountPoint  string /* where the device is mounted */
+	FSType      int    /* File system type, see the constants below */
+	Flags       uint   /* Flags of the file system */
+	TotalBlocks int64  /* number of 512 bytes blocks in the filesystem */
+	FreeBlocks  int64  /* number of free 512 bytes block in the filesystem */
+	TotalInodes int64  /* total number of inodes in the filesystem */
+	FreeInodes  int64  /* number of free inodes in the filesystem */
+}
+
+func (f *FileSystem) TypeString() string {
+	switch f.FSType {
+	case FS_JFS2:
+		return "jfs2"
+	case FS_NAMEFS:
+		return "namefs"
+	case FS_NFS:
+		return "nfs"
+	case FS_JFS:
+		return "jfs"
+	case FS_CDROM:
+		return "cdrfs"
+	case FS_PROCFS:
+		return "procfs"
+	case FS_SFS:
+		return "sfs"
+	case FS_CACHEFS:
+		return "cachefs"
+	case FS_NFS3:
+		return "nfs3"
+	case FS_AUTOFS:
+		return "autofs"
+	case FS_POOLFS:
+		return "poolfs"
+	case FS_VXFS:
+		return "vxfs"
+	case FS_VXODM:
+		return "vxodm"
+	case FS_UDF:
+		return "udfs"
+	case FS_NFS4:
+		return "nfs4"
+	case FS_RFS4:
+		return "rfs4"
+	case FS_CIFS:
+		return "cifs"
+	case FS_PMEMFS:
+		return "pmemfs"
+	case FS_AHAFS:
+		return "ahafs"
+	case FS_STNFS:
+		return "stnfs"
+	case FS_ASMFS:
+		return "asmfs"
+	}
+	return "unknown"
+}
+
+func (f *FileSystem) FlagsString() string {
+	var flags []string
+
+	switch {
+	case f.Flags&VFS_READONLY != 0:
+		flags = append(flags, "ro")
+	case f.Flags&VFS_REMOVABLE != 0:
+		flags = append(flags, "removable")
+	case f.Flags&VFS_DEVMOUNT != 0:
+		flags = append(flags, "local")
+	case f.Flags&VFS_REMOTE != 0:
+		flags = append(flags, "remote")
+	case f.Flags&VFS_SYSV_MOUNT != 0:
+		flags = append(flags, "sysv")
+	case f.Flags&VFS_UNMOUNTING != 0:
+		flags = append(flags, "unmounting")
+	case f.Flags&VFS_NOSUID != 0:
+		flags = append(flags, "nosuid")
+	case f.Flags&VFS_NODEV != 0:
+		flags = append(flags, "nodev")
+	case f.Flags&VFS_NOINTEG != 0:
+		flags = append(flags, "nointeg")
+	case f.Flags&VFS_NOMANAGER != 0:
+		flags = append(flags, "nomanager")
+	case f.Flags&VFS_NOCASE != 0:
+		flags = append(flags, "nocase")
+	case f.Flags&VFS_UPCASE != 0:
+		flags = append(flags, "upcase")
+	case f.Flags&VFS_NBC != 0:
+		flags = append(flags, "nbc")
+	case f.Flags&VFS_MIND != 0:
+		flags = append(flags, "mind")
+	case f.Flags&VFS_RBR != 0:
+		flags = append(flags, "rbr")
+	case f.Flags&VFS_RBW != 0:
+		flags = append(flags, "rbw")
+	case f.Flags&VFS_DISCONNECTED != 0:
+		flags = append(flags, "disconnected")
+	case f.Flags&VFS_SHUTDOWN != 0:
+		flags = append(flags, "shutdown")
+	case f.Flags&VFS_VMOUNTOK != 0:
+		flags = append(flags, "vmountok")
+	case f.Flags&VFS_SUSER != 0:
+		flags = append(flags, "suser")
+	case f.Flags&VFS_SOFT_MOUNT != 0:
+		flags = append(flags, "soft")
+	case f.Flags&VFS_UNMOUNTED != 0:
+		flags = append(flags, "unmounted")
+	case f.Flags&VFS_DEADMOUNT != 0:
+		flags = append(flags, "deadmount")
+	case f.Flags&VFS_SNAPSHOT != 0:
+		flags = append(flags, "snapshot")
+	case f.Flags&VFS_VCM_ON != 0:
+		flags = append(flags, "vcm_on")
+	case f.Flags&VFS_VCM_MONITOR != 0:
+		flags = append(flags, "vcm_monitor")
+	case f.Flags&VFS_ATIMEOFF != 0:
+		flags = append(flags, "noatime")
+	case f.Flags&VFS_READMOSTLY != 0:
+		flags = append(flags, "readmostly")
+	case f.Flags&VFS_CIOR != 0:
+		flags = append(flags, "cior")
+	case f.Flags&VFS_CIO != 0:
+		flags = append(flags, "cio")
+	case f.Flags&VFS_DIO != 0:
+		flags = append(flags, "dio")
+	}
+
+	return strings.Join(flags, ",")
+}
+
+// Filesystem types
+const (
+	FS_JFS2    = 0  /* AIX physical fs "jfs2" */
+	FS_NAMEFS  = 1  /* AIX pseudo fs "namefs" */
+	FS_NFS     = 2  /* SUN Network File System "nfs" */
+	FS_JFS     = 3  /* AIX R3 physical fs "jfs" */
+	FS_CDROM   = 5  /* CDROM File System "cdrom" */
+	FS_PROCFS  = 6  /* PROCFS File System "proc" */
+	FS_SFS     = 16 /* AIX Special FS (STREAM mounts) */
+	FS_CACHEFS = 17 /* Cachefs file system */
+	FS_NFS3    = 18 /* NFSv3 file system */
+	FS_AUTOFS  = 19 /* Automount file system */
+	FS_POOLFS  = 20 /* Pool file system */
+	FS_VXFS    = 32 /* THRPGIO File System "vxfs" */
+	FS_VXODM   = 33 /* For Veritas File System */
+	FS_UDF     = 34 /* UDFS file system */
+	FS_NFS4    = 35 /* NFSv4 file system */
+	FS_RFS4    = 36 /* NFSv4 Pseudo file system */
+	FS_CIFS    = 37 /* AIX SMBFS (CIFS client) */
+	FS_PMEMFS  = 38 /* MCR Async Mobility pseudo file system */
+	FS_AHAFS   = 39 /* AHAFS File System "aha" */
+	FS_STNFS   = 40 /* Short-Term NFS */
+	FS_ASMFS   = 41 /* Oracle ASM FS */
+)
+
+// Filesystem flags
+const (
+	VFS_READONLY     = 0x00000001 /* rdonly access to vfs */
+	VFS_REMOVABLE    = 0x00000002 /* removable (diskette) media */
+	VFS_DEVMOUNT     = 0x00000004 /* physical device mount */
+	VFS_REMOTE       = 0x00000008 /* file system is on network */
+	VFS_SYSV_MOUNT   = 0x00000010 /* System V style mount */
+	VFS_UNMOUNTING   = 0x00000020 /* originated by unmount() */
+	VFS_NOSUID       = 0x00000040 /* don't maintain suid-ness across this mount */
+	VFS_NODEV        = 0x00000080 /* don't allow device access across this mount */
+	VFS_NOINTEG      = 0x00000100 /* no integrity mount option */
+	VFS_NOMANAGER    = 0x00000200 /* mount managed fs w/o manager */
+	VFS_NOCASE       = 0x00000400 /* do not map dir names */
+	VFS_UPCASE       = 0x00000800 /* map dir names to uppercase */
+	VFS_NBC          = 0x00001000 /* NBC cached file in this vfs */
+	VFS_MIND         = 0x00002000 /* multi-segment .indirect */
+	VFS_RBR          = 0x00004000 /* Release-behind when reading */
+	VFS_RBW          = 0x00008000 /* Release-behind when writing */
+	VFS_DISCONNECTED = 0x00010000 /* file mount not in use */
+	VFS_SHUTDOWN     = 0x00020000 /* forced unmount for shutdown */
+	VFS_VMOUNTOK     = 0x00040000 /* dir/file mnt permission flag */
+	VFS_SUSER        = 0x00080000 /* client-side suser perm. flag */
+	VFS_SOFT_MOUNT   = 0x00100000 /* file-over-file or directory over directory "soft" mount */
+	VFS_UNMOUNTED    = 0x00200000 /* unmount completed, stale vnodes are left in the vfs */
+	VFS_DEADMOUNT    = 0x00400000 /* softmount vfs should be disconnected at last vnode free */
+	VFS_SNAPSHOT     = 0x00800000 /* snapshot mount */
+	VFS_VCM_ON       = 0x01000000 /* VCM is currently active */
+	VFS_VCM_MONITOR  = 0x02000000 /* VCM monitoring is active */
+	VFS_ATIMEOFF     = 0x04000000 /* no atime updates during i/o */
+	VFS_READMOSTLY   = 0x10000000 /* ROFS allows open for write */
+	VFS_CIOR         = 0x20000000 /* O_CIOR mount */
+	VFS_CIO          = 0x40000000 /* O_CIO mount */
+	VFS_DIO          = 0x80000000 /* O_DIRECT mount */
+)

vendor/github.com/power-devops/perfstat/types_lpar.go

@@ -0,0 +1,68 @@
+package perfstat
+
+type PartitionType struct {
+	SmtCapable        bool /* OS supports SMT mode */
+	SmtEnabled        bool /* SMT mode is on */
+	LparCapable       bool /* OS supports logical partitioning */
+	LparEnabled       bool /* logical partitioning is on */
+	SharedCapable     bool /* OS supports shared processor LPAR */
+	SharedEnabled     bool /* partition runs in shared mode */
+	DLparCapable      bool /* OS supports dynamic LPAR */
+	Capped            bool /* partition is capped */
+	Kernel64bit       bool /* kernel is 64 bit */
+	PoolUtilAuthority bool /* pool utilization available */
+	DonateCapable     bool /* capable of donating cycles */
+	DonateEnabled     bool /* enabled for donating cycles */
+	AmsCapable        bool /* 1 = AMS(Active Memory Sharing) capable, 0 = Not AMS capable */
+	AmsEnabled        bool /* 1 = AMS(Active Memory Sharing) enabled, 0 = Not AMS enabled */
+	PowerSave         bool /*1= Power saving mode is enabled*/
+	AmeEnabled        bool /* Active Memory Expansion is enabled */
+	SharedExtended    bool
+}
+
+type PartitionValue struct {
+	Online  int64
+	Max     int64
+	Min     int64
+	Desired int64
+}
+
+type PartitionConfig struct {
+	Version                  int64          /* Version number */
+	Name                     string         /* Partition Name */
+	Node                     string         /* Node Name */
+	Conf                     PartitionType  /* Partition Properties */
+	Number                   int32          /* Partition Number */
+	GroupID                  int32          /* Group ID */
+	ProcessorFamily          string         /* Processor Type */
+	ProcessorModel           string         /* Processor Model */
+	MachineID                string         /* Machine ID */
+	ProcessorMhz             float64        /* Processor Clock Speed in MHz */
+	NumProcessors            PartitionValue /* Number of Configured Physical Processors in frame*/
+	OSName                   string         /* Name of Operating System */
+	OSVersion                string         /* Version of operating System */
+	OSBuild                  string         /* Build of Operating System */
+	LCpus                    int32          /* Number of Logical CPUs */
+	SmtThreads               int32          /* Number of SMT Threads */
+	Drives                   int32          /* Total Number of Drives */
+	NetworkAdapters          int32          /* Total Number of Network Adapters */
+	CpuCap                   PartitionValue /* Min, Max and Online CPU Capacity */
+	Weightage                int32          /* Variable Processor Capacity Weightage */
+	EntCapacity              int32          /* number of processor units this partition is entitled to receive */
+	VCpus                    PartitionValue /* Min, Max and Online Virtual CPUs */
+	PoolID                   int32          /* Shared Pool ID of physical processors, to which this partition belongs*/
+	ActiveCpusInPool         int32          /* Count of physical CPUs in the shared processor pool, to which this partition belongs */
+	PoolWeightage            int32          /* Pool Weightage */
+	SharedPCpu               int32          /* Number of physical processors allocated for shared processor use */
+	MaxPoolCap               int32          /* Maximum processor capacity of partition's pool */
+	EntPoolCap               int32          /* Entitled processor capacity of partition's pool */
+	Mem                      PartitionValue /* Min, Max and Online Memory */
+	MemWeightage             int32          /* Variable Memory Capacity Weightage */
+	TotalIOMemoryEntitlement int64          /* I/O Memory Entitlement of the partition in bytes */
+	MemPoolID                int32          /* AMS pool id of the pool the LPAR belongs to */
+	HyperPgSize              int64          /* Hypervisor page size in KB*/
+	ExpMem                   PartitionValue /* Min, Max and Online Expanded Memory */
+	TargetMemExpFactor       int64          /* Target Memory Expansion Factor scaled by 100 */
+	TargetMemExpSize         int64          /* Expanded Memory Size in MB */
+	SubProcessorMode         int32          /* Split core mode, its value can be 0,1,2 or 4. 0 for unsupported, 1 for capable but not enabled, 2 or 4 for enabled*/
+}

vendor/github.com/power-devops/perfstat/types_lvm.go

@@ -0,0 +1,31 @@
+package perfstat
+
+type LogicalVolume struct {
+	Name                   string /* logical volume name */
+	VGName                 string /* volume group name  */
+	OpenClose              int64  /* LVM_QLVOPEN, etc. (see lvm.h) */
+	State                  int64  /* LVM_UNDEF, etc. (see lvm.h) */
+	MirrorPolicy           int64  /* LVM_PARALLEL, etc. (see lvm.h) */
+	MirrorWriteConsistency int64  /* LVM_CONSIST, etc. (see lvm.h) */
+	WriteVerify            int64  /* LVM_VERIFY, etc. (see lvm.h) */
+	PPsize                 int64  /* physical partition size in MB */
+	LogicalPartitions      int64  /* total number of logical paritions configured for this logical volume */
+	Mirrors                int32  /* number of physical mirrors for each logical partition */
+	IOCnt                  int64  /* Number of read and write requests */
+	KBReads                int64  /* Number of Kilobytes read */
+	KBWrites               int64  /* Number of Kilobytes written */
+	Version                int64  /* version number (1, 2, etc.,) */
+}
+
+type VolumeGroup struct {
+	Name                 string /* volume group name */
+	TotalDisks           int64  /* number of physical volumes in the volume group */
+	ActiveDisks          int64  /* number of active physical volumes in the volume group */
+	TotalLogicalVolumes  int64  /* number of logical volumes in the volume group */
+	OpenedLogicalVolumes int64  /* number of logical volumes opened in the volume group */
+	IOCnt                int64  /* Number of read and write requests */
+	KBReads              int64  /* Number of Kilobytes read */
+	KBWrites             int64  /* Number of Kilobytes written */
+	Version              int64  /* version number (1, 2, etc.,) */
+	VariedState          int    /* Indicates volume group available or not */
+}

vendor/github.com/power-devops/perfstat/types_memory.go

@@ -0,0 +1,101 @@
+package perfstat
+
+type MemoryTotal struct {
+	VirtualTotal          int64 /* total virtual memory (in 4KB pages) */
+	RealTotal             int64 /* total real memory (in 4KB pages) */
+	RealFree              int64 /* free real memory (in 4KB pages) */
+	RealPinned            int64 /* real memory which is pinned (in 4KB pages) */
+	RealInUse             int64 /* real memory which is in use (in 4KB pages) */
+	BadPages              int64 /* number of bad pages */
+	PageFaults            int64 /* number of page faults */
+	PageIn                int64 /* number of pages paged in */
+	PageOut               int64 /* number of pages paged out */
+	PgSpIn                int64 /* number of page ins from paging space */
+	PgSpOut               int64 /* number of page outs from paging space */
+	Scans                 int64 /* number of page scans by clock */
+	Cycles                int64 /* number of page replacement cycles */
+	PgSteals              int64 /* number of page steals */
+	NumPerm               int64 /* number of frames used for files (in 4KB pages) */
+	PgSpTotal             int64 /* total paging space (in 4KB pages) */
+	PgSpFree              int64 /* free paging space (in 4KB pages) */
+	PgSpRsvd              int64 /* reserved paging space (in 4KB pages) */
+	RealSystem            int64 /* real memory used by system segments (in 4KB pages). */
+	RealUser              int64 /* real memory used by non-system segments (in 4KB pages). */
+	RealProcess           int64 /* real memory used by process segments (in 4KB pages). */
+	VirtualActive         int64 /* Active virtual pages. Virtual pages are considered active if they have been accessed */
+	IOME                  int64 /* I/O memory entitlement of the partition in bytes*/
+	IOMU                  int64 /* I/O memory entitlement of the partition in use in bytes*/
+	IOHWM                 int64 /* High water mark of I/O memory entitlement used in bytes*/
+	PMem                  int64 /* Amount of physical mmeory currently backing partition's logical memory in bytes*/
+	CompressedTotal       int64 /* Total numbers of pages in compressed pool (in 4KB pages) */
+	CompressedWSegPg      int64 /* Number of compressed working storage pages */
+	CPgIn                 int64 /* number of page ins to compressed pool */
+	CPgOut                int64 /* number of page outs from compressed pool */
+	TrueSize              int64 /* True Memory Size in 4KB pages */
+	ExpandedMemory        int64 /* Expanded Memory Size in 4KB pages */
+	CompressedWSegSize    int64 /* Total size of the compressed working storage pages in the pool */
+	TargetCPoolSize       int64 /* Target Compressed Pool Size in bytes */
+	MaxCPoolSize          int64 /* Max Size of Compressed Pool in bytes */
+	MinUCPoolSize         int64 /* Min Size of Uncompressed Pool in bytes */
+	CPoolSize             int64 /* Compressed Pool size in bytes */
+	UCPoolSize            int64 /* Uncompressed Pool size in bytes */
+	CPoolInUse            int64 /* Compressed Pool Used in bytes */
+	UCPoolInUse           int64 /* Uncompressed Pool Used in bytes */
+	Version               int64 /* version number (1, 2, etc.,) */
+	RealAvailable         int64 /* number of pages (in 4KB pages) of memory available without paging out working segments */
+	BytesCoalesced        int64 /* The number of bytes of the calling partition.s logical real memory  coalesced because they contained duplicated data */
+	BytesCoalescedMemPool int64 /* number of bytes of logical real memory coalesced because they contained duplicated data in the calling partition.s memory */
+}
+
+type MemoryPage struct {
+	PSize           int64 /* page size in bytes */
+	RealTotal       int64 /* number of real memory frames of this page size */
+	RealFree        int64 /* number of pages on free list */
+	RealPinned      int64 /* number of pages pinned */
+	RealInUse       int64 /* number of pages in use */
+	PgExct          int64 /* number of page faults  */
+	PgIns           int64 /* number of pages paged in */
+	PgOuts          int64 /* number of pages paged out */
+	PgSpIns         int64 /* number of page ins from paging space */
+	PgSpOuts        int64 /* number of page outs from paging space */
+	Scans           int64 /* number of page scans by clock */
+	Cycles          int64 /* number of page replacement cycles */
+	PgSteals        int64 /* number of page steals */
+	NumPerm         int64 /* number of frames used for files */
+	NumPgSp         int64 /* number of pages with allocated paging space */
+	RealSystem      int64 /* number of pages used by system segments. */
+	RealUser        int64 /* number of pages used by non-system segments. */
+	RealProcess     int64 /* number of pages used by process segments. */
+	VirtActive      int64 /* Active virtual pages. */
+	ComprsdTotal    int64 /* Number of pages of this size compressed */
+	ComprsdWsegPgs  int64 /* Number of compressed working storage pages */
+	CPgIns          int64 /* number of page ins of this page size to compressed pool */
+	CPgOuts         int64 /* number of page outs of this page size from compressed pool */
+	CPoolInUse      int64 /* Compressed Size of this page size in Compressed Pool */
+	UCPoolSize      int64 /* Uncompressed Pool size in bytes of this page size */
+	ComprsdWsegSize int64 /* Total size of the compressed working storage pages in the pool */
+	Version         int64 /* version number (1, 2, etc.,) */
+	RealAvail       int64 /* number of pages (in 4KB pages) of memory available without paging out working segments */
+}
+
+// paging space types
+const (
+	LV_PAGING      = 1
+	NFS_PAGING     = 2
+	UNKNOWN_PAGING = 3
+)
+
+type PagingSpace struct {
+	Name      string /* Paging space name */
+	Type      uint8  /* type of paging device (LV_PAGING or NFS_PAGING) */
+	VGName    string /* volume group name */
+	Hostname  string /* host name of paging server */
+	Filename  string /* swap file name on server */
+	LPSize    int64  /* size in number of logical partitions  */
+	MBSize    int64  /* size in megabytes  */
+	MBUsed    int64  /* portion used in megabytes  */
+	IOPending int64  /* number of pending I/O */
+	Active    uint8  /* indicates if active (1 if so, 0 if not) */
+	Automatic uint8  /* indicates if automatic (1 if so, 0 if not) */
+	Version   int64  /* version number (1, 2, etc.,) */
+}

vendor/github.com/power-devops/perfstat/types_network.go

@@ -0,0 +1,163 @@
+package perfstat
+
+// Network Interface types
+const (
+	IFT_OTHER       = 0x1
+	IFT_1822        = 0x2 /* old-style arpanet imp */
+	IFT_HDH1822     = 0x3 /* HDH arpanet imp */
+	IFT_X25DDN      = 0x4 /* x25 to imp */
+	IFT_X25         = 0x5 /* PDN X25 interface (RFC877) */
+	IFT_ETHER       = 0x6 /* Ethernet CSMACD */
+	IFT_ISO88023    = 0x7 /* CMSA CD */
+	IFT_ISO88024    = 0x8 /* Token Bus */
+	IFT_ISO88025    = 0x9 /* Token Ring */
+	IFT_ISO88026    = 0xa /* MAN */
+	IFT_STARLAN     = 0xb
+	IFT_P10         = 0xc /* Proteon 10MBit ring */
+	IFT_P80         = 0xd /* Proteon 10MBit ring */
+	IFT_HY          = 0xe /* Hyperchannel */
+	IFT_FDDI        = 0xf
+	IFT_LAPB        = 0x10
+	IFT_SDLC        = 0x11
+	IFT_T1          = 0x12
+	IFT_CEPT        = 0x13 /* E1 - european T1 */
+	IFT_ISDNBASIC   = 0x14
+	IFT_ISDNPRIMARY = 0x15
+	IFT_PTPSERIAL   = 0x16 /* Proprietary PTP serial */
+	IFT_PPP         = 0x17 /* RFC 1331 */
+	IFT_LOOP        = 0x18 /* loopback */
+	IFT_EON         = 0x19 /* ISO over IP */
+	IFT_XETHER      = 0x1a /* obsolete 3MB experimental ethernet */
+	IFT_NSIP        = 0x1b /* XNS over IP */
+	IFT_SLIP        = 0x1c /* IP over generic TTY */
+	IFT_ULTRA       = 0x1d /* Ultra Technologies */
+	IFT_DS3         = 0x1e /* Generic T3 */
+	IFT_SIP         = 0x1f /* SMDS */
+	IFT_FRELAY      = 0x20 /* Frame Relay DTE only */
+	IFT_RS232       = 0x21
+	IFT_PARA        = 0x22 /* parallel-port */
+	IFT_ARCNET      = 0x23
+	IFT_ARCNETPLUS  = 0x24
+	IFT_ATM         = 0x25 /* ATM cells */
+	IFT_MIOX25      = 0x26
+	IFT_SONET       = 0x27 /* SONET or SDH */
+	IFT_X25PLE      = 0x28
+	IFT_ISO88022LLC = 0x29
+	IFT_LOCALTALK   = 0x2a
+	IFT_SMDSDXI     = 0x2b
+	IFT_FRELAYDCE   = 0x2c /* Frame Relay DCE */
+	IFT_V35         = 0x2d
+	IFT_HSSI        = 0x2e
+	IFT_HIPPI       = 0x2f
+	IFT_MODEM       = 0x30 /* Generic Modem */
+	IFT_AAL5        = 0x31 /* AAL5 over ATM */
+	IFT_SONETPATH   = 0x32
+	IFT_SONETVT     = 0x33
+	IFT_SMDSICIP    = 0x34 /* SMDS InterCarrier Interface */
+	IFT_PROPVIRTUAL = 0x35 /* Proprietary Virtual/internal */
+	IFT_PROPMUX     = 0x36 /* Proprietary Multiplexing */
+	IFT_VIPA        = 0x37 /* Virtual Interface */
+	IFT_SN          = 0x38 /* Federation Switch */
+	IFT_SP          = 0x39 /* SP switch */
+	IFT_FCS         = 0x3a /* IP over Fiber Channel */
+	IFT_TUNNEL      = 0x3b
+	IFT_GIFTUNNEL   = 0x3c /* IPv4 over IPv6 tunnel */
+	IFT_HF          = 0x3d /* Support for PERCS HFI*/
+	IFT_CLUSTER     = 0x3e /* cluster pseudo network interface */
+	IFT_FB          = 0xc7 /* IP over Infiniband. Number by IANA */
+)
+
+type NetIfaceTotal struct {
+	Number     int32 /* number of network interfaces  */
+	IPackets   int64 /* number of packets received on interface */
+	IBytes     int64 /* number of bytes received on interface */
+	IErrors    int64 /* number of input errors on interface */
+	OPackets   int64 /* number of packets sent on interface */
+	OBytes     int64 /* number of bytes sent on interface */
+	OErrors    int64 /* number of output errors on interface */
+	Collisions int64 /* number of collisions on csma interface */
+	XmitDrops  int64 /* number of packets not transmitted */
+	Version    int64 /* version number (1, 2, etc.,) */
+}
+
+type NetIface struct {
+	Name        string /* name of the interface */
+	Description string /* interface description (from ODM, similar to lscfg output) */
+	Type        uint8  /* ethernet, tokenring, etc. interpretation can be done using /usr/include/net/if_types.h */
+	MTU         int64  /* network frame size */
+	IPackets    int64  /* number of packets received on interface */
+	IBytes      int64  /* number of bytes received on interface */
+	IErrors     int64  /* number of input errors on interface */
+	OPackets    int64  /* number of packets sent on interface */
+	OBytes      int64  /* number of bytes sent on interface */
+	OErrors     int64  /* number of output errors on interface */
+	Collisions  int64  /* number of collisions on csma interface */
+	Bitrate     int64  /* adapter rating in bit per second */
+	XmitDrops   int64  /* number of packets not transmitted */
+	Version     int64  /* version number (1, 2, etc.,) */
+	IfIqDrops   int64  /* Dropped on input, this interface */
+	IfArpDrops  int64  /* Dropped because no arp response */
+}
+
+type NetBuffer struct {
+	Name          string /* size in ascii, always power of 2 (ex: "32", "64", "128") */
+	InUse         int64  /* number of buffer currently allocated */
+	Calls         int64  /* number of buffer allocations since last reset */
+	Delayed       int64  /* number of delayed allocations */
+	Free          int64  /* number of free calls */
+	Failed        int64  /* number of failed allocations */
+	HighWatermark int64  /* high threshold for number of buffer allocated */
+	Freed         int64  /* number of buffers freed */
+	Version       int64  /* version number (1, 2, etc.,) */
+}
+
+// Network adapter types
+const (
+	NET_PHY  = 0 /* physical device */
+	NET_SEA  = 1 /* shared ethernet adapter */
+	NET_VIR  = 2 /* virtual device */
+	NET_HEA  = 3 /* host ethernet adapter */
+	NET_EC   = 4 /* etherchannel */
+	NET_VLAN = 5 /* vlan pseudo device */
+)
+
+type NetAdapter struct {
+	Version                    int64  /* version number (1,2, etc) */
+	Name                       string /* name of the adapter */
+	TxPackets                  int64  /* Transmit Packets on interface */
+	TxBytes                    int64  /* Transmit Bytes on interface */
+	TxInterrupts               int64  /* Transfer Interrupts */
+	TxErrors                   int64  /* Transmit Errors */
+	TxPacketsDropped           int64  /* Packets Dropped at the time of Data Transmission */
+	TxQueueSize                int64  /* Maximum Packets on Software Transmit Queue */
+	TxQueueLen                 int64  /* Transmission Queue Length */
+	TxQueueOverflow            int64  /* Transmission Queue Overflow */
+	TxBroadcastPackets         int64  /* Number of Broadcast Packets Transmitted */
+	TxMulticastPackets         int64  /* Number of Multicast packets Transmitted */
+	TxCarrierSense             int64  /* Lost Carrier Sense signal count */
+	TxDMAUnderrun              int64  /* Count of DMA Under-runs for Transmission */
+	TxLostCTSErrors            int64  /* The number of unsuccessful transmissions due to the loss of the Clear-to-Send signal error */
+	TxMaxCollisionErrors       int64  /* Maximum Collision Errors at Transmission */
+	TxLateCollisionErrors      int64  /* Late Collision Errors at Transmission */
+	TxDeferred                 int64  /* The number of packets deferred for Transmission. */
+	TxTimeoutErrors            int64  /* Time Out Errors for Transmission */
+	TxSingleCollisionCount     int64  /* Count of Single Collision error at Transmission */
+	TxMultipleCollisionCount   int64  /* Count of Multiple Collision error at Transmission */
+	RxPackets                  int64  /* Receive Packets on interface */
+	RxBytes                    int64  /* Receive Bytes on interface */
+	RxInterrupts               int64  /* Receive Interrupts */
+	RxErrors                   int64  /* Input errors on interface */
+	RxPacketsDropped           int64  /* The number of packets accepted by the device driver for transmission which were not (for any reason) given to the device. */
+	RxBadPackets               int64  /* Count of Bad Packets Received. */
+	RxMulticastPackets         int64  /* Number of MultiCast Packets Received */
+	RxBroadcastPackets         int64  /* Number of Broadcast Packets Received */
+	RxCRCErrors                int64  /* Count of Packets Received with CRC errors  */
+	RxDMAOverrun               int64  /* Count of DMA over-runs for Data Receival. */
+	RxAlignmentErrors          int64  /* Packets Received with Alignment Error  */
+	RxNoResourceErrors         int64  /* Packets Received with No Resource Errors */
+	RxCollisionErrors          int64  /* Packets Received with Collision errors */
+	RxPacketTooShortErrors     int64  /* Count of Short Packets Received. */
+	RxPacketTooLongErrors      int64  /* Count of Too Long Packets Received. */
+	RxPacketDiscardedByAdapter int64  /* Count of Received Packets discarded by Adapter. */
+	AdapterType                int32  /* 0 - Physical, 1 - SEA, 2 - Virtual, 3 -HEA */
+}

vendor/github.com/power-devops/perfstat/types_process.go

@@ -0,0 +1,43 @@
+package perfstat
+
+type Process struct {
+	Version           int64   /* version number (1, 2, etc.,) */
+	PID               int64   /* Process ID */
+	ProcessName       string  /* Name of The Process */
+	Priority          int32   /* Process Priority */
+	NumThreads        int64   /* Thread Count */
+	UID               int64   /* Owner Info */
+	ClassID           int64   /* WLM Class Name */
+	Size              int64   /* Virtual Size of the Process in KB(Exclusive Usage, Leaving all Shared Library Text & Shared File Pages, Shared Memory, Memory Mapped) */
+	RealMemData       int64   /* Real Memory used for Data in KB */
+	RealMemText       int64   /* Real Memory used for Text in KB */
+	VirtMemData       int64   /* Virtual Memory used to Data in KB */
+	VirtMemText       int64   /* Virtual Memory used for Text in KB */
+	SharedLibDataSize int64   /* Data Size from Shared Library in KB */
+	HeapSize          int64   /* Heap Size in KB */
+	RealInUse         int64   /* The Real memory in use(in KB) by the process including all kind of segments (excluding system segments). This includes Text, Data, Shared Library Text, Shared Library Data, File Pages, Shared Memory & Memory Mapped */
+	VirtInUse         int64   /* The Virtual memory in use(in KB) by the process including all kind of segments (excluding system segments). This includes Text, Data, Shared Library Text, Shared Library Data, File Pages, Shared Memory & Memory Mapped */
+	Pinned            int64   /* Pinned Memory(in KB) for this process inclusive of all segments */
+	PgSpInUse         int64   /* Paging Space used(in KB) inclusive of all segments */
+	FilePages         int64   /* File Pages used(in KB) including shared pages */
+	RealInUseMap      int64   /* Real memory used(in KB) for Shared Memory and Memory Mapped regions */
+	VirtInUseMap      int64   /* Virtual Memory used(in KB) for Shared Memory and Memory Mapped regions */
+	PinnedInUseMap    int64   /* Pinned memory(in KB) for Shared Memory and Memory Mapped regions */
+	UCpuTime          float64 /* User Mode CPU time will be in percentage or milliseconds based on, whether it is filled by perfstat_process_util or perfstat_process respectively. */
+	SCpuTime          float64 /* System Mode CPU time will be in percentage or milliseconds based on, whether it is filled by perfstat_process_util or perfstat_process respectively. */
+	LastTimeBase      int64   /* Timebase Counter */
+	InBytes           int64   /* Bytes Read from Disk */
+	OutBytes          int64   /* Bytes Written to Disk */
+	InOps             int64   /* In Operations from Disk */
+	OutOps            int64   /* Out Operations from Disk */
+}
+
+type Thread struct {
+	TID          int64   /* thread identifier */
+	PID          int64   /* process identifier */
+	CpuID        int64   /* processor on which I'm bound */
+	UCpuTime     float64 /* User Mode CPU time will be in percentage or milliseconds based on, whether it is filled by perfstat_thread_util or perfstat_thread respectively. */
+	SCpuTime     float64 /* System Mode CPU time will be in percentage or milliseconds based on, whether it is filled by perfstat_thread_util or perfstat_thread respectively. */
+	LastTimeBase int64   /* Timebase Counter */
+	Version      int64
+}

vendor/github.com/power-devops/perfstat/uptime.go

@@ -0,0 +1,35 @@
+// +build aix
+
+package perfstat
+
+/*
+#include "c_helpers.h"
+*/
+import "C"
+
+import (
+	"fmt"
+	"time"
+)
+
+func timeSince(ts uint64) uint64 {
+	return uint64(time.Now().Unix()) - ts
+}
+
+// BootTime() returns the time of the last boot in UNIX seconds
+func BootTime() (uint64, error) {
+	sec := C.boottime()
+	if sec == -1 {
+		return 0, fmt.Errorf("Can't determine boot time")
+	}
+	return uint64(sec), nil
+}
+
+// UptimeSeconds() calculates uptime in seconds
+func UptimeSeconds() (uint64, error) {
+	boot, err := BootTime()
+	if err != nil {
+		return 0, err
+	}
+	return timeSince(boot), nil
+}