...
Run Format

Source file src/os/doc.go

     1	// Copyright 2012 The Go Authors. All rights reserved.
     2	// Use of this source code is governed by a BSD-style
     3	// license that can be found in the LICENSE file.
     4	
     5	package os
     6	
     7	import "time"
     8	
     9	// FindProcess looks for a running process by its pid.
    10	//
    11	// The Process it returns can be used to obtain information
    12	// about the underlying operating system process.
    13	//
    14	// On Unix systems, FindProcess always succeeds and returns a Process
    15	// for the given pid, regardless of whether the process exists.
    16	func FindProcess(pid int) (*Process, error) {
    17		return findProcess(pid)
    18	}
    19	
    20	// StartProcess starts a new process with the program, arguments and attributes
    21	// specified by name, argv and attr.
    22	//
    23	// StartProcess is a low-level interface. The os/exec package provides
    24	// higher-level interfaces.
    25	//
    26	// If there is an error, it will be of type *PathError.
    27	func StartProcess(name string, argv []string, attr *ProcAttr) (*Process, error) {
    28		return startProcess(name, argv, attr)
    29	}
    30	
    31	// Release releases any resources associated with the Process p,
    32	// rendering it unusable in the future.
    33	// Release only needs to be called if Wait is not.
    34	func (p *Process) Release() error {
    35		return p.release()
    36	}
    37	
    38	// Kill causes the Process to exit immediately.
    39	func (p *Process) Kill() error {
    40		return p.kill()
    41	}
    42	
    43	// Wait waits for the Process to exit, and then returns a
    44	// ProcessState describing its status and an error, if any.
    45	// Wait releases any resources associated with the Process.
    46	// On most operating systems, the Process must be a child
    47	// of the current process or an error will be returned.
    48	func (p *Process) Wait() (*ProcessState, error) {
    49		return p.wait()
    50	}
    51	
    52	// Signal sends a signal to the Process.
    53	// Sending Interrupt on Windows is not implemented.
    54	func (p *Process) Signal(sig Signal) error {
    55		return p.signal(sig)
    56	}
    57	
    58	// UserTime returns the user CPU time of the exited process and its children.
    59	func (p *ProcessState) UserTime() time.Duration {
    60		return p.userTime()
    61	}
    62	
    63	// SystemTime returns the system CPU time of the exited process and its children.
    64	func (p *ProcessState) SystemTime() time.Duration {
    65		return p.systemTime()
    66	}
    67	
    68	// Exited reports whether the program has exited.
    69	func (p *ProcessState) Exited() bool {
    70		return p.exited()
    71	}
    72	
    73	// Success reports whether the program exited successfully,
    74	// such as with exit status 0 on Unix.
    75	func (p *ProcessState) Success() bool {
    76		return p.success()
    77	}
    78	
    79	// Sys returns system-dependent exit information about
    80	// the process.  Convert it to the appropriate underlying
    81	// type, such as syscall.WaitStatus on Unix, to access its contents.
    82	func (p *ProcessState) Sys() interface{} {
    83		return p.sys()
    84	}
    85	
    86	// SysUsage returns system-dependent resource usage information about
    87	// the exited process.  Convert it to the appropriate underlying
    88	// type, such as *syscall.Rusage on Unix, to access its contents.
    89	// (On Unix, *syscall.Rusage matches struct rusage as defined in the
    90	// getrusage(2) manual page.)
    91	func (p *ProcessState) SysUsage() interface{} {
    92		return p.sysUsage()
    93	}
    94	
    95	// Hostname returns the host name reported by the kernel.
    96	func Hostname() (name string, err error) {
    97		return hostname()
    98	}
    99	
   100	// Readdir reads the contents of the directory associated with file and
   101	// returns a slice of up to n FileInfo values, as would be returned
   102	// by Lstat, in directory order. Subsequent calls on the same file will yield
   103	// further FileInfos.
   104	//
   105	// If n > 0, Readdir returns at most n FileInfo structures. In this case, if
   106	// Readdir returns an empty slice, it will return a non-nil error
   107	// explaining why. At the end of a directory, the error is io.EOF.
   108	//
   109	// If n <= 0, Readdir returns all the FileInfo from the directory in
   110	// a single slice. In this case, if Readdir succeeds (reads all
   111	// the way to the end of the directory), it returns the slice and a
   112	// nil error. If it encounters an error before the end of the
   113	// directory, Readdir returns the FileInfo read until that point
   114	// and a non-nil error.
   115	func (f *File) Readdir(n int) (fi []FileInfo, err error) {
   116		if f == nil {
   117			return nil, ErrInvalid
   118		}
   119		return f.readdir(n)
   120	}
   121	
   122	// Readdirnames reads and returns a slice of names from the directory f.
   123	//
   124	// If n > 0, Readdirnames returns at most n names. In this case, if
   125	// Readdirnames returns an empty slice, it will return a non-nil error
   126	// explaining why. At the end of a directory, the error is io.EOF.
   127	//
   128	// If n <= 0, Readdirnames returns all the names from the directory in
   129	// a single slice. In this case, if Readdirnames succeeds (reads all
   130	// the way to the end of the directory), it returns the slice and a
   131	// nil error. If it encounters an error before the end of the
   132	// directory, Readdirnames returns the names read until that point and
   133	// a non-nil error.
   134	func (f *File) Readdirnames(n int) (names []string, err error) {
   135		if f == nil {
   136			return nil, ErrInvalid
   137		}
   138		return f.readdirnames(n)
   139	}
   140	

View as plain text