Fix the spoc e2e tests when the proc is started externally

Change-Id: I1c0502d9a7972868d15b32d06ce318898686a7ab
Signed-off-by: Cosmin Cojocar <[email protected]>

internal/pkg/cli/recorder/impl.go

@@ -35,6 +35,7 @@ import (
 
  "sigs.k8s.io/security-profiles-operator/internal/pkg/cli/command"
  "sigs.k8s.io/security-profiles-operator/internal/pkg/daemon/bpfrecorder"
+ "sigs.k8s.io/security-profiles-operator/internal/pkg/util"
 )
 
 type defaultImpl struct{}
@@ -58,6 +59,7 @@ type impl interface {
  PrintObj(printers.YAMLPrinter, runtime.Object, io.Writer) error
  GoArchToSeccompArch(string) (seccomp.Arch, error)
  Notify(chan<- os.Signal, ...os.Signal)
+ ProcessIDByName(name string) (int, error)
 }
 
 func (*defaultImpl) LoadBpfRecorder(b *bpfrecorder.BpfRecorder) error {
@@ -123,3 +125,7 @@ func (*defaultImpl) GoArchToSeccompArch(arch string) (seccomp.Arch, error) {
 func (*defaultImpl) Notify(c chan<- os.Signal, sig ...os.Signal) {
  signal.Notify(c, sig...)
 }
+
+func (*defaultImpl) ProcessIDByName(name string) (int, error) {
+ return util.ProcessIDByName(name)
+}

internal/pkg/cli/recorder/recorder.go

@@ -95,6 +95,22 @@ func (r *Recorder) Run() error {
  ch := make(chan os.Signal, 1)
  r.Notify(ch, os.Interrupt)
  log.Print(WaitForSigIntMessage)
+
+ // searching the mntns of the process started outside of spoc
+ cmd := r.options.commandOptions.Command()
+ if err := util.Retry(func() (err error) {
+ pid, err := r.ProcessIDByName(cmd)
+ if err != nil {
+ return fmt.Errorf("getting PID by name: %w", err)
+ }
+ mntns, err = r.FindProcMountNamespace(r.bpfRecorder, uint32(pid))
+ if err != nil {
+ return fmt.Errorf("finding mntns of PID %d: %w", pid, err)
+ }
+ return nil
+ }, func(err error) bool { return true }); err != nil {
+ return fmt.Errorf("searching the PID of %q command: %w", cmd, err)
+ }
  <-ch
  } else {
  cmd := command.New(r.options.commandOptions)
@@ -105,7 +121,7 @@ func (r *Recorder) Run() error {
 
  mntns, err = r.FindProcMountNamespace(r.bpfRecorder, pid)
  if err != nil {
- return fmt.Errorf("finding mntns for command PID %d: %w", pid, err)
+ return fmt.Errorf("finding mntns of PID %d: %w", pid, err)
  }
 
  if err := r.CommandWait(cmd); err != nil {

internal/pkg/util/process.go

@@ -0,0 +1,114 @@
+/*
+Copyright 2024 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http:https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package util
+
+import (
+ "errors"
+ "fmt"
+ "os"
+ "path"
+ "path/filepath"
+ "regexp"
+ "strconv"
+ "strings"
+)
+
+const (
+ defaultPID = -1
+ processRoot = "/proc"
+)
+
+// ErrEmptyPIDName indicates an erorr for a PID with an empty process name
+var ErrEmptyPIDName = errors.New("process Name of given PID is empty")
+
+var procRegexp = regexp.MustCompile(`[/]*proc/[\d]+/cmdline`)
+
+// ProcessIDByName is looking up the PID by process name
+func ProcessIDByName(name string) (int, error) {
+ p := &proc{
+ name: name,
+ pid: defaultPID,
+ }
+ return p.findPIDByName(processRoot)
+}
+
+type proc struct {
+ name string
+ pid int
+}
+
+func (p *proc) findPIDByName(root string) (int, error) {
+ err := filepath.Walk(root, p.walkProc)
+ if err != nil {
+ return -1, fmt.Errorf("looking for pid of process %q: %w", p.name, err)
+ }
+ if p.pid != defaultPID {
+ return p.pid, nil
+ }
+ return -1, fmt.Errorf("could not find a valid pid for process name %q", p.name)
+}
+
+func (p *proc) walkProc(path string, info os.FileInfo, err error) error {
+ // Return already if there is an existing error due to for instance
+ // insufficient privileges.
+ if err != nil {
+ return nil
+ }
+
+ // Skip paths which doesn't look like /proc/<pid>cmdline.
+ if !procRegexp.Match([]byte(path)) {
+ return nil
+ }
+
+ pid, err := parsePID(path)
+ if err != nil {
+ return fmt.Errorf("parsing PID from path %s: %w", path, err)
+ }
+
+ name, err := parseName(path)
+ if err != nil {
+ // skip pids without empty command and keep going
+ if err == ErrEmptyPIDName {
+ return nil
+ }
+ return fmt.Errorf("parsing process name from path %s: %w", path, err)
+ }
+
+ // Update the PID if we found the process
+ if strings.HasPrefix(name, p.name) {
+ p.pid = pid
+ }
+
+ return nil
+}
+
+func parsePID(dir string) (int, error) {
+ pidDir, _ := path.Split(dir)
+ return strconv.Atoi(path.Base(pidDir))
+}
+
+func parseName(path string) (string, error) {
+ f, err := os.ReadFile(path)
+ if err != nil {
+ return "", fmt.Errorf("reading from %s: %w", path, err)
+ }
+ name := strings.TrimSpace(string(f))
+ if len(name) > 0 {
+ return name, nil
+ }
+ return "", ErrEmptyPIDName
+}

internal/pkg/util/process_test.go

@@ -0,0 +1,122 @@
+/*
+Copyright 2024 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http:https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package util
+
+import (
+ "fmt"
+ "os"
+ "path"
+ "testing"
+
+ "github.com/stretchr/testify/require"
+)
+
+func TestFindPIDByName(t *testing.T) {
+ t.Parallel()
+
+ cases := []struct {
+ name string
+ pid int
+ cmd string
+ cmdline string
+ create bool
+ skipCmd bool
+ emptyCmd bool
+ wantError bool
+ }{
+ {
+ name: "Find PID successfully",
+ pid: 123,
+ cmd: "/security-profiles-operator/test/spoc/demobinary",
+ cmdline: "/security-profiles-operator/test/spoc/demobinary--net-tcp--sleep60",
+ create: true,
+ skipCmd: false,
+ wantError: false,
+ },
+ {
+ name: "No pid available",
+ create: false,
+ wantError: true,
+ },
+ {
+ name: "No cmd available",
+ pid: 123,
+ cmd: "test-cmd",
+ create: true,
+ skipCmd: true,
+ wantError: true,
+ },
+ {
+ name: "Find PID successfully",
+ pid: 123,
+ cmd: "test-cmd",
+ cmdline: "test-cmd",
+ create: true,
+ skipCmd: false,
+ emptyCmd: true,
+ wantError: false,
+ },
+ }
+
+ for _, tc := range cases {
+ tc := tc
+ t.Run(tc.name, func(t *testing.T) {
+ t.Parallel()
+ tempDir := t.TempDir()
+ if tc.create {
+ err := createProcData(tempDir, tc.pid, tc.cmdline, tc.skipCmd, tc.emptyCmd)
+ require.NoError(t, err)
+ }
+ p := &proc{name: tc.cmd, pid: defaultPID}
+ gotPid, gotErr := p.findPIDByName(tempDir)
+ if !tc.wantError {
+ require.NoError(t, gotErr)
+ require.Equal(t, tc.pid, gotPid, "should find a valid PID by process name")
+ } else {
+ require.Error(t, gotErr)
+ }
+ })
+ }
+}
+
+func createProcData(root string, pid int, cmd string, skipCmd bool, emptyCmd bool) error {
+ procPath := path.Join(root, processRoot)
+ if err := os.Mkdir(procPath, 0700); err != nil {
+ return fmt.Errorf("creating proc root dir: %w", err)
+ }
+ procDir := path.Join(procPath, fmt.Sprintf("%d", pid))
+ if err := os.Mkdir(procDir, 0700); err != nil {
+ return fmt.Errorf("creating proc dir: %w", err)
+ }
+ if !skipCmd {
+ cmdFile := path.Join(procDir, "cmdline")
+ if err := os.WriteFile(cmdFile, []byte(cmd), 0644); err != nil {
+ return fmt.Errorf("creating cmd file: %w", err)
+ }
+ }
+ if emptyCmd {
+ procDir := path.Join(procPath, "567")
+ if err := os.Mkdir(procDir, 0700); err != nil {
+ return fmt.Errorf("creating proc dir: %w", err)
+ }
+ cmdFile := path.Join(procDir, "cmdline")
+ if err := os.WriteFile(cmdFile, []byte(""), 0644); err != nil {
+ return fmt.Errorf("creating cmd file: %w", err)
+ }
+ }
+ return nil
+}