Imported Upstream version 59upstream/59

20 files changed, 310 insertions, 117 deletions

diff --git a/src/pkg/os/Makefile b/src/pkg/os/Makefile
index 497e5a958..354e1e8db 100644
--- a/src/pkg/os/Makefile
+++ b/src/pkg/os/Makefile
@@ -73,6 +73,7 @@ GOFILES_plan9=\
 	path_plan9.go\
 	sys_plan9.go\
 	exec_plan9.go\
+	str.go\
 
 GOFILES+=$(GOFILES_$(GOOS))
 
@@ -83,5 +84,5 @@ include ../../Make.pkg
 signal_unix.go: ../syscall/zerrors_$(GOOS)_$(GOARCH).go
 	./mkunixsignals.sh $< > $@ || rm -f $@
 
-signal_windows.go: ../syscall/ztypes_$(GOOS)_$(GOARCH).go
+signal_windows.go: ../syscall/ztypes_$(GOOS).go
 	./mkunixsignals.sh $< > $@ || rm -f $@
diff --git a/src/pkg/os/env_windows.go b/src/pkg/os/env_windows.go
index a45d79be3..e6ddc4065 100644
--- a/src/pkg/os/env_windows.go
+++ b/src/pkg/os/env_windows.go
@@ -119,7 +119,7 @@ func init() {
 	if e != 0 {
 		return
 	}
-	defer syscall.LocalFree(uint32(uintptr(unsafe.Pointer(argv))))
+	defer syscall.LocalFree(syscall.Handle(uintptr(unsafe.Pointer(argv))))
 	Args = make([]string, argc)
 	for i, v := range (*argv)[:argc] {
 		Args[i] = string(syscall.UTF16ToString((*v)[:]))
diff --git a/src/pkg/os/error.go b/src/pkg/os/error.go
index 2c4516ca7..b4511dd2f 100644
--- a/src/pkg/os/error.go
+++ b/src/pkg/os/error.go
@@ -9,20 +9,17 @@ type Error interface {
 	String() string
 }
 
-// A helper type that can be embedded or wrapped to simplify satisfying
-// Error.
-type ErrorString string
+// // errorString is a helper type used by NewError.
+type errorString string
 
-func (e ErrorString) String() string  { return string(e) }
-func (e ErrorString) Temporary() bool { return false }
-func (e ErrorString) Timeout() bool   { return false }
+func (e errorString) String() string { return string(e) }
 
 // Note: If the name of the function NewError changes,
 // pkg/go/doc/doc.go should be adjusted since it hardwires
 // this name in a heuristic.
 
-// NewError converts s to an ErrorString, which satisfies the Error interface.
-func NewError(s string) Error { return ErrorString(s) }
+// // NewError returns a new error with error.String() == s.
+func NewError(s string) Error { return errorString(s) }
 
 // PathError records an error and the operation and file path that caused it.
 type PathError struct {
diff --git a/src/pkg/os/error_plan9.go b/src/pkg/os/error_plan9.go
index 3374775b8..cacfc150c 100644
--- a/src/pkg/os/error_plan9.go
+++ b/src/pkg/os/error_plan9.go
@@ -45,6 +45,7 @@ var (
 	EEXIST  = Eexist
 	EIO     = Eio
 	EACCES  = Eperm
+	EPERM   = Eperm
 	EISDIR  = syscall.EISDIR
 
 	ENAMETOOLONG = NewError("file name too long")
diff --git a/src/pkg/os/exec.go b/src/pkg/os/exec.go
index f62caf9a0..e2234f14a 100644
--- a/src/pkg/os/exec.go
+++ b/src/pkg/os/exec.go
@@ -37,6 +37,12 @@ type ProcAttr struct {
 	// depending on the underlying operating system.  A nil entry corresponds
 	// to that file being closed when the process starts.
 	Files []*File
+
+	// Operating system-specific process creation attributes.
+	// Note that setting this field means that your program
+	// may not execute properly or even compile on some
+	// operating systems.
+	Sys *syscall.SysProcAttr
 }
 
 // Getpid returns the process id of the caller.
diff --git a/src/pkg/os/exec_plan9.go b/src/pkg/os/exec_plan9.go
index 11874aba6..2590dd67d 100644
--- a/src/pkg/os/exec_plan9.go
+++ b/src/pkg/os/exec_plan9.go
@@ -15,6 +15,7 @@ func StartProcess(name string, argv []string, attr *ProcAttr) (p *Process, err E
 	sysattr := &syscall.ProcAttr{
 		Dir: attr.Dir,
 		Env: attr.Env,
+		Sys: attr.Sys,
 	}
 
 	// Create array of integer (system) fds.
@@ -37,6 +38,17 @@ func StartProcess(name string, argv []string, attr *ProcAttr) (p *Process, err E
 	return newProcess(pid, h), nil
 }
 
+// Kill causes the Process to exit immediately.
+func (p *Process) Kill() Error {
+	f, e := OpenFile("/proc/"+itoa(p.Pid)+"/ctl", O_WRONLY, 0)
+	if iserror(e) {
+		return NewSyscallError("kill", e)
+	}
+	defer f.Close()
+	_, e = f.Write([]byte("kill"))
+	return e
+}
+
 // 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.
@@ -51,7 +63,9 @@ func Exec(name string, argv []string, envv []string) Error {
 }
 
 // Waitmsg stores the information about an exited process as reported by Wait.
-type Waitmsg syscall.Waitmsg
+type Waitmsg struct {
+	syscall.Waitmsg
+}
 
 // Wait waits for the Process to exit or stop, and then returns a
 // Waitmsg describing its status and an Error, if any. The options
@@ -75,7 +89,7 @@ func (p *Process) Wait(options int) (w *Waitmsg, err Error) {
 		}
 	}
 
-	return (*Waitmsg)(&waitmsg), nil
+	return &Waitmsg{waitmsg}, nil
 }
 
 // Wait waits for process pid to exit or stop, and then returns a
@@ -109,6 +123,9 @@ func FindProcess(pid int) (p *Process, err Error) {
 	return newProcess(pid, 0), nil
 }
 
-func (w Waitmsg) String() string {
+func (w *Waitmsg) String() string {
+	if w == nil {
+		return "<nil>"
+	}
 	return "exit status: " + w.Msg
 }
diff --git a/src/pkg/os/exec_posix.go b/src/pkg/os/exec_posix.go
index bf992ef42..e2097700e 100644
--- a/src/pkg/os/exec_posix.go
+++ b/src/pkg/os/exec_posix.go
@@ -30,20 +30,14 @@ func StartProcess(name string, argv []string, attr *ProcAttr) (p *Process, err E
 	sysattr := &syscall.ProcAttr{
 		Dir: attr.Dir,
 		Env: attr.Env,
+		Sys: attr.Sys,
 	}
 	if sysattr.Env == nil {
 		sysattr.Env = Environ()
 	}
-	// Create array of integer (system) fds.
-	intfd := make([]int, len(attr.Files))
-	for i, f := range attr.Files {
-		if f == nil {
-			intfd[i] = -1
-		} else {
-			intfd[i] = f.Fd()
-		}
+	for _, f := range attr.Files {
+		sysattr.Files = append(sysattr.Files, f.Fd())
 	}
-	sysattr.Files = intfd
 
 	pid, h, e := syscall.StartProcess(name, argv, sysattr)
 	if iserror(e) {
@@ -127,7 +121,10 @@ func itod(i int) string {
 	return string(b[bp:])
 }
 
-func (w Waitmsg) String() string {
+func (w *Waitmsg) String() string {
+	if w == nil {
+		return "<nil>"
+	}
 	// TODO(austin) Use signal names when possible?
 	res := ""
 	switch {
diff --git a/src/pkg/os/exec_windows.go b/src/pkg/os/exec_windows.go
index bac33b908..5b432d398 100644
--- a/src/pkg/os/exec_windows.go
+++ b/src/pkg/os/exec_windows.go
@@ -10,17 +10,17 @@ import (
 )
 
 func (p *Process) Wait(options int) (w *Waitmsg, err Error) {
-	s, e := syscall.WaitForSingleObject(int32(p.handle), syscall.INFINITE)
+	s, e := syscall.WaitForSingleObject(syscall.Handle(p.handle), syscall.INFINITE)
 	switch s {
 	case syscall.WAIT_OBJECT_0:
 		break
 	case syscall.WAIT_FAILED:
 		return nil, NewSyscallError("WaitForSingleObject", e)
 	default:
-		return nil, ErrorString("os: unexpected result from WaitForSingleObject")
+		return nil, NewError("os: unexpected result from WaitForSingleObject")
 	}
 	var ec uint32
-	e = syscall.GetExitCodeProcess(int32(p.handle), &ec)
+	e = syscall.GetExitCodeProcess(syscall.Handle(p.handle), &ec)
 	if e != 0 {
 		return nil, NewSyscallError("GetExitCodeProcess", e)
 	}
@@ -31,7 +31,7 @@ func (p *Process) Wait(options int) (w *Waitmsg, err Error) {
 func (p *Process) Signal(sig Signal) Error {
 	switch sig.(UnixSignal) {
 	case SIGKILL:
-		e := syscall.TerminateProcess(int32(p.handle), 1)
+		e := syscall.TerminateProcess(syscall.Handle(p.handle), 1)
 		return NewSyscallError("TerminateProcess", e)
 	}
 	return Errno(syscall.EWINDOWS)
@@ -41,7 +41,7 @@ func (p *Process) Release() Error {
 	if p.handle == -1 {
 		return EINVAL
 	}
-	e := syscall.CloseHandle(int32(p.handle))
+	e := syscall.CloseHandle(syscall.Handle(p.handle))
 	if e != 0 {
 		return NewSyscallError("CloseHandle", e)
 	}
diff --git a/src/pkg/os/file.go b/src/pkg/os/file.go
index dff8fa862..4335d45e5 100644
--- a/src/pkg/os/file.go
+++ b/src/pkg/os/file.go
@@ -4,39 +4,17 @@
 
 // Package os provides a platform-independent interface to operating system
 // functionality.  The design is Unix-like.
+// The os interface is intended to be uniform across all operating systems.
+// Features not generally available appear in the system-specific package syscall.
 package os
 
 import (
-	"runtime"
-	"sync"
 	"syscall"
 )
 
-// File represents an open file descriptor.
-type File struct {
-	fd      int
-	name    string
-	dirinfo *dirInfo   // nil unless directory being read
-	nepipe  int        // number of consecutive EPIPE in Write
-	l       sync.Mutex // used to implement windows pread/pwrite
-}
-
-// Fd returns the integer Unix file descriptor referencing the open file.
-func (file *File) Fd() int { return file.fd }
-
 // Name returns the name of the file as presented to Open.
 func (file *File) Name() string { return file.name }
 
-// NewFile returns a new File with the given file descriptor and name.
-func NewFile(fd int, name string) *File {
-	if fd < 0 {
-		return nil
-	}
-	f := &File{fd: fd, name: name}
-	runtime.SetFinalizer(f, (*File).Close)
-	return f
-}
-
 // Stdin, Stdout, and Stderr are open Files pointing to the standard input,
 // standard output, and standard error file descriptors.
 var (
@@ -185,9 +163,7 @@ func (file *File) WriteString(s string) (ret int, err Error) {
 	if file == nil {
 		return 0, EINVAL
 	}
-	b := syscall.StringByteSlice(s)
-	b = b[0 : len(b)-1]
-	return file.Write(b)
+	return file.Write([]byte(s))
 }
 
 // Mkdir creates a new directory with the specified name and permission bits.
diff --git a/src/pkg/os/file_plan9.go b/src/pkg/os/file_plan9.go
index 7b473f802..03792191e 100644
--- a/src/pkg/os/file_plan9.go
+++ b/src/pkg/os/file_plan9.go
@@ -9,6 +9,32 @@ import (
 	"syscall"
 )
 
+// File represents an open file descriptor.
+type File struct {
+	fd      int
+	name    string
+	dirinfo *dirInfo // nil unless directory being read
+	nepipe  int      // number of consecutive EPIPE in Write
+}
+
+// Fd returns the integer Unix file descriptor referencing the open file.
+func (file *File) Fd() int {
+	if file == nil {
+		return -1
+	}
+	return file.fd
+}
+
+// NewFile returns a new File with the given file descriptor and name.
+func NewFile(fd int, name string) *File {
+	if fd < 0 {
+		return nil
+	}
+	f := &File{fd: fd, name: name}
+	runtime.SetFinalizer(f, (*File).Close)
+	return f
+}
+
 // Auxiliary information if the File describes a directory
 type dirInfo struct {
 	buf  [syscall.STATMAX]byte // buffer for directory I/O
@@ -30,14 +56,43 @@ const DevNull = "/dev/null"
 // methods on the returned File can be used for I/O.
 // It returns the File and an Error, if any.
 func OpenFile(name string, flag int, perm uint32) (file *File, err Error) {
-	var fd int
-	var e syscall.Error
+	var (
+		fd     int
+		e      syscall.Error
+		create bool
+		excl   bool
+		trunc  bool
+		append bool
+	)
 
-	syscall.ForkLock.RLock()
 	if flag&O_CREATE == O_CREATE {
-		fd, e = syscall.Create(name, flag & ^O_CREATE, perm)
+		flag = flag & ^O_CREATE
+		create = true
+	}
+	if flag&O_EXCL == O_EXCL {
+		excl = true
+	}
+	if flag&O_TRUNC == O_TRUNC {
+		trunc = true
+	}
+	// O_APPEND is emulated on Plan 9
+	if flag&O_APPEND == O_APPEND {
+		flag = flag &^ O_APPEND
+		append = true
+	}
+
+	syscall.ForkLock.RLock()
+	if (create && trunc) || excl {
+		fd, e = syscall.Create(name, flag, perm)
 	} else {
 		fd, e = syscall.Open(name, flag)
+		if e != nil && create {
+			var e1 syscall.Error
+			fd, e1 = syscall.Create(name, flag, perm)
+			if e1 == nil {
+				e = nil
+			}
+		}
 	}
 	syscall.ForkLock.RUnlock()
 
@@ -45,6 +100,12 @@ func OpenFile(name string, flag int, perm uint32) (file *File, err Error) {
 		return nil, &PathError{"open", name, e}
 	}
 
+	if append {
+		if _, e = syscall.Seek(fd, 0, SEEK_END); e != nil {
+			return nil, &PathError{"seek", name, e}
+		}
+	}
+
 	return NewFile(fd, name), nil
 }
 
@@ -69,8 +130,12 @@ func (file *File) Close() Error {
 
 // Stat returns the FileInfo structure describing file.
 // It returns the FileInfo and an error, if any.
-func (file *File) Stat() (fi *FileInfo, err Error) {
-	return dirstat(file)
+func (f *File) Stat() (fi *FileInfo, err Error) {
+	d, err := dirstat(f)
+	if iserror(err) {
+		return nil, err
+	}
+	return fileInfoFromStat(new(FileInfo), d), err
 }
 
 // Truncate changes the size of the file.
@@ -90,10 +155,15 @@ func (f *File) Truncate(size int64) Error {
 // Chmod changes the mode of the file to mode.
 func (f *File) Chmod(mode uint32) Error {
 	var d Dir
-	d.Null()
+	var mask = ^uint32(0777)
 
-	d.Mode = mode & 0777
+	d.Null()
+	odir, e := dirstat(f)
+	if iserror(e) {
+		return &PathError{"chmod", f.name, e}
+	}
 
+	d.Mode = (odir.Mode & mask) | (mode &^ mask)
 	if e := syscall.Fwstat(f.fd, pdir(nil, &d)); iserror(e) {
 		return &PathError{"chmod", f.name, e}
 	}
@@ -188,10 +258,15 @@ func Rename(oldname, newname string) Error {
 // Chmod changes the mode of the named file to mode.
 func Chmod(name string, mode uint32) Error {
 	var d Dir
-	d.Null()
+	var mask = ^uint32(0777)
 
-	d.Mode = mode & 0777
+	d.Null()
+	odir, e := dirstat(name)
+	if iserror(e) {
+		return &PathError{"chmod", name, e}
+	}
 
+	d.Mode = (odir.Mode & mask) | (mode &^ mask)
 	if e := syscall.Wstat(name, pdir(nil, &d)); iserror(e) {
 		return &PathError{"chmod", name, e}
 	}
diff --git a/src/pkg/os/file_posix.go b/src/pkg/os/file_posix.go
index f1191d61f..0791a0dc0 100644
--- a/src/pkg/os/file_posix.go
+++ b/src/pkg/os/file_posix.go
@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// The os package provides a platform-independent interface to operating
-// system functionality.  The design is Unix-like.
 package os
 
 import (
@@ -23,26 +21,6 @@ func epipecheck(file *File, e int) {
 	}
 }
 
-
-// Pipe returns a connected pair of Files; reads from r return bytes written to w.
-// It returns the files and an Error, if any.
-func Pipe() (r *File, w *File, err Error) {
-	var p [2]int
-
-	// See ../syscall/exec.go for description of lock.
-	syscall.ForkLock.RLock()
-	e := syscall.Pipe(p[0:])
-	if iserror(e) {
-		syscall.ForkLock.RUnlock()
-		return nil, nil, NewSyscallError("pipe", e)
-	}
-	syscall.CloseOnExec(p[0])
-	syscall.CloseOnExec(p[1])
-	syscall.ForkLock.RUnlock()
-
-	return NewFile(p[0], "|0"), NewFile(p[1], "|1"), nil
-}
-
 // Stat returns a FileInfo structure describing the named file and an error, if any.
 // If name names a valid symbolic link, the returned FileInfo describes
 // the file pointed at by the link and has fi.FollowedSymlink set to true.
diff --git a/src/pkg/os/file_unix.go b/src/pkg/os/file_unix.go
index def9b3bf0..301c2f473 100644
--- a/src/pkg/os/file_unix.go
+++ b/src/pkg/os/file_unix.go
@@ -9,6 +9,32 @@ import (
 	"syscall"
 )
 
+// File represents an open file descriptor.
+type File struct {
+	fd      int
+	name    string
+	dirinfo *dirInfo // nil unless directory being read
+	nepipe  int      // number of consecutive EPIPE in Write
+}
+
+// Fd returns the integer Unix file descriptor referencing the open file.
+func (file *File) Fd() int {
+	if file == nil {
+		return -1
+	}
+	return file.fd
+}
+
+// NewFile returns a new File with the given file descriptor and name.
+func NewFile(fd int, name string) *File {
+	if fd < 0 {
+		return nil
+	}
+	f := &File{fd: fd, name: name}
+	runtime.SetFinalizer(f, (*File).Close)
+	return f
+}
+
 // Auxiliary information if the File describes a directory
 type dirInfo struct {
 	buf  []byte // buffer for directory I/O
@@ -161,3 +187,22 @@ func basename(name string) string {
 
 	return name
 }
+
+// Pipe returns a connected pair of Files; reads from r return bytes written to w.
+// It returns the files and an Error, if any.
+func Pipe() (r *File, w *File, err Error) {
+	var p [2]int
+
+	// See ../syscall/exec.go for description of lock.
+	syscall.ForkLock.RLock()
+	e := syscall.Pipe(p[0:])
+	if iserror(e) {
+		syscall.ForkLock.RUnlock()
+		return nil, nil, NewSyscallError("pipe", e)
+	}
+	syscall.CloseOnExec(p[0])
+	syscall.CloseOnExec(p[1])
+	syscall.ForkLock.RUnlock()
+
+	return NewFile(p[0], "|0"), NewFile(p[1], "|1"), nil
+}
diff --git a/src/pkg/os/file_windows.go b/src/pkg/os/file_windows.go
index 80886f6f5..70dd6e241 100644
--- a/src/pkg/os/file_windows.go
+++ b/src/pkg/os/file_windows.go
@@ -6,9 +6,37 @@ package os
 
 import (
 	"runtime"
+	"sync"
 	"syscall"
 )
 
+// File represents an open file descriptor.
+type File struct {
+	fd      syscall.Handle
+	name    string
+	dirinfo *dirInfo   // nil unless directory being read
+	nepipe  int        // number of consecutive EPIPE in Write
+	l       sync.Mutex // used to implement windows pread/pwrite
+}
+
+// Fd returns the Windows handle referencing the open file.
+func (file *File) Fd() syscall.Handle {
+	if file == nil {
+		return syscall.InvalidHandle
+	}
+	return file.fd
+}
+
+// NewFile returns a new File with the given file descriptor and name.
+func NewFile(fd syscall.Handle, name string) *File {
+	if fd < 0 {
+		return nil
+	}
+	f := &File{fd: fd, name: name}
+	runtime.SetFinalizer(f, (*File).Close)
+	return f
+}
+
 // Auxiliary information if the File describes a directory
 type dirInfo struct {
 	stat         syscall.Stat_t
@@ -40,7 +68,7 @@ func openDir(name string) (file *File, err Error) {
 	if e != 0 {
 		return nil, &PathError{"open", name, Errno(e)}
 	}
-	f := NewFile(int(r), name)
+	f := NewFile(r, name)
 	d.usefirststat = true
 	f.dirinfo = d
 	return f, nil
@@ -85,15 +113,15 @@ func (file *File) Close() Error {
 	}
 	var e int
 	if file.isdir() {
-		e = syscall.FindClose(int32(file.fd))
+		e = syscall.FindClose(syscall.Handle(file.fd))
 	} else {
-		e = syscall.CloseHandle(int32(file.fd))
+		e = syscall.CloseHandle(syscall.Handle(file.fd))
 	}
 	var err Error
 	if e != 0 {
 		err = &PathError{"close", file.name, Errno(e)}
 	}
-	file.fd = -1 // so it can't be closed again
+	file.fd = syscall.InvalidHandle // so it can't be closed again
 
 	// no need for a finalizer anymore
 	runtime.SetFinalizer(file, nil)
@@ -102,7 +130,7 @@ func (file *File) Close() Error {
 
 func (file *File) statFile(name string) (fi *FileInfo, err Error) {
 	var stat syscall.ByHandleFileInformation
-	e := syscall.GetFileInformationByHandle(int32(file.fd), &stat)
+	e := syscall.GetFileInformationByHandle(syscall.Handle(file.fd), &stat)
 	if e != 0 {
 		return nil, &PathError{"stat", file.name, Errno(e)}
 	}
@@ -156,7 +184,7 @@ func (file *File) Readdir(n int) (fi []FileInfo, err Error) {
 		if di.usefirststat {
 			di.usefirststat = false
 		} else {
-			e := syscall.FindNextFile(int32(file.fd), &di.stat.Windata)
+			e := syscall.FindNextFile(syscall.Handle(file.fd), &di.stat.Windata)
 			if e != 0 {
 				if e == syscall.ERROR_NO_MORE_FILES {
 					break
@@ -207,7 +235,7 @@ func (f *File) pread(b []byte, off int64) (n int, err int) {
 		Offset:     uint32(off),
 	}
 	var done uint32
-	e = syscall.ReadFile(int32(f.fd), b, &done, &o)
+	e = syscall.ReadFile(syscall.Handle(f.fd), b, &done, &o)
 	if e != 0 {
 		return 0, e
 	}
@@ -237,7 +265,7 @@ func (f *File) pwrite(b []byte, off int64) (n int, err int) {
 		Offset:     uint32(off),
 	}
 	var done uint32
-	e = syscall.WriteFile(int32(f.fd), b, &done, &o)
+	e = syscall.WriteFile(syscall.Handle(f.fd), b, &done, &o)
 	if e != 0 {
 		return 0, e
 	}
@@ -268,3 +296,22 @@ func Truncate(name string, size int64) Error {
 	}
 	return nil
 }
+
+// Pipe returns a connected pair of Files; reads from r return bytes written to w.
+// It returns the files and an Error, if any.
+func Pipe() (r *File, w *File, err Error) {
+	var p [2]syscall.Handle
+
+	// See ../syscall/exec.go for description of lock.
+	syscall.ForkLock.RLock()
+	e := syscall.Pipe(p[0:])
+	if iserror(e) {
+		syscall.ForkLock.RUnlock()
+		return nil, nil, NewSyscallError("pipe", e)
+	}
+	syscall.CloseOnExec(p[0])
+	syscall.CloseOnExec(p[1])
+	syscall.ForkLock.RUnlock()
+
+	return NewFile(p[0], "|0"), NewFile(p[1], "|1"), nil
+}
diff --git a/src/pkg/os/mkunixsignals.sh b/src/pkg/os/mkunixsignals.sh
index 6ec764cbd..4bbc43f3d 100755
--- a/src/pkg/os/mkunixsignals.sh
+++ b/src/pkg/os/mkunixsignals.sh
@@ -14,7 +14,7 @@ import (
   "syscall"
 )
 
-var _ = syscall.Syscall  // in case there are zero signals
+var _ = syscall.Open  // in case there are zero signals
 
 const (
 EOH
diff --git a/src/pkg/os/os_test.go b/src/pkg/os/os_test.go
index 8eabdee6b..c22b536d5 100644
--- a/src/pkg/os/os_test.go
+++ b/src/pkg/os/os_test.go
@@ -359,8 +359,8 @@ func TestReaddirNValues(t *testing.T) {
 }
 
 func TestHardLink(t *testing.T) {
-	// Hardlinks are not supported under windows.
-	if syscall.OS == "windows" {
+	// Hardlinks are not supported under windows or Plan 9.
+	if syscall.OS == "windows" || syscall.OS == "plan9" {
 		return
 	}
 	from, to := "hardlinktestfrom", "hardlinktestto"
@@ -392,8 +392,8 @@ func TestHardLink(t *testing.T) {
 }
 
 func TestSymLink(t *testing.T) {
-	// Symlinks are not supported under windows.
-	if syscall.OS == "windows" {
+	// Symlinks are not supported under windows or Plan 9.
+	if syscall.OS == "windows" || syscall.OS == "plan9" {
 		return
 	}
 	from, to := "symlinktestfrom", "symlinktestto"
@@ -454,8 +454,8 @@ func TestSymLink(t *testing.T) {
 }
 
 func TestLongSymlink(t *testing.T) {
-	// Symlinks are not supported under windows.
-	if syscall.OS == "windows" {
+	// Symlinks are not supported under windows or Plan 9.
+	if syscall.OS == "windows" || syscall.OS == "plan9" {
 		return
 	}
 	s := "0123456789abcdef"
@@ -588,8 +588,9 @@ func checkUidGid(t *testing.T, path string, uid, gid int) {
 }
 
 func TestChown(t *testing.T) {
-	// Chown is not supported under windows.
-	if syscall.OS == "windows" {
+	// Chown is not supported under windows or Plan 9.
+	// Plan9 provides a native ChownPlan9 version instead.
+	if syscall.OS == "windows" || syscall.OS == "plan9" {
 		return
 	}
 	// Use TempDir() to make sure we're on a local file system,
@@ -708,7 +709,11 @@ func TestChtimes(t *testing.T) {
 		t.Fatalf("second Stat %s: %s", f.Name(), err)
 	}
 
-	if postStat.Atime_ns >= preStat.Atime_ns {
+	/* Plan 9:
+		Mtime is the time of the last change of content.  Similarly, atime is set whenever the
+	    contents are accessed; also, it is set whenever mtime is set.
+	*/
+	if postStat.Atime_ns >= preStat.Atime_ns && syscall.OS != "plan9" {
 		t.Errorf("Atime_ns didn't go backwards; was=%d, after=%d",
 			preStat.Atime_ns,
 			postStat.Atime_ns)
@@ -733,6 +738,10 @@ func TestChdirAndGetwd(t *testing.T) {
 	// These are chosen carefully not to be symlinks on a Mac
 	// (unlike, say, /var, /etc, and /tmp).
 	dirs := []string{"/", "/usr/bin"}
+	// /usr/bin does not usually exist on Plan 9.
+	if syscall.OS == "plan9" {
+		dirs = []string{"/", "/usr"}
+	}
 	for mode := 0; mode < 2; mode++ {
 		for _, d := range dirs {
 			if mode == 0 {
@@ -858,7 +867,15 @@ func TestOpenError(t *testing.T) {
 			t.Errorf("Open(%q, %d) returns error of %T type; want *os.PathError", tt.path, tt.mode, err)
 		}
 		if perr.Error != tt.error {
-			t.Errorf("Open(%q, %d) = _, %q; want %q", tt.path, tt.mode, perr.Error.String(), tt.error.String())
+			if syscall.OS == "plan9" {
+				syscallErrStr := perr.Error.String()
+				expectedErrStr := strings.Replace(tt.error.String(), "file ", "", 1)
+				if !strings.HasSuffix(syscallErrStr, expectedErrStr) {
+					t.Errorf("Open(%q, %d) = _, %q; want suffix %q", tt.path, tt.mode, syscallErrStr, expectedErrStr)
+				}
+			} else {
+				t.Errorf("Open(%q, %d) = _, %q; want %q", tt.path, tt.mode, perr.Error.String(), tt.error.String())
+			}
 		}
 	}
 }
@@ -893,7 +910,8 @@ func run(t *testing.T, cmd []string) string {
 
 func TestHostname(t *testing.T) {
 	// There is no other way to fetch hostname on windows, but via winapi.
-	if syscall.OS == "windows" {
+	// On Plan 9 it is can be taken from #c/sysname as Hostname() does.
+	if syscall.OS == "windows" || syscall.OS == "plan9" {
 		return
 	}
 	// Check internal Hostname() against the output of /bin/hostname.
@@ -1024,3 +1042,11 @@ func TestStatDirWithTrailingSlash(t *testing.T) {
 		t.Fatal("stat failed:", err)
 	}
 }
+
+func TestNilWaitmsgString(t *testing.T) {
+	var w *Waitmsg
+	s := w.String()
+	if s != "<nil>" {
+		t.Errorf("(*Waitmsg)(nil).String() = %q, want %q", s, "<nil>")
+	}
+}
diff --git a/src/pkg/os/path_test.go b/src/pkg/os/path_test.go
index d58945aab..31acbaa43 100644
--- a/src/pkg/os/path_test.go
+++ b/src/pkg/os/path_test.go
@@ -166,8 +166,8 @@ func TestRemoveAll(t *testing.T) {
 }
 
 func TestMkdirAllWithSymlink(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		t.Log("Skipping test: symlinks don't exist under Windows")
+	if runtime.GOOS == "windows" || runtime.GOOS == "plan9" {
+		t.Log("Skipping test: symlinks don't exist under Windows/Plan 9")
 		return
 	}
 
@@ -191,7 +191,7 @@ func TestMkdirAllWithSymlink(t *testing.T) {
 }
 
 func TestMkdirAllAtSlash(t *testing.T) {
-	if runtime.GOOS == "windows" {
+	if runtime.GOOS == "windows" || runtime.GOOS == "plan9" {
 		return
 	}
 	RemoveAll("/_go_os_test")
diff --git a/src/pkg/os/path_windows.go b/src/pkg/os/path_windows.go
index 8740a9e61..61f2ca59f 100644
--- a/src/pkg/os/path_windows.go
+++ b/src/pkg/os/path_windows.go
@@ -6,7 +6,7 @@ package os
 
 const (
 	PathSeparator     = '\\' // OS-specific path separator
-	PathListSeparator = ':'  // OS-specific path list separator
+	PathListSeparator = ';'  // OS-specific path list separator
 )
 
 // IsPathSeparator returns true if c is a directory separator character.
diff --git a/src/pkg/os/stat_plan9.go b/src/pkg/os/stat_plan9.go
index e96749d33..d2300d598 100644
--- a/src/pkg/os/stat_plan9.go
+++ b/src/pkg/os/stat_plan9.go
@@ -26,7 +26,7 @@ func fileInfoFromStat(fi *FileInfo, d *Dir) *FileInfo {
 }
 
 // arg is an open *File or a path string. 
-func dirstat(arg interface{}) (fi *FileInfo, err Error) {
+func dirstat(arg interface{}) (d *Dir, err Error) {
 	var name string
 	nd := syscall.STATFIXLEN + 16*4
 
@@ -62,8 +62,7 @@ func dirstat(arg interface{}) (fi *FileInfo, err Error) {
 			if e != nil {
 				return nil, &PathError{"stat", name, e}
 			}
-
-			return fileInfoFromStat(new(FileInfo), d), nil
+			return d, e
 		}
 	}
 
@@ -73,12 +72,20 @@ func dirstat(arg interface{}) (fi *FileInfo, err Error) {
 
 // Stat returns a FileInfo structure describing the named file and an error, if any.
 func Stat(name string) (fi *FileInfo, err Error) {
-	return dirstat(name)
+	d, err := dirstat(name)
+	if iserror(err) {
+		return nil, err
+	}
+	return fileInfoFromStat(new(FileInfo), d), err
 }
 
 // Lstat returns the FileInfo structure describing the named file and an
 // error, if any.  If the file is a symbolic link (though Plan 9 does not have symbolic links), 
 // the returned FileInfo describes the symbolic link.  Lstat makes no attempt to follow the link.
 func Lstat(name string) (fi *FileInfo, err Error) {
-	return dirstat(name)
+	d, err := dirstat(name)
+	if iserror(err) {
+		return nil, err
+	}
+	return fileInfoFromStat(new(FileInfo), d), err
 }
diff --git a/src/pkg/os/str.go b/src/pkg/os/str.go
new file mode 100644
index 000000000..8dc9e4747
--- /dev/null
+++ b/src/pkg/os/str.go
@@ -0,0 +1,20 @@
+// 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.
+
+package os
+
+func itoa(val int) string { // do it here rather than with fmt to avoid dependency
+	if val < 0 {
+		return "-" + itoa(-val)
+	}
+	var buf [32]byte // big enough for int64
+	i := len(buf) - 1
+	for val >= 10 {
+		buf[i] = byte(val%10 + '0')
+		i--
+		val /= 10
+	}
+	buf[i] = byte(val + '0')
+	return string(buf[i:])
+}
diff --git a/src/pkg/os/types.go b/src/pkg/os/types.go
index 79f6e9d49..df57b59a3 100644
--- a/src/pkg/os/types.go
+++ b/src/pkg/os/types.go
@@ -27,7 +27,7 @@ type FileInfo struct {
 	Atime_ns        int64  // access time; nanoseconds since epoch.
 	Mtime_ns        int64  // modified time; nanoseconds since epoch.
 	Ctime_ns        int64  // status change time; nanoseconds since epoch.
-	Name            string // name of file as presented to Open.
+	Name            string // base name of the file name provided in Open, Stat, etc.
 	FollowedSymlink bool   // followed a symlink to get this information
 }