os.FindProcess, process.Release

src/os/exec.go

@@ -58,10 +58,13 @@ type Process struct {
 }
 
 func StartProcess(name string, argv []string, attr *ProcAttr) (*Process, error) {
- return nil, &PathError{"fork/exec", name, ErrNotImplemented}
+ return nil, &PathError{Op: "fork/exec", Path: name, Err: ErrNotImplemented}
 }
 
 func (p *Process) Wait() (*ProcessState, error) {
+ if p.Pid == -1 {
+ return nil, syscall.EINVAL
+ }
  return nil, ErrNotImplemented
 }
 
@@ -77,3 +80,15 @@ func Ignore(sig ...Signal) {
  // leave all the signals unaltered
  return
 }
+
+// Release releases any resources associated with the Process p,
+// rendering it unusable in the future.
+// Release only needs to be called if Wait is not.
+func (p *Process) Release() error {
+ return p.release()
+}
+
+// Keep compatibility with golang and always succeed and return new proc with pid on Linux.
+func FindProcess(pid int) (*Process, error) {
+ return findProcess(pid)
+}

src/os/exec_posix.go

@@ -7,6 +7,7 @@
 package os
 
 import (
+ "runtime"
  "syscall"
 )
 
@@ -19,3 +20,16 @@ var (
  Interrupt Signal = syscall.SIGINT
  Kill Signal = syscall.SIGKILL
 )
+
+// Keep compatible with golang and always succeed and return new proc with pid on Linux.
+func findProcess(pid int) (*Process, error) {
+ return &Process{Pid: pid}, nil
+}
+
+func (p *Process) release() error {
+ // NOOP for unix.
+ p.Pid = -1
+ // no need for a finalizer anymore
+ runtime.SetFinalizer(p, nil)
+ return nil
+}

src/os/exec_test.go

@@ -0,0 +1,28 @@
+// Copyright 2024 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 (
+ . "os"
+ "testing"
+)
+
+func TestFindProcess(t *testing.T) {
+ // NOTE: For now, we only test the Linux case since only exec_posix.go is currently the only implementation.
+ // Linux guarantees that there is pid 0
+ proc, err := FindProcess(0)
+ if err != nil {
+ t.Error("FindProcess(0): wanted err == nil, got %v:", err)
+ }
+
+ if proc.Pid != 0 {
+ t.Error("Expected pid 0, got: ", proc.Pid)
+ }
+
+ pid0 := Process{Pid: 0}
+ if *proc != pid0 {
+ t.Error("Expected &Process{Pid: 0}, got", *proc)
+ }
+}