class ProcessFixture {
    final Long pid;

    ProcessFixture(Long pid) {
        this.pid = pid
    }

    /**
     * Forcefully kills this daemon.
     */
    void kill(boolean killTree) {
        println "Killing process with pid: $pid"
        if (pid == null) {
            throw new RuntimeException("Unable to force kill the process because provided pid is null!")
        }

    @Nullable
    private final Long pid;
    private final File daemonLog;
    private final static int TAIL_SIZE = 20;

    public DaemonDiagnostics(File daemonLog, @Nullable Long pid) {
        this.daemonLog = daemonLog;
        this.pid = pid;
    }

    /**
     * @return pid. Can be null, it means the daemon was not able to identify its pid.
     */
    public @Nullable Long getPid() {

	}

	return convertESRCH(syscall.Kill(p.Pid, s))
}

func convertESRCH(err error) error {
	if err == syscall.ESRCH {
		return ErrProcessDone
	}
	return err
}

func (p *Process) release() error {
	// We clear the Pid field only for API compatibility. On Unix, Release
	// has always set Pid to -1. Internally, the implementation relies

		return nil, ErrInvalid
	}

	err = syscall.WaitProcess(p.Pid, &waitmsg)
	if err != nil {
		return nil, NewSyscallError("wait", err)
	}

	p.pidDeactivate(statusDone)
	ps = &ProcessState{
		pid:    waitmsg.Pid,
		status: &waitmsg,
	}
	return ps, nil
}

func (p *Process) release() error {
	p.Pid = -1

	// Just mark the PID unusable.
	p.pidDeactivate(statusReleased)

    def "PID can be null"() {
        given:
        def daemonContext = new DefaultDaemonContext(null, null, null, null, null, null, null, false, NativeServicesMode.ENABLED, null)

        when:
        def pid = daemonContext.pid;

        then:
        noExceptionThrown()
        pid == null
    }

    def "PID unboxing should not happen in Status"() {
        given:

            encoder.writeSmallInt(context.javaVersion.asInt());
            encoder.writeString(context.daemonRegistryDir.getPath());
            encoder.writeBoolean(context.pid != null);
            if (context.pid != null) {
                encoder.writeLong(context.pid);
            }
            encoder.writeBoolean(context.idleTimeout != null);
            if (context.idleTimeout != null) {

                System.out.println("Killing Gradle process with PID " + pid + ": " + line);
                pkill(pid);
            });
        } else {
            forEachLeakingJavaProcess(rootProjectDir, (pid, line) -> {
                System.out.println("A process wasn't shutdown properly in a previous Gradle run. Killing process with PID " + pid + ": " + line);
                pkill(pid);

    @Nullable
    private final Long pid;
    @Nullable
    private final DaemonExpirationStatus status;
    @Nullable
    private final String reason;

    public DaemonStopEvent(Date timestamp, @Nullable Long pid, @Nullable DaemonExpirationStatus status, @Nullable String reason) {
        this.timestamp = timestamp;
        this.status = status;
        this.reason = reason;
        this.pid = pid;
    }

	}
}

func isProcessRunningInHost(pid int) (bool, error) {
	// Get init pid namespace.
	initPidNs, err := os.Readlink("/proc/1/ns/pid")
	if err != nil {
		return false, fmt.Errorf("failed to find pid namespace of init process")
	}
	klog.V(10).InfoS("Found init PID namespace", "namespace", initPidNs)
	processPidNs, err := os.Readlink(fmt.Sprintf("/proc/%d/ns/pid", pid))
	if err != nil {

	l := p.local                              // load-consume
	if uintptr(pid) < s {
		return indexLocal(l, pid), pid
	}
	return p.pinSlow()
}

func (p *Pool) pinSlow() (*poolLocal, int) {
	// Retry under the mutex.
	// Can not lock the mutex while pinned.
	runtime_procUnpin()
	allPoolsMu.Lock()
	defer allPoolsMu.Unlock()
	pid := runtime_procPin()
	// poolCleanup won't be called while we are pinned.