Subversion Repositories openrisc

// Copyright 2009 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.

// +build darwin freebsd linux netbsd openbsd windows

package os

import (

        "runtime"

        "syscall"

)

type UnixSignal int32

func (sig UnixSignal) String() string {

        s := runtime.Signame(int32(sig))

        if len(s) > 0 {

                return s

        }

        return "UnixSignal"

}

// 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.

func StartProcess(name string, argv []string, attr *ProcAttr) (p *Process, err error) {

        sysattr := &syscall.ProcAttr{

                Dir: attr.Dir,

                Env: attr.Env,

                Sys: attr.Sys,

        }

        if sysattr.Env == nil {

                sysattr.Env = Environ()

        }

        for _, f := range attr.Files {

                sysattr.Files = append(sysattr.Files, f.Fd())

        }

        pid, h, e := syscall.StartProcess(name, argv, sysattr)

        if e != nil {

                return nil, &PathError{"fork/exec", name, e}

        }

        return newProcess(pid, h), nil

}

// Kill causes the Process to exit immediately.

func (p *Process) Kill() error {

        return p.Signal(UnixSignal(syscall.SIGKILL))

}

// Exec replaces the current process with an execution of the

// named binary, with arguments argv and environment envv.

// If successful, Exec never returns.  If it fails, it returns an error.

//

// To run a child process, see StartProcess (for a low-level interface)

// or the os/exec package (for higher-level interfaces).

func Exec(name string, argv []string, envv []string) error {

        if envv == nil {

                envv = Environ()

        }

        e := syscall.Exec(name, argv, envv)

        if e != nil {

                return &PathError{"exec", name, e}

        }

        return nil

}

// TODO(rsc): Should os implement its own syscall.WaitStatus

// wrapper with the methods, or is exposing the underlying one enough?

//

// TODO(rsc): Certainly need to have Rusage struct,

// since syscall one might have different field types across

// different OS.

// Waitmsg stores the information about an exited process as reported by Wait.

type Waitmsg struct {

        Pid                int             // The process's id.

        syscall.WaitStatus                 // System-dependent status info.

        Rusage             *syscall.Rusage // System-dependent resource usage info.

}

// Wait waits for process pid to exit or stop, and then returns a

// Waitmsg describing its status and an error, if any. The options

// (WNOHANG etc.) affect the behavior of the Wait call.

// Wait is equivalent to calling FindProcess and then Wait

// and Release on the result.

func Wait(pid int, options int) (w *Waitmsg, err error) {

        p, e := FindProcess(pid)

        if e != nil {

                return nil, e

        }

        defer p.Release()

        return p.Wait(options)

}

// Convert i to decimal string.

func itod(i int) string {

        if i == 0 {

                return "0"

        }

        u := uint64(i)

        if i < 0 {

                u = -u

        }

        // Assemble decimal in reverse order.

        var b [32]byte

        bp := len(b)

        for ; u > 0; u /= 10 {

                bp--

                b[bp] = byte(u%10) + '0'

        }

        if i < 0 {

                bp--

                b[bp] = '-'

        }

        return string(b[bp:])

}

func (w *Waitmsg) String() string {

        if w == nil {

                return ""

        }

        // TODO(austin) Use signal names when possible?

        res := ""

        switch {

        case w.Exited():

                res = "exit status " + itod(w.ExitStatus())

        case w.Signaled():

                res = "signal " + itod(w.Signal())

        case w.Stopped():

                res = "stop signal " + itod(w.StopSignal())

                if w.StopSignal() == syscall.SIGTRAP && w.TrapCause() != 0 {

                        res += " (trap " + itod(w.TrapCause()) + ")"

                }

        case w.Continued():

                res = "continued"

        }

        if w.CoreDump() {

                res += " (core dumped)"

        }

        return res

}