diff --git a/cpu/cpu_aix_nocgo.go b/cpu/cpu_aix_nocgo.go
index 9796cf571..f3a3186aa 100644
--- a/cpu/cpu_aix_nocgo.go
+++ b/cpu/cpu_aix_nocgo.go
@@ -48,7 +48,7 @@ func TimesWithContext(ctx context.Context, percpu bool) ([]TimesStat, error) {
 				if t, err := strconv.ParseFloat(v[pos], 64); err == nil {
 					switch header {
 					case `cpu`:
-						ct.CPU = t
+						ct.CPU = strconv.FormatFloat(t, 'f', -1, 64)
 					case `%usr`:
 						ct.User = t
 					case `%sys`:
diff --git a/disk/disk_aix_nocgo.go b/disk/disk_aix_nocgo.go
index b8197b053..a7b6bf933 100644
--- a/disk/disk_aix_nocgo.go
+++ b/disk/disk_aix_nocgo.go
@@ -83,22 +83,22 @@ func getFsType(stat unix.Statfs_t) string {
 }
 
 func UsageWithContext(ctx context.Context, path string) (*UsageStat, error) {
-	var ret []UsageStat
 	out, err := invoke.CommandWithContext(ctx, "df", "-v")
 	if err != nil {
 		return nil, err
 	}
 
+	ret := &UsageStat{}
+
 	blocksize := uint64(512)
 	lines := strings.Split(string(out), "\n")
 	if len(lines) < 2 {
-		return []UsageStat{}, common.ErrNotImplementedError
+		return &UsageStat{}, common.ErrNotImplementedError
 	}
 
 	hf := strings.Fields(strings.Replace(lines[0], "Mounted on", "Path", -1)) // headers
 	for line := 1; line < len(lines); line++ {
 		fs := strings.Fields(lines[line]) // values
-		us := &UsageStat{}
 		for i, header := range hf {
 			// We're done in any of these use cases
 			if i >= len(fs) {
@@ -108,65 +108,68 @@ func UsageWithContext(ctx context.Context, path string) (*UsageStat, error) {
 			switch header {
 			case `Filesystem`:
 				// This is not a valid fs for us to parse
-				if fs[i] == "/proc" || fs[i] == "/ahafs" {
-					continue
+				if fs[i] == "/proc" || fs[i] == "/ahafs" || fs[i] != path {
+					break
 				}
 
-				us.Fstype, err = GetMountFSType(fs[i])
+				ret.Fstype, err = GetMountFSTypeWithContext(ctx, fs[i])
 				if err != nil {
 					return nil, err
 				}
 			case `Path`:
-				us.Path = fs[i]
+				ret.Path = fs[i]
 			case `512-blocks`:
-				us.Total, err = strconv.Atoi(fs[i])
+				total, err := strconv.ParseUint(fs[i], 10, 64)
+				ret.Total = total * blocksize
 				if err != nil {
 					return nil, err
 				}
 			case `Used`:
-				us.Used, err = strconv.Atoi(fs[i])
+				ret.Used, err = strconv.ParseUint(fs[i], 10, 64)
 				if err != nil {
 					return nil, err
 				}
 			case `Free`:
-				us.Free, err = strconv.Atoi(fs[i])
+				ret.Free, err = strconv.ParseUint(fs[i], 10, 64)
 				if err != nil {
 					return nil, err
 				}
 			case `%Used`:
-				us.UsedPercent, err = strconv.ParseFloat(fs[i])
+				val, err := strconv.Atoi(strings.Replace(fs[i], "%", "", -1))
 				if err != nil {
 					return nil, err
 				}
+				ret.UsedPercent = float64(val) / float64(100)
 			case `Ifree`:
-				us.InodesFree, err = strconv.Atoi(fs[i])
+				ret.InodesFree, err = strconv.ParseUint(fs[i], 10, 64)
 				if err != nil {
 					return nil, err
 				}
 			case `Iused`:
-				us.InodesUsed, err = strconv.Atoi(fs[i])
+				ret.InodesUsed, err = strconv.ParseUint(fs[i], 10, 64)
 				if err != nil {
 					return nil, err
 				}
 			case `%Iused`:
-				us.InodesUsedPercent, err = strconv.ParseFloat(fs[i])
+				val, err := strconv.Atoi(strings.Replace(fs[i], "%", "", -1))
 				if err != nil {
 					return nil, err
 				}
+				ret.InodesUsedPercent = float64(val) / float64(100)
 			}
 		}
 
 		// Calculated value, since it isn't returned by the command
-		us.InodesTotal = us.InodesUsed + us.InodesFree
+		ret.InodesTotal = ret.InodesUsed + ret.InodesFree
 
 		// Valid Usage data, so append it
-		ret = append(ret, *us)
+		return ret, nil
 	}
 
-	return *ret, nil
+	return ret, nil
 }
 
-func GetMountFSType(mp string) (string, error) {
+func GetMountFSTypeWithContext(ctx context.Context, mp string) (string, error) {
 	out, err := invoke.CommandWithContext(ctx, "mount")
 	if err != nil {
 		return "", err
@@ -212,11 +215,11 @@ func SerialNumberWithContext(ctx context.Context, name string) (string, error) {
 		if strings.HasPrefix(v, "Serial Number...............") {
 			ret = strings.TrimPrefix(v, "Serial Number...............")
 			if ret == "" {
-				return "", errors.New("empty eerial for disk")
+				return "", errors.New("empty serial for disk")
 			}
 			return ret, nil
 		}
 	}
 
-	sreturn ret, errors.New("serial entry not found for disk")
+	return ret, errors.New("serial entry not found for disk")
 }
diff --git a/disk/disk_unix.go b/disk/disk_unix.go
index 1e7352408..4cef8cbac 100644
--- a/disk/disk_unix.go
+++ b/disk/disk_unix.go
@@ -1,5 +1,5 @@
-//go:build freebsd || linux || darwin || (aix && !cgo)
-// +build freebsd linux darwin aix,!cgo
+//go:build freebsd || linux || darwin
+// +build freebsd linux darwin
 
 package disk
 
diff --git a/host/host_aix.go b/host/host_aix.go
index 16dcf1c0e..8574a6125 100644
--- a/host/host_aix.go
+++ b/host/host_aix.go
@@ -26,11 +26,11 @@ func HostIDWithContext(ctx context.Context) (string, error) {
 	}
 
 	// The command always returns an extra newline, so we make use of Split() to get only the first line
-	return strings.Split(string(out[:]), "\n")[0]
+	return strings.Split(string(out[:]), "\n")[0], nil
 }
 
 func numProcs(ctx context.Context) (uint64, error) {
-	return common.NumProcsWithContext(ctx)
+	return 0, common.ErrNotImplementedError
 }
 
 func BootTimeWithContext(ctx context.Context) (btime uint64, err error) {
@@ -52,7 +52,7 @@ func BootTimeWithContext(ctx context.Context) (btime uint64, err error) {
 //07:43PM   up 5 hrs,  1 user,  load average: 3.27, 2.91, 2.72
 //11:18:23  up 83 days, 18:29,  4 users,  load average: 0.16, 0.03, 0.01
 func UptimeWithContext(ctx context.Context) (uint64, error) {
-	out, err := invoke.CommandWithContext(ctx, "uptime").Output()
+	out, err := invoke.CommandWithContext(ctx, "uptime")
 	if err != nil {
 		return 0, err
 	}
@@ -112,7 +112,7 @@ func UptimeWithContext(ctx context.Context) (uint64, error) {
 // This is a weak implementation due to the limitations on retrieving this data in AIX
 func UsersWithContext(ctx context.Context) ([]UserStat, error) {
 	var ret []UserStat
-	out, err := invoke.CommandWithContext(ctx, "w").Output()
+	out, err := invoke.CommandWithContext(ctx, "w")
 	if err != nil {
 		return nil, err
 	}
@@ -134,9 +134,9 @@ func UsersWithContext(ctx context.Context) ([]UserStat, error) {
 			if t, err := strconv.ParseFloat(v[i], 64); err == nil {
 				switch header {
 				case `User`:
-					us.User = t
+					us.User = strconv.FormatFloat(t, 'f', 1, 64)
 				case `tty`:
-					us.Terminal = t
+					us.Terminal = strconv.FormatFloat(t, 'f', 1, 64)
 				}
 			}
 		}
@@ -151,46 +151,49 @@ func UsersWithContext(ctx context.Context) ([]UserStat, error) {
 // Much of this function could be static. However, to be future proofed, I've made it call the OS for the information in all instances.
 func PlatformInformationWithContext(ctx context.Context) (platform string, family string, version string, err error) {
 	// Set the platform (which should always, and only be, "AIX") from `uname -s`
-	out, err := invoke.CommandWithContext(ctx, "uname", "-s").Output()
+	out, err := invoke.CommandWithContext(ctx, "uname", "-s")
 	if err != nil {
 		return "", "", "", err
 	}
-	platform = string(out[:])
+	platform = strings.TrimRight(string(out[:]), "\n")
 
 	// Set the family
-	out, err = invoke.CommandWithContext(ctx, "bootinfo", "-p").Output()
-	if err != nil {
-		return "", "", "", err
-	}
-	// Family seems to always be the second field from this uname, so pull that out
-	family = string(out[:])
+	family = strings.TrimRight(string(out[:]), "\n")
 
 	// Set the version
-	out, err = invoke.CommandWithContext(ctx, "oslevel").Output()
+	out, err = invoke.CommandWithContext(ctx, "oslevel")
 	if err != nil {
 		return "", "", "", err
 	}
-	version = string(out[:])
+	version = strings.TrimRight(string(out[:]), "\n")
 
 	return platform, family, version, nil
 }
 
 func KernelVersionWithContext(ctx context.Context) (version string, err error) {
-	out, err := invoke.CommandWithContext(ctx, "oslevel", "-s").Output()
+	out, err := invoke.CommandWithContext(ctx, "oslevel", "-s")
 	if err != nil {
 		return "", err
 	}
-	version = string(out[:])
+	version = strings.TrimRight(string(out[:]), "\n")
 
 	return version, nil
 }
 
 func KernelArch() (arch string, err error) {
-	out, err := invoke.CommandWithContext(ctx, "bootinfo", "-y").Output()
+	out, err := invoke.Command("bootinfo", "-y")
 	if err != nil {
 		return "", err
 	}
-	arch = string(out[:])
+	arch = strings.TrimRight(string(out[:]), "\n")
 
 	return arch, nil
 }
+
+func VirtualizationWithContext(ctx context.Context) (string, string, error) {
+	return "", "", common.ErrNotImplementedError
+}
+
+func SensorsTemperaturesWithContext(ctx context.Context) ([]TemperatureStat, error) {
+	return nil, common.ErrNotImplementedError
+}
diff --git a/host/host_fallback.go b/host/host_fallback.go
index a393ca15d..150ccf008 100644
--- a/host/host_fallback.go
+++ b/host/host_fallback.go
@@ -1,5 +1,5 @@
-//go:build !darwin && !linux && !freebsd && !openbsd && !netbsd && !solaris && !windows
-// +build !darwin,!linux,!freebsd,!openbsd,!netbsd,!solaris,!windows
+//go:build !darwin && !linux && !freebsd && !openbsd && !netbsd && !solaris && !windows && !aix
+// +build !darwin,!linux,!freebsd,!openbsd,!netbsd,!solaris,!windows,!aix
 
 package host