system/process fixes on AIX

CHANGELOG.md

@@ -6,6 +6,7 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 ## [Unreleased]
 
 ### Added
+- Add process existence check for AIX in system/process #61
 
 ### Changed
 
@@ -17,6 +18,8 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 
 - Fix thread safety in process code #43
 - Fix process package build on AIX #54
+- Fix out-of-range panic on AIX in system/process while getting exe from procargs #61
+- Implement GetPIDState for AIX in system/process #61
 
 ## [0.4.4]
 

metric/system/process/process.go

@@ -24,8 +24,10 @@ import (
  "context"
  "fmt"
  "os"
+ "runtime"
  "sort"
  "strings"
+ "syscall"
  "time"
 
  psutil "github.com/shirou/gopsutil/process"
@@ -62,6 +64,23 @@ func ListStates(hostfs resolve.Resolver) ([]ProcState, error) {
 // GetPIDState returns the state of a given PID
 // It will return ProcNotExist if the process was not found.
 func GetPIDState(hostfs resolve.Resolver, pid int) (PidState, error) {
+ // As psutils doesn't support AIX, we use GetInfoForPid directly.
+ // It returns an ESRCH if no process is found.
+ if runtime.GOOS == "aix" {
+ state, err := GetInfoForPid(hostfs, pid)
+ if err == syscall.ESRCH {
+ // We assume that syscall.ESRCH is mapped for all GOOS
+ // this package is compiled for. If not, we will have to give this
+ // to a build-flag controlled function to check.
+ return "", ProcNotExist
+ }
+ if err != nil {
+ return "", fmt.Errorf("error getting PID info for %d: %w", pid, err)
+ }
+
+ return state.State, nil
+ }
+
  // This library still doesn't have a good cross-platform way to distinguish between "does not eixst" and other process errors.
  // This is a fairly difficult problem to solve in a cross-platform way
  exists, err := psutil.PidExistsWithContext(context.Background(), int32(pid))
@@ -71,6 +90,7 @@ func GetPIDState(hostfs resolve.Resolver, pid int) (PidState, error) {
  if !exists {
  return "", ProcNotExist
  }
+
  //GetInfoForPid will return the smallest possible dataset for a PID
  procState, err := GetInfoForPid(hostfs, pid)
  if err != nil {

metric/system/process/process_aix.go

@@ -48,7 +48,6 @@ func (procStats *Stats) FetchPids() (ProcsMap, []ProcState, error) {
  procMap := make(ProcsMap, 0)
  var plist []ProcState
  for {
- // getprocs first argument is a void*
  num, err := C.getprocs(unsafe.Pointer(&info), C.sizeof_struct_procsinfo64, nil, 0, &pid, 1)
  if err != nil {
  return nil, nil, fmt.Errorf("error fetching PIDs: %w", err)
@@ -62,11 +61,39 @@ func (procStats *Stats) FetchPids() (ProcsMap, []ProcState, error) {
  return procMap, plist, nil
 }
 
+// procExists returns true if a process is present in the AIX process table
+func procExists(pid int) (bool, error) {
+ info := [20]C.struct_procsinfo64{}
+ idxPtr := C.pid_t(0)
+
+ for {
+ num, err := C.getprocs(unsafe.Pointer(&info), C.sizeof_struct_procsinfo64, nil, 0, &idxPtr, 20)
+ if err != nil {
+ return false, fmt.Errorf("error fetching PID at IndexPointer %d: %w", int(idxPtr), err)
+ }
+
+ if num == 0 {
+ break
+ }
+
+ for i := 0; i < len(info); i++ {
+ if int(info[i].pi_pid) == pid {
+ return true, nil
+ }
+ }
+
+ }
+
+ return false, nil
+}
+
 // GetInfoForPid returns basic info for the process
 func GetInfoForPid(_ resolve.Resolver, pid int) (ProcState, error) {
  info := C.struct_procsinfo64{}
  cpid := C.pid_t(pid)
 
+ // getprocs uses an IndexPointer, which doesn't need to correlate in every case to the PID
+ // but here we fetch a count of 1 procs and therefore it should match it.
  num, err := C.getprocs(unsafe.Pointer(&info), C.sizeof_struct_procsinfo64, nil, 0, &cpid, 1)
  if err != nil {
  return ProcState{}, fmt.Errorf("error in getprocs: %w", err)
@@ -75,6 +102,16 @@ func GetInfoForPid(_ resolve.Resolver, pid int) (ProcState, error) {
  return ProcState{}, syscall.ESRCH
  }
 
+ // Since getprocs can return a proccess with pi_state=Running which is already
+ // dead, we need to check if it really exist.
+ ok, err := procExists(pid)
+ if err != nil {
+ return ProcState{}, fmt.Errorf("error in procExists: %w", err)
+ }
+ if !ok {
+ return ProcState{}, syscall.ESRCH
+ }
+
  state := ProcState{}
  state.Pid = opt.IntWith(pid)
 
@@ -109,12 +146,16 @@ func GetInfoForPid(_ resolve.Resolver, pid int) (ProcState, error) {
  return state, nil
 }
 
-// FillPidMetrics is the aix implementation
+// FillPidMetrics is the aix implementation. If the process died in the meantime and is still present in the
+// process table, this call still succeeds.
 func FillPidMetrics(_ resolve.Resolver, pid int, state ProcState, filter func(string) bool) (ProcState, error) {
  pagesize := uint64(os.Getpagesize())
  info := C.struct_procsinfo64{}
  cpid := C.pid_t(pid)
 
+ // getprocs uses an IndexPointer, which doesn't need to correlate in every case to the PID
+ // but here we fetch a count of 1 procs and therefore it should match it.
+ // A dead process could still be looked up when directly using the IndexPointer as pid.
  num, err := C.getprocs(unsafe.Pointer(&info), C.sizeof_struct_procsinfo64, nil, 0, &cpid, 1)
  if err != nil {
  return state, fmt.Errorf("error in getprocs: %w", err)
@@ -155,8 +196,11 @@ func FillPidMetrics(_ resolve.Resolver, pid int, state ProcState, filter func(st
 
  args = append(args, stripNullByte(arg))
  }
+
  state.Args = args
- state.Exe = args[0]
+ if len(args) > 0 {
+ state.Exe = args[0]
+ }
 
  // get env vars
  buf = make([]byte, 8192)

metric/system/process/process_test.go

@@ -15,8 +15,8 @@
 // specific language governing permissions and limitations
 // under the License.
 
-//go:build darwin || freebsd || linux || windows
-// +build darwin freebsd linux windows
+//go:build darwin || freebsd || linux || windows || aix
+// +build darwin freebsd linux windows aix
 
 package process