*/
    File getDaemonRegistryDir();

    /**
     * The process id of the daemon.
     */
    Long getPid();

    /**
     * The daemon's idle timeout in milliseconds.
     */
    Integer getIdleTimeout();

    /**
     * Returns the JVM options that the daemon was started with.
     *
     * @return the JVM options that the daemon was started with
     */

//sys	Fstatfs(fd int, buf *Statfs_t) (err error)
//sys	Ftruncate(fd int, length int64) (err error)
//sysnb	Getegid() (egid int)
//sysnb	Geteuid() (euid int)
//sysnb	Getgid() (gid int)
//sysnb	Getrlimit(resource int, rlim *Rlimit) (err error) = SYS_GETRLIMIT
//sysnb	Getuid() (uid int)
//sysnb	InotifyInit() (fd int, err error)
//sys	Lchown(path string, uid int, gid int) (err error)

	if len(name) == 0 {
		return []int{}, fmt.Errorf("name should not be empty")
	}
	re, err := regexp.Compile("(^|/)" + name + "$")
	if err != nil {
		return []int{}, err
	}
	return getPids(re), nil
}

func getPids(re *regexp.Regexp) []int {
	pids := []int{}

	dirFD, err := os.Open("/proc")
	if err != nil {
		return nil
	}
	defer dirFD.Close()

	for {

	if runtime.GOARCH == "wasm" {
		t.Skip("Signals send + notify not fully supported om wasm port")
	}

	c := make(chan os.Signal, 1)
	signal.Notify(c, os.Interrupt)
	defer signal.Stop(c)

	p := &os.Process{Pid: os.Getpid()}
	if err := p.Signal(os.Interrupt); err != nil {
		t.Fatalf("Signal got err %v, want nil", err)
	}

	// Verify we actually received the signal.
	select {
	case <-time.After(1 * time.Second):

TEXT ·fcntl1(SB),NOSPLIT,$0
	JMP	runtime·syscall_fcntl(SB)

TEXT ·forkx(SB),NOSPLIT,$0
	JMP	runtime·syscall_forkx(SB)

TEXT ·gethostname(SB),NOSPLIT,$0
	JMP	runtime·syscall_gethostname(SB)

TEXT ·getpid(SB),NOSPLIT,$0
	JMP	runtime·syscall_getpid(SB)

TEXT ·ioctl(SB),NOSPLIT,$0
	JMP	runtime·syscall_ioctl(SB)

TEXT ·RawSyscall(SB),NOSPLIT,$0
	JMP	runtime·syscall_rawsyscall(SB)

TEXT ·RawSyscall6(SB),NOSPLIT,$0

}

func createModuleSnapshot() (syscall.Handle, error) {
	for {
		snap, err := syscall.CreateToolhelp32Snapshot(windows.TH32CS_SNAPMODULE|windows.TH32CS_SNAPMODULE32, uint32(syscall.Getpid()))
		var errno syscall.Errno
		if err != nil && errors.As(err, &errno) && errno == windows.ERROR_BAD_LENGTH {
			// When CreateToolhelp32Snapshot(SNAPMODULE|SNAPMODULE32, ...) fails

        throw notSupported();
    }

    @Override
    public boolean maybeSetProcessDir(File processDir) {
        return false;
    }

    @Override
    public Long getPid() throws NativeIntegrationException {
        if (pid != null) {
            return pid;
        }
        throw notSupported();
    }

    @Override
    public Long maybeGetPid() {

                return 0;
            }
        });

        // User likely doesn't care about daemons that stopped a long time ago
        for (DaemonStopEvent event : sortedEvents) {
            Long pid = event.getPid();
            if (event.occurredInLastHours(RECENTLY) && !uniqueStoppedPids.contains(pid)) {
                // We can only determine if two DaemonStopEvent point at the same daemon if we know the PIDs

	for i := 0; i < goCount; i++ {
		go func() {
			defer wg.Done()
			for j := 0; j < execCount; j++ {
				c2 := make(chan os.Signal, 1)
				signal.Notify(c2, syscall.SIGUSR1)
				syscall.Kill(os.Getpid(), syscall.SIGTERM)
				go func(j int) {
					defer wg.Done()
					cmd := exec.Command(os.Args[0], "CgoExecSignalMask", "testsigint")
					cmd.Stdin = os.Stdin
					cmd.Stdout = os.Stdout
					cmd.Stderr = os.Stderr

	// we can't test that it does anything.
	// Instead we're testing that the conditions are good
	// for how it is used in init (must be on main thread).
	pid, tid = syscall.Getpid(), syscall.Gettid()
	LockOSThread()

	sysNanosleep = func(d time.Duration) {
		// Invoke a blocking syscall directly; calling time.Sleep()
		// would deschedule the goroutine instead.