| // Copyright 2023 The Go Authors. All rights reserved. | |
| // Use of this source code is governed by a BSD-style | |
| // license that can be found in the LICENSE file. | |
| package os_test | |
| import ( | |
| "errors" | |
| "internal/syscall/unix" | |
| "internal/testenv" | |
| "os" | |
| "os/exec" | |
| "syscall" | |
| "testing" | |
| ) | |
| func TestFindProcessViaPidfd(t *testing.T) { | |
| testenv.MustHaveGoBuild(t) | |
| t.Parallel() | |
| if err := os.CheckPidfdOnce(); err != nil { | |
| // Non-pidfd code paths tested in exec_unix_test.go. | |
| t.Skipf("skipping: pidfd not available: %v", err) | |
| } | |
| p, err := os.StartProcess(testenv.GoToolPath(t), []string{"go"}, &os.ProcAttr{}) | |
| if err != nil { | |
| t.Fatalf("starting test process: %v", err) | |
| } | |
| p.Wait() | |
| // Use pid of a non-existing process. | |
| proc, err := os.FindProcess(p.Pid) | |
| // FindProcess should never return errors on Unix. | |
| if err != nil { | |
| t.Fatalf("FindProcess: got error %v, want <nil>", err) | |
| } | |
| // FindProcess should never return nil Process. | |
| if proc == nil { | |
| t.Fatal("FindProcess: got nil, want non-nil") | |
| } | |
| if proc.Status() != os.StatusDone { | |
| t.Fatalf("got process status: %v, want %d", proc.Status(), os.StatusDone) | |
| } | |
| // Check that all Process' public methods work as expected with | |
| // "done" Process. | |
| if err := proc.Kill(); err != os.ErrProcessDone { | |
| t.Errorf("Kill: got %v, want %v", err, os.ErrProcessDone) | |
| } | |
| if err := proc.Signal(os.Kill); err != os.ErrProcessDone { | |
| t.Errorf("Signal: got %v, want %v", err, os.ErrProcessDone) | |
| } | |
| if _, err := proc.Wait(); !errors.Is(err, syscall.ECHILD) { | |
| t.Errorf("Wait: got %v, want %v", err, os.ErrProcessDone) | |
| } | |
| // Release never returns errors on Unix. | |
| if err := proc.Release(); err != nil { | |
| t.Fatalf("Release: got %v, want <nil>", err) | |
| } | |
| } | |
| func TestStartProcessWithPidfd(t *testing.T) { | |
| testenv.MustHaveGoBuild(t) | |
| t.Parallel() | |
| if err := os.CheckPidfdOnce(); err != nil { | |
| // Non-pidfd code paths tested in exec_unix_test.go. | |
| t.Skipf("skipping: pidfd not available: %v", err) | |
| } | |
| var pidfd int | |
| p, err := os.StartProcess(testenv.GoToolPath(t), []string{"go"}, &os.ProcAttr{ | |
| Sys: &syscall.SysProcAttr{ | |
| PidFD: &pidfd, | |
| }, | |
| }) | |
| if err != nil { | |
| t.Fatalf("starting test process: %v", err) | |
| } | |
| defer syscall.Close(pidfd) | |
| if _, err := p.Wait(); err != nil { | |
| t.Fatalf("Wait: got %v, want <nil>", err) | |
| } | |
| // Check the pidfd is still valid | |
| err = unix.PidFDSendSignal(uintptr(pidfd), syscall.Signal(0)) | |
| if !errors.Is(err, syscall.ESRCH) { | |
| t.Errorf("SendSignal: got %v, want %v", err, syscall.ESRCH) | |
| } | |
| } | |
| // Issue #69284 | |
| func TestPidfdLeak(t *testing.T) { | |
| exe := testenv.Executable(t) | |
| // Find the next 10 descriptors. | |
| // We need to get more than one descriptor in practice; | |
| // the pidfd winds up not being the next descriptor. | |
| const count = 10 | |
| want := make([]int, count) | |
| for i := range count { | |
| var err error | |
| want[i], err = syscall.Open(exe, syscall.O_RDONLY, 0) | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| } | |
| // Close the descriptors. | |
| for _, d := range want { | |
| syscall.Close(d) | |
| } | |
| // Start a process 10 times. | |
| for range 10 { | |
| // For testing purposes this has to be an absolute path. | |
| // Otherwise we will fail finding the executable | |
| // and won't start a process at all. | |
| cmd := exec.Command("/noSuchExecutable") | |
| cmd.Run() | |
| } | |
| // Open the next 10 descriptors again. | |
| got := make([]int, count) | |
| for i := range count { | |
| var err error | |
| got[i], err = syscall.Open(exe, syscall.O_RDONLY, 0) | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| } | |
| // Close the descriptors | |
| for _, d := range got { | |
| syscall.Close(d) | |
| } | |
| t.Logf("got %v", got) | |
| t.Logf("want %v", want) | |
| // Allow some slack for runtime epoll descriptors and the like. | |
| if got[count-1] > want[count-1]+5 { | |
| t.Errorf("got descriptor %d, want %d", got[count-1], want[count-1]) | |
| } | |
| } |