Engage!

22 files changed, 2367 insertions, 0 deletions

diff --git a/vendor/golang.org/x/sys/plan9/asm.s b/vendor/golang.org/x/sys/plan9/asm.s
new file mode 100644
index 0000000..06449eb
--- /dev/null
+++ b/vendor/golang.org/x/sys/plan9/asm.s
@@ -0,0 +1,8 @@
+// Copyright 2014 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.
+
+#include "textflag.h"
+
+TEXT ·use(SB),NOSPLIT,$0
+        RET
diff --git a/vendor/golang.org/x/sys/plan9/asm_plan9_386.s b/vendor/golang.org/x/sys/plan9/asm_plan9_386.s
new file mode 100644
index 0000000..bc5cab1
--- /dev/null
+++ b/vendor/golang.org/x/sys/plan9/asm_plan9_386.s
@@ -0,0 +1,30 @@
+// 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.
+
+#include "textflag.h"
+
+//
+// System call support for 386, Plan 9
+//
+
+// Just jump to package syscall's implementation for all these functions.
+// The runtime may know about them.
+
+TEXT    ·Syscall(SB),NOSPLIT,$0-32
+        JMP     syscall·Syscall(SB)
+
+TEXT    ·Syscall6(SB),NOSPLIT,$0-44
+        JMP     syscall·Syscall6(SB)
+
+TEXT ·RawSyscall(SB),NOSPLIT,$0-28
+        JMP     syscall·RawSyscall(SB)
+
+TEXT ·RawSyscall6(SB),NOSPLIT,$0-40
+        JMP     syscall·RawSyscall6(SB)
+
+TEXT ·seek(SB),NOSPLIT,$0-36
+        JMP     syscall·seek(SB)
+
+TEXT ·exit(SB),NOSPLIT,$4-4
+        JMP     syscall·exit(SB)
diff --git a/vendor/golang.org/x/sys/plan9/asm_plan9_amd64.s b/vendor/golang.org/x/sys/plan9/asm_plan9_amd64.s
new file mode 100644
index 0000000..d3448e6
--- /dev/null
+++ b/vendor/golang.org/x/sys/plan9/asm_plan9_amd64.s
@@ -0,0 +1,30 @@
+// 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.
+
+#include "textflag.h"
+
+//
+// System call support for amd64, Plan 9
+//
+
+// Just jump to package syscall's implementation for all these functions.
+// The runtime may know about them.
+
+TEXT    ·Syscall(SB),NOSPLIT,$0-64
+        JMP     syscall·Syscall(SB)
+
+TEXT    ·Syscall6(SB),NOSPLIT,$0-88
+        JMP     syscall·Syscall6(SB)
+
+TEXT ·RawSyscall(SB),NOSPLIT,$0-56
+        JMP     syscall·RawSyscall(SB)
+
+TEXT    ·RawSyscall6(SB),NOSPLIT,$0-80
+        JMP     syscall·RawSyscall6(SB)
+
+TEXT ·seek(SB),NOSPLIT,$0-56
+        JMP     syscall·seek(SB)
+
+TEXT ·exit(SB),NOSPLIT,$8-8
+        JMP     syscall·exit(SB)
diff --git a/vendor/golang.org/x/sys/plan9/asm_plan9_arm.s b/vendor/golang.org/x/sys/plan9/asm_plan9_arm.s
new file mode 100644
index 0000000..afb7c0a
--- /dev/null
+++ b/vendor/golang.org/x/sys/plan9/asm_plan9_arm.s
@@ -0,0 +1,25 @@
+// 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.
+
+#include "textflag.h"
+
+// System call support for plan9 on arm
+
+// Just jump to package syscall's implementation for all these functions.
+// The runtime may know about them.
+
+TEXT ·Syscall(SB),NOSPLIT,$0-32
+        JMP     syscall·Syscall(SB)
+
+TEXT ·Syscall6(SB),NOSPLIT,$0-44
+        JMP     syscall·Syscall6(SB)
+
+TEXT ·RawSyscall(SB),NOSPLIT,$0-28
+        JMP     syscall·RawSyscall(SB)
+
+TEXT ·RawSyscall6(SB),NOSPLIT,$0-40
+        JMP     syscall·RawSyscall6(SB)
+
+TEXT ·seek(SB),NOSPLIT,$0-36
+        JMP     syscall·exit(SB)
diff --git a/vendor/golang.org/x/sys/plan9/const_plan9.go b/vendor/golang.org/x/sys/plan9/const_plan9.go
new file mode 100644
index 0000000..b4e85a3
--- /dev/null
+++ b/vendor/golang.org/x/sys/plan9/const_plan9.go
@@ -0,0 +1,70 @@
+package plan9
+
+// Plan 9 Constants
+
+// Open modes
+const (
+        O_RDONLY  = 0
+        O_WRONLY  = 1
+        O_RDWR    = 2
+        O_TRUNC   = 16
+        O_CLOEXEC = 32
+        O_EXCL    = 0x1000
+)
+
+// Rfork flags
+const (
+        RFNAMEG  = 1 << 0
+        RFENVG   = 1 << 1
+        RFFDG    = 1 << 2
+        RFNOTEG  = 1 << 3
+        RFPROC   = 1 << 4
+        RFMEM    = 1 << 5
+        RFNOWAIT = 1 << 6
+        RFCNAMEG = 1 << 10
+        RFCENVG  = 1 << 11
+        RFCFDG   = 1 << 12
+        RFREND   = 1 << 13
+        RFNOMNT  = 1 << 14
+)
+
+// Qid.Type bits
+const (
+        QTDIR    = 0x80
+        QTAPPEND = 0x40
+        QTEXCL   = 0x20
+        QTMOUNT  = 0x10
+        QTAUTH   = 0x08
+        QTTMP    = 0x04
+        QTFILE   = 0x00
+)
+
+// Dir.Mode bits
+const (
+        DMDIR    = 0x80000000
+        DMAPPEND = 0x40000000
+        DMEXCL   = 0x20000000
+        DMMOUNT  = 0x10000000
+        DMAUTH   = 0x08000000
+        DMTMP    = 0x04000000
+        DMREAD   = 0x4
+        DMWRITE  = 0x2
+        DMEXEC   = 0x1
+)
+
+const (
+        STATMAX    = 65535
+        ERRMAX     = 128
+        STATFIXLEN = 49
+)
+
+// Mount and bind flags
+const (
+        MREPL   = 0x0000
+        MBEFORE = 0x0001
+        MAFTER  = 0x0002
+        MORDER  = 0x0003
+        MCREATE = 0x0004
+        MCACHE  = 0x0010
+        MMASK   = 0x0017
+)
diff --git a/vendor/golang.org/x/sys/plan9/dir_plan9.go b/vendor/golang.org/x/sys/plan9/dir_plan9.go
new file mode 100644
index 0000000..0955e0c
--- /dev/null
+++ b/vendor/golang.org/x/sys/plan9/dir_plan9.go
@@ -0,0 +1,212 @@
+// 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.
+
+// Plan 9 directory marshalling. See intro(5).
+
+package plan9
+
+import "errors"
+
+var (
+        ErrShortStat = errors.New("stat buffer too short")
+        ErrBadStat   = errors.New("malformed stat buffer")
+        ErrBadName   = errors.New("bad character in file name")
+)
+
+// A Qid represents a 9P server's unique identification for a file.
+type Qid struct {
+        Path uint64 // the file server's unique identification for the file
+        Vers uint32 // version number for given Path
+        Type uint8  // the type of the file (plan9.QTDIR for example)
+}
+
+// A Dir contains the metadata for a file.
+type Dir struct {
+        // system-modified data
+        Type uint16 // server type
+        Dev  uint32 // server subtype
+
+        // file data
+        Qid    Qid    // unique id from server
+        Mode   uint32 // permissions
+        Atime  uint32 // last read time
+        Mtime  uint32 // last write time
+        Length int64  // file length
+        Name   string // last element of path
+        Uid    string // owner name
+        Gid    string // group name
+        Muid   string // last modifier name
+}
+
+var nullDir = Dir{
+        Type: ^uint16(0),
+        Dev:  ^uint32(0),
+        Qid: Qid{
+                Path: ^uint64(0),
+                Vers: ^uint32(0),
+                Type: ^uint8(0),
+        },
+        Mode:   ^uint32(0),
+        Atime:  ^uint32(0),
+        Mtime:  ^uint32(0),
+        Length: ^int64(0),
+}
+
+// Null assigns special "don't touch" values to members of d to
+// avoid modifying them during plan9.Wstat.
+func (d *Dir) Null() { *d = nullDir }
+
+// Marshal encodes a 9P stat message corresponding to d into b
+//
+// If there isn't enough space in b for a stat message, ErrShortStat is returned.
+func (d *Dir) Marshal(b []byte) (n int, err error) {
+        n = STATFIXLEN + len(d.Name) + len(d.Uid) + len(d.Gid) + len(d.Muid)
+        if n > len(b) {
+                return n, ErrShortStat
+        }
+
+        for _, c := range d.Name {
+                if c == '/' {
+                        return n, ErrBadName
+                }
+        }
+
+        b = pbit16(b, uint16(n)-2)
+        b = pbit16(b, d.Type)
+        b = pbit32(b, d.Dev)
+        b = pbit8(b, d.Qid.Type)
+        b = pbit32(b, d.Qid.Vers)
+        b = pbit64(b, d.Qid.Path)
+        b = pbit32(b, d.Mode)
+        b = pbit32(b, d.Atime)
+        b = pbit32(b, d.Mtime)
+        b = pbit64(b, uint64(d.Length))
+        b = pstring(b, d.Name)
+        b = pstring(b, d.Uid)
+        b = pstring(b, d.Gid)
+        b = pstring(b, d.Muid)
+
+        return n, nil
+}
+
+// UnmarshalDir decodes a single 9P stat message from b and returns the resulting Dir.
+//
+// If b is too small to hold a valid stat message, ErrShortStat is returned.
+//
+// If the stat message itself is invalid, ErrBadStat is returned.
+func UnmarshalDir(b []byte) (*Dir, error) {
+        if len(b) < STATFIXLEN {
+                return nil, ErrShortStat
+        }
+        size, buf := gbit16(b)
+        if len(b) != int(size)+2 {
+                return nil, ErrBadStat
+        }
+        b = buf
+
+        var d Dir
+        d.Type, b = gbit16(b)
+        d.Dev, b = gbit32(b)
+        d.Qid.Type, b = gbit8(b)
+        d.Qid.Vers, b = gbit32(b)
+        d.Qid.Path, b = gbit64(b)
+        d.Mode, b = gbit32(b)
+        d.Atime, b = gbit32(b)
+        d.Mtime, b = gbit32(b)
+
+        n, b := gbit64(b)
+        d.Length = int64(n)
+
+        var ok bool
+        if d.Name, b, ok = gstring(b); !ok {
+                return nil, ErrBadStat
+        }
+        if d.Uid, b, ok = gstring(b); !ok {
+                return nil, ErrBadStat
+        }
+        if d.Gid, b, ok = gstring(b); !ok {
+                return nil, ErrBadStat
+        }
+        if d.Muid, b, ok = gstring(b); !ok {
+                return nil, ErrBadStat
+        }
+
+        return &d, nil
+}
+
+// pbit8 copies the 8-bit number v to b and returns the remaining slice of b.
+func pbit8(b []byte, v uint8) []byte {
+        b[0] = byte(v)
+        return b[1:]
+}
+
+// pbit16 copies the 16-bit number v to b in little-endian order and returns the remaining slice of b.
+func pbit16(b []byte, v uint16) []byte {
+        b[0] = byte(v)
+        b[1] = byte(v >> 8)
+        return b[2:]
+}
+
+// pbit32 copies the 32-bit number v to b in little-endian order and returns the remaining slice of b.
+func pbit32(b []byte, v uint32) []byte {
+        b[0] = byte(v)
+        b[1] = byte(v >> 8)
+        b[2] = byte(v >> 16)
+        b[3] = byte(v >> 24)
+        return b[4:]
+}
+
+// pbit64 copies the 64-bit number v to b in little-endian order and returns the remaining slice of b.
+func pbit64(b []byte, v uint64) []byte {
+        b[0] = byte(v)
+        b[1] = byte(v >> 8)
+        b[2] = byte(v >> 16)
+        b[3] = byte(v >> 24)
+        b[4] = byte(v >> 32)
+        b[5] = byte(v >> 40)
+        b[6] = byte(v >> 48)
+        b[7] = byte(v >> 56)
+        return b[8:]
+}
+
+// pstring copies the string s to b, prepending it with a 16-bit length in little-endian order, and
+// returning the remaining slice of b..
+func pstring(b []byte, s string) []byte {
+        b = pbit16(b, uint16(len(s)))
+        n := copy(b, s)
+        return b[n:]
+}
+
+// gbit8 reads an 8-bit number from b and returns it with the remaining slice of b.
+func gbit8(b []byte) (uint8, []byte) {
+        return uint8(b[0]), b[1:]
+}
+
+// gbit16 reads a 16-bit number in little-endian order from b and returns it with the remaining slice of b.
+func gbit16(b []byte) (uint16, []byte) {
+        return uint16(b[0]) | uint16(b[1])<<8, b[2:]
+}
+
+// gbit32 reads a 32-bit number in little-endian order from b and returns it with the remaining slice of b.
+func gbit32(b []byte) (uint32, []byte) {
+        return uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24, b[4:]
+}
+
+// gbit64 reads a 64-bit number in little-endian order from b and returns it with the remaining slice of b.
+func gbit64(b []byte) (uint64, []byte) {
+        lo := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
+        hi := uint32(b[4]) | uint32(b[5])<<8 | uint32(b[6])<<16 | uint32(b[7])<<24
+        return uint64(lo) | uint64(hi)<<32, b[8:]
+}
+
+// gstring reads a string from b, prefixed with a 16-bit length in little-endian order.
+// It returns the string with the remaining slice of b and a boolean. If the length is
+// greater than the number of bytes in b, the boolean will be false.
+func gstring(b []byte) (string, []byte, bool) {
+        n, b := gbit16(b)
+        if int(n) > len(b) {
+                return "", b, false
+        }
+        return string(b[:n]), b[n:], true
+}
diff --git a/vendor/golang.org/x/sys/plan9/env_plan9.go b/vendor/golang.org/x/sys/plan9/env_plan9.go
new file mode 100644
index 0000000..8f19180
--- /dev/null
+++ b/vendor/golang.org/x/sys/plan9/env_plan9.go
@@ -0,0 +1,31 @@
+// Copyright 2011 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.
+
+// Plan 9 environment variables.
+
+package plan9
+
+import (
+        "syscall"
+)
+
+func Getenv(key string) (value string, found bool) {
+        return syscall.Getenv(key)
+}
+
+func Setenv(key, value string) error {
+        return syscall.Setenv(key, value)
+}
+
+func Clearenv() {
+        syscall.Clearenv()
+}
+
+func Environ() []string {
+        return syscall.Environ()
+}
+
+func Unsetenv(key string) error {
+        return syscall.Unsetenv(key)
+}
diff --git a/vendor/golang.org/x/sys/plan9/errors_plan9.go b/vendor/golang.org/x/sys/plan9/errors_plan9.go
new file mode 100644
index 0000000..65fe74d
--- /dev/null
+++ b/vendor/golang.org/x/sys/plan9/errors_plan9.go
@@ -0,0 +1,50 @@
+// Copyright 2011 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 plan9
+
+import "syscall"
+
+// Constants
+const (
+        // Invented values to support what package os expects.
+        O_CREAT    = 0x02000
+        O_APPEND   = 0x00400
+        O_NOCTTY   = 0x00000
+        O_NONBLOCK = 0x00000
+        O_SYNC     = 0x00000
+        O_ASYNC    = 0x00000
+
+        S_IFMT   = 0x1f000
+        S_IFIFO  = 0x1000
+        S_IFCHR  = 0x2000
+        S_IFDIR  = 0x4000
+        S_IFBLK  = 0x6000
+        S_IFREG  = 0x8000
+        S_IFLNK  = 0xa000
+        S_IFSOCK = 0xc000
+)
+
+// Errors
+var (
+        EINVAL       = syscall.NewError("bad arg in system call")
+        ENOTDIR      = syscall.NewError("not a directory")
+        EISDIR       = syscall.NewError("file is a directory")
+        ENOENT       = syscall.NewError("file does not exist")
+        EEXIST       = syscall.NewError("file already exists")
+        EMFILE       = syscall.NewError("no free file descriptors")
+        EIO          = syscall.NewError("i/o error")
+        ENAMETOOLONG = syscall.NewError("file name too long")
+        EINTR        = syscall.NewError("interrupted")
+        EPERM        = syscall.NewError("permission denied")
+        EBUSY        = syscall.NewError("no free devices")
+        ETIMEDOUT    = syscall.NewError("connection timed out")
+        EPLAN9       = syscall.NewError("not supported by plan 9")
+
+        // The following errors do not correspond to any
+        // Plan 9 system messages. Invented to support
+        // what package os and others expect.
+        EACCES       = syscall.NewError("access permission denied")
+        EAFNOSUPPORT = syscall.NewError("address family not supported by protocol")
+)
diff --git a/vendor/golang.org/x/sys/plan9/mkall.sh b/vendor/golang.org/x/sys/plan9/mkall.sh
new file mode 100644
index 0000000..1650fbc
--- /dev/null
+++ b/vendor/golang.org/x/sys/plan9/mkall.sh
@@ -0,0 +1,150 @@
+#!/usr/bin/env bash
+# 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.
+
+# The plan9 package provides access to the raw system call
+# interface of the underlying operating system.  Porting Go to
+# a new architecture/operating system combination requires
+# some manual effort, though there are tools that automate
+# much of the process.  The auto-generated files have names
+# beginning with z.
+#
+# This script runs or (given -n) prints suggested commands to generate z files
+# for the current system.  Running those commands is not automatic.
+# This script is documentation more than anything else.
+#
+# * asm_${GOOS}_${GOARCH}.s
+#
+# This hand-written assembly file implements system call dispatch.
+# There are three entry points:
+#
+#       func Syscall(trap, a1, a2, a3 uintptr) (r1, r2, err uintptr);
+#       func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr);
+#       func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2, err uintptr);
+#
+# The first and second are the standard ones; they differ only in
+# how many arguments can be passed to the kernel.
+# The third is for low-level use by the ForkExec wrapper;
+# unlike the first two, it does not call into the scheduler to
+# let it know that a system call is running.
+#
+# * syscall_${GOOS}.go
+#
+# This hand-written Go file implements system calls that need
+# special handling and lists "//sys" comments giving prototypes
+# for ones that can be auto-generated.  Mksyscall reads those
+# comments to generate the stubs.
+#
+# * syscall_${GOOS}_${GOARCH}.go
+#
+# Same as syscall_${GOOS}.go except that it contains code specific
+# to ${GOOS} on one particular architecture.
+#
+# * types_${GOOS}.c
+#
+# This hand-written C file includes standard C headers and then
+# creates typedef or enum names beginning with a dollar sign
+# (use of $ in variable names is a gcc extension).  The hardest
+# part about preparing this file is figuring out which headers to
+# include and which symbols need to be #defined to get the
+# actual data structures that pass through to the kernel system calls.
+# Some C libraries present alternate versions for binary compatibility
+# and translate them on the way in and out of system calls, but
+# there is almost always a #define that can get the real ones.
+# See types_darwin.c and types_linux.c for examples.
+#
+# * zerror_${GOOS}_${GOARCH}.go
+#
+# This machine-generated file defines the system's error numbers,
+# error strings, and signal numbers.  The generator is "mkerrors.sh".
+# Usually no arguments are needed, but mkerrors.sh will pass its
+# arguments on to godefs.
+#
+# * zsyscall_${GOOS}_${GOARCH}.go
+#
+# Generated by mksyscall.pl; see syscall_${GOOS}.go above.
+#
+# * zsysnum_${GOOS}_${GOARCH}.go
+#
+# Generated by mksysnum_${GOOS}.
+#
+# * ztypes_${GOOS}_${GOARCH}.go
+#
+# Generated by godefs; see types_${GOOS}.c above.
+
+GOOSARCH="${GOOS}_${GOARCH}"
+
+# defaults
+mksyscall="go run mksyscall.go"
+mkerrors="./mkerrors.sh"
+zerrors="zerrors_$GOOSARCH.go"
+mksysctl=""
+zsysctl="zsysctl_$GOOSARCH.go"
+mksysnum=
+mktypes=
+run="sh"
+
+case "$1" in
+-syscalls)
+        for i in zsyscall*go
+        do
+                sed 1q $i | sed 's;^// ;;' | sh > _$i && gofmt < _$i > $i
+                rm _$i
+        done
+        exit 0
+        ;;
+-n)
+        run="cat"
+        shift
+esac
+
+case "$#" in
+0)
+        ;;
+*)
+        echo 'usage: mkall.sh [-n]' 1>&2
+        exit 2
+esac
+
+case "$GOOSARCH" in
+_* | *_ | _)
+        echo 'undefined $GOOS_$GOARCH:' "$GOOSARCH" 1>&2
+        exit 1
+        ;;
+plan9_386)
+        mkerrors=
+        mksyscall="go run mksyscall.go -l32 -plan9 -tags plan9,386"
+        mksysnum="./mksysnum_plan9.sh /n/sources/plan9/sys/src/libc/9syscall/sys.h"
+        mktypes="XXX"
+        ;;
+plan9_amd64)
+        mkerrors=
+        mksyscall="go run mksyscall.go -l32 -plan9 -tags plan9,amd64"
+        mksysnum="./mksysnum_plan9.sh /n/sources/plan9/sys/src/libc/9syscall/sys.h"
+        mktypes="XXX"
+        ;;
+plan9_arm)
+        mkerrors=
+        mksyscall="go run mksyscall.go -l32 -plan9 -tags plan9,arm"
+        mksysnum="./mksysnum_plan9.sh /n/sources/plan9/sys/src/libc/9syscall/sys.h"
+        mktypes="XXX"
+        ;;
+*)
+        echo 'unrecognized $GOOS_$GOARCH: ' "$GOOSARCH" 1>&2
+        exit 1
+        ;;
+esac
+
+(
+        if [ -n "$mkerrors" ]; then echo "$mkerrors |gofmt >$zerrors"; fi
+        case "$GOOS" in
+        plan9)
+                syscall_goos="syscall_$GOOS.go"
+                if [ -n "$mksyscall" ]; then echo "$mksyscall $syscall_goos |gofmt >zsyscall_$GOOSARCH.go"; fi
+                ;;
+        esac
+        if [ -n "$mksysctl" ]; then echo "$mksysctl |gofmt >$zsysctl"; fi
+        if [ -n "$mksysnum" ]; then echo "$mksysnum |gofmt >zsysnum_$GOOSARCH.go"; fi
+        if [ -n "$mktypes" ]; then echo "$mktypes types_$GOOS.go |gofmt >ztypes_$GOOSARCH.go"; fi
+) | $run
diff --git a/vendor/golang.org/x/sys/plan9/mkerrors.sh b/vendor/golang.org/x/sys/plan9/mkerrors.sh
new file mode 100644
index 0000000..526d04a
--- /dev/null
+++ b/vendor/golang.org/x/sys/plan9/mkerrors.sh
@@ -0,0 +1,246 @@
+#!/usr/bin/env bash
+# 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.
+
+# Generate Go code listing errors and other #defined constant
+# values (ENAMETOOLONG etc.), by asking the preprocessor
+# about the definitions.
+
+unset LANG
+export LC_ALL=C
+export LC_CTYPE=C
+
+CC=${CC:-gcc}
+
+uname=$(uname)
+
+includes='
+#include <sys/types.h>
+#include <sys/file.h>
+#include <fcntl.h>
+#include <dirent.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netinet/ip.h>
+#include <netinet/ip6.h>
+#include <netinet/tcp.h>
+#include <errno.h>
+#include <sys/signal.h>
+#include <signal.h>
+#include <sys/resource.h>
+'
+
+ccflags="$@"
+
+# Write go tool cgo -godefs input.
+(
+        echo package plan9
+        echo
+        echo '/*'
+        indirect="includes_$(uname)"
+        echo "${!indirect} $includes"
+        echo '*/'
+        echo 'import "C"'
+        echo
+        echo 'const ('
+
+        # The gcc command line prints all the #defines
+        # it encounters while processing the input
+        echo "${!indirect} $includes" | $CC -x c - -E -dM $ccflags |
+        awk '
+                $1 != "#define" || $2 ~ /\(/ || $3 == "" {next}
+
+                $2 ~ /^E([ABCD]X|[BIS]P|[SD]I|S|FL)$/ {next}  # 386 registers
+                $2 ~ /^(SIGEV_|SIGSTKSZ|SIGRT(MIN|MAX))/ {next}
+                $2 ~ /^(SCM_SRCRT)$/ {next}
+                $2 ~ /^(MAP_FAILED)$/ {next}
+
+                $2 !~ /^ETH_/ &&
+                $2 !~ /^EPROC_/ &&
+                $2 !~ /^EQUIV_/ &&
+                $2 !~ /^EXPR_/ &&
+                $2 ~ /^E[A-Z0-9_]+$/ ||
+                $2 ~ /^B[0-9_]+$/ ||
+                $2 ~ /^V[A-Z0-9]+$/ ||
+                $2 ~ /^CS[A-Z0-9]/ ||
+                $2 ~ /^I(SIG|CANON|CRNL|EXTEN|MAXBEL|STRIP|UTF8)$/ ||
+                $2 ~ /^IGN/ ||
+                $2 ~ /^IX(ON|ANY|OFF)$/ ||
+                $2 ~ /^IN(LCR|PCK)$/ ||
+                $2 ~ /(^FLU?SH)|(FLU?SH$)/ ||
+                $2 ~ /^C(LOCAL|READ)$/ ||
+                $2 == "BRKINT" ||
+                $2 == "HUPCL" ||
+                $2 == "PENDIN" ||
+                $2 == "TOSTOP" ||
+                $2 ~ /^PAR/ ||
+                $2 ~ /^SIG[^_]/ ||
+                $2 ~ /^O[CNPFP][A-Z]+[^_][A-Z]+$/ ||
+                $2 ~ /^IN_/ ||
+                $2 ~ /^LOCK_(SH|EX|NB|UN)$/ ||
+                $2 ~ /^(AF|SOCK|SO|SOL|IPPROTO|IP|IPV6|ICMP6|TCP|EVFILT|NOTE|EV|SHUT|PROT|MAP|PACKET|MSG|SCM|MCL|DT|MADV|PR)_/ ||
+                $2 == "ICMPV6_FILTER" ||
+                $2 == "SOMAXCONN" ||
+                $2 == "NAME_MAX" ||
+                $2 == "IFNAMSIZ" ||
+                $2 ~ /^CTL_(MAXNAME|NET|QUERY)$/ ||
+                $2 ~ /^SYSCTL_VERS/ ||
+                $2 ~ /^(MS|MNT)_/ ||
+                $2 ~ /^TUN(SET|GET|ATTACH|DETACH)/ ||
+                $2 ~ /^(O|F|FD|NAME|S|PTRACE|PT)_/ ||
+                $2 ~ /^LINUX_REBOOT_CMD_/ ||
+                $2 ~ /^LINUX_REBOOT_MAGIC[12]$/ ||
+                $2 !~ "NLA_TYPE_MASK" &&
+                $2 ~ /^(NETLINK|NLM|NLMSG|NLA|IFA|IFAN|RT|RTCF|RTN|RTPROT|RTNH|ARPHRD|ETH_P)_/ ||
+                $2 ~ /^SIOC/ ||
+                $2 ~ /^TIOC/ ||
+                $2 !~ "RTF_BITS" &&
+                $2 ~ /^(IFF|IFT|NET_RT|RTM|RTF|RTV|RTA|RTAX)_/ ||
+                $2 ~ /^BIOC/ ||
+                $2 ~ /^RUSAGE_(SELF|CHILDREN|THREAD)/ ||
+                $2 ~ /^RLIMIT_(AS|CORE|CPU|DATA|FSIZE|NOFILE|STACK)|RLIM_INFINITY/ ||
+                $2 ~ /^PRIO_(PROCESS|PGRP|USER)/ ||
+                $2 ~ /^CLONE_[A-Z_]+/ ||
+                $2 !~ /^(BPF_TIMEVAL)$/ &&
+                $2 ~ /^(BPF|DLT)_/ ||
+                $2 !~ "WMESGLEN" &&
+                $2 ~ /^W[A-Z0-9]+$/ {printf("\t%s = C.%s\n", $2, $2)}
+                $2 ~ /^__WCOREFLAG$/ {next}
+                $2 ~ /^__W[A-Z0-9]+$/ {printf("\t%s = C.%s\n", substr($2,3), $2)}
+
+                {next}
+        ' | sort
+
+        echo ')'
+) >_const.go
+
+# Pull out the error names for later.
+errors=$(
+        echo '#include <errno.h>' | $CC -x c - -E -dM $ccflags |
+        awk '$1=="#define" && $2 ~ /^E[A-Z0-9_]+$/ { print $2 }' |
+        sort
+)
+
+# Pull out the signal names for later.
+signals=$(
+        echo '#include <signal.h>' | $CC -x c - -E -dM $ccflags |
+        awk '$1=="#define" && $2 ~ /^SIG[A-Z0-9]+$/ { print $2 }' |
+        grep -v 'SIGSTKSIZE\|SIGSTKSZ\|SIGRT' |
+        sort
+)
+
+# Again, writing regexps to a file.
+echo '#include <errno.h>' | $CC -x c - -E -dM $ccflags |
+        awk '$1=="#define" && $2 ~ /^E[A-Z0-9_]+$/ { print "^\t" $2 "[ \t]*=" }' |
+        sort >_error.grep
+echo '#include <signal.h>' | $CC -x c - -E -dM $ccflags |
+        awk '$1=="#define" && $2 ~ /^SIG[A-Z0-9]+$/ { print "^\t" $2 "[ \t]*=" }' |
+        grep -v 'SIGSTKSIZE\|SIGSTKSZ\|SIGRT' |
+        sort >_signal.grep
+
+echo '// mkerrors.sh' "$@"
+echo '// Code generated by the command above; DO NOT EDIT.'
+echo
+go tool cgo -godefs -- "$@" _const.go >_error.out
+cat _error.out | grep -vf _error.grep | grep -vf _signal.grep
+echo
+echo '// Errors'
+echo 'const ('
+cat _error.out | grep -f _error.grep | sed 's/=\(.*\)/= Errno(\1)/'
+echo ')'
+
+echo
+echo '// Signals'
+echo 'const ('
+cat _error.out | grep -f _signal.grep | sed 's/=\(.*\)/= Signal(\1)/'
+echo ')'
+
+# Run C program to print error and syscall strings.
+(
+        echo -E "
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <ctype.h>
+#include <string.h>
+#include <signal.h>
+
+#define nelem(x) (sizeof(x)/sizeof((x)[0]))
+
+enum { A = 'A', Z = 'Z', a = 'a', z = 'z' }; // avoid need for single quotes below
+
+int errors[] = {
+"
+        for i in $errors
+        do
+                echo -E '       '$i,
+        done
+
+        echo -E "
+};
+
+int signals[] = {
+"
+        for i in $signals
+        do
+                echo -E '       '$i,
+        done
+
+        # Use -E because on some systems bash builtin interprets \n itself.
+        echo -E '
+};
+
+static int
+intcmp(const void *a, const void *b)
+{
+        return *(int*)a - *(int*)b;
+}
+
+int
+main(void)
+{
+        int i, j, e;
+        char buf[1024], *p;
+
+        printf("\n\n// Error table\n");
+        printf("var errors = [...]string {\n");
+        qsort(errors, nelem(errors), sizeof errors[0], intcmp);
+        for(i=0; i<nelem(errors); i++) {
+                e = errors[i];
+                if(i > 0 && errors[i-1] == e)
+                        continue;
+                strcpy(buf, strerror(e));
+                // lowercase first letter: Bad -> bad, but STREAM -> STREAM.
+                if(A <= buf[0] && buf[0] <= Z && a <= buf[1] && buf[1] <= z)
+                        buf[0] += a - A;
+                printf("\t%d: \"%s\",\n", e, buf);
+        }
+        printf("}\n\n");
+        
+        printf("\n\n// Signal table\n");
+        printf("var signals = [...]string {\n");
+        qsort(signals, nelem(signals), sizeof signals[0], intcmp);
+        for(i=0; i<nelem(signals); i++) {
+                e = signals[i];
+                if(i > 0 && signals[i-1] == e)
+                        continue;
+                strcpy(buf, strsignal(e));
+                // lowercase first letter: Bad -> bad, but STREAM -> STREAM.
+                if(A <= buf[0] && buf[0] <= Z && a <= buf[1] && buf[1] <= z)
+                        buf[0] += a - A;
+                // cut trailing : number.
+                p = strrchr(buf, ":"[0]);
+                if(p)
+                        *p = '\0';
+                printf("\t%d: \"%s\",\n", e, buf);
+        }
+        printf("}\n\n");
+
+        return 0;
+}
+
+'
+) >_errors.c
+
+$CC $ccflags -o _errors _errors.c && $GORUN ./_errors && rm -f _errors.c _errors _const.go _error.grep _signal.grep _error.out
diff --git a/vendor/golang.org/x/sys/plan9/mksysnum_plan9.sh b/vendor/golang.org/x/sys/plan9/mksysnum_plan9.sh
new file mode 100644
index 0000000..3c3ab05
--- /dev/null
+++ b/vendor/golang.org/x/sys/plan9/mksysnum_plan9.sh
@@ -0,0 +1,23 @@
+#!/bin/sh
+# 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.
+
+COMMAND="mksysnum_plan9.sh $@"
+
+cat <<EOF
+// $COMMAND
+// MACHINE GENERATED BY THE ABOVE COMMAND; DO NOT EDIT
+
+package plan9
+
+const(
+EOF
+
+SP='[   ]' # space or tab
+sed "s/^#define${SP}\\([A-Z0-9_][A-Z0-9_]*\\)${SP}${SP}*\\([0-9][0-9]*\\)/SYS_\\1=\\2/g" \
+        < $1 | grep -v SYS__
+
+cat <<EOF
+)
+EOF
diff --git a/vendor/golang.org/x/sys/plan9/pwd_go15_plan9.go b/vendor/golang.org/x/sys/plan9/pwd_go15_plan9.go
new file mode 100644
index 0000000..73687de
--- /dev/null
+++ b/vendor/golang.org/x/sys/plan9/pwd_go15_plan9.go
@@ -0,0 +1,21 @@
+// Copyright 2015 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.
+
+//go:build go1.5
+
+package plan9
+
+import "syscall"
+
+func fixwd() {
+        syscall.Fixwd()
+}
+
+func Getwd() (wd string, err error) {
+        return syscall.Getwd()
+}
+
+func Chdir(path string) error {
+        return syscall.Chdir(path)
+}
diff --git a/vendor/golang.org/x/sys/plan9/pwd_plan9.go b/vendor/golang.org/x/sys/plan9/pwd_plan9.go
new file mode 100644
index 0000000..fb94582
--- /dev/null
+++ b/vendor/golang.org/x/sys/plan9/pwd_plan9.go
@@ -0,0 +1,23 @@
+// Copyright 2015 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.
+
+//go:build !go1.5
+
+package plan9
+
+func fixwd() {
+}
+
+func Getwd() (wd string, err error) {
+        fd, err := open(".", O_RDONLY)
+        if err != nil {
+                return "", err
+        }
+        defer Close(fd)
+        return Fd2path(fd)
+}
+
+func Chdir(path string) error {
+        return chdir(path)
+}
diff --git a/vendor/golang.org/x/sys/plan9/race.go b/vendor/golang.org/x/sys/plan9/race.go
new file mode 100644
index 0000000..c02d9ed
--- /dev/null
+++ b/vendor/golang.org/x/sys/plan9/race.go
@@ -0,0 +1,30 @@
+// 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.
+
+//go:build plan9 && race
+
+package plan9
+
+import (
+        "runtime"
+        "unsafe"
+)
+
+const raceenabled = true
+
+func raceAcquire(addr unsafe.Pointer) {
+        runtime.RaceAcquire(addr)
+}
+
+func raceReleaseMerge(addr unsafe.Pointer) {
+        runtime.RaceReleaseMerge(addr)
+}
+
+func raceReadRange(addr unsafe.Pointer, len int) {
+        runtime.RaceReadRange(addr, len)
+}
+
+func raceWriteRange(addr unsafe.Pointer, len int) {
+        runtime.RaceWriteRange(addr, len)
+}
diff --git a/vendor/golang.org/x/sys/plan9/race0.go b/vendor/golang.org/x/sys/plan9/race0.go
new file mode 100644
index 0000000..7b15e15
--- /dev/null
+++ b/vendor/golang.org/x/sys/plan9/race0.go
@@ -0,0 +1,25 @@
+// 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.
+
+//go:build plan9 && !race
+
+package plan9
+
+import (
+        "unsafe"
+)
+
+const raceenabled = false
+
+func raceAcquire(addr unsafe.Pointer) {
+}
+
+func raceReleaseMerge(addr unsafe.Pointer) {
+}
+
+func raceReadRange(addr unsafe.Pointer, len int) {
+}
+
+func raceWriteRange(addr unsafe.Pointer, len int) {
+}
diff --git a/vendor/golang.org/x/sys/plan9/str.go b/vendor/golang.org/x/sys/plan9/str.go
new file mode 100644
index 0000000..ba3e8ff
--- /dev/null
+++ b/vendor/golang.org/x/sys/plan9/str.go
@@ -0,0 +1,22 @@
+// 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.
+
+//go:build plan9
+
+package plan9
+
+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/vendor/golang.org/x/sys/plan9/syscall.go b/vendor/golang.org/x/sys/plan9/syscall.go
new file mode 100644
index 0000000..d631fd6
--- /dev/null
+++ b/vendor/golang.org/x/sys/plan9/syscall.go
@@ -0,0 +1,109 @@
+// 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.
+
+//go:build plan9
+
+// Package plan9 contains an interface to the low-level operating system
+// primitives. OS details vary depending on the underlying system, and
+// by default, godoc will display the OS-specific documentation for the current
+// system. If you want godoc to display documentation for another
+// system, set $GOOS and $GOARCH to the desired system. For example, if
+// you want to view documentation for freebsd/arm on linux/amd64, set $GOOS
+// to freebsd and $GOARCH to arm.
+//
+// The primary use of this package is inside other packages that provide a more
+// portable interface to the system, such as "os", "time" and "net".  Use
+// those packages rather than this one if you can.
+//
+// For details of the functions and data types in this package consult
+// the manuals for the appropriate operating system.
+//
+// These calls return err == nil to indicate success; otherwise
+// err represents an operating system error describing the failure and
+// holds a value of type syscall.ErrorString.
+package plan9 // import "golang.org/x/sys/plan9"
+
+import (
+        "bytes"
+        "strings"
+        "unsafe"
+)
+
+// ByteSliceFromString returns a NUL-terminated slice of bytes
+// containing the text of s. If s contains a NUL byte at any
+// location, it returns (nil, EINVAL).
+func ByteSliceFromString(s string) ([]byte, error) {
+        if strings.IndexByte(s, 0) != -1 {
+                return nil, EINVAL
+        }
+        a := make([]byte, len(s)+1)
+        copy(a, s)
+        return a, nil
+}
+
+// BytePtrFromString returns a pointer to a NUL-terminated array of
+// bytes containing the text of s. If s contains a NUL byte at any
+// location, it returns (nil, EINVAL).
+func BytePtrFromString(s string) (*byte, error) {
+        a, err := ByteSliceFromString(s)
+        if err != nil {
+                return nil, err
+        }
+        return &a[0], nil
+}
+
+// ByteSliceToString returns a string form of the text represented by the slice s, with a terminating NUL and any
+// bytes after the NUL removed.
+func ByteSliceToString(s []byte) string {
+        if i := bytes.IndexByte(s, 0); i != -1 {
+                s = s[:i]
+        }
+        return string(s)
+}
+
+// BytePtrToString takes a pointer to a sequence of text and returns the corresponding string.
+// If the pointer is nil, it returns the empty string. It assumes that the text sequence is terminated
+// at a zero byte; if the zero byte is not present, the program may crash.
+func BytePtrToString(p *byte) string {
+        if p == nil {
+                return ""
+        }
+        if *p == 0 {
+                return ""
+        }
+
+        // Find NUL terminator.
+        n := 0
+        for ptr := unsafe.Pointer(p); *(*byte)(ptr) != 0; n++ {
+                ptr = unsafe.Pointer(uintptr(ptr) + 1)
+        }
+
+        return string(unsafe.Slice(p, n))
+}
+
+// Single-word zero for use when we need a valid pointer to 0 bytes.
+// See mksyscall.pl.
+var _zero uintptr
+
+func (ts *Timespec) Unix() (sec int64, nsec int64) {
+        return int64(ts.Sec), int64(ts.Nsec)
+}
+
+func (tv *Timeval) Unix() (sec int64, nsec int64) {
+        return int64(tv.Sec), int64(tv.Usec) * 1000
+}
+
+func (ts *Timespec) Nano() int64 {
+        return int64(ts.Sec)*1e9 + int64(ts.Nsec)
+}
+
+func (tv *Timeval) Nano() int64 {
+        return int64(tv.Sec)*1e9 + int64(tv.Usec)*1000
+}
+
+// use is a no-op, but the compiler cannot see that it is.
+// Calling use(p) ensures that p is kept live until that point.
+//
+//go:noescape
+func use(p unsafe.Pointer)
diff --git a/vendor/golang.org/x/sys/plan9/syscall_plan9.go b/vendor/golang.org/x/sys/plan9/syscall_plan9.go
new file mode 100644
index 0000000..d079d81
--- /dev/null
+++ b/vendor/golang.org/x/sys/plan9/syscall_plan9.go
@@ -0,0 +1,361 @@
+// Copyright 2011 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.
+
+// Plan 9 system calls.
+// This file is compiled as ordinary Go code,
+// but it is also input to mksyscall,
+// which parses the //sys lines and generates system call stubs.
+// Note that sometimes we use a lowercase //sys name and
+// wrap it in our own nicer implementation.
+
+package plan9
+
+import (
+        "bytes"
+        "syscall"
+        "unsafe"
+)
+
+// A Note is a string describing a process note.
+// It implements the os.Signal interface.
+type Note string
+
+func (n Note) Signal() {}
+
+func (n Note) String() string {
+        return string(n)
+}
+
+var (
+        Stdin  = 0
+        Stdout = 1
+        Stderr = 2
+)
+
+// For testing: clients can set this flag to force
+// creation of IPv6 sockets to return EAFNOSUPPORT.
+var SocketDisableIPv6 bool
+
+func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.ErrorString)
+func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.ErrorString)
+func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2, err uintptr)
+func RawSyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr)
+
+func atoi(b []byte) (n uint) {
+        n = 0
+        for i := 0; i < len(b); i++ {
+                n = n*10 + uint(b[i]-'0')
+        }
+        return
+}
+
+func cstring(s []byte) string {
+        i := bytes.IndexByte(s, 0)
+        if i == -1 {
+                i = len(s)
+        }
+        return string(s[:i])
+}
+
+func errstr() string {
+        var buf [ERRMAX]byte
+
+        RawSyscall(SYS_ERRSTR, uintptr(unsafe.Pointer(&buf[0])), uintptr(len(buf)), 0)
+
+        buf[len(buf)-1] = 0
+        return cstring(buf[:])
+}
+
+// Implemented in assembly to import from runtime.
+func exit(code int)
+
+func Exit(code int) { exit(code) }
+
+func readnum(path string) (uint, error) {
+        var b [12]byte
+
+        fd, e := Open(path, O_RDONLY)
+        if e != nil {
+                return 0, e
+        }
+        defer Close(fd)
+
+        n, e := Pread(fd, b[:], 0)
+
+        if e != nil {
+                return 0, e
+        }
+
+        m := 0
+        for ; m < n && b[m] == ' '; m++ {
+        }
+
+        return atoi(b[m : n-1]), nil
+}
+
+func Getpid() (pid int) {
+        n, _ := readnum("#c/pid")
+        return int(n)
+}
+
+func Getppid() (ppid int) {
+        n, _ := readnum("#c/ppid")
+        return int(n)
+}
+
+func Read(fd int, p []byte) (n int, err error) {
+        return Pread(fd, p, -1)
+}
+
+func Write(fd int, p []byte) (n int, err error) {
+        return Pwrite(fd, p, -1)
+}
+
+var ioSync int64
+
+//sys   fd2path(fd int, buf []byte) (err error)
+
+func Fd2path(fd int) (path string, err error) {
+        var buf [512]byte
+
+        e := fd2path(fd, buf[:])
+        if e != nil {
+                return "", e
+        }
+        return cstring(buf[:]), nil
+}
+
+//sys   pipe(p *[2]int32) (err error)
+
+func Pipe(p []int) (err error) {
+        if len(p) != 2 {
+                return syscall.ErrorString("bad arg in system call")
+        }
+        var pp [2]int32
+        err = pipe(&pp)
+        if err == nil {
+                p[0] = int(pp[0])
+                p[1] = int(pp[1])
+        }
+        return
+}
+
+// Underlying system call writes to newoffset via pointer.
+// Implemented in assembly to avoid allocation.
+func seek(placeholder uintptr, fd int, offset int64, whence int) (newoffset int64, err string)
+
+func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {
+        newoffset, e := seek(0, fd, offset, whence)
+
+        if newoffset == -1 {
+                err = syscall.ErrorString(e)
+        }
+        return
+}
+
+func Mkdir(path string, mode uint32) (err error) {
+        fd, err := Create(path, O_RDONLY, DMDIR|mode)
+
+        if fd != -1 {
+                Close(fd)
+        }
+
+        return
+}
+
+type Waitmsg struct {
+        Pid  int
+        Time [3]uint32
+        Msg  string
+}
+
+func (w Waitmsg) Exited() bool   { return true }
+func (w Waitmsg) Signaled() bool { return false }
+
+func (w Waitmsg) ExitStatus() int {
+        if len(w.Msg) == 0 {
+                // a normal exit returns no message
+                return 0
+        }
+        return 1
+}
+
+//sys   await(s []byte) (n int, err error)
+
+func Await(w *Waitmsg) (err error) {
+        var buf [512]byte
+        var f [5][]byte
+
+        n, err := await(buf[:])
+
+        if err != nil || w == nil {
+                return
+        }
+
+        nf := 0
+        p := 0
+        for i := 0; i < n && nf < len(f)-1; i++ {
+                if buf[i] == ' ' {
+                        f[nf] = buf[p:i]
+                        p = i + 1
+                        nf++
+                }
+        }
+        f[nf] = buf[p:]
+        nf++
+
+        if nf != len(f) {
+                return syscall.ErrorString("invalid wait message")
+        }
+        w.Pid = int(atoi(f[0]))
+        w.Time[0] = uint32(atoi(f[1]))
+        w.Time[1] = uint32(atoi(f[2]))
+        w.Time[2] = uint32(atoi(f[3]))
+        w.Msg = cstring(f[4])
+        if w.Msg == "''" {
+                // await() returns '' for no error
+                w.Msg = ""
+        }
+        return
+}
+
+func Unmount(name, old string) (err error) {
+        fixwd()
+        oldp, err := BytePtrFromString(old)
+        if err != nil {
+                return err
+        }
+        oldptr := uintptr(unsafe.Pointer(oldp))
+
+        var r0 uintptr
+        var e syscall.ErrorString
+
+        // bind(2) man page: If name is zero, everything bound or mounted upon old is unbound or unmounted.
+        if name == "" {
+                r0, _, e = Syscall(SYS_UNMOUNT, _zero, oldptr, 0)
+        } else {
+                namep, err := BytePtrFromString(name)
+                if err != nil {
+                        return err
+                }
+                r0, _, e = Syscall(SYS_UNMOUNT, uintptr(unsafe.Pointer(namep)), oldptr, 0)
+        }
+
+        if int32(r0) == -1 {
+                err = e
+        }
+        return
+}
+
+func Fchdir(fd int) (err error) {
+        path, err := Fd2path(fd)
+
+        if err != nil {
+                return
+        }
+
+        return Chdir(path)
+}
+
+type Timespec struct {
+        Sec  int32
+        Nsec int32
+}
+
+type Timeval struct {
+        Sec  int32
+        Usec int32
+}
+
+func NsecToTimeval(nsec int64) (tv Timeval) {
+        nsec += 999 // round up to microsecond
+        tv.Usec = int32(nsec % 1e9 / 1e3)
+        tv.Sec = int32(nsec / 1e9)
+        return
+}
+
+func nsec() int64 {
+        var scratch int64
+
+        r0, _, _ := Syscall(SYS_NSEC, uintptr(unsafe.Pointer(&scratch)), 0, 0)
+        // TODO(aram): remove hack after I fix _nsec in the pc64 kernel.
+        if r0 == 0 {
+                return scratch
+        }
+        return int64(r0)
+}
+
+func Gettimeofday(tv *Timeval) error {
+        nsec := nsec()
+        *tv = NsecToTimeval(nsec)
+        return nil
+}
+
+func Getpagesize() int { return 0x1000 }
+
+func Getegid() (egid int) { return -1 }
+func Geteuid() (euid int) { return -1 }
+func Getgid() (gid int)   { return -1 }
+func Getuid() (uid int)   { return -1 }
+
+func Getgroups() (gids []int, err error) {
+        return make([]int, 0), nil
+}
+
+//sys   open(path string, mode int) (fd int, err error)
+
+func Open(path string, mode int) (fd int, err error) {
+        fixwd()
+        return open(path, mode)
+}
+
+//sys   create(path string, mode int, perm uint32) (fd int, err error)
+
+func Create(path string, mode int, perm uint32) (fd int, err error) {
+        fixwd()
+        return create(path, mode, perm)
+}
+
+//sys   remove(path string) (err error)
+
+func Remove(path string) error {
+        fixwd()
+        return remove(path)
+}
+
+//sys   stat(path string, edir []byte) (n int, err error)
+
+func Stat(path string, edir []byte) (n int, err error) {
+        fixwd()
+        return stat(path, edir)
+}
+
+//sys   bind(name string, old string, flag int) (err error)
+
+func Bind(name string, old string, flag int) (err error) {
+        fixwd()
+        return bind(name, old, flag)
+}
+
+//sys   mount(fd int, afd int, old string, flag int, aname string) (err error)
+
+func Mount(fd int, afd int, old string, flag int, aname string) (err error) {
+        fixwd()
+        return mount(fd, afd, old, flag, aname)
+}
+
+//sys   wstat(path string, edir []byte) (err error)
+
+func Wstat(path string, edir []byte) (err error) {
+        fixwd()
+        return wstat(path, edir)
+}
+
+//sys   chdir(path string) (err error)
+//sys   Dup(oldfd int, newfd int) (fd int, err error)
+//sys   Pread(fd int, p []byte, offset int64) (n int, err error)
+//sys   Pwrite(fd int, p []byte, offset int64) (n int, err error)
+//sys   Close(fd int) (err error)
+//sys   Fstat(fd int, edir []byte) (n int, err error)
+//sys   Fwstat(fd int, edir []byte) (err error)
diff --git a/vendor/golang.org/x/sys/plan9/zsyscall_plan9_386.go b/vendor/golang.org/x/sys/plan9/zsyscall_plan9_386.go
new file mode 100644
index 0000000..f780d5c
--- /dev/null
+++ b/vendor/golang.org/x/sys/plan9/zsyscall_plan9_386.go
@@ -0,0 +1,284 @@
+// go run mksyscall.go -l32 -plan9 -tags plan9,386 syscall_plan9.go
+// Code generated by the command above; see README.md. DO NOT EDIT.
+
+//go:build plan9 && 386
+
+package plan9
+
+import "unsafe"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func fd2path(fd int, buf []byte) (err error) {
+        var _p0 unsafe.Pointer
+        if len(buf) > 0 {
+                _p0 = unsafe.Pointer(&buf[0])
+        } else {
+                _p0 = unsafe.Pointer(&_zero)
+        }
+        r0, _, e1 := Syscall(SYS_FD2PATH, uintptr(fd), uintptr(_p0), uintptr(len(buf)))
+        if int32(r0) == -1 {
+                err = e1
+        }
+        return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func pipe(p *[2]int32) (err error) {
+        r0, _, e1 := Syscall(SYS_PIPE, uintptr(unsafe.Pointer(p)), 0, 0)
+        if int32(r0) == -1 {
+                err = e1
+        }
+        return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func await(s []byte) (n int, err error) {
+        var _p0 unsafe.Pointer
+        if len(s) > 0 {
+                _p0 = unsafe.Pointer(&s[0])
+        } else {
+                _p0 = unsafe.Pointer(&_zero)
+        }
+        r0, _, e1 := Syscall(SYS_AWAIT, uintptr(_p0), uintptr(len(s)), 0)
+        n = int(r0)
+        if int32(r0) == -1 {
+                err = e1
+        }
+        return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func open(path string, mode int) (fd int, err error) {
+        var _p0 *byte
+        _p0, err = BytePtrFromString(path)
+        if err != nil {
+                return
+        }
+        r0, _, e1 := Syscall(SYS_OPEN, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+        fd = int(r0)
+        if int32(r0) == -1 {
+                err = e1
+        }
+        return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func create(path string, mode int, perm uint32) (fd int, err error) {
+        var _p0 *byte
+        _p0, err = BytePtrFromString(path)
+        if err != nil {
+                return
+        }
+        r0, _, e1 := Syscall(SYS_CREATE, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
+        fd = int(r0)
+        if int32(r0) == -1 {
+                err = e1
+        }
+        return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func remove(path string) (err error) {
+        var _p0 *byte
+        _p0, err = BytePtrFromString(path)
+        if err != nil {
+                return
+        }
+        r0, _, e1 := Syscall(SYS_REMOVE, uintptr(unsafe.Pointer(_p0)), 0, 0)
+        if int32(r0) == -1 {
+                err = e1
+        }
+        return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func stat(path string, edir []byte) (n int, err error) {
+        var _p0 *byte
+        _p0, err = BytePtrFromString(path)
+        if err != nil {
+                return
+        }
+        var _p1 unsafe.Pointer
+        if len(edir) > 0 {
+                _p1 = unsafe.Pointer(&edir[0])
+        } else {
+                _p1 = unsafe.Pointer(&_zero)
+        }
+        r0, _, e1 := Syscall(SYS_STAT, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(edir)))
+        n = int(r0)
+        if int32(r0) == -1 {
+                err = e1
+        }
+        return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func bind(name string, old string, flag int) (err error) {
+        var _p0 *byte
+        _p0, err = BytePtrFromString(name)
+        if err != nil {
+                return
+        }
+        var _p1 *byte
+        _p1, err = BytePtrFromString(old)
+        if err != nil {
+                return
+        }
+        r0, _, e1 := Syscall(SYS_BIND, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(flag))
+        if int32(r0) == -1 {
+                err = e1
+        }
+        return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func mount(fd int, afd int, old string, flag int, aname string) (err error) {
+        var _p0 *byte
+        _p0, err = BytePtrFromString(old)
+        if err != nil {
+                return
+        }
+        var _p1 *byte
+        _p1, err = BytePtrFromString(aname)
+        if err != nil {
+                return
+        }
+        r0, _, e1 := Syscall6(SYS_MOUNT, uintptr(fd), uintptr(afd), uintptr(unsafe.Pointer(_p0)), uintptr(flag), uintptr(unsafe.Pointer(_p1)), 0)
+        if int32(r0) == -1 {
+                err = e1
+        }
+        return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func wstat(path string, edir []byte) (err error) {
+        var _p0 *byte
+        _p0, err = BytePtrFromString(path)
+        if err != nil {
+                return
+        }
+        var _p1 unsafe.Pointer
+        if len(edir) > 0 {
+                _p1 = unsafe.Pointer(&edir[0])
+        } else {
+                _p1 = unsafe.Pointer(&_zero)
+        }
+        r0, _, e1 := Syscall(SYS_WSTAT, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(edir)))
+        if int32(r0) == -1 {
+                err = e1
+        }
+        return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func chdir(path string) (err error) {
+        var _p0 *byte
+        _p0, err = BytePtrFromString(path)
+        if err != nil {
+                return
+        }
+        r0, _, e1 := Syscall(SYS_CHDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
+        if int32(r0) == -1 {
+                err = e1
+        }
+        return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Dup(oldfd int, newfd int) (fd int, err error) {
+        r0, _, e1 := Syscall(SYS_DUP, uintptr(oldfd), uintptr(newfd), 0)
+        fd = int(r0)
+        if int32(r0) == -1 {
+                err = e1
+        }
+        return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Pread(fd int, p []byte, offset int64) (n int, err error) {
+        var _p0 unsafe.Pointer
+        if len(p) > 0 {
+                _p0 = unsafe.Pointer(&p[0])
+        } else {
+                _p0 = unsafe.Pointer(&_zero)
+        }
+        r0, _, e1 := Syscall6(SYS_PREAD, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), uintptr(offset>>32), 0)
+        n = int(r0)
+        if int32(r0) == -1 {
+                err = e1
+        }
+        return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
+        var _p0 unsafe.Pointer
+        if len(p) > 0 {
+                _p0 = unsafe.Pointer(&p[0])
+        } else {
+                _p0 = unsafe.Pointer(&_zero)
+        }
+        r0, _, e1 := Syscall6(SYS_PWRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), uintptr(offset>>32), 0)
+        n = int(r0)
+        if int32(r0) == -1 {
+                err = e1
+        }
+        return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Close(fd int) (err error) {
+        r0, _, e1 := Syscall(SYS_CLOSE, uintptr(fd), 0, 0)
+        if int32(r0) == -1 {
+                err = e1
+        }
+        return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Fstat(fd int, edir []byte) (n int, err error) {
+        var _p0 unsafe.Pointer
+        if len(edir) > 0 {
+                _p0 = unsafe.Pointer(&edir[0])
+        } else {
+                _p0 = unsafe.Pointer(&_zero)
+        }
+        r0, _, e1 := Syscall(SYS_FSTAT, uintptr(fd), uintptr(_p0), uintptr(len(edir)))
+        n = int(r0)
+        if int32(r0) == -1 {
+                err = e1
+        }
+        return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Fwstat(fd int, edir []byte) (err error) {
+        var _p0 unsafe.Pointer
+        if len(edir) > 0 {
+                _p0 = unsafe.Pointer(&edir[0])
+        } else {
+                _p0 = unsafe.Pointer(&_zero)
+        }
+        r0, _, e1 := Syscall(SYS_FWSTAT, uintptr(fd), uintptr(_p0), uintptr(len(edir)))
+        if int32(r0) == -1 {
+                err = e1
+        }
+        return
+}
diff --git a/vendor/golang.org/x/sys/plan9/zsyscall_plan9_amd64.go b/vendor/golang.org/x/sys/plan9/zsyscall_plan9_amd64.go
new file mode 100644
index 0000000..7de6106
--- /dev/null
+++ b/vendor/golang.org/x/sys/plan9/zsyscall_plan9_amd64.go
@@ -0,0 +1,284 @@
+// go run mksyscall.go -l32 -plan9 -tags plan9,amd64 syscall_plan9.go
+// Code generated by the command above; see README.md. DO NOT EDIT.
+
+//go:build plan9 && amd64
+
+package plan9
+
+import "unsafe"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func fd2path(fd int, buf []byte) (err error) {
+        var _p0 unsafe.Pointer
+        if len(buf) > 0 {
+                _p0 = unsafe.Pointer(&buf[0])
+        } else {
+                _p0 = unsafe.Pointer(&_zero)
+        }
+        r0, _, e1 := Syscall(SYS_FD2PATH, uintptr(fd), uintptr(_p0), uintptr(len(buf)))
+        if int32(r0) == -1 {
+                err = e1
+        }
+        return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func pipe(p *[2]int32) (err error) {
+        r0, _, e1 := Syscall(SYS_PIPE, uintptr(unsafe.Pointer(p)), 0, 0)
+        if int32(r0) == -1 {
+                err = e1
+        }
+        return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func await(s []byte) (n int, err error) {
+        var _p0 unsafe.Pointer
+        if len(s) > 0 {
+                _p0 = unsafe.Pointer(&s[0])
+        } else {
+                _p0 = unsafe.Pointer(&_zero)
+        }
+        r0, _, e1 := Syscall(SYS_AWAIT, uintptr(_p0), uintptr(len(s)), 0)
+        n = int(r0)
+        if int32(r0) == -1 {
+                err = e1
+        }
+        return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func open(path string, mode int) (fd int, err error) {
+        var _p0 *byte
+        _p0, err = BytePtrFromString(path)
+        if err != nil {
+                return
+        }
+        r0, _, e1 := Syscall(SYS_OPEN, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+        fd = int(r0)
+        if int32(r0) == -1 {
+                err = e1
+        }
+        return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func create(path string, mode int, perm uint32) (fd int, err error) {
+        var _p0 *byte
+        _p0, err = BytePtrFromString(path)
+        if err != nil {
+                return
+        }
+        r0, _, e1 := Syscall(SYS_CREATE, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
+        fd = int(r0)
+        if int32(r0) == -1 {
+                err = e1
+        }
+        return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func remove(path string) (err error) {
+        var _p0 *byte
+        _p0, err = BytePtrFromString(path)
+        if err != nil {
+                return
+        }
+        r0, _, e1 := Syscall(SYS_REMOVE, uintptr(unsafe.Pointer(_p0)), 0, 0)
+        if int32(r0) == -1 {
+                err = e1
+        }
+        return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func stat(path string, edir []byte) (n int, err error) {
+        var _p0 *byte
+        _p0, err = BytePtrFromString(path)
+        if err != nil {
+                return
+        }
+        var _p1 unsafe.Pointer
+        if len(edir) > 0 {
+                _p1 = unsafe.Pointer(&edir[0])
+        } else {
+                _p1 = unsafe.Pointer(&_zero)
+        }
+        r0, _, e1 := Syscall(SYS_STAT, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(edir)))
+        n = int(r0)
+        if int32(r0) == -1 {
+                err = e1
+        }
+        return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func bind(name string, old string, flag int) (err error) {
+        var _p0 *byte
+        _p0, err = BytePtrFromString(name)
+        if err != nil {
+                return
+        }
+        var _p1 *byte
+        _p1, err = BytePtrFromString(old)
+        if err != nil {
+                return
+        }
+        r0, _, e1 := Syscall(SYS_BIND, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(flag))
+        if int32(r0) == -1 {
+                err = e1
+        }
+        return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func mount(fd int, afd int, old string, flag int, aname string) (err error) {
+        var _p0 *byte
+        _p0, err = BytePtrFromString(old)
+        if err != nil {
+                return
+        }
+        var _p1 *byte
+        _p1, err = BytePtrFromString(aname)
+        if err != nil {
+                return
+        }
+        r0, _, e1 := Syscall6(SYS_MOUNT, uintptr(fd), uintptr(afd), uintptr(unsafe.Pointer(_p0)), uintptr(flag), uintptr(unsafe.Pointer(_p1)), 0)
+        if int32(r0) == -1 {
+                err = e1
+        }
+        return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func wstat(path string, edir []byte) (err error) {
+        var _p0 *byte
+        _p0, err = BytePtrFromString(path)
+        if err != nil {
+                return
+        }
+        var _p1 unsafe.Pointer
+        if len(edir) > 0 {
+                _p1 = unsafe.Pointer(&edir[0])
+        } else {
+                _p1 = unsafe.Pointer(&_zero)
+        }
+        r0, _, e1 := Syscall(SYS_WSTAT, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(edir)))
+        if int32(r0) == -1 {
+                err = e1
+        }
+        return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func chdir(path string) (err error) {
+        var _p0 *byte
+        _p0, err = BytePtrFromString(path)
+        if err != nil {
+                return
+        }
+        r0, _, e1 := Syscall(SYS_CHDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
+        if int32(r0) == -1 {
+                err = e1
+        }
+        return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Dup(oldfd int, newfd int) (fd int, err error) {
+        r0, _, e1 := Syscall(SYS_DUP, uintptr(oldfd), uintptr(newfd), 0)
+        fd = int(r0)
+        if int32(r0) == -1 {
+                err = e1
+        }
+        return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Pread(fd int, p []byte, offset int64) (n int, err error) {
+        var _p0 unsafe.Pointer
+        if len(p) > 0 {
+                _p0 = unsafe.Pointer(&p[0])
+        } else {
+                _p0 = unsafe.Pointer(&_zero)
+        }
+        r0, _, e1 := Syscall6(SYS_PREAD, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), uintptr(offset>>32), 0)
+        n = int(r0)
+        if int32(r0) == -1 {
+                err = e1
+        }
+        return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
+        var _p0 unsafe.Pointer
+        if len(p) > 0 {
+                _p0 = unsafe.Pointer(&p[0])
+        } else {
+                _p0 = unsafe.Pointer(&_zero)
+        }
+        r0, _, e1 := Syscall6(SYS_PWRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), uintptr(offset>>32), 0)
+        n = int(r0)
+        if int32(r0) == -1 {
+                err = e1
+        }
+        return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Close(fd int) (err error) {
+        r0, _, e1 := Syscall(SYS_CLOSE, uintptr(fd), 0, 0)
+        if int32(r0) == -1 {
+                err = e1
+        }
+        return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Fstat(fd int, edir []byte) (n int, err error) {
+        var _p0 unsafe.Pointer
+        if len(edir) > 0 {
+                _p0 = unsafe.Pointer(&edir[0])
+        } else {
+                _p0 = unsafe.Pointer(&_zero)
+        }
+        r0, _, e1 := Syscall(SYS_FSTAT, uintptr(fd), uintptr(_p0), uintptr(len(edir)))
+        n = int(r0)
+        if int32(r0) == -1 {
+                err = e1
+        }
+        return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Fwstat(fd int, edir []byte) (err error) {
+        var _p0 unsafe.Pointer
+        if len(edir) > 0 {
+                _p0 = unsafe.Pointer(&edir[0])
+        } else {
+                _p0 = unsafe.Pointer(&_zero)
+        }
+        r0, _, e1 := Syscall(SYS_FWSTAT, uintptr(fd), uintptr(_p0), uintptr(len(edir)))
+        if int32(r0) == -1 {
+                err = e1
+        }
+        return
+}
diff --git a/vendor/golang.org/x/sys/plan9/zsyscall_plan9_arm.go b/vendor/golang.org/x/sys/plan9/zsyscall_plan9_arm.go
new file mode 100644
index 0000000..ea85780
--- /dev/null
+++ b/vendor/golang.org/x/sys/plan9/zsyscall_plan9_arm.go
@@ -0,0 +1,284 @@
+// go run mksyscall.go -l32 -plan9 -tags plan9,arm syscall_plan9.go
+// Code generated by the command above; see README.md. DO NOT EDIT.
+
+//go:build plan9 && arm
+
+package plan9
+
+import "unsafe"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func fd2path(fd int, buf []byte) (err error) {
+        var _p0 unsafe.Pointer
+        if len(buf) > 0 {
+                _p0 = unsafe.Pointer(&buf[0])
+        } else {
+                _p0 = unsafe.Pointer(&_zero)
+        }
+        r0, _, e1 := Syscall(SYS_FD2PATH, uintptr(fd), uintptr(_p0), uintptr(len(buf)))
+        if int32(r0) == -1 {
+                err = e1
+        }
+        return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func pipe(p *[2]int32) (err error) {
+        r0, _, e1 := Syscall(SYS_PIPE, uintptr(unsafe.Pointer(p)), 0, 0)
+        if int32(r0) == -1 {
+                err = e1
+        }
+        return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func await(s []byte) (n int, err error) {
+        var _p0 unsafe.Pointer
+        if len(s) > 0 {
+                _p0 = unsafe.Pointer(&s[0])
+        } else {
+                _p0 = unsafe.Pointer(&_zero)
+        }
+        r0, _, e1 := Syscall(SYS_AWAIT, uintptr(_p0), uintptr(len(s)), 0)
+        n = int(r0)
+        if int32(r0) == -1 {
+                err = e1
+        }
+        return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func open(path string, mode int) (fd int, err error) {
+        var _p0 *byte
+        _p0, err = BytePtrFromString(path)
+        if err != nil {
+                return
+        }
+        r0, _, e1 := Syscall(SYS_OPEN, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+        fd = int(r0)
+        if int32(r0) == -1 {
+                err = e1
+        }
+        return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func create(path string, mode int, perm uint32) (fd int, err error) {
+        var _p0 *byte
+        _p0, err = BytePtrFromString(path)
+        if err != nil {
+                return
+        }
+        r0, _, e1 := Syscall(SYS_CREATE, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
+        fd = int(r0)
+        if int32(r0) == -1 {
+                err = e1
+        }
+        return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func remove(path string) (err error) {
+        var _p0 *byte
+        _p0, err = BytePtrFromString(path)
+        if err != nil {
+                return
+        }
+        r0, _, e1 := Syscall(SYS_REMOVE, uintptr(unsafe.Pointer(_p0)), 0, 0)
+        if int32(r0) == -1 {
+                err = e1
+        }
+        return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func stat(path string, edir []byte) (n int, err error) {
+        var _p0 *byte
+        _p0, err = BytePtrFromString(path)
+        if err != nil {
+                return
+        }
+        var _p1 unsafe.Pointer
+        if len(edir) > 0 {
+                _p1 = unsafe.Pointer(&edir[0])
+        } else {
+                _p1 = unsafe.Pointer(&_zero)
+        }
+        r0, _, e1 := Syscall(SYS_STAT, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(edir)))
+        n = int(r0)
+        if int32(r0) == -1 {
+                err = e1
+        }
+        return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func bind(name string, old string, flag int) (err error) {
+        var _p0 *byte
+        _p0, err = BytePtrFromString(name)
+        if err != nil {
+                return
+        }
+        var _p1 *byte
+        _p1, err = BytePtrFromString(old)
+        if err != nil {
+                return
+        }
+        r0, _, e1 := Syscall(SYS_BIND, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(flag))
+        if int32(r0) == -1 {
+                err = e1
+        }
+        return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func mount(fd int, afd int, old string, flag int, aname string) (err error) {
+        var _p0 *byte
+        _p0, err = BytePtrFromString(old)
+        if err != nil {
+                return
+        }
+        var _p1 *byte
+        _p1, err = BytePtrFromString(aname)
+        if err != nil {
+                return
+        }
+        r0, _, e1 := Syscall6(SYS_MOUNT, uintptr(fd), uintptr(afd), uintptr(unsafe.Pointer(_p0)), uintptr(flag), uintptr(unsafe.Pointer(_p1)), 0)
+        if int32(r0) == -1 {
+                err = e1
+        }
+        return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func wstat(path string, edir []byte) (err error) {
+        var _p0 *byte
+        _p0, err = BytePtrFromString(path)
+        if err != nil {
+                return
+        }
+        var _p1 unsafe.Pointer
+        if len(edir) > 0 {
+                _p1 = unsafe.Pointer(&edir[0])
+        } else {
+                _p1 = unsafe.Pointer(&_zero)
+        }
+        r0, _, e1 := Syscall(SYS_WSTAT, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(edir)))
+        if int32(r0) == -1 {
+                err = e1
+        }
+        return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func chdir(path string) (err error) {
+        var _p0 *byte
+        _p0, err = BytePtrFromString(path)
+        if err != nil {
+                return
+        }
+        r0, _, e1 := Syscall(SYS_CHDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
+        if int32(r0) == -1 {
+                err = e1
+        }
+        return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Dup(oldfd int, newfd int) (fd int, err error) {
+        r0, _, e1 := Syscall(SYS_DUP, uintptr(oldfd), uintptr(newfd), 0)
+        fd = int(r0)
+        if int32(r0) == -1 {
+                err = e1
+        }
+        return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Pread(fd int, p []byte, offset int64) (n int, err error) {
+        var _p0 unsafe.Pointer
+        if len(p) > 0 {
+                _p0 = unsafe.Pointer(&p[0])
+        } else {
+                _p0 = unsafe.Pointer(&_zero)
+        }
+        r0, _, e1 := Syscall6(SYS_PREAD, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), uintptr(offset>>32), 0)
+        n = int(r0)
+        if int32(r0) == -1 {
+                err = e1
+        }
+        return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
+        var _p0 unsafe.Pointer
+        if len(p) > 0 {
+                _p0 = unsafe.Pointer(&p[0])
+        } else {
+                _p0 = unsafe.Pointer(&_zero)
+        }
+        r0, _, e1 := Syscall6(SYS_PWRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), uintptr(offset>>32), 0)
+        n = int(r0)
+        if int32(r0) == -1 {
+                err = e1
+        }
+        return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Close(fd int) (err error) {
+        r0, _, e1 := Syscall(SYS_CLOSE, uintptr(fd), 0, 0)
+        if int32(r0) == -1 {
+                err = e1
+        }
+        return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Fstat(fd int, edir []byte) (n int, err error) {
+        var _p0 unsafe.Pointer
+        if len(edir) > 0 {
+                _p0 = unsafe.Pointer(&edir[0])
+        } else {
+                _p0 = unsafe.Pointer(&_zero)
+        }
+        r0, _, e1 := Syscall(SYS_FSTAT, uintptr(fd), uintptr(_p0), uintptr(len(edir)))
+        n = int(r0)
+        if int32(r0) == -1 {
+                err = e1
+        }
+        return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Fwstat(fd int, edir []byte) (err error) {
+        var _p0 unsafe.Pointer
+        if len(edir) > 0 {
+                _p0 = unsafe.Pointer(&edir[0])
+        } else {
+                _p0 = unsafe.Pointer(&_zero)
+        }
+        r0, _, e1 := Syscall(SYS_FWSTAT, uintptr(fd), uintptr(_p0), uintptr(len(edir)))
+        if int32(r0) == -1 {
+                err = e1
+        }
+        return
+}
diff --git a/vendor/golang.org/x/sys/plan9/zsysnum_plan9.go b/vendor/golang.org/x/sys/plan9/zsysnum_plan9.go
new file mode 100644
index 0000000..22e8abd
--- /dev/null
+++ b/vendor/golang.org/x/sys/plan9/zsysnum_plan9.go
@@ -0,0 +1,49 @@
+// mksysnum_plan9.sh /opt/plan9/sys/src/libc/9syscall/sys.h
+// MACHINE GENERATED BY THE ABOVE COMMAND; DO NOT EDIT
+
+package plan9
+
+const (
+        SYS_SYSR1       = 0
+        SYS_BIND        = 2
+        SYS_CHDIR       = 3
+        SYS_CLOSE       = 4
+        SYS_DUP         = 5
+        SYS_ALARM       = 6
+        SYS_EXEC        = 7
+        SYS_EXITS       = 8
+        SYS_FAUTH       = 10
+        SYS_SEGBRK      = 12
+        SYS_OPEN        = 14
+        SYS_OSEEK       = 16
+        SYS_SLEEP       = 17
+        SYS_RFORK       = 19
+        SYS_PIPE        = 21
+        SYS_CREATE      = 22
+        SYS_FD2PATH     = 23
+        SYS_BRK_        = 24
+        SYS_REMOVE      = 25
+        SYS_NOTIFY      = 28
+        SYS_NOTED       = 29
+        SYS_SEGATTACH   = 30
+        SYS_SEGDETACH   = 31
+        SYS_SEGFREE     = 32
+        SYS_SEGFLUSH    = 33
+        SYS_RENDEZVOUS  = 34
+        SYS_UNMOUNT     = 35
+        SYS_SEMACQUIRE  = 37
+        SYS_SEMRELEASE  = 38
+        SYS_SEEK        = 39
+        SYS_FVERSION    = 40
+        SYS_ERRSTR      = 41
+        SYS_STAT        = 42
+        SYS_FSTAT       = 43
+        SYS_WSTAT       = 44
+        SYS_FWSTAT      = 45
+        SYS_MOUNT       = 46
+        SYS_AWAIT       = 47
+        SYS_PREAD       = 50
+        SYS_PWRITE      = 51
+        SYS_TSEMACQUIRE = 52
+        SYS_NSEC        = 53
+)