| // 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. |
| // |
| // On Unix systems, FindProcess always succeeds and returns a Process |
| // for the given pid, regardless of whether the process exists. |
| func FindProcess(pid int) (*Process, 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. |
| // 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) { |
| return p.wait() |
| } |
| |
| // Signal sends a signal to the Process. |
| // Sending Interrupt on Windows is not implemented. |
| 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) ([]FileInfo, 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) |
| } |