var ErrProcessDone … type processMode … const modePID … const modeHandle … type processStatus … const statusOK … const statusDone … const statusReleased … const processStatusMask … type Process … func newPIDProcess(pid int) *Process { … } func newHandleProcess(pid int, handle uintptr) *Process { … } func newDoneProcess(pid int) *Process { … } func (p *Process) handleTransientAcquire() (uintptr, processStatus) { … } func (p *Process) handleTransientRelease() { … } // Drop the Process' persistent reference on the handle, deactivating future // Wait/Signal calls with the passed reason. // // Returns the status prior to this call. If this is not statusOK, then the // reference was not dropped or status changed. func (p *Process) handlePersistentRelease(reason processStatus) processStatus { … } func (p *Process) pidStatus() processStatus { … } func (p *Process) pidDeactivate(reason processStatus) { … } type ProcAttr … type Signal … // Getpid returns the process id of the caller. func Getpid() int { … } // Getppid returns the process id of the caller's parent. func Getppid() int { … } // FindProcess looks for a running process by its pid. // // The [Process] it returns can be used to obtain information // about the underlying operating system process. // // On Unix systems, FindProcess always succeeds and returns a Process // for the given pid, regardless of whether the process exists. To test whether // the process actually exists, see whether p.Signal(syscall.Signal(0)) reports // an error. func FindProcess(pid int) (*Process, error) { … } // StartProcess starts a new process with the program, arguments and attributes // specified by name, argv and attr. The argv slice will become [os.Args] in the // new process, so it normally starts with the program name. // // If the calling goroutine has locked the operating system thread // with [runtime.LockOSThread] and modified any inheritable OS-level // thread state (for example, Linux or Plan 9 name spaces), the new // process will inherit the caller's thread state. // // StartProcess is a low-level interface. The [os/exec] package provides // higher-level interfaces. // // If there is an error, it will be of type [*PathError]. func StartProcess(name string, argv []string, attr *ProcAttr) (*Process, error) { … } // Release releases any resources associated with the [Process] p, // rendering it unusable in the future. // Release only needs to be called if [Process.Wait] is not. func (p *Process) Release() error { … } // Kill causes the [Process] to exit immediately. Kill does not wait until // the Process has actually exited. This only kills the Process itself, // not any other processes it may have started. func (p *Process) Kill() error { … } // Wait waits for the [Process] to exit, and then returns a // ProcessState describing its status and an error, if any. // Wait releases any resources associated with the Process. // On most operating systems, the Process must be a child // of the current process or an error will be returned. func (p *Process) Wait() (*ProcessState, error) { … } // Signal sends a signal to the [Process]. // Sending [Interrupt] on Windows is not implemented. func (p *Process) Signal(sig Signal) error { … } // UserTime returns the user CPU time of the exited process and its children. func (p *ProcessState) UserTime() time.Duration { … } // SystemTime returns the system CPU time of the exited process and its children. func (p *ProcessState) SystemTime() time.Duration { … } // Exited reports whether the program has exited. // On Unix systems this reports true if the program exited due to calling exit, // but false if the program terminated due to a signal. func (p *ProcessState) Exited() bool { … } // Success reports whether the program exited successfully, // such as with exit status 0 on Unix. func (p *ProcessState) Success() bool { … } // Sys returns system-dependent exit information about // the process. Convert it to the appropriate underlying // type, such as [syscall.WaitStatus] on Unix, to access its contents. func (p *ProcessState) Sys() any { … } // SysUsage returns system-dependent resource usage information about // the exited process. Convert it to the appropriate underlying // type, such as [*syscall.Rusage] on Unix, to access its contents. // (On Unix, *syscall.Rusage matches struct rusage as defined in the // getrusage(2) manual page.) func (p *ProcessState) SysUsage() any { … }
Codebase Browser
go