os: process already finished when sending syscall.SIGCONT (possible bug?)

When executing a process and sending signals to it using: Process.Signal I notice that after sending the second signal syscall.SIGCONT I got a: os: process already finished but if using syscall.Kill everything works as expected.

For demonstrative purposes I have created this naive example:

package main

import (
	"fmt"
	"os"
	"os/exec"
	"syscall"
	"time"
)

func main() {
	exit := make(chan error, 1)
	go run(exit)

	for {
		select {
		case <-exit:
			println("fin, restarting")
			run(exit)
		default:
			time.Sleep(time.Second)
			println("running...")
		}
	}
}

func run(ch chan<- error) {
	cmd := exec.Command("sleep", "3")
	if err := cmd.Start(); err != nil {
		print(err.Error())
	 	os.Exit(1)
	}
	fmt.Printf("Pid: %d\n", cmd.Process.Pid)
    go func() {
		ch <- cmd.Wait()
	}()

	time.Sleep(2 * time.Second)
	fmt.Printf("%v\n", cmd.Process.Signal(syscall.SIGSTOP))
	
    time.Sleep(2 * time.Second)
	
    // Using this will return an os: process already finished  
    fmt.Printf("%v\n", cmd.Process.Signal(syscall.SIGCONT)) 

    // This works as expected
	//fmt.Printf("%v\n", syscall.Kill(cmd.Process.Pid, syscall.SIGCONT))
}

So basically if using:

cmd.Process.Signal(syscall.SIGCONT)

os: process already finished is returned

But when using:

syscall.Kill(cmd.Process.Pid, syscall.SIGCONT)

It works as expected.

Could this be a bug on os.exec or it the expected behavior?

UPDATE: seems to be happening only on mac os X

This issue seems to be only happening on Mac OS X, tested on "Sierra" and "El Capitan" https://go-review.googlesource.com/#/c/37610/

So, for now, to keep things cross-platform better user:

syscall.Kill(cmd.Process.Pid, syscall.SIGCONT))

Example code to test if your system has this issue:

package main

import (
	"fmt"
	"log"
	"os/exec"
	"syscall"
	"unsafe"
)

func main() {
	cmd := exec.Command("sleep", "10")
	if err := cmd.Start(); err != nil {
		log.Fatal(err)
	}

	// signal when wait4 will return immediately
	go func() {
		var siginfo [128]byte
		psig := &siginfo[0]
		_, _, e := syscall.Syscall6(syscall.SYS_WAITID, 1, uintptr(cmd.Process.Pid), uintptr(unsafe.Pointer(psig)), syscall.WEXITED|syscall.WNOWAIT, 0, 0)
		fmt.Println("WAITID RETURNED -- this shouldn't happen:", e)
	}()

	err := cmd.Process.Signal(syscall.SIGSTOP)
	if err != nil {
		log.Fatal(err)
	}
	cmd.Wait()
}