133 lines
4.4 KiB
Go
133 lines
4.4 KiB
Go
// Copyright 2012 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package os
|
|
|
|
import "time"
|
|
|
|
// 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.
|
|
func FindProcess(pid int) (p *Process, err error) {
|
|
return findProcess(pid)
|
|
}
|
|
|
|
// StartProcess starts a new process with the program, arguments and attributes
|
|
// specified by name, argv and attr.
|
|
//
|
|
// 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) {
|
|
return startProcess(name, argv, attr)
|
|
}
|
|
|
|
// Release releases any resources associated with the Process p,
|
|
// rendering it unusable in the future.
|
|
// Release only needs to be called if Wait is not.
|
|
func (p *Process) Release() error {
|
|
return p.release()
|
|
}
|
|
|
|
// Kill causes the Process to exit immediately.
|
|
func (p *Process) Kill() error {
|
|
return p.kill()
|
|
}
|
|
|
|
// 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.
|
|
func (p *Process) Wait() (*ProcessState, error) {
|
|
return p.wait()
|
|
}
|
|
|
|
// Signal sends a signal to the Process.
|
|
func (p *Process) Signal(sig Signal) error {
|
|
return p.signal(sig)
|
|
}
|
|
|
|
// UserTime returns the user CPU time of the exited process and its children.
|
|
func (p *ProcessState) UserTime() time.Duration {
|
|
return p.userTime()
|
|
}
|
|
|
|
// SystemTime returns the system CPU time of the exited process and its children.
|
|
func (p *ProcessState) SystemTime() time.Duration {
|
|
return p.systemTime()
|
|
}
|
|
|
|
// Exited reports whether the program has exited.
|
|
func (p *ProcessState) Exited() bool {
|
|
return p.exited()
|
|
}
|
|
|
|
// Success reports whether the program exited successfully,
|
|
// such as with exit status 0 on Unix.
|
|
func (p *ProcessState) Success() bool {
|
|
return p.success()
|
|
}
|
|
|
|
// 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() interface{} {
|
|
return p.sys()
|
|
}
|
|
|
|
// 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() interface{} {
|
|
return p.sysUsage()
|
|
}
|
|
|
|
// Hostname returns the host name reported by the kernel.
|
|
func Hostname() (name string, err error) {
|
|
return hostname()
|
|
}
|
|
|
|
// Readdir reads the contents of the directory associated with file and
|
|
// returns a slice of up to n FileInfo values, as would be returned
|
|
// by Lstat, in directory order. Subsequent calls on the same file will yield
|
|
// further FileInfos.
|
|
//
|
|
// If n > 0, Readdir returns at most n FileInfo structures. In this case, if
|
|
// Readdir returns an empty slice, it will return a non-nil error
|
|
// explaining why. At the end of a directory, the error is io.EOF.
|
|
//
|
|
// If n <= 0, Readdir returns all the FileInfo from the directory in
|
|
// a single slice. In this case, if Readdir succeeds (reads all
|
|
// the way to the end of the directory), it returns the slice and a
|
|
// nil error. If it encounters an error before the end of the
|
|
// directory, Readdir returns the FileInfo read until that point
|
|
// and a non-nil error.
|
|
func (f *File) Readdir(n int) (fi []FileInfo, err error) {
|
|
if f == nil {
|
|
return nil, ErrInvalid
|
|
}
|
|
return f.readdir(n)
|
|
}
|
|
|
|
// Readdirnames reads and returns a slice of names from the directory f.
|
|
//
|
|
// If n > 0, Readdirnames returns at most n names. In this case, if
|
|
// Readdirnames returns an empty slice, it will return a non-nil error
|
|
// explaining why. At the end of a directory, the error is io.EOF.
|
|
//
|
|
// If n <= 0, Readdirnames returns all the names from the directory in
|
|
// a single slice. In this case, if Readdirnames succeeds (reads all
|
|
// the way to the end of the directory), it returns the slice and a
|
|
// nil error. If it encounters an error before the end of the
|
|
// directory, Readdirnames returns the names read until that point and
|
|
// a non-nil error.
|
|
func (f *File) Readdirnames(n int) (names []string, err error) {
|
|
if f == nil {
|
|
return nil, ErrInvalid
|
|
}
|
|
return f.readdirnames(n)
|
|
}
|