@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) {

    @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;
    }

	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.

    @Nullable
    private final Long pid;
    private final String version;
    private final String status;

    public Status(Long pid, String version, String status) {
        this.pid = pid;
        this.version = version;
        this.status = status;
    }

    @Nullable
    public Long getPid() {
        return pid;
    }

    public String getVersion() {
        return version;

		buildscripts/verify-build.sh \
		minio/healing-rewrite-bucket/ \
		--disable-multipart --quiet

	kill ${pid}
	sleep 3

	"${MINIO[@]}" --address ":$start_port" "${WORK_DIR}/xl{1...16}" >"${WORK_DIR}/server1.log" 2>&1 &
	pid=$!
	disown $pid

	"${WORK_DIR}/mc" ready minio/

	if ! ps -p ${pid} 1>&2 >/dev/null; then
		echo "server1 log:"
		cat "${WORK_DIR}/server1.log"
		echo "FAILED"
		purge "$WORK_DIR"

	if !pidfdWorks() {
		return 0, false
	}

	return uintptr(*sysAttr.PidFD), true
}

func pidfdFind(pid int) (uintptr, error) {
	if !pidfdWorks() {
		return 0, syscall.ENOSYS
	}

	h, err := unix.PidFDOpen(pid, 0)
	if err != nil {
		return 0, convertESRCH(err)
	}
	return h, nil
}

// _P_PIDFD is used as idtype argument to waitid syscall.
const _P_PIDFD = 3