...
Run Format

Source file src/os/exec_plan9.go

Documentation: os

     1  // Copyright 2009 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 (
     8  	"errors"
     9  	"runtime"
    10  	"syscall"
    11  	"time"
    12  )
    13  
    14  // The only signal values guaranteed to be present in the os package
    15  // on all systems are Interrupt (send the process an interrupt) and
    16  // Kill (force the process to exit). Interrupt is not implemented on
    17  // Windows; using it with os.Process.Signal will return an error.
    18  var (
    19  	Interrupt Signal = syscall.Note("interrupt")
    20  	Kill      Signal = syscall.Note("kill")
    21  )
    22  
    23  func startProcess(name string, argv []string, attr *ProcAttr) (p *Process, err error) {
    24  	sysattr := &syscall.ProcAttr{
    25  		Dir: attr.Dir,
    26  		Env: attr.Env,
    27  		Sys: attr.Sys,
    28  	}
    29  
    30  	for _, f := range attr.Files {
    31  		sysattr.Files = append(sysattr.Files, f.Fd())
    32  	}
    33  
    34  	pid, h, e := syscall.StartProcess(name, argv, sysattr)
    35  	if e != nil {
    36  		return nil, &PathError{"fork/exec", name, e}
    37  	}
    38  
    39  	return newProcess(pid, h), nil
    40  }
    41  
    42  func (p *Process) writeProcFile(file string, data string) error {
    43  	f, e := OpenFile("/proc/"+itoa(p.Pid)+"/"+file, O_WRONLY, 0)
    44  	if e != nil {
    45  		return e
    46  	}
    47  	defer f.Close()
    48  	_, e = f.Write([]byte(data))
    49  	return e
    50  }
    51  
    52  func (p *Process) signal(sig Signal) error {
    53  	if p.done() {
    54  		return errors.New("os: process already finished")
    55  	}
    56  	if e := p.writeProcFile("note", sig.String()); e != nil {
    57  		return NewSyscallError("signal", e)
    58  	}
    59  	return nil
    60  }
    61  
    62  func (p *Process) kill() error {
    63  	return p.signal(Kill)
    64  }
    65  
    66  func (p *Process) wait() (ps *ProcessState, err error) {
    67  	var waitmsg syscall.Waitmsg
    68  
    69  	if p.Pid == -1 {
    70  		return nil, ErrInvalid
    71  	}
    72  	err = syscall.WaitProcess(p.Pid, &waitmsg)
    73  	if err != nil {
    74  		return nil, NewSyscallError("wait", err)
    75  	}
    76  
    77  	p.setDone()
    78  	ps = &ProcessState{
    79  		pid:    waitmsg.Pid,
    80  		status: &waitmsg,
    81  	}
    82  	return ps, nil
    83  }
    84  
    85  func (p *Process) release() error {
    86  	// NOOP for Plan 9.
    87  	p.Pid = -1
    88  	// no need for a finalizer anymore
    89  	runtime.SetFinalizer(p, nil)
    90  	return nil
    91  }
    92  
    93  func findProcess(pid int) (p *Process, err error) {
    94  	// NOOP for Plan 9.
    95  	return newProcess(pid, 0), nil
    96  }
    97  
    98  // ProcessState stores information about a process, as reported by Wait.
    99  type ProcessState struct {
   100  	pid    int              // The process's id.
   101  	status *syscall.Waitmsg // System-dependent status info.
   102  }
   103  
   104  // Pid returns the process id of the exited process.
   105  func (p *ProcessState) Pid() int {
   106  	return p.pid
   107  }
   108  
   109  func (p *ProcessState) exited() bool {
   110  	return p.status.Exited()
   111  }
   112  
   113  func (p *ProcessState) success() bool {
   114  	return p.status.ExitStatus() == 0
   115  }
   116  
   117  func (p *ProcessState) sys() interface{} {
   118  	return p.status
   119  }
   120  
   121  func (p *ProcessState) sysUsage() interface{} {
   122  	return p.status
   123  }
   124  
   125  func (p *ProcessState) userTime() time.Duration {
   126  	return time.Duration(p.status.Time[0]) * time.Millisecond
   127  }
   128  
   129  func (p *ProcessState) systemTime() time.Duration {
   130  	return time.Duration(p.status.Time[1]) * time.Millisecond
   131  }
   132  
   133  func (p *ProcessState) String() string {
   134  	if p == nil {
   135  		return "<nil>"
   136  	}
   137  	return "exit status: " + p.status.Msg
   138  }
   139  

View as plain text