0
0
//go:build linux
package hostos
import (
"bytes"
"context"
"errors"
"fmt"
"io/fs"
"os"
"path/filepath"
"strconv"
"strings"
"syscall"
"time"
"golang.org/x/sys/unix"
"github.com/johnandersen777/socialweb-computer-kcp/internal/kit/strs"
)
const statFieldState = 3
const statFieldStartTime = 22
func ProcStart(pid int) (uint64, error) {
b, err := os.ReadFile(filepath.Join("/proc", strconv.Itoa(pid), "stat"))
if errors.Is(err, fs.ErrNotExist) {
return 0, fmt.Errorf("hostos: no process at pid %d: %w", pid, fs.ErrNotExist)
}
if err != nil {
return 0, fmt.Errorf("hostos: reading the stat of pid %d: %w", pid, err)
}
state, start, err := parseStat(b)
if err != nil {
return 0, err
}
if state == 'Z' || state == 'X' {
return 0, fmt.Errorf("hostos: pid %d has exited (state %c): %w", pid, state, fs.ErrNotExist)
}
return start, nil
}
func parseStat(b []byte) (byte, uint64, error) {
comm := bytes.LastIndexByte(b, ')')
if comm < 0 {
return 0, 0, fmt.Errorf("hostos: a /proc/<pid>/stat with no ) closing the comm field: %q",
string(bytes.TrimSpace(b)))
}
fields := strings.Fields(string(b[comm+1:]))
state := 0
start := statFieldStartTime - statFieldState
if len(fields) <= start {
return 0, 0, fmt.Errorf("hostos: /proc/<pid>/stat carries %d fields after the comm field, "+
"and the process start time is field %d, so this process cannot be told apart from a "+
"later one that reuses its pid", len(fields), statFieldStartTime)
}
if len(fields[state]) != 1 {
return 0, 0, fmt.Errorf("hostos: /proc/<pid>/stat names the state %q, which is not one character",
fields[state])
}
n, err := strconv.ParseUint(fields[start], 10, 64)
if err != nil {
return 0, 0, fmt.Errorf("hostos: /proc/<pid>/stat carries %q where the process start time "+
"(field %d) belongs: %w", fields[start], statFieldStartTime, err)
}
return fields[state][0], n, nil
}
func Cmdline(pid int) ([]string, error) {
b, err := os.ReadFile(filepath.Join("/proc", strconv.Itoa(pid), "cmdline"))
if errors.Is(err, fs.ErrNotExist) {
return nil, fmt.Errorf("hostos: no process at pid %d: %w", pid, fs.ErrNotExist)
}
if err != nil {
return nil, fmt.Errorf("hostos: reading the command line of pid %d: %w", pid, err)
}
return strs.SplitNUL(b), nil
}
func Alive(pid int) (bool, error) {
err := syscall.Kill(pid, 0)
switch {
case err == nil:
return true, nil
case errors.Is(err, syscall.ESRCH):
return false, nil
case errors.Is(err, syscall.EPERM):
return true, nil
}
return false, fmt.Errorf("hostos: probing pid %d: %w", pid, err)
}
func Signal(pid int, force bool) error {
sig := syscall.SIGTERM
if force {
sig = syscall.SIGKILL
}
if err := syscall.Kill(pid, sig); err != nil && !errors.Is(err, syscall.ESRCH) {
return fmt.Errorf("hostos: signalling pid %d: %w", pid, err)
}
return nil
}
func Reload(pid int) error {
if err := syscall.Kill(pid, syscall.SIGHUP); err != nil {
return fmt.Errorf("hostos: sending SIGHUP to pid %d: %w", pid, err)
}
return nil
}
func Terminate(ctx context.Context, pid int, grace time.Duration) error {
ticks, err := ProcStart(pid)
if errors.Is(err, fs.ErrNotExist) {
return nil
}
if err != nil {
return err
}
if err := Signal(pid, false); err != nil {
return err
}
ctx, cancel := context.WithTimeout(context.WithoutCancel(ctx), grace)
defer cancel()
err = AwaitExit(ctx, pid, ticks)
if err == nil {
return nil
}
if ctx.Err() == nil {
return err
}
return Signal(pid, true)
}
func AwaitExit(ctx context.Context, pid int, startTicks uint64) error {
if pid <= 0 {
return fmt.Errorf("hostos: no process at pid %d to wait for", pid)
}
fd, err := unix.PidfdOpen(pid, 0)
if errors.Is(err, unix.ESRCH) {
return nil
}
if err != nil {
return fmt.Errorf("hostos: pidfd_open(%d): %w", pid, err)
}
if err := unix.SetNonblock(fd, true); err != nil {
unix.Close(fd)
return fmt.Errorf("hostos: the pidfd of pid %d: %w", pid, err)
}
f := os.NewFile(uintptr(fd), "pidfd:"+strconv.Itoa(pid))
defer f.Close()
if startTicks != 0 {
ticks, err := ProcStart(pid)
if errors.Is(err, fs.ErrNotExist) {
return nil
}
if err != nil {
return err
}
if ticks != startTicks {
return nil
}
}
if err := f.SetReadDeadline(time.Time{}); err != nil {
return fmt.Errorf("hostos: the pidfd of pid %d cannot be polled: %w", pid, err)
}
rc, err := f.SyscallConn()
if err != nil {
return fmt.Errorf("hostos: the pidfd of pid %d: %w", pid, err)
}
stop := context.AfterFunc(ctx, func() { f.SetReadDeadline(time.Unix(1, 0)) })
defer stop()
var perr error
err = rc.Read(func(fd uintptr) bool {
fds := []unix.PollFd{{Fd: int32(fd), Events: unix.POLLIN}}
n, err := unix.Poll(fds, 0)
if err != nil && !errors.Is(err, unix.EINTR) {
perr = err
return true
}
return n > 0
})
switch {
case err == nil && perr == nil:
return nil
case err == nil:
return fmt.Errorf("hostos: polling the pidfd of pid %d: %w", pid, perr)
case ctx.Err() != nil:
return ctx.Err()
}
return fmt.Errorf("hostos: waiting on the pidfd of pid %d: %w", pid, err)
}