Merge tag 'go1.11rc2'
Change-Id: I5e4800603950d6ae91dcde331c0f8161d254ecdc
diff --git a/BUILD.gn b/BUILD.gn
new file mode 100644
index 0000000..31d334d
--- /dev/null
+++ b/BUILD.gn
@@ -0,0 +1,122 @@
+# Copyright 2016 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+import("//build/config/sysroot.gni")
+import("//build/go/go_test.gni")
+import("//build/host.gni")
+import("//build/package.gni")
+
+if (current_toolchain == target_toolchain) {
+ action("go_toolchain") {
+ go_root = "$host_tools_dir/goroot"
+
+ # These files are copied over to //out by makefuchsia.go.
+ copied_files = [
+ "misc/fuchsia/clangwrap.sh",
+ "misc/fuchsia/gccwrap.sh",
+ "misc/fuchsia/go_stdlib_tests.json",
+ ]
+
+ inputs = copied_files
+ inputs += [ "makefuchsia.go" ]
+
+ outputs = [
+ "$root_gen_dir/goroot.done",
+ ]
+ foreach(file, copied_files) {
+ outputs += [ "$go_root/$file" ]
+ }
+
+ depfile = "$root_gen_dir/goroot.d"
+
+ visibility = [ ":*" ]
+
+ script = rebase_path("//buildtools/go")
+ args = [
+ "run",
+ rebase_path("makefuchsia.go", root_build_dir),
+ "-buildtools-go",
+ rebase_path("//buildtools/go"),
+ "-fuchsia-goroot",
+ rebase_path("."),
+ "-depfile",
+ rebase_path(depfile),
+ "-root-gen-dir",
+ rebase_path("$root_gen_dir"),
+ "-root-out-dir",
+ rebase_path("$root_out_dir"),
+ "--out-goroot",
+ rebase_path(go_root),
+ "-target-cpu",
+ target_cpu,
+ ]
+ }
+
+ # A symlink from the old location to the new, while we're transitioning
+ # to the new.
+ action("old_go_toolchain_symlink") {
+ old_go_root = "$root_out_dir/goroot"
+ go_root = "$host_tools_dir/goroot"
+ script = "make-goroot-symlink.sh"
+ args = [
+ rebase_path(go_root),
+ rebase_path(old_go_root),
+ ]
+ outputs = [
+ old_go_root
+ ]
+ deps = [
+ ":go_toolchain"
+ ]
+ }
+}
+
+group("go_runtime") {
+ public_deps = [
+ ":go_toolchain(${target_toolchain})",
+ ":old_go_toolchain_symlink(${target_toolchain})",
+ ]
+}
+
+go_test("go_dispatch_test") {
+ gopackage = "syscall/zx/dispatch"
+}
+
+go_test("go_zxwait_test") {
+ gopackage = "syscall/zx/zxwait"
+}
+
+go_test("go_os_test") {
+ gopackage = "os"
+}
+
+go_test("go_net_test") {
+ gopackage = "net"
+}
+
+package("go_stdlib_tests") {
+ testonly = true
+
+ deps = [
+ ":go_dispatch_test",
+ ":go_os_test",
+ ":go_net_test",
+ ":go_zxwait_test",
+ ]
+
+ tests = [
+ {
+ name = "go_dispatch_test"
+ },
+ {
+ name = "go_net_test"
+ },
+ {
+ name = "go_os_test"
+ },
+ {
+ name = "go_zxwait_test"
+ },
+ ]
+}
diff --git a/make-goroot-symlink.sh b/make-goroot-symlink.sh
new file mode 100755
index 0000000..ecc5d76
--- /dev/null
+++ b/make-goroot-symlink.sh
@@ -0,0 +1,37 @@
+#!/bin/bash
+# Copyright 2018 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+#
+# Make a symlink, handling the case where the source is a directory
+# by removing the source first.
+# "ln -sf" doesn't work in this case: the symbolic link is placed in the
+# directory named LINK-NAME.
+# For paranoia purposes, this script only works if the basename of
+# TARGET and LINK-NAME are "goroot". This is to avoid accidents resulting
+# in rm -rf removing way more than intended.
+
+set -e
+
+if [[ $# != 2 ]]
+then
+ echo >&2 "Usage: $(basename $0) TARGET LINK-NAME"
+ exit 1
+fi
+
+declare -r TARGET=$1
+declare -r LINK_NAME=$2
+
+if [[ $(basename "$TARGET") != "goroot" ]]
+then
+ echo >&2 "TARGET basename is not goroot"
+ exit 1
+fi
+if [[ $(basename "$LINK_NAME") != "goroot" ]]
+then
+ echo >&2 "LINK-NAME basename is not goroot"
+ exit 1
+fi
+
+/bin/rm -rf "$LINK_NAME"
+/bin/ln -s "$TARGET" "$LINK_NAME"
diff --git a/makefuchsia.go b/makefuchsia.go
new file mode 100644
index 0000000..d2c995b
--- /dev/null
+++ b/makefuchsia.go
@@ -0,0 +1,187 @@
+// Copyright 2017 The Fuchsia 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 makefuchsia.go script builds a GOROOT in the out/ build directory
+// using sources from third_party/go.
+package main
+
+import (
+ "bytes"
+ "flag"
+ "fmt"
+ "io"
+ "io/ioutil"
+ "log"
+ "os"
+ "os/exec"
+ "path/filepath"
+ "strings"
+)
+
+var (
+ flagBuildtoolsGo = flag.String("buildtools-go", "", "Path to go tool used for bootstrap")
+ flagFuchsiaGoroot = flag.String("fuchsia-goroot", "", "Path to Fuchsia's source GOROOT")
+ flagDepfile = flag.String("depfile", "", "Stdlib depfile")
+ flagRootOutDir = flag.String("root-out-dir", "", "GN variable")
+ flagRootGenDir = flag.String("root-gen-dir", "", "GN variable")
+ flagTargetCPU = flag.String("target-cpu", "", "GN variable")
+ flagOutGoroot = flag.String("out-goroot", "", "Path to the output GOROOT")
+)
+
+func relGenDir() string {
+ return (*flagRootGenDir)[len(*flagRootOutDir)+1:]
+}
+
+func mkdir(path ...string) {
+ if err := os.MkdirAll(join(path...), 0755); err != nil {
+ log.Fatal(err)
+ }
+}
+
+func join(path ...string) string { return filepath.Join(path...) }
+
+// copyfile copies src to dst if the two files have different contents.
+func copyfile(src, dst string) {
+ srcfile, err := os.Open(src)
+ if err != nil {
+ log.Fatal(err)
+ }
+ defer srcfile.Close()
+
+ fi, err := srcfile.Stat()
+ if err != nil {
+ log.Fatal(err)
+ }
+
+ mkdir(filepath.Dir(dst))
+ f, err := os.OpenFile(dst, os.O_CREATE|os.O_RDWR|os.O_TRUNC, fi.Mode())
+ if err != nil {
+ log.Fatal(err)
+ }
+ if _, err := io.Copy(f, srcfile); err != nil {
+ log.Fatalf("cp %s %s: %v", src, dst, err)
+ }
+ if err := f.Close(); err != nil {
+ log.Fatalf("cp %s %s: close: %v", src, dst, err)
+ }
+}
+
+func convCPU(cpu string) (arch string) {
+ switch cpu {
+ case "x64":
+ return "amd64"
+ case "arm64":
+ return "arm64"
+ }
+ return ""
+}
+
+// allFilesIn recursively walks a set of files, returning the entire tree in
+// paths relative to the given root. A map is returned for convenience. If
+// prefix is given, only files that match the prefix are considered.
+func allFilesIn(root string, paths map[string]struct{}, prefix ...string) error {
+ return filepath.Walk(root, func(path string, info os.FileInfo, err error) error {
+ if err != nil || info.IsDir() {
+ return err
+ }
+ for _, pfx := range prefix {
+ if strings.HasPrefix(path, join(root, pfx)) {
+ relPath := strings.TrimPrefix(path, root)[1:]
+ paths[relPath] = struct{}{}
+ return err
+ }
+ }
+ return err
+ })
+}
+
+func main() {
+ log.SetFlags(0)
+ log.SetPrefix("makefuchsia.go: ")
+ flag.Parse()
+
+ if *flagRootGenDir == "" {
+ log.Fatal("must specify -root-gen-dir")
+ }
+
+ if *flagFuchsiaGoroot == "" {
+ log.Fatal("must specify -fuchsia-goroot when building toolchain")
+ }
+
+ goarchTarget := convCPU(*flagTargetCPU)
+ if goarchTarget == "" {
+ log.Fatalf("unsupported target CPU: %s", *flagTargetCPU)
+ }
+
+ srcGoroot := *flagFuchsiaGoroot
+ dstGoroot := *flagOutGoroot
+
+ srcFiles := map[string]struct{}{}
+ if err := allFilesIn(join(srcGoroot), srcFiles, "src/", "misc/fuchsia/"); err != nil {
+ log.Fatal(err)
+ }
+
+ dstFiles := map[string]struct{}{}
+ if _, err := os.Stat(join(dstGoroot)); err == nil {
+ if err := allFilesIn(join(dstGoroot), dstFiles, ""); err != nil {
+ log.Fatal(err)
+ }
+ }
+
+ for f := range dstFiles {
+ if _, ok := srcFiles[f]; !ok {
+ // try to preserve the bin/ and pkg/ trees, as they can be used to do faster
+ // rebuilds of the toolchain.
+ if strings.HasPrefix(f, "src/") || strings.HasPrefix(f, "misc/fuchsia/") {
+ os.Remove(filepath.Join(dstGoroot, f))
+ }
+ }
+ }
+
+ for f := range srcFiles {
+ src, dst := join(srcGoroot, f), join(dstGoroot, f)
+ copyfile(src, dst)
+ }
+
+ versionFile := join(dstGoroot, "VERSION")
+ if err := ioutil.WriteFile(versionFile, []byte("devel third_party/go fuchsia"), 0664); err != nil {
+ log.Fatal(err)
+ }
+
+ cmd := exec.Command(*flagBuildtoolsGo, "env", "GOROOT")
+ out, err := cmd.CombinedOutput()
+ if err != nil {
+ log.Fatalf("cannot find bootstrap GOROOT: %v", err)
+ }
+
+ env := os.Environ()
+ env = append(env, "GOROOT_BOOTSTRAP="+strings.TrimSpace(string(out)))
+ env = append(env, "CC_FOR_fuchsia_"+goarchTarget+"="+dstGoroot+"/misc/fuchsia/gccwrap.sh")
+
+ cmd = exec.Command(join(dstGoroot, "src", "make.bash"))
+ cmd.Args = []string{"--no-clean"}
+ cmd.Dir = join(dstGoroot, "src")
+ cmd.Env = env
+ buf := new(bytes.Buffer)
+ cmd.Stdout = buf
+ cmd.Stderr = buf
+ if err := cmd.Run(); err != nil {
+ log.Fatalf("make.bash failed: %v\n%s", err, buf.String())
+ }
+
+ depfile, err := os.Create(*flagDepfile)
+ if err != nil {
+ log.Fatal(err)
+ }
+ fmt.Fprintf(depfile, "%s/goroot.done:", relGenDir())
+ for f := range srcFiles {
+ fmt.Fprintf(depfile, " %s", join(srcGoroot, f))
+ }
+ fmt.Fprintf(depfile, " %s", join(srcGoroot, "makefuchsia.go"))
+
+ donePath := join(*flagRootGenDir, "goroot.done")
+ if err := ioutil.WriteFile(donePath, []byte("done"), 0664); err != nil {
+ log.Fatalf("writing goroot.done failed: %v", err)
+ }
+}
diff --git a/misc/fuchsia/README.md b/misc/fuchsia/README.md
new file mode 100644
index 0000000..e26e84b
--- /dev/null
+++ b/misc/fuchsia/README.md
@@ -0,0 +1,47 @@
+Go on Fuchsia
+=========
+
+To build a toolchain on Linux for Fuchsia, first follow the
+instructions on
+
+ https://fuchsia.googlesource.com/manifest/
+
+Then,
+* Set the SDK environment variable to the location of the Fuchsia SDK:
+ If you downloaded fuchsia to your ${HOME} directory:
+ ```
+ export SDK=${HOME}/fuchsia/buildtools
+ ```
+
+* Identify where a host version of go exists, with:
+ ```
+ export GOROOT_BOOTSTRAP=`path to directory containing go`
+ ```
+ On my machine, `which go` returned /usr/lib/golang/bin/go, so I set
+ GOROOT_BOOTSTRAP=/usr/lib/golang/
+
+* Build Go in `fuchsia/third_party/go/src` using
+ ```
+ GOOS=fuchsia CC_FOR_TARGET=../misc/fuchsia/clangwrap.sh ./make.bash
+ ```
+
+* To build a program, junk.go in go/src, use:
+ ```
+ GOOS=fuchsia ../bin/go build junk.go
+ ```
+ This program can be put in a bootfs and run on qemu with:
+ ```
+ echo bin/junk=junk > junk.manifest
+ fuchsia/buildtools/mkbootfs -o junk.bootfs junk.manifest
+ ./scripts/run-zircon-x64 -x path/to/fuchsia/third_party/go/src/junk.bootfs
+ ```
+ A cgo variant can be build by adding CGO_ENABLED=1 to both
+ the make.bash command and the go build command.
+
+* To build a program using just the zircon prebuild toolchain
+ (useful for debugging if the fuchsia sysroot is out of sync
+ with your zircon) set the environment variable ZIRCON to
+ the location of your zircon and build with the gccwrap.sh
+ script:
+ ```
+ ZIRCON=$HOME/zircon CGO_ENABLED=1 CC_FOR_TARGET=$(pwd)/../misc/fuchsia/gccwrap.sh GOOS=fuchsia ./make.bash
diff --git a/misc/fuchsia/clangwrap.sh b/misc/fuchsia/clangwrap.sh
new file mode 100755
index 0000000..40514e2
--- /dev/null
+++ b/misc/fuchsia/clangwrap.sh
@@ -0,0 +1,40 @@
+#!/bin/bash
+# This uses the Fuchsia clang and Zircon sysroot.
+set -eu
+
+if [ "$GOHOSTARCH" == "amd64" ]; then
+ HOST_ARCH="x64"
+elif [ "$GOHOSTARCH" == "arm64" ]; then
+ HOST_ARCH="arm64"
+else
+ echo "clangwrap.sh: missing/invalid GOHOSTARCH env variable" >&2
+ exit 1
+fi
+
+if [ "$GOHOSTOS" == "linux" ]; then
+ HOST_OS="linux"
+elif [ "$GOHOSTOS" == "darwin" ]; then
+ HOST_OS="mac"
+else
+ echo "clangwrap.sh: missing/invalid GOHOSTOS env variable" >&2
+ exit 1
+fi
+
+if [ "$GOARCH" == "amd64" ]; then
+ TARGET_ARCH="x86_64"
+elif [ "$GOHOSTARCH" == "arm64" ]; then
+ TARGET_ARCH="aarch64"
+else
+ echo "clangwrap.sh: missing/invalid GOARCH env variable" >&2
+ exit 1
+fi
+
+if [ "$FUCHSIA" == "" ]; then
+ echo "clangwrap.sh: missing FUCHSIA env variable" >&2
+ exit 1
+fi
+
+exec ${FUCHSIA}/buildtools/${HOST_OS}-${HOST_ARCH}/clang/bin/clang \
+ --target=${TARGET_ARCH}-fuchsia \
+ --sysroot=${FUCHSIA}/out/sysroot/${TARGET_ARCH}-fuchsia \
+ "$@"
diff --git a/misc/fuchsia/gccwrap.sh b/misc/fuchsia/gccwrap.sh
new file mode 100755
index 0000000..93c86cd
--- /dev/null
+++ b/misc/fuchsia/gccwrap.sh
@@ -0,0 +1,66 @@
+#!/bin/bash
+# This uses the zircon prebuild C++ toolchain
+
+if [ -z "${ZIRCON}" ]; then
+ echo "gccwrap.sh: missing ZIRCON env variable" >&2
+ exit 1
+fi
+
+zirconsysroot="${ZIRCON_SYSROOT}"
+if [ -z "${zirconsysroot}" ]; then
+ echo "gccwrap.sh: missing ZIRCON_SYSROOT env variable" >&2
+ exit 1
+fi
+
+if [ -z "${FUCHSIA_ROOT_OUT_DIR}" ]; then
+ echo "gccwrap.sh: missing FUCHSIA_ROOT_OUT_DIR env variable" >&2
+ exit 1
+fi
+
+if [ "$GOARCH" == "amd64" ]; then
+ libdir="x64-shared"
+ gccbin="$ZIRCON/prebuilt/downloads/gcc/bin/x86_64-elf-gcc"
+elif [ "$GOARCH" == "arm64" ]; then
+ libdir="arm64-shared"
+ gccbin="$ZIRCON/prebuilt/downloads/gcc/bin/aarch64-elf-gcc"
+else
+ echo "gccwrap.sh: unsupported GOARCH: $GOARCH" >&2
+ exit 1
+fi
+
+compiler=false
+extra_args=""
+
+for var in "$@"
+do
+ if [[ "$var" == "-r" || "$var" == "-c" ]]; then
+ compiler=true
+ fi
+done
+
+if ! $compiler; then
+ extra_args="-lc $zirconsysroot/lib/Scrt1.o $zirconsysroot/lib/libzircon.so -lfdio"
+fi
+
+exec $gccbin \
+ --sysroot=$zirconsysroot \
+ -I$zirconsysroot/include \
+ -I${ZIRCON}/system/ulib/fdio/include \
+ -L$zirconsysroot/lib \
+ -L${FUCHSIA_ROOT_OUT_DIR}/${libdir} \
+ -nostdlib \
+ -fuse-ld=gold \
+ -fno-use-linker-plugin \
+ -Wl,-nostdlib \
+ -Wl,--build-id \
+ -Wl,-z,max-page-size=4096 \
+ -Wl,-z,combreloc \
+ -Wl,-z,relro \
+ -Wl,-z,now \
+ -Wl,-z,text \
+ -Wl,-z,noexecstack \
+ -Wl,--hash-style=gnu \
+ -Wl,--eh-frame-hdr \
+ -Wl,-dynamic-linker=ld.so.1 \
+ $extra_args \
+ "$@"
diff --git a/misc/fuchsia/go_stdlib_tests.json b/misc/fuchsia/go_stdlib_tests.json
new file mode 100644
index 0000000..e52c708
--- /dev/null
+++ b/misc/fuchsia/go_stdlib_tests.json
@@ -0,0 +1,8 @@
+{
+ "tests":[
+ {
+ "name":"go_os_test",
+ "exec":"/system/bin/report_result /system/test/go_os_test"
+ }
+ ]
+}
diff --git a/src/cmd/dist/build.go b/src/cmd/dist/build.go
index eed9866..a4eeb3d 100644
--- a/src/cmd/dist/build.go
+++ b/src/cmd/dist/build.go
@@ -81,6 +81,7 @@
"android",
"solaris",
"freebsd",
+ "fuchsia",
"nacl",
"netbsd",
"openbsd",
@@ -1034,6 +1035,8 @@
xremoveall(pathf("%s/pkg/%s_%s", goroot, goos, goarch))
xremoveall(pathf("%s/pkg/%s_%s_race", goroot, gohostos, gohostarch))
xremoveall(pathf("%s/pkg/%s_%s_race", goroot, goos, goarch))
+ xremoveall(pathf("%s/pkg/%s_%s_shared", goroot, gohostos, gohostarch))
+ xremoveall(pathf("%s/pkg/%s_%s_shared", goroot, goos, goarch))
xremoveall(tooldir)
// Remove cached version info.
@@ -1390,6 +1393,8 @@
"freebsd/386": true,
"freebsd/amd64": true,
"freebsd/arm": false,
+ "fuchsia/amd64": true,
+ "fuchsia/arm64": true,
"linux/386": true,
"linux/amd64": true,
"linux/arm": true,
diff --git a/src/cmd/go/internal/base/signal_notunix.go b/src/cmd/go/internal/base/signal_notunix.go
index 9e869b0..a8e5a34 100644
--- a/src/cmd/go/internal/base/signal_notunix.go
+++ b/src/cmd/go/internal/base/signal_notunix.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// +build plan9 windows
+// +build plan9 fuchsia windows
package base
diff --git a/src/cmd/go/internal/load/pkg.go b/src/cmd/go/internal/load/pkg.go
index ec2fa73..1f6e72c 100644
--- a/src/cmd/go/internal/load/pkg.go
+++ b/src/cmd/go/internal/load/pkg.go
@@ -1550,6 +1550,11 @@
// LinkerDeps returns the list of linker-induced dependencies for main package p.
func LinkerDeps(p *Package) []string {
+ // Don't add deps to Fuchsia internal syscall stuff.
+ if p.ImportPath == "syscall/zx" || p.ImportPath == "syscall/mx" {
+ return []string{}
+ }
+
// Everything links runtime.
deps := []string{"runtime"}
@@ -1578,7 +1583,7 @@
func externalLinkingForced(p *Package) bool {
// Some targets must use external linking even inside GOROOT.
switch cfg.BuildContext.GOOS {
- case "android":
+ case "android", "fuchsia":
return true
case "darwin":
switch cfg.BuildContext.GOARCH {
diff --git a/src/cmd/go/internal/work/exec.go b/src/cmd/go/internal/work/exec.go
index 42fa0e6..0ec6710 100644
--- a/src/cmd/go/internal/work/exec.go
+++ b/src/cmd/go/internal/work/exec.go
@@ -2157,6 +2157,7 @@
switch cfg.Goos {
case "windows":
a = append(a, "-mthreads")
+ case "fuchsia":
default:
a = append(a, "-pthread")
}
diff --git a/src/cmd/go/internal/work/gccgo.go b/src/cmd/go/internal/work/gccgo.go
index 91daf52..1e30cf2 100644
--- a/src/cmd/go/internal/work/gccgo.go
+++ b/src/cmd/go/internal/work/gccgo.go
@@ -395,7 +395,12 @@
// split-stack and non-split-stack code in a single -r
// link, and libgo picks up non-split-stack code from
// libffi.
- ldflags = append(ldflags, "-Wl,-r", "-nostdlib", "-Wl,--whole-archive", "-lgolibbegin", "-Wl,--no-whole-archive")
+ if cfg.Goos == "fuchsia" {
+ ldflags = append(ldflags, "-r")
+ } else {
+ ldflags = append(ldflags, "-Wl,-r")
+ }
+ ldflags = append(ldflags, "-nostdlib", "-Wl,--whole-archive", "-lgolibbegin", "-Wl,--no-whole-archive")
if nopie := b.gccNoPie([]string{tools.linker()}); nopie != "" {
ldflags = append(ldflags, nopie)
diff --git a/src/cmd/go/internal/work/init.go b/src/cmd/go/internal/work/init.go
index eb99815..bf2cefe 100644
--- a/src/cmd/go/internal/work/init.go
+++ b/src/cmd/go/internal/work/init.go
@@ -123,7 +123,8 @@
ldBuildmode = "c-shared"
case "default":
switch platform {
- case "android/arm", "android/arm64", "android/amd64", "android/386":
+ case "android/arm", "android/arm64", "android/amd64", "android/386",
+ "fuchsia/amd64", "fuchsia/arm64":
codegenArg = "-shared"
ldBuildmode = "pie"
case "darwin/arm", "darwin/arm64":
@@ -151,7 +152,8 @@
switch platform {
case "linux/386", "linux/amd64", "linux/arm", "linux/arm64", "linux/ppc64le", "linux/s390x",
"android/amd64", "android/arm", "android/arm64", "android/386",
- "freebsd/amd64":
+ "freebsd/amd64",
+ "fuchsia/amd64", "fuchsia/arm64":
codegenArg = "-shared"
case "darwin/amd64":
codegenArg = "-shared"
diff --git a/src/cmd/internal/obj/x86/asm6.go b/src/cmd/internal/obj/x86/asm6.go
index d3389e4..ad21e38 100644
--- a/src/cmd/internal/obj/x86/asm6.go
+++ b/src/cmd/internal/obj/x86/asm6.go
@@ -2350,6 +2350,9 @@
return 0x64 // FS
}
+ case objabi.Hfuchsia:
+ log.Fatalf("unknown TLS base register, fuchsia requires PIC code")
+
case objabi.Hdragonfly,
objabi.Hfreebsd,
objabi.Hnetbsd,
@@ -4977,7 +4980,7 @@
default:
log.Fatalf("unknown TLS base location for %v", ctxt.Headtype)
- case objabi.Hlinux, objabi.Hfreebsd:
+ case objabi.Hlinux, objabi.Hfreebsd, objabi.Hfuchsia:
if !ctxt.Flag_shared {
log.Fatalf("unknown TLS base location for linux/freebsd without -shared")
}
diff --git a/src/cmd/internal/obj/x86/obj6.go b/src/cmd/internal/obj/x86/obj6.go
index 139f293..7e42dcc 100644
--- a/src/cmd/internal/obj/x86/obj6.go
+++ b/src/cmd/internal/obj/x86/obj6.go
@@ -67,6 +67,8 @@
return false
case objabi.Hlinux, objabi.Hfreebsd:
return !ctxt.Flag_shared
+ case objabi.Hfuchsia:
+ return false
}
return true
diff --git a/src/cmd/internal/objabi/head.go b/src/cmd/internal/objabi/head.go
index 23c7b62..521876a 100644
--- a/src/cmd/internal/objabi/head.go
+++ b/src/cmd/internal/objabi/head.go
@@ -40,6 +40,7 @@
Hdarwin
Hdragonfly
Hfreebsd
+ Hfuchsia
Hjs
Hlinux
Hnacl
@@ -58,6 +59,8 @@
*h = Hdragonfly
case "freebsd":
*h = Hfreebsd
+ case "fuchsia":
+ *h = Hfuchsia
case "js":
*h = Hjs
case "linux", "android":
@@ -88,6 +91,8 @@
return "dragonfly"
case Hfreebsd:
return "freebsd"
+ case Hfuchsia:
+ return "fuchsia"
case Hjs:
return "js"
case Hlinux:
diff --git a/src/cmd/link/internal/amd64/asm.go b/src/cmd/link/internal/amd64/asm.go
index af27444..7817240 100644
--- a/src/cmd/link/internal/amd64/asm.go
+++ b/src/cmd/link/internal/amd64/asm.go
@@ -37,6 +37,7 @@
"cmd/link/internal/sym"
"debug/elf"
"log"
+ "strings"
)
func PADDR(x uint32) uint32 {
@@ -414,6 +415,8 @@
if r.Siz == 4 {
if r.Xsym.Type == sym.SDYNIMPORT && r.Xsym.ElfType == elf.STT_FUNC {
ctxt.Out.Write64(uint64(elf.R_X86_64_PLT32) | uint64(elfsym)<<32)
+ } else if r.Xsym.Type == sym.SDYNIMPORT && ctxt.HeadType == objabi.Hfuchsia && strings.HasPrefix(r.Xsym.Name, "vdso_") {
+ ctxt.Out.Write64(uint64(elf.R_X86_64_GOTPCREL) | uint64(elfsym)<<32)
} else {
ctxt.Out.Write64(uint64(elf.R_X86_64_PC32) | uint64(elfsym)<<32)
}
@@ -723,6 +726,7 @@
case objabi.Hlinux,
objabi.Hfreebsd,
+ objabi.Hfuchsia,
objabi.Hnetbsd,
objabi.Hopenbsd,
objabi.Hdragonfly,
@@ -753,6 +757,7 @@
case objabi.Hlinux,
objabi.Hfreebsd,
+ objabi.Hfuchsia,
objabi.Hnetbsd,
objabi.Hopenbsd,
objabi.Hdragonfly,
@@ -833,6 +838,7 @@
case objabi.Hlinux,
objabi.Hfreebsd,
+ objabi.Hfuchsia,
objabi.Hnetbsd,
objabi.Hopenbsd,
objabi.Hdragonfly,
diff --git a/src/cmd/link/internal/amd64/obj.go b/src/cmd/link/internal/amd64/obj.go
index 87e8091..96f5e66 100644
--- a/src/cmd/link/internal/amd64/obj.go
+++ b/src/cmd/link/internal/amd64/obj.go
@@ -105,6 +105,7 @@
case objabi.Hlinux, /* elf64 executable */
objabi.Hfreebsd, /* freebsd */
+ objabi.Hfuchsia, /* fuchsia */
objabi.Hnetbsd, /* netbsd */
objabi.Hopenbsd, /* openbsd */
objabi.Hdragonfly, /* dragonfly */
diff --git a/src/cmd/link/internal/arm64/asm.go b/src/cmd/link/internal/arm64/asm.go
index 5b3b9e5..d899d45 100644
--- a/src/cmd/link/internal/arm64/asm.go
+++ b/src/cmd/link/internal/arm64/asm.go
@@ -363,7 +363,7 @@
return true
case objabi.R_ARM64_TLS_LE:
r.Done = false
- if ctxt.HeadType != objabi.Hlinux {
+ if ctxt.HeadType != objabi.Hlinux && ctxt.HeadType != objabi.Hfuchsia {
ld.Errorf(s, "TLS reloc on unsupported OS %v", ctxt.HeadType)
}
// The TCB is two pointers. This is not documented anywhere, but is
@@ -514,6 +514,7 @@
case objabi.Hlinux,
objabi.Hfreebsd,
+ objabi.Hfuchsia,
objabi.Hnetbsd,
objabi.Hopenbsd,
objabi.Hnacl:
diff --git a/src/cmd/link/internal/arm64/obj.go b/src/cmd/link/internal/arm64/obj.go
index 405d22d..3a14d43 100644
--- a/src/cmd/link/internal/arm64/obj.go
+++ b/src/cmd/link/internal/arm64/obj.go
@@ -87,7 +87,7 @@
*ld.FlagRound = 4096
}
- case objabi.Hlinux: /* arm64 elf */
+ case objabi.Hlinux, objabi.Hfuchsia: /* arm64 elf */
ld.Elfinit(ctxt)
ld.HEADR = ld.ELFRESERVE
if *ld.FlagTextAddr == -1 {
diff --git a/src/cmd/link/internal/ld/config.go b/src/cmd/link/internal/ld/config.go
index 18fbea6..f9d438c 100644
--- a/src/cmd/link/internal/ld/config.go
+++ b/src/cmd/link/internal/ld/config.go
@@ -35,10 +35,13 @@
default:
return fmt.Errorf("invalid buildmode: %q", s)
case "exe":
+ if objabi.GOOS == "fuchsia" {
+ return badmode()
+ }
*mode = BuildModeExe
case "pie":
switch objabi.GOOS {
- case "android", "linux":
+ case "android", "linux", "fuchsia":
case "darwin", "freebsd":
switch objabi.GOARCH {
case "amd64":
diff --git a/src/cmd/link/internal/ld/data.go b/src/cmd/link/internal/ld/data.go
index 0ae93f1..a2b4443 100644
--- a/src/cmd/link/internal/ld/data.go
+++ b/src/cmd/link/internal/ld/data.go
@@ -162,8 +162,8 @@
}
// We need to be able to reference dynimport symbols when linking against
- // shared libraries, and Solaris and Darwin need it always
- if ctxt.HeadType != objabi.Hsolaris && ctxt.HeadType != objabi.Hdarwin && r.Sym != nil && r.Sym.Type == sym.SDYNIMPORT && !ctxt.DynlinkingGo() && !r.Sym.Attr.SubSymbol() {
+ // shared libraries; Solaris, Fuchsia, and Darwin need it always
+ if ctxt.HeadType != objabi.Hsolaris && ctxt.HeadType != objabi.Hdarwin && ctxt.HeadType != objabi.Hfuchsia && r.Sym != nil && r.Sym.Type == sym.SDYNIMPORT && !ctxt.DynlinkingGo() && !r.Sym.Attr.SubSymbol() {
if !(ctxt.Arch.Family == sys.PPC64 && ctxt.LinkMode == LinkExternal && r.Sym.Name == ".TOC.") {
Errorf(s, "unhandled relocation for %s (type %d (%s) rtype %d (%s))", r.Sym.Name, r.Sym.Type, r.Sym.Type, r.Type, sym.RelocName(ctxt.Arch, r.Type))
}
diff --git a/src/cmd/link/internal/ld/elf.go b/src/cmd/link/internal/ld/elf.go
index 4ecbff8..49089c0 100644
--- a/src/cmd/link/internal/ld/elf.go
+++ b/src/cmd/link/internal/ld/elf.go
@@ -1848,6 +1848,9 @@
case objabi.Hfreebsd:
interpreter = thearch.Freebsddynld
+ case objabi.Hfuchsia:
+ interpreter = "lib/ld.so.1"
+
case objabi.Hnetbsd:
interpreter = thearch.Netbsddynld
@@ -2085,7 +2088,7 @@
}
}
- if ctxt.HeadType == objabi.Hlinux {
+ if ctxt.HeadType == objabi.Hlinux || ctxt.HeadType == objabi.Hfuchsia {
ph := newElfPhdr()
ph.type_ = PT_GNU_STACK
ph.flags = PF_W + PF_R
diff --git a/src/cmd/link/internal/ld/lib.go b/src/cmd/link/internal/ld/lib.go
index 220aab3..d89bbea 100644
--- a/src/cmd/link/internal/ld/lib.go
+++ b/src/cmd/link/internal/ld/lib.go
@@ -1213,7 +1213,10 @@
}
// Force global symbols to be exported for dlopen, etc.
- if ctxt.IsELF {
+ if ctxt.HeadType == objabi.Hfuchsia && !strings.Contains(argv[0], "clang") {
+ // Find libgcc
+ argv = append(argv, ctxt.findLibPathCmd("--print-libgcc-file-name", "libgcc"))
+ } else if ctxt.IsELF {
argv = append(argv, "-rdynamic")
}
@@ -1314,6 +1317,9 @@
argv = append(argv, "-Wl,--start-group", "-lmingwex", "-lmingw32", "-Wl,--end-group")
argv = append(argv, peimporteddlls()...)
}
+ if ctxt.HeadType == objabi.Hfuchsia && strings.Contains(argv[0], "clang") {
+ argv = append(argv, "-lzircon", "-lfdio")
+ }
if ctxt.Debugvlog != 0 {
ctxt.Logf("%5.2f host link:", Cputime())
diff --git a/src/cmd/link/internal/ld/sym.go b/src/cmd/link/internal/ld/sym.go
index 3aa90c1..d8ea7ed 100644
--- a/src/cmd/link/internal/ld/sym.go
+++ b/src/cmd/link/internal/ld/sym.go
@@ -96,6 +96,9 @@
ctxt.Tlsoffset = -1 * ctxt.Arch.PtrSize
}
+ case objabi.Hfuchsia:
+ ctxt.Tlsoffset = -1 * ctxt.Arch.PtrSize
+
case objabi.Hnacl:
switch ctxt.Arch.Family {
default:
diff --git a/src/crypto/rand/rand_fuchsia.go b/src/crypto/rand/rand_fuchsia.go
new file mode 100644
index 0000000..40be276
--- /dev/null
+++ b/src/crypto/rand/rand_fuchsia.go
@@ -0,0 +1,25 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build fuchsia
+
+package rand
+
+import "syscall/zx"
+
+func init() {
+ Reader = new(cprngReader)
+}
+
+// cprngReader uses the PRNG exposed by zircon syscall.
+//
+// TODO(crawshaw): does it perform as well as /dev/urandom?
+// If not, borrow newReader from rand_unix.go and use this
+// as the entropy source.
+type cprngReader struct{}
+
+func (r *cprngReader) Read(b []byte) (n int, err error) {
+ zx.RandRead(b)
+ return len(b), nil
+}
diff --git a/src/crypto/x509/root_darwin_armx.go b/src/crypto/x509/root_darwin_armx.go
index fcbbd6b..87c9334 100644
--- a/src/crypto/x509/root_darwin_armx.go
+++ b/src/crypto/x509/root_darwin_armx.go
@@ -4,9 +4,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// +build cgo
-// +build darwin
-// +build arm arm64 ios
+// +build cgo,darwin,arm cgo,darwin,arm64 ios fuchsia
package x509
diff --git a/src/crypto/x509/root_fuchsia.go b/src/crypto/x509/root_fuchsia.go
new file mode 100644
index 0000000..bf37319
--- /dev/null
+++ b/src/crypto/x509/root_fuchsia.go
@@ -0,0 +1,9 @@
+// Copyright 2016 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 x509
+
+func (c *Certificate) systemVerify(opts *VerifyOptions) (chains [][]*Certificate, err error) {
+ return nil, nil
+}
diff --git a/src/go/build/syslist.go b/src/go/build/syslist.go
index d7938fa..2ccc386 100644
--- a/src/go/build/syslist.go
+++ b/src/go/build/syslist.go
@@ -4,5 +4,5 @@
package build
-const goosList = "android darwin dragonfly freebsd js linux nacl netbsd openbsd plan9 solaris windows zos "
+const goosList = "android darwin dragonfly freebsd fuchsia js linux nacl netbsd openbsd plan9 solaris windows zos "
const goarchList = "386 amd64 amd64p32 arm armbe arm64 arm64be ppc64 ppc64le mips mipsle mips64 mips64le mips64p32 mips64p32le ppc riscv riscv64 s390 s390x sparc sparc64 wasm "
diff --git a/src/internal/poll/fd_fuchsia.go b/src/internal/poll/fd_fuchsia.go
new file mode 100644
index 0000000..ccdd9e5
--- /dev/null
+++ b/src/internal/poll/fd_fuchsia.go
@@ -0,0 +1,305 @@
+// Copyright 2017 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 poll
+
+import (
+ "io"
+ "sync/atomic"
+ "syscall"
+ "syscall/zx/fdio"
+ "syscall/zx/zxsocket"
+)
+
+// FD is a file descriptor. The net and os packages embed this type in
+// a larger type representing a network connection or OS file.
+type FD struct {
+ // Lock sysfd and serialize access to Read and Write methods.
+ fdmu fdMutex
+
+ // System file descriptor. Immutable until Close.
+ Sysfd int
+ Handle fdio.FDIO
+
+ // I/O poller.
+ pd pollDesc
+
+ // Semaphore signaled when file is closed.
+ csema uint32
+
+ // Whether this is a streaming descriptor, as opposed to a
+ // packet-based descriptor like a UDP socket.
+ IsStream bool
+
+ // Whether a zero byte read indicates EOF. This is false for a
+ // message based socket connection.
+ ZeroReadIsEOF bool
+
+ // Whether this is a normal file.
+ isFile bool
+
+ // Whether in blocking mode
+ isBlocking uint32
+}
+
+// Init initializes the FD. The Sysfd field should already be set.
+// This can be called multiple times on a single FD.
+// The net argument is a network name from the net package (e.g., "tcp"),
+// or "file".
+// Set pollable to true if fd should be managed by runtime netpoll.
+func (fd *FD) Init(net string, pollable bool) error {
+ // We don't actually care about the various network types.
+ if net == "file" {
+ fd.isFile = true
+ }
+ if fd.Handle == nil {
+ fd.Handle = syscall.FDIOForFD(fd.Sysfd)
+ if fd.Handle == nil {
+ panic("No Handle available")
+ }
+ }
+ if !pollable {
+ fd.isBlocking = 1
+ return nil
+ }
+ return fd.pd.init(fd)
+}
+
+// Destroy closes the file descriptor. This is called when there are
+// no remaining references.
+func (fd *FD) destroy() error {
+ // Poller may want to unregister fd in readiness notification mechanism,
+ // so this must be executed before closing the fd.
+ fd.pd.close()
+ err := fd.Handle.Close()
+ fd.Sysfd = -1
+ fd.Handle = nil
+ runtime_Semrelease(&fd.csema)
+ return err
+}
+
+// Close closes the FD. The underlying file descriptor is closed by the
+// destroy method when there are no remaining references.
+func (fd *FD) Close() error {
+ if !fd.fdmu.increfAndClose() {
+ return errClosing(fd.isFile)
+ }
+ fd.pd.evict()
+ err := fd.decref()
+ // Wait until the descriptor is closed. If this was the only
+ // reference, it is already closed.
+ runtime_Semacquire(&fd.csema)
+ return err
+}
+
+// Shutdown wraps the shutdown network call.
+func (fd *FD) Shutdown(how int) error {
+ if err := fd.incref(); err != nil {
+ return err
+ }
+ defer fd.decref()
+ panic("TODO shutdown")
+ //return syscall.Shutdown(fd.Sysfd, how) // TODO
+}
+
+func (fd *FD) Read(p []byte) (int, error) {
+ if err := fd.readLock(); err != nil {
+ return 0, err
+ }
+ defer fd.readUnlock()
+ if len(p) == 0 {
+ // If the caller wanted a zero byte read, return immediately
+ // without trying (but after acquiring the readLock).
+ return 0, nil
+ }
+ if err := fd.pd.prepareRead(fd.isFile); err != nil {
+ return 0, err
+ }
+ // TODO: pollable() read
+ n, err := syscall.Read(fd.Sysfd, p)
+ err = fd.eofError(n, err)
+ return n, err
+}
+
+// Pread wraps the pread system call.
+func (fd *FD) Pread(p []byte, off int64) (int, error) {
+ // Call incref, not readLock, because since pread specifies the
+ // offset it is independent from other reads.
+ // Similarly, using the poller doesn't make sense for pread.
+ if err := fd.incref(); err != nil {
+ return 0, err
+ }
+ n, err := syscall.Pread(fd.Sysfd, p, off)
+ if err != nil {
+ n = 0
+ }
+ fd.decref()
+ err = fd.eofError(n, err)
+ return n, err
+}
+
+// Write implements io.Writer.
+func (fd *FD) Write(p []byte) (int, error) {
+ if err := fd.writeLock(); err != nil {
+ return 0, err
+ }
+ defer fd.writeUnlock()
+ if err := fd.pd.prepareWrite(fd.isFile); err != nil {
+ return 0, err
+ }
+ var nn int
+ for {
+ n, err := fd.Handle.Write(p[nn:])
+ if n > 0 {
+ nn += n
+ }
+ if nn == len(p) {
+ return nn, err
+ }
+ if n == 0 {
+ return nn, io.ErrUnexpectedEOF
+ }
+ }
+}
+
+// Pwrite wraps the pwrite system call.
+func (fd *FD) Pwrite(p []byte, off int64) (int, error) {
+ // Call incref, not writeLock, because since pwrite specifies the
+ // offset it is independent from other writes.
+ // Similarly, using the poller doesn't make sense for pwrite.
+ if err := fd.incref(); err != nil {
+ return 0, err
+ }
+ defer fd.decref()
+ var nn int
+ for {
+ n, err := syscall.Pwrite(fd.Sysfd, p[nn:], off+int64(nn))
+ if n > 0 {
+ nn += n
+ }
+ if nn == len(p) {
+ return nn, err
+ }
+ if err != nil {
+ return nn, err
+ }
+ if n == 0 {
+ return nn, io.ErrUnexpectedEOF
+ }
+ }
+}
+
+// Accept wraps the accept network call.
+func (fd *FD) Accept() (newm *zxsocket.Socket, err error) {
+ if err := fd.readLock(); err != nil {
+ return nil, err
+ }
+ defer fd.readUnlock()
+
+ if err := fd.pd.prepareRead(fd.isFile); err != nil {
+ return nil, err
+ }
+
+ return fd.Handle.(*zxsocket.Socket).Accept()
+}
+
+// Seek wraps syscall.Seek.
+func (fd *FD) Seek(offset int64, whence int) (int64, error) {
+ if err := fd.incref(); err != nil {
+ return 0, err
+ }
+ defer fd.decref()
+ return syscall.Seek(fd.Sysfd, offset, whence)
+}
+
+// ReadDirent wraps syscall.ReadDirent.
+// We treat this like an ordinary system call rather than a call
+// that tries to fill the buffer.
+func (fd *FD) ReadDirent(buf []byte) (int, error) {
+ if err := fd.incref(); err != nil {
+ return 0, err
+ }
+ defer fd.decref()
+ return syscall.ReadDirent(fd.Sysfd, buf)
+}
+
+// Fstat wraps syscall.Fstat
+func (fd *FD) Fstat(s *syscall.Stat_t) error {
+ if err := fd.incref(); err != nil {
+ return err
+ }
+ defer fd.decref()
+ return syscall.Fstat(fd.Sysfd, s)
+}
+
+// eofError returns io.EOF when fd is available for reading end of
+// file.
+func (fd *FD) eofError(n int, err error) error {
+ if n == 0 && err == nil && fd.ZeroReadIsEOF {
+ return io.EOF
+ }
+ return err
+}
+
+// RawControl invokes the user-defined function f for a non-IO
+// operation.
+func (fd *FD) RawControl(f func(uintptr)) error {
+ if err := fd.incref(); err != nil {
+ return err
+ }
+ defer fd.decref()
+ f(uintptr(fd.Sysfd))
+ return nil
+}
+
+// RawRead invokes the user-defined function f for a read operation.
+func (fd *FD) RawRead(f func(uintptr) bool) error {
+ if err := fd.readLock(); err != nil {
+ return err
+ }
+ defer fd.readUnlock()
+ if err := fd.pd.prepareRead(fd.isFile); err != nil {
+ return err
+ }
+ for {
+ if f(uintptr(fd.Sysfd)) {
+ return nil
+ }
+ if err := fd.pd.waitRead(fd.isFile); err != nil {
+ return err
+ }
+ }
+}
+
+// RawWrite invokes the user-defined function f for a write operation.
+func (fd *FD) RawWrite(f func(uintptr) bool) error {
+ if err := fd.writeLock(); err != nil {
+ return err
+ }
+ defer fd.writeUnlock()
+ if err := fd.pd.prepareWrite(fd.isFile); err != nil {
+ return err
+ }
+ for {
+ if f(uintptr(fd.Sysfd)) {
+ return nil
+ }
+ if err := fd.pd.waitWrite(fd.isFile); err != nil {
+ return err
+ }
+ }
+}
+
+// SetBlocking puts the file into blocking mode.
+func (fd *FD) SetBlocking() error {
+ if err := fd.incref(); err != nil {
+ return err
+ }
+ defer fd.decref()
+ // Atomic store so that concurrent calls to SetBlocking
+ // do not cause a race condition. isBlocking only ever goes
+ // from 0 to 1 so there is no real race here.
+ atomic.StoreUint32(&fd.isBlocking, 1)
+ return syscall.SetNonblock(fd.Sysfd, false)
+}
diff --git a/src/internal/poll/fd_poll_fuchsia.go b/src/internal/poll/fd_poll_fuchsia.go
new file mode 100644
index 0000000..1ccc1c7
--- /dev/null
+++ b/src/internal/poll/fd_poll_fuchsia.go
@@ -0,0 +1,78 @@
+// Copyright 2013 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.
+
+// TODO: use fd_poll_runtime.go for fuchsia
+
+package poll
+
+import (
+ "time"
+)
+
+type pollDesc struct {
+ fd *FD
+ closing bool
+}
+
+func (pd *pollDesc) init(fd *FD) error { pd.fd = fd; return nil }
+
+func (pd *pollDesc) close() {}
+
+func (pd *pollDesc) evict() {
+ pd.closing = true
+ if pd.fd != nil {
+ // TODO syscall.StopIO(pd.fd.Sysfd)
+ }
+}
+
+func (pd *pollDesc) prepare(mode int, isFile bool) error {
+ if pd.closing {
+ return errClosing(isFile)
+ }
+ return nil
+}
+
+func (pd *pollDesc) prepareRead(isFile bool) error { return pd.prepare('r', isFile) }
+
+func (pd *pollDesc) prepareWrite(isFile bool) error { return pd.prepare('w', isFile) }
+
+func (pd *pollDesc) wait(mode int, isFile bool) error {
+ if pd.closing {
+ return errClosing(isFile)
+ }
+ return ErrTimeout
+}
+
+func (pd *pollDesc) waitRead(isFile bool) error { return pd.wait('r', isFile) }
+
+func (pd *pollDesc) waitWrite(isFile bool) error { return pd.wait('w', isFile) }
+
+func (pd *pollDesc) waitCanceled(mode int) {}
+
+func (pd *pollDesc) pollable() bool { return true }
+
+// SetDeadline sets the read and write deadlines associated with fd.
+func (fd *FD) SetDeadline(t time.Time) error {
+ return setDeadlineImpl(fd, t, 'r'+'w')
+}
+
+// SetReadDeadline sets the read deadline associated with fd.
+func (fd *FD) SetReadDeadline(t time.Time) error {
+ return setDeadlineImpl(fd, t, 'r')
+}
+
+// SetWriteDeadline sets the write deadline associated with fd.
+func (fd *FD) SetWriteDeadline(t time.Time) error {
+ return setDeadlineImpl(fd, t, 'w')
+}
+
+func setDeadlineImpl(fd *FD, t time.Time, mode int) error {
+ return ErrNoDeadline // TODO set deadline
+}
+
+// PollDescriptor returns the descriptor being used by the poller,
+// or ^uintptr(0) if there isn't one. This is only used for testing.
+func PollDescriptor() uintptr {
+ return ^uintptr(0)
+}
diff --git a/src/internal/syscall/unix/nonblocking_fuchsia.go b/src/internal/syscall/unix/nonblocking_fuchsia.go
new file mode 100644
index 0000000..ff67c75
--- /dev/null
+++ b/src/internal/syscall/unix/nonblocking_fuchsia.go
@@ -0,0 +1,9 @@
+// Copyright 2018 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 unix
+
+func IsNonblock(fd int) (nonblocking bool, err error) {
+ return false, nil
+}
diff --git a/src/internal/syscall/unix/stub_fuchsia.go b/src/internal/syscall/unix/stub_fuchsia.go
new file mode 100644
index 0000000..2d7b8de
--- /dev/null
+++ b/src/internal/syscall/unix/stub_fuchsia.go
@@ -0,0 +1,7 @@
+// 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.
+
+// This file exists to make the go tool happy.
+
+package unix
diff --git a/src/internal/testenv/testenv.go b/src/internal/testenv/testenv.go
index 8f69fe0..fd09e35 100644
--- a/src/internal/testenv/testenv.go
+++ b/src/internal/testenv/testenv.go
@@ -149,7 +149,7 @@
// HasExternalNetwork reports whether the current system can use
// external (non-localhost) networks.
func HasExternalNetwork() bool {
- return !testing.Short() && runtime.GOOS != "nacl" && runtime.GOOS != "js"
+ return !testing.Short() && runtime.GOOS != "nacl" && runtime.GOOS != "js" && runtime.GOOS != "fuchsia"
}
// MustHaveExternalNetwork checks that the current system can use
@@ -162,6 +162,10 @@
if testing.Short() {
t.Skipf("skipping test: no external network in -short mode")
}
+
+ if runtime.GOOS == "fuchsia" {
+ t.Skipf("external network tests disabled on fuchsia; not all builders have one.")
+ }
}
var haveCGO bool
@@ -209,6 +213,11 @@
}
}
+// HasChmod reports whether the current system can use os.Chmod.
+func HasChmod() bool {
+ return runtime.GOOS != "fuchsia"
+}
+
var flaky = flag.Bool("flaky", false, "run known-flaky tests too")
func SkipFlaky(t testing.TB, issue int) {
diff --git a/src/internal/testenv/testenv_notwin.go b/src/internal/testenv/testenv_notwin.go
index d8ce6cd..e587e6a 100644
--- a/src/internal/testenv/testenv_notwin.go
+++ b/src/internal/testenv/testenv_notwin.go
@@ -12,7 +12,7 @@
func hasSymlink() (ok bool, reason string) {
switch runtime.GOOS {
- case "android", "nacl", "plan9":
+ case "android", "nacl", "plan9", "fuchsia":
return false, ""
}
diff --git a/src/io/io_fuchsia.go b/src/io/io_fuchsia.go
new file mode 100644
index 0000000..ac81e67
--- /dev/null
+++ b/src/io/io_fuchsia.go
@@ -0,0 +1,15 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build fuchsia
+
+package io
+
+import (
+ "syscall/zx"
+)
+
+func init() {
+ zx.EOF = EOF
+}
diff --git a/src/mime/type_fuchsia.go b/src/mime/type_fuchsia.go
new file mode 100644
index 0000000..986c0bb
--- /dev/null
+++ b/src/mime/type_fuchsia.go
@@ -0,0 +1,15 @@
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build fuchsia
+
+package mime
+
+func init() {
+ osInitMime = initMimeFuchsia
+}
+
+func initMimeFuchsia() {
+ // TODO: find an equivalent to /etc/mime.types.
+}
diff --git a/src/net/addrselect.go b/src/net/addrselect.go
index 1ab9fc5..16871fc 100644
--- a/src/net/addrselect.go
+++ b/src/net/addrselect.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// +build darwin dragonfly freebsd linux netbsd openbsd solaris
+// +build darwin dragonfly freebsd fuchsia linux netbsd openbsd solaris
// Minimal RFC 6724 address selection.
diff --git a/src/net/cgo_stub.go b/src/net/cgo_stub.go
index 5125972..94c95b5 100644
--- a/src/net/cgo_stub.go
+++ b/src/net/cgo_stub.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// +build !cgo netgo
+// +build !cgo netgo fuchsia
package net
diff --git a/src/net/conf.go b/src/net/conf.go
index 71ed136..fa7dcf4 100644
--- a/src/net/conf.go
+++ b/src/net/conf.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// +build darwin dragonfly freebsd linux netbsd openbsd solaris
+// +build darwin dragonfly freebsd fuchsia linux netbsd openbsd solaris
package net
diff --git a/src/net/dial_test.go b/src/net/dial_test.go
index 00a84d1..cfc4c37 100644
--- a/src/net/dial_test.go
+++ b/src/net/dial_test.go
@@ -77,7 +77,7 @@
func TestDialerDualStackFDLeak(t *testing.T) {
switch runtime.GOOS {
- case "plan9":
+ case "plan9", "fuchsia":
t.Skipf("%s does not have full support of socktest", runtime.GOOS)
case "windows":
t.Skipf("not implemented a way to cancel dial racers in TCP SYN-SENT state on %s", runtime.GOOS)
@@ -431,6 +431,10 @@
if !supportsIPv4() || !supportsIPv6() {
t.Skip("both IPv4 and IPv6 are required")
}
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
var wg sync.WaitGroup
wg.Add(2)
@@ -541,6 +545,10 @@
if !supportsIPv4() || !supportsIPv6() {
t.Skip("both IPv4 and IPv6 are required")
}
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
type test struct {
network, raddr string
@@ -712,6 +720,11 @@
}
func TestDialerKeepAlive(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
+
handler := func(ls *localServer, ln Listener) {
for {
c, err := ln.Accept()
@@ -815,6 +828,10 @@
}
func TestCancelAfterDial(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
if testing.Short() {
t.Skip("avoiding time.Sleep")
}
@@ -916,7 +933,7 @@
func TestDialerControl(t *testing.T) {
switch runtime.GOOS {
- case "nacl", "plan9":
+ case "fuchsia", "nacl", "plan9":
t.Skipf("not supported on %s", runtime.GOOS)
}
diff --git a/src/net/dnsclient_unix.go b/src/net/dnsclient_unix.go
index 2fee334..bd3b7ae 100644
--- a/src/net/dnsclient_unix.go
+++ b/src/net/dnsclient_unix.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// +build darwin dragonfly freebsd linux netbsd openbsd solaris
+// +build darwin dragonfly freebsd fuchsia linux netbsd openbsd solaris
// DNS client: see RFC 1035.
// Has to be linked into package net for Dial.
diff --git a/src/net/dnsconfig_fuchsia.go b/src/net/dnsconfig_fuchsia.go
new file mode 100644
index 0000000..c13658b
--- /dev/null
+++ b/src/net/dnsconfig_fuchsia.go
@@ -0,0 +1,44 @@
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build fuchsia
+
+// TODO: use dnsconfig_unix when 127.0.0.1:53 is a valid DNS server.
+
+package net
+
+import (
+ "os"
+ "time"
+)
+
+var (
+ defaultNS = []string{"8.8.8.8:53"}
+ getHostname = os.Hostname // variable for testing
+)
+
+type dnsConfig struct {
+ servers []string
+ attempts int
+ timeout time.Duration
+ search []string
+ ndots int
+ rotate bool
+ unknownOpt bool
+ lookup []string
+ err error
+ mtime time.Time
+ soffset uint32
+}
+
+func dnsReadConfig(filename string) *dnsConfig {
+ return &dnsConfig{
+ ndots: 1,
+ timeout: 5 * time.Second,
+ attempts: 2,
+ servers: defaultNS,
+ }
+}
+
+func (c *dnsConfig) serverOffset() uint32 { return 0 }
diff --git a/src/net/dnsconfig_unix.go b/src/net/dnsconfig_unix.go
index 707fd6f..348d2a4 100644
--- a/src/net/dnsconfig_unix.go
+++ b/src/net/dnsconfig_unix.go
@@ -15,7 +15,7 @@
)
var (
- defaultNS = []string{"127.0.0.1:53", "[::1]:53"}
+ defaultNS = []string{"8.8.8.8:53"}
getHostname = os.Hostname // variable for testing
)
diff --git a/src/net/error_fuchsia.go b/src/net/error_fuchsia.go
new file mode 100644
index 0000000..caad133
--- /dev/null
+++ b/src/net/error_fuchsia.go
@@ -0,0 +1,9 @@
+// Copyright 2018 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 net
+
+func isConnError(err error) bool {
+ return false
+}
diff --git a/src/net/error_fuchsia_test.go b/src/net/error_fuchsia_test.go
new file mode 100644
index 0000000..a72a2b8
--- /dev/null
+++ b/src/net/error_fuchsia_test.go
@@ -0,0 +1,35 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build fuchsia !plan9,!windows,!unix
+
+package net
+
+import (
+ "os"
+ "syscall"
+ "syscall/zx"
+)
+
+var (
+ errTimedout = syscall.ETIMEDOUT
+ errOpNotSupported = syscall.EOPNOTSUPP
+
+ abortedConnRequestErrors = []error{syscall.ECONNABORTED} // see accept in fd_unix.go
+)
+
+func isPlatformError(err error) bool {
+ _, ok := err.(zx.Error)
+ return ok
+}
+
+func samePlatformError(err, want error) bool {
+ if op, ok := err.(*OpError); ok {
+ err = op.Err
+ }
+ if sys, ok := err.(*os.SyscallError); ok {
+ err = sys.Err
+ }
+ return err == want
+}
diff --git a/src/net/error_posix_test.go b/src/net/error_posix_test.go
index b411a37..ab44e70 100644
--- a/src/net/error_posix_test.go
+++ b/src/net/error_posix_test.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// +build !plan9
+// +build !plan9,!fuchsia
package net
diff --git a/src/net/error_test.go b/src/net/error_test.go
index e09670e..0a9ebd0 100644
--- a/src/net/error_test.go
+++ b/src/net/error_test.go
@@ -137,8 +137,9 @@
}
func TestDialError(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
switch runtime.GOOS {
- case "plan9":
+ case "plan9", "fuchsia":
t.Skipf("%s does not have full support of socktest", runtime.GOOS)
}
@@ -184,6 +185,10 @@
}
func TestProtocolDialError(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
switch runtime.GOOS {
case "nacl", "solaris":
t.Skipf("not supported on %s", runtime.GOOS)
@@ -286,6 +291,10 @@
}
func TestListenError(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
switch runtime.GOOS {
case "plan9":
t.Skipf("%s does not have full support of socktest", runtime.GOOS)
@@ -346,6 +355,10 @@
}
func TestListenPacketError(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
switch runtime.GOOS {
case "plan9":
t.Skipf("%s does not have full support of socktest", runtime.GOOS)
@@ -375,6 +388,10 @@
}
func TestProtocolListenError(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
switch runtime.GOOS {
case "nacl", "plan9":
t.Skipf("not supported on %s", runtime.GOOS)
@@ -548,6 +565,10 @@
}
func TestCloseError(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
ln, err := newLocalListener("tcp")
if err != nil {
t.Fatal(err)
@@ -582,6 +603,11 @@
}
}
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
+
pc, err := ListenPacket("udp", "127.0.0.1:0")
if err != nil {
t.Fatal(err)
@@ -640,6 +666,11 @@
}
func TestAcceptError(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
+
handler := func(ls *localServer, ln Listener) {
for {
ln.(*TCPListener).SetDeadline(time.Now().Add(5 * time.Millisecond))
@@ -719,6 +750,10 @@
}
func TestFileError(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
switch runtime.GOOS {
case "windows":
t.Skipf("not supported on %s", runtime.GOOS)
diff --git a/src/net/error_unix_test.go b/src/net/error_unix_test.go
index 9ce9e12..441ca49 100644
--- a/src/net/error_unix_test.go
+++ b/src/net/error_unix_test.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// +build !plan9,!windows
+// +build !plan9,!windows,!fuchsia
package net
diff --git a/src/net/fd_fuchsia.go b/src/net/fd_fuchsia.go
new file mode 100644
index 0000000..385bd0f
--- /dev/null
+++ b/src/net/fd_fuchsia.go
@@ -0,0 +1,146 @@
+// Copyright 2016 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.
+
+// TODO: move to using fd_unix for fuchsia?
+
+package net
+
+import (
+ "errors"
+ "internal/poll"
+ "os"
+ "runtime"
+ "syscall"
+ "syscall/zx/mxnet"
+ "syscall/zx/zxsocket"
+ "time"
+)
+
+// Network file descriptor.
+type netFD struct {
+ pfd poll.FD
+
+ // immutable until Close
+ net string
+ family int
+ sotype int
+ isStream bool
+ isConnected bool
+ laddr Addr
+ raddr Addr
+}
+
+func newFD(handle *zxsocket.Socket, family, sotype int, net string) *netFD {
+ netfd := &netFD{
+ pfd: poll.FD{
+ Sysfd: syscall.OpenFDIO(handle),
+ Handle: handle,
+ },
+ family: family,
+ sotype: sotype,
+ net: net,
+ }
+ return netfd
+}
+
+func (fd *netFD) destroy() {
+ panic("TODO")
+}
+
+func sysInit() {
+}
+
+func (fd *netFD) isTCP() bool {
+ return len(fd.net) >= 3 && fd.net[:3] == "tcp"
+}
+
+func (fd *netFD) Read(b []byte) (n int, err error) {
+ n, err = fd.pfd.Read(b)
+ runtime.KeepAlive(fd)
+ return n, err
+}
+
+func (fd *netFD) Write(b []byte) (n int, err error) {
+ n, err = fd.pfd.Write(b)
+ runtime.KeepAlive(fd)
+ return n, err
+}
+
+func (fd *netFD) readMsg(b []byte) (n, flags int, addr string, port uint16, err error) {
+ // TODO: move call to pfd
+ data, flags, addr, port, err := fd.pfd.Handle.(*zxsocket.Socket).RecvMsg(len(b))
+ runtime.KeepAlive(fd)
+ n = copy(b, data)
+ return n, flags, addr, port, err
+}
+
+func (fd *netFD) sendMsg(b []byte, addr string, port uint16) (n int, err error) {
+ // TODO: move call to pfd
+ n, err = fd.pfd.Handle.(*zxsocket.Socket).SendMsg(b, addr, port)
+ runtime.KeepAlive(fd)
+ return n, err
+}
+
+func (fd *netFD) closeRead() error {
+ return errors.New("net: closeRead not implemented on fuchsia")
+}
+
+func (fd *netFD) closeWrite() error {
+ return errors.New("net: closeWrite not implemented on fuchsia")
+}
+
+func (fd *netFD) Close() error {
+ return fd.pfd.Close()
+}
+
+func (fd *netFD) dup() (*os.File, error) {
+ // TODO(mknyszek): fd.sock is an FDIO so one can make an FD from it to
+ // implement this.
+ return nil, errors.New("net: dup not implemented on fuchsia")
+}
+
+func (fd *netFD) accept() (netfd *netFD, err error) {
+ newm, err := fd.pfd.Accept()
+ if err != nil {
+ return nil, err
+ }
+ netfd = newFD(newm, fd.family, fd.sotype, fd.net)
+ netfd.setAddr()
+ return netfd, nil
+}
+
+func (fd *netFD) asAddr(ipAddr mxnet.Addr, port uint16, err error) sockaddr {
+ if err != nil {
+ return nil
+ }
+ ip := IP(ipAddr)
+ if isZeros(ip) && port == 0 {
+ return nil
+ }
+ switch fd.sotype {
+ case syscall.SOCK_STREAM:
+ return &TCPAddr{IP: ip, Port: int(port)}
+ case syscall.SOCK_DGRAM:
+ return &UDPAddr{IP: ip, Port: int(port)}
+ }
+ return nil
+}
+
+func (fd *netFD) setAddr() {
+ fd.laddr = fd.asAddr(fd.pfd.Handle.(*zxsocket.Socket).SockName())
+ fd.raddr = fd.asAddr(fd.pfd.Handle.(*zxsocket.Socket).PeerName())
+ runtime.SetFinalizer(fd, (*netFD).Close)
+}
+
+func (fd *netFD) SetDeadline(t time.Time) error {
+ return fd.pfd.SetDeadline(t)
+}
+
+func (fd *netFD) SetReadDeadline(t time.Time) error {
+ return fd.pfd.SetReadDeadline(t)
+}
+
+func (fd *netFD) SetWriteDeadline(t time.Time) error {
+ return fd.pfd.SetWriteDeadline(t)
+}
diff --git a/src/net/file_stub.go b/src/net/file_stub.go
index 2256608..dce5470 100644
--- a/src/net/file_stub.go
+++ b/src/net/file_stub.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// +build nacl js,wasm
+// +build nacl js,wasm fuchsia
package net
diff --git a/src/net/file_test.go b/src/net/file_test.go
index cd71774..87aeaf6 100644
--- a/src/net/file_test.go
+++ b/src/net/file_test.go
@@ -30,8 +30,9 @@
}
func TestFileConn(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
switch runtime.GOOS {
- case "nacl", "plan9", "windows":
+ case "nacl", "plan9", "windows", "fuchsia":
t.Skipf("not supported on %s", runtime.GOOS)
}
@@ -137,8 +138,9 @@
}
func TestFileListener(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
switch runtime.GOOS {
- case "nacl", "plan9", "windows":
+ case "nacl", "plan9", "windows", "fuchsia":
t.Skipf("not supported on %s", runtime.GOOS)
}
@@ -229,8 +231,9 @@
}
func TestFilePacketConn(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
switch runtime.GOOS {
- case "nacl", "plan9", "windows":
+ case "nacl", "plan9", "windows", "fuchsia":
t.Skipf("not supported on %s", runtime.GOOS)
}
@@ -297,7 +300,7 @@
// Issue 24483.
func TestFileCloseRace(t *testing.T) {
switch runtime.GOOS {
- case "nacl", "plan9", "windows":
+ case "fuchsia", "nacl", "plan9", "windows":
t.Skipf("not supported on %s", runtime.GOOS)
}
if !testableNetwork("tcp") {
diff --git a/src/net/hook_fuchsia.go b/src/net/hook_fuchsia.go
new file mode 100644
index 0000000..e445c1a
--- /dev/null
+++ b/src/net/hook_fuchsia.go
@@ -0,0 +1,17 @@
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build fuchsia
+
+package net
+
+import "syscall"
+
+var (
+ testHookDialChannel = func() {} // for golang.org/issue/5349
+ testHookCanceledDial = func() {} // for golang.org/issue/16523
+
+ // Placeholders for socket system calls.
+ closeFunc func(int) error = syscall.Close
+)
diff --git a/src/net/hosts_test.go b/src/net/hosts_test.go
index f850e2f..3169866 100644
--- a/src/net/hosts_test.go
+++ b/src/net/hosts_test.go
@@ -6,6 +6,7 @@
import (
"reflect"
+ "runtime"
"strings"
"testing"
)
@@ -59,6 +60,11 @@
}
func TestLookupStaticHost(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
+
defer func(orig string) { testHookHostsPath = orig }(testHookHostsPath)
for _, tt := range lookupStaticHostTests {
@@ -128,6 +134,10 @@
}
func TestLookupStaticAddr(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
defer func(orig string) { testHookHostsPath = orig }(testHookHostsPath)
for _, tt := range lookupStaticAddrTests {
@@ -149,6 +159,10 @@
}
func TestHostCacheModification(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
// Ensure that programs can't modify the internals of the host cache.
// See https://golang.org/issues/14212.
defer func(orig string) { testHookHostsPath = orig }(testHookHostsPath)
diff --git a/src/net/interface_stub.go b/src/net/interface_stub.go
index 0afaa80..426ac46 100644
--- a/src/net/interface_stub.go
+++ b/src/net/interface_stub.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// +build nacl js,wasm
+// +build nacl js,wasm fuchsia
package net
diff --git a/src/net/internal/socktest/switch_posix.go b/src/net/internal/socktest/switch_posix.go
index 863edef..0ead109 100644
--- a/src/net/internal/socktest/switch_posix.go
+++ b/src/net/internal/socktest/switch_posix.go
@@ -3,6 +3,7 @@
// license that can be found in the LICENSE file.
// +build !plan9
+// +build !fuchsia
package socktest
diff --git a/src/net/internal/socktest/switch_stub.go b/src/net/internal/socktest/switch_stub.go
index 28ce72c..9ba7d73 100644
--- a/src/net/internal/socktest/switch_stub.go
+++ b/src/net/internal/socktest/switch_stub.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// +build plan9
+// +build plan9 fuchsia
package socktest
diff --git a/src/net/ip_test.go b/src/net/ip_test.go
index a5fc5e6..cde5eca 100644
--- a/src/net/ip_test.go
+++ b/src/net/ip_test.go
@@ -61,6 +61,7 @@
}
func TestLookupWithIP(t *testing.T) {
+ mustHaveExternalNetwork(t)
_, err := LookupIP("")
if err == nil {
t.Errorf(`LookupIP("") succeeded, should fail`)
diff --git a/src/net/iprawsock_fuchsia.go b/src/net/iprawsock_fuchsia.go
new file mode 100644
index 0000000..0bfd133
--- /dev/null
+++ b/src/net/iprawsock_fuchsia.go
@@ -0,0 +1,34 @@
+// Copyright 2016 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 net
+
+import (
+ "context"
+ "syscall"
+)
+
+func (c *IPConn) readFrom(b []byte) (int, *IPAddr, error) {
+ return 0, nil, syscall.EFUCHSIA
+}
+
+func (c *IPConn) readMsg(b, oob []byte) (n, oobn, flags int, addr *IPAddr, err error) {
+ return 0, 0, 0, nil, syscall.EFUCHSIA
+}
+
+func (c *IPConn) writeTo(b []byte, addr *IPAddr) (int, error) {
+ return 0, syscall.EFUCHSIA
+}
+
+func (c *IPConn) writeMsg(b, oob []byte, addr *IPAddr) (n, oobn int, err error) {
+ return 0, 0, syscall.EFUCHSIA
+}
+
+func (sd *sysDialer) dialIP(ctx context.Context, laddr, raddr *IPAddr) (*IPConn, error) {
+ return nil, syscall.EFUCHSIA
+}
+
+func (sl *sysListener) listenIP(ctx context.Context, laddr *IPAddr) (*IPConn, error) {
+ return nil, syscall.EFUCHSIA
+}
diff --git a/src/net/iprawsock_test.go b/src/net/iprawsock_test.go
index 8e3543d..4985e88 100644
--- a/src/net/iprawsock_test.go
+++ b/src/net/iprawsock_test.go
@@ -8,6 +8,7 @@
import (
"reflect"
+ "runtime"
"testing"
)
@@ -88,6 +89,10 @@
}
func TestIPConnLocalName(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
for _, tt := range ipConnLocalNameTests {
if !testableNetwork(tt.net) {
t.Logf("skipping %s test", tt.net)
@@ -105,6 +110,10 @@
}
func TestIPConnRemoteName(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
if !testableNetwork("ip:tcp") {
t.Skip("ip:tcp test")
}
diff --git a/src/net/ipsock_fuchsia.go b/src/net/ipsock_fuchsia.go
new file mode 100644
index 0000000..4af25bb
--- /dev/null
+++ b/src/net/ipsock_fuchsia.go
@@ -0,0 +1,174 @@
+// Copyright 2016 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 net
+
+import (
+ "context"
+ "errors"
+ "sync"
+ "syscall"
+ "syscall/zx"
+ "syscall/zx/fdio"
+ "syscall/zx/fidl"
+ "syscall/zx/mxnet"
+ zxnet "syscall/zx/net"
+ "syscall/zx/zxsocket"
+ "time"
+)
+
+func (p *ipStackCapabilities) probe() {
+ p.ipv4Enabled = true
+ p.ipv6Enabled = true
+ p.ipv4MappedIPv6Enabled = true
+}
+
+// A sockaddr represents a TCP, UDP, IP or Unix network endpoint
+// address that can be converted into an fdio sockaddr message.
+type sockaddr interface {
+ Addr
+
+ family() int
+ isWildcard() bool
+ sockaddr(family int) (addr mxnet.Addr, port uint16, err error)
+}
+
+func favoriteAddrFamily(net string, laddr, raddr sockaddr, mode string) (family int, ipv6only bool) {
+ switch net[len(net)-1] {
+ case '4':
+ return syscall.AF_INET, false
+ case '6':
+ return syscall.AF_INET6, true
+ }
+
+ if mode == "listen" && (laddr == nil || laddr.isWildcard()) {
+ if supportsIPv4map() || !supportsIPv4() {
+ return syscall.AF_INET6, false
+ }
+ if laddr == nil {
+ return syscall.AF_INET, false
+ }
+ return laddr.family(), false
+ }
+
+ if (laddr == nil || laddr.family() == syscall.AF_INET) &&
+ (raddr == nil || raddr.family() == syscall.AF_INET) {
+ return syscall.AF_INET, false
+ }
+ return syscall.AF_INET6, false
+}
+
+type socketProviderInfo struct {
+ mu sync.Mutex
+ h zx.Handle
+}
+
+var socketProvider socketProviderInfo
+
+func getSocketProvider() zx.Handle {
+ socketProvider.mu.Lock()
+ defer socketProvider.mu.Unlock()
+ if socketProvider.h == zx.HandleInvalid {
+ c0, c1, err := zx.NewChannel(0)
+ if err == nil {
+ err = fdio.ServiceConnect("/svc/fuchsia.net.LegacySocketProvider", zx.Handle(c0))
+ if err == nil {
+ socketProvider.h = zx.Handle(c1)
+ }
+ }
+ }
+ return socketProvider.h
+}
+
+func dialFuchsia(ctx context.Context, net string, laddr, raddr sockaddr) (fd *netFD, err error) {
+ family, _ := favoriteAddrFamily(net, laddr, raddr, "dial")
+
+ sotype := syscall.SOCK_STREAM
+ if len(net) >= 3 && net[:3] == "udp" {
+ sotype = syscall.SOCK_DGRAM
+ }
+ proto := syscall.IPPROTO_IP
+
+ var sock *zxsocket.Socket
+ // Wait for the network stack to publish the socket device.
+ // See similar logic in zircon/system/ulib/fdio/bsdsocket.c.
+ for i := 0; i < 40; i++ {
+ c := zx.Channel(getSocketProvider())
+ if c.Handle().IsValid() {
+ sp := zxnet.LegacySocketProviderInterface(fidl.Proxy{Channel: c})
+ s, _, err := sp.OpenSocket(zxnet.SocketDomain(family), zxnet.SocketType(sotype), zxnet.SocketProtocol(proto))
+ if err == nil {
+ sock = zxsocket.NewSocket(s)
+ break
+ }
+ }
+ time.Sleep(250 * time.Millisecond)
+ }
+ if err != nil {
+ return nil, err
+ }
+ if sotype == syscall.SOCK_DGRAM {
+ sock.SetDgram()
+ }
+
+ fd = newFD(sock, family, sotype, net)
+ if laddr != nil {
+ addr, port, err := laddr.sockaddr(family)
+ if err != nil {
+ return nil, err
+ }
+ if addr != "" || port != 0 {
+ if err := fd.pfd.Handle.(*zxsocket.Socket).Bind(addr, port); err != nil {
+ return nil, err
+ }
+ }
+ if raddr == nil {
+ switch sotype {
+ case syscall.SOCK_STREAM:
+ if err := fd.pfd.Handle.(*zxsocket.Socket).ListenStream(listenerBacklog); err != nil {
+ return nil, err
+ }
+ case syscall.SOCK_DGRAM:
+ return nil, errors.New("net: TODO listen datagram")
+ }
+ }
+ }
+ if raddr != nil {
+ addr, port, err := raddr.sockaddr(family)
+ if err != nil {
+ return nil, err
+ }
+ if err := fd.pfd.Handle.(*zxsocket.Socket).Connect(addr, port); err != nil {
+ return nil, err
+ }
+ fd.isConnected = true
+ }
+ fd.setAddr()
+
+ return fd, nil
+}
+
+func ipToSockaddr(family int, ip IP, port int, zone string) (addr mxnet.Addr, portres uint16, err error) {
+ switch family {
+ case syscall.AF_INET:
+ if len(ip) == 0 {
+ ip = IPv4zero
+ }
+ ip4 := ip.To4()
+ if ip4 == nil {
+ return "", 0, &AddrError{Err: "non-IPv4 address", Addr: ip.String()}
+ }
+ return mxnet.Addr(ip4)[:4], uint16(port), nil
+ case syscall.AF_INET6:
+ if len(ip) == 0 || ip.Equal(IPv4zero) {
+ ip = IPv6zero
+ }
+ ip6 := ip.To16()
+ if ip6 == nil {
+ return "", 0, &AddrError{Err: "non-IPv6 address", Addr: ip.String()}
+ }
+ return mxnet.Addr(ip6), uint16(port), nil
+ }
+ return "", 0, &AddrError{Err: "invalid address family", Addr: ip.String()}
+}
diff --git a/src/net/listen_test.go b/src/net/listen_test.go
index ffce8e2..971f233 100644
--- a/src/net/listen_test.go
+++ b/src/net/listen_test.go
@@ -63,6 +63,10 @@
// listener with same address family, same listening address and
// same port.
func TestTCPListener(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
switch runtime.GOOS {
case "plan9":
t.Skipf("not supported on %s", runtime.GOOS)
@@ -124,8 +128,9 @@
// listener with same address family, same listening address and
// same port.
func TestUDPListener(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
switch runtime.GOOS {
- case "plan9":
+ case "plan9", "fuchsia":
t.Skipf("not supported on %s", runtime.GOOS)
}
@@ -223,6 +228,10 @@
// On DragonFly BSD, we expect the kernel version of node under test
// to be greater than or equal to 4.4.
func TestDualStackTCPListener(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
switch runtime.GOOS {
case "nacl", "plan9":
t.Skipf("not supported on %s", runtime.GOOS)
@@ -313,8 +322,9 @@
// On DragonFly BSD, we expect the kernel version of node under test
// to be greater than or equal to 4.4.
func TestDualStackUDPListener(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
switch runtime.GOOS {
- case "nacl", "plan9":
+ case "nacl", "plan9", "fuchsia":
t.Skipf("not supported on %s", runtime.GOOS)
}
if !supportsIPv4() || !supportsIPv6() {
@@ -488,8 +498,9 @@
func TestWildWildcardListener(t *testing.T) {
testenv.MustHaveExternalNetwork(t)
+ // TODO(TC-149): disabled without further triage. Needs work.
switch runtime.GOOS {
- case "plan9":
+ case "plan9", "fuchsia":
t.Skipf("not supported on %s", runtime.GOOS)
}
@@ -531,8 +542,9 @@
func TestIPv4MulticastListener(t *testing.T) {
testenv.MustHaveExternalNetwork(t)
+ // TODO(TC-149): disabled without further triage. Needs work.
switch runtime.GOOS {
- case "android", "nacl", "plan9":
+ case "android", "nacl", "plan9", "fuchsia":
t.Skipf("not supported on %s", runtime.GOOS)
case "solaris":
t.Skipf("not supported on solaris, see golang.org/issue/7399")
@@ -606,8 +618,9 @@
func TestIPv6MulticastListener(t *testing.T) {
testenv.MustHaveExternalNetwork(t)
+ // TODO(TC-149): disabled without further triage. Needs work.
switch runtime.GOOS {
- case "plan9":
+ case "plan9", "fuchsia":
t.Skipf("not supported on %s", runtime.GOOS)
case "solaris":
t.Skipf("not supported on solaris, see issue 7399")
@@ -701,6 +714,11 @@
// Issue 21856.
func TestClosingListener(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
+
ln, err := newLocalListener("tcp")
if err != nil {
t.Fatal(err)
@@ -733,7 +751,7 @@
func TestListenConfigControl(t *testing.T) {
switch runtime.GOOS {
- case "nacl", "plan9":
+ case "fuchsia", "nacl", "plan9":
t.Skipf("not supported on %s", runtime.GOOS)
}
diff --git a/src/net/lookup_fuchsia.go b/src/net/lookup_fuchsia.go
new file mode 100644
index 0000000..b3d5f97
--- /dev/null
+++ b/src/net/lookup_fuchsia.go
@@ -0,0 +1,323 @@
+// 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.
+
+// +build darwin dragonfly freebsd fuchsia linux netbsd openbsd solaris
+
+package net
+
+import (
+ "context"
+ "sync"
+
+ "golang_org/x/net/dns/dnsmessage"
+)
+
+var onceReadProtocols sync.Once
+
+// readProtocols loads contents of /etc/protocols into protocols map
+// for quick access.
+func readProtocols() {
+ file, err := open("/etc/protocols")
+ if err != nil {
+ return
+ }
+ defer file.close()
+
+ for line, ok := file.readLine(); ok; line, ok = file.readLine() {
+ // tcp 6 TCP # transmission control protocol
+ if i := byteIndex(line, '#'); i >= 0 {
+ line = line[0:i]
+ }
+ f := getFields(line)
+ if len(f) < 2 {
+ continue
+ }
+ if proto, _, ok := dtoi(f[1]); ok {
+ if _, ok := protocols[f[0]]; !ok {
+ protocols[f[0]] = proto
+ }
+ for _, alias := range f[2:] {
+ if _, ok := protocols[alias]; !ok {
+ protocols[alias] = proto
+ }
+ }
+ }
+ }
+}
+
+// lookupProtocol looks up IP protocol name in /etc/protocols and
+// returns correspondent protocol number.
+func lookupProtocol(_ context.Context, name string) (int, error) {
+ onceReadProtocols.Do(readProtocols)
+ return lookupProtocolMap(name)
+}
+
+func (r *Resolver) dial(ctx context.Context, network, server string) (Conn, error) {
+ // Calling Dial here is scary -- we have to be sure not to
+ // dial a name that will require a DNS lookup, or Dial will
+ // call back here to translate it. The DNS config parser has
+ // already checked that all the cfg.servers are IP
+ // addresses, which Dial will use without a DNS lookup.
+ var c Conn
+ var err error
+ if r != nil && r.Dial != nil {
+ c, err = r.Dial(ctx, network, server)
+ } else {
+ var d Dialer
+ c, err = d.DialContext(ctx, network, server)
+ }
+ if err != nil {
+ return nil, mapErr(err)
+ }
+ return c, nil
+}
+
+func (r *Resolver) lookupHost(ctx context.Context, host string) (addrs []string, err error) {
+ order := systemConf().hostLookupOrder(r, host)
+ if !r.preferGo() && order == hostLookupCgo {
+ if addrs, err, ok := cgoLookupHost(ctx, host); ok {
+ return addrs, err
+ }
+ // cgo not available (or netgo); fall back to Go's DNS resolver
+ order = hostLookupFilesDNS
+ }
+ return r.goLookupHostOrder(ctx, host, order)
+}
+
+func (r *Resolver) lookupIP(ctx context.Context, host string) (addrs []IPAddr, err error) {
+ if r.preferGo() {
+ return r.goLookupIP(ctx, host)
+ }
+ order := systemConf().hostLookupOrder(r, host)
+ if order == hostLookupCgo {
+ if addrs, err, ok := cgoLookupIP(ctx, host); ok {
+ return addrs, err
+ }
+ // cgo not available (or netgo); fall back to Go's DNS resolver
+ order = hostLookupFilesDNS
+ }
+ ips, _, err := r.goLookupIPCNAMEOrder(ctx, host, order)
+ return ips, err
+}
+
+func (r *Resolver) lookupPort(ctx context.Context, network, service string) (int, error) {
+ if !r.preferGo() && systemConf().canUseCgo() {
+ if port, err, ok := cgoLookupPort(ctx, network, service); ok {
+ if err != nil {
+ // Issue 18213: if cgo fails, first check to see whether we
+ // have the answer baked-in to the net package.
+ if port, err := goLookupPort(network, service); err == nil {
+ return port, nil
+ }
+ }
+ return port, err
+ }
+ }
+ return goLookupPort(network, service)
+}
+
+func (r *Resolver) lookupCNAME(ctx context.Context, name string) (string, error) {
+ if !r.preferGo() && systemConf().canUseCgo() {
+ if cname, err, ok := cgoLookupCNAME(ctx, name); ok {
+ return cname, err
+ }
+ }
+ return r.goLookupCNAME(ctx, name)
+}
+
+func (r *Resolver) lookupSRV(ctx context.Context, service, proto, name string) (string, []*SRV, error) {
+ var target string
+ if service == "" && proto == "" {
+ target = name
+ } else {
+ target = "_" + service + "._" + proto + "." + name
+ }
+ p, server, err := r.lookup(ctx, target, dnsmessage.TypeSRV)
+ if err != nil {
+ return "", nil, err
+ }
+ var srvs []*SRV
+ var cname dnsmessage.Name
+ for {
+ h, err := p.AnswerHeader()
+ if err == dnsmessage.ErrSectionDone {
+ break
+ }
+ if err != nil {
+ return "", nil, &DNSError{
+ Err: "cannot unmarshal DNS message",
+ Name: name,
+ Server: server,
+ }
+ }
+ if h.Type != dnsmessage.TypeSRV {
+ if err := p.SkipAnswer(); err != nil {
+ return "", nil, &DNSError{
+ Err: "cannot unmarshal DNS message",
+ Name: name,
+ Server: server,
+ }
+ }
+ continue
+ }
+ if cname.Length == 0 && h.Name.Length != 0 {
+ cname = h.Name
+ }
+ srv, err := p.SRVResource()
+ if err != nil {
+ return "", nil, &DNSError{
+ Err: "cannot unmarshal DNS message",
+ Name: name,
+ Server: server,
+ }
+ }
+ srvs = append(srvs, &SRV{Target: srv.Target.String(), Port: srv.Port, Priority: srv.Priority, Weight: srv.Weight})
+ }
+ byPriorityWeight(srvs).sort()
+ return cname.String(), srvs, nil
+}
+
+func (r *Resolver) lookupMX(ctx context.Context, name string) ([]*MX, error) {
+ p, server, err := r.lookup(ctx, name, dnsmessage.TypeMX)
+ if err != nil {
+ return nil, err
+ }
+ var mxs []*MX
+ for {
+ h, err := p.AnswerHeader()
+ if err == dnsmessage.ErrSectionDone {
+ break
+ }
+ if err != nil {
+ return nil, &DNSError{
+ Err: "cannot unmarshal DNS message",
+ Name: name,
+ Server: server,
+ }
+ }
+ if h.Type != dnsmessage.TypeMX {
+ if err := p.SkipAnswer(); err != nil {
+ return nil, &DNSError{
+ Err: "cannot unmarshal DNS message",
+ Name: name,
+ Server: server,
+ }
+ }
+ continue
+ }
+ mx, err := p.MXResource()
+ if err != nil {
+ return nil, &DNSError{
+ Err: "cannot unmarshal DNS message",
+ Name: name,
+ Server: server,
+ }
+ }
+ mxs = append(mxs, &MX{Host: mx.MX.String(), Pref: mx.Pref})
+
+ }
+ byPref(mxs).sort()
+ return mxs, nil
+}
+
+func (r *Resolver) lookupNS(ctx context.Context, name string) ([]*NS, error) {
+ p, server, err := r.lookup(ctx, name, dnsmessage.TypeNS)
+ if err != nil {
+ return nil, err
+ }
+ var nss []*NS
+ for {
+ h, err := p.AnswerHeader()
+ if err == dnsmessage.ErrSectionDone {
+ break
+ }
+ if err != nil {
+ return nil, &DNSError{
+ Err: "cannot unmarshal DNS message",
+ Name: name,
+ Server: server,
+ }
+ }
+ if h.Type != dnsmessage.TypeNS {
+ if err := p.SkipAnswer(); err != nil {
+ return nil, &DNSError{
+ Err: "cannot unmarshal DNS message",
+ Name: name,
+ Server: server,
+ }
+ }
+ continue
+ }
+ ns, err := p.NSResource()
+ if err != nil {
+ return nil, &DNSError{
+ Err: "cannot unmarshal DNS message",
+ Name: name,
+ Server: server,
+ }
+ }
+ nss = append(nss, &NS{Host: ns.NS.String()})
+ }
+ return nss, nil
+}
+
+func (r *Resolver) lookupTXT(ctx context.Context, name string) ([]string, error) {
+ p, server, err := r.lookup(ctx, name, dnsmessage.TypeTXT)
+ if err != nil {
+ return nil, err
+ }
+ var txts []string
+ for {
+ h, err := p.AnswerHeader()
+ if err == dnsmessage.ErrSectionDone {
+ break
+ }
+ if err != nil {
+ return nil, &DNSError{
+ Err: "cannot unmarshal DNS message",
+ Name: name,
+ Server: server,
+ }
+ }
+ if h.Type != dnsmessage.TypeTXT {
+ if err := p.SkipAnswer(); err != nil {
+ return nil, &DNSError{
+ Err: "cannot unmarshal DNS message",
+ Name: name,
+ Server: server,
+ }
+ }
+ continue
+ }
+ txt, err := p.TXTResource()
+ if err != nil {
+ return nil, &DNSError{
+ Err: "cannot unmarshal DNS message",
+ Name: name,
+ Server: server,
+ }
+ }
+ if len(txts) == 0 {
+ txts = txt.TXT
+ } else {
+ txts = append(txts, txt.TXT...)
+ }
+ }
+ return txts, nil
+}
+
+func (r *Resolver) lookupAddr(ctx context.Context, addr string) ([]string, error) {
+ if !r.preferGo() && systemConf().canUseCgo() {
+ if ptrs, err, ok := cgoLookupPTR(ctx, addr); ok {
+ return ptrs, err
+ }
+ }
+ return r.goLookupPTR(ctx, addr)
+}
+
+// concurrentThreadsLimit returns the number of threads we permit to
+// run concurrently doing DNS lookups via cgo.
+func concurrentThreadsLimit() int {
+ return 500
+}
diff --git a/src/net/lookup_test.go b/src/net/lookup_test.go
index 5c66dfa..cb92c3c 100644
--- a/src/net/lookup_test.go
+++ b/src/net/lookup_test.go
@@ -742,6 +742,11 @@
}
func TestLookupPort(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
+
// See https://www.iana.org/assignments/service-names-port-numbers/service-names-port-numbers.xhtml
//
// Please be careful about adding new test cases.
@@ -800,6 +805,10 @@
// Like TestLookupPort but with minimal tests that should always pass
// because the answers are baked-in to the net package.
func TestLookupPort_Minimal(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
type test struct {
network string
name string
diff --git a/src/net/main_fuchsia_test.go b/src/net/main_fuchsia_test.go
new file mode 100644
index 0000000..b266361
--- /dev/null
+++ b/src/net/main_fuchsia_test.go
@@ -0,0 +1,20 @@
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build fuchsia
+
+package net
+
+func installTestHooks() {
+}
+
+func uninstallTestHooks() {
+}
+
+// forceCloseSockets must be called only from TestMain.
+func forceCloseSockets() {
+ for s := range sw.Sockets() {
+ closeFunc(s)
+ }
+}
diff --git a/src/net/net_test.go b/src/net/net_test.go
index 692f269..e880564 100644
--- a/src/net/net_test.go
+++ b/src/net/net_test.go
@@ -19,6 +19,10 @@
)
func TestCloseRead(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
switch runtime.GOOS {
case "plan9":
t.Skipf("not supported on %s", runtime.GOOS)
@@ -71,8 +75,9 @@
}
func TestCloseWrite(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
switch runtime.GOOS {
- case "nacl", "plan9":
+ case "nacl", "plan9", "fuchsia":
t.Skipf("not supported on %s", runtime.GOOS)
}
@@ -255,6 +260,10 @@
}
func TestPacketConnClose(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
for _, network := range []string{"udp", "unixgram"} {
if !testableNetwork(network) {
t.Logf("skipping %s test", network)
@@ -287,6 +296,10 @@
// nacl was previous failing to reuse an address.
func TestListenCloseListen(t *testing.T) {
+ // TODO(NET-1266): disabled.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
const maxTries = 10
for tries := 0; tries < maxTries; tries++ {
ln, err := newLocalListener("tcp")
@@ -313,6 +326,10 @@
// See golang.org/issue/6163, golang.org/issue/6987.
func TestAcceptIgnoreAbortedConnRequest(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
switch runtime.GOOS {
case "plan9":
t.Skipf("%s does not have full support of socktest", runtime.GOOS)
@@ -460,6 +477,10 @@
// See golang.org/cl/30164 which documented this. The net/http package
// depends on this.
func TestReadTimeoutUnblocksRead(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
serverDone := make(chan struct{})
server := func(cs *TCPConn) error {
defer close(serverDone)
@@ -503,6 +524,10 @@
// Issue 17695: verify that a blocked Read is woken up by a Close.
func TestCloseUnblocksRead(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
t.Parallel()
server := func(cs *TCPConn) error {
// Give the client time to get stuck in a Read:
@@ -522,6 +547,10 @@
// Issue 24808: verify that ECONNRESET is not temporary for read.
func TestNotTemporaryRead(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
if runtime.GOOS == "freebsd" {
testenv.SkipFlaky(t, 25289)
}
diff --git a/src/net/nss.go b/src/net/nss.go
index 08c3e6a..3533ab0 100644
--- a/src/net/nss.go
+++ b/src/net/nss.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// +build darwin dragonfly freebsd linux netbsd openbsd solaris
+// +build darwin dragonfly freebsd fuchsia linux netbsd openbsd solaris
package net
diff --git a/src/net/packetconn_test.go b/src/net/packetconn_test.go
index a377d33..eafad0a 100644
--- a/src/net/packetconn_test.go
+++ b/src/net/packetconn_test.go
@@ -11,6 +11,7 @@
import (
"os"
+ "runtime"
"testing"
"time"
)
@@ -38,6 +39,10 @@
}
func TestPacketConn(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
closer := func(c PacketConn, net, addr1, addr2 string) {
c.Close()
switch net {
@@ -92,6 +97,10 @@
}
func TestConnAndPacketConn(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
closer := func(c PacketConn, net, addr1, addr2 string) {
c.Close()
switch net {
diff --git a/src/net/parse_test.go b/src/net/parse_test.go
index c5f8bfd..ffe4d12 100644
--- a/src/net/parse_test.go
+++ b/src/net/parse_test.go
@@ -14,7 +14,7 @@
func TestReadLine(t *testing.T) {
// /etc/services file does not exist on android, plan9, windows.
switch runtime.GOOS {
- case "android", "plan9", "windows":
+ case "android", "plan9", "windows", "fuchsia":
t.Skipf("not supported on %s", runtime.GOOS)
}
filename := "/etc/services" // a nice big file
diff --git a/src/net/platform_test.go b/src/net/platform_test.go
index 8e7d915..13b59df 100644
--- a/src/net/platform_test.go
+++ b/src/net/platform_test.go
@@ -33,7 +33,7 @@
}
case "unix", "unixgram":
switch runtime.GOOS {
- case "android", "nacl", "plan9", "windows":
+ case "android", "fuchsia", "nacl", "plan9", "windows":
return false
}
// iOS does not support unix, unixgram.
@@ -42,7 +42,7 @@
}
case "unixpacket":
switch runtime.GOOS {
- case "android", "darwin", "nacl", "plan9", "windows":
+ case "android", "darwin", "fuchsia", "nacl", "plan9", "windows":
return false
case "netbsd":
// It passes on amd64 at least. 386 fails (Issue 22927). arm is unknown.
diff --git a/src/net/port_fuchsia.go b/src/net/port_fuchsia.go
new file mode 100644
index 0000000..c8438b1
--- /dev/null
+++ b/src/net/port_fuchsia.go
@@ -0,0 +1,11 @@
+// Copyright 2017 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 net
+
+import "errors"
+
+func goLookupPort(network, service string) (port int, err error) {
+ return -1, errors.New("net: port lookup not supported yet on fuchsia")
+}
diff --git a/src/net/protoconn_test.go b/src/net/protoconn_test.go
index 9f6772c..266657f 100644
--- a/src/net/protoconn_test.go
+++ b/src/net/protoconn_test.go
@@ -23,6 +23,10 @@
// golang.org/x/net/icmp
func TestTCPListenerSpecificMethods(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
switch runtime.GOOS {
case "plan9":
t.Skipf("not supported on %s", runtime.GOOS)
@@ -115,6 +119,10 @@
}
func TestUDPConnSpecificMethods(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
la, err := ResolveUDPAddr("udp4", "127.0.0.1:0")
if err != nil {
t.Fatal(err)
@@ -164,6 +172,10 @@
}
func TestIPConnSpecificMethods(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
if os.Getuid() != 0 {
t.Skip("must be root")
}
@@ -203,6 +215,10 @@
}
func TestUnixListenerSpecificMethods(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
if !testableNetwork("unix") {
t.Skip("unix test")
}
@@ -244,6 +260,10 @@
}
func TestUnixConnSpecificMethods(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
if !testableNetwork("unixgram") {
t.Skip("unixgram test")
}
diff --git a/src/net/rawconn_stub_test.go b/src/net/rawconn_stub_test.go
index 0a033c1..9c18a62 100644
--- a/src/net/rawconn_stub_test.go
+++ b/src/net/rawconn_stub_test.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// +build js,wasm nacl plan9
+// +build fuchsia js,wasm nacl plan9
package net
diff --git a/src/net/rawconn_test.go b/src/net/rawconn_test.go
index 11900df..e01318d 100644
--- a/src/net/rawconn_test.go
+++ b/src/net/rawconn_test.go
@@ -15,7 +15,7 @@
func TestRawConnReadWrite(t *testing.T) {
switch runtime.GOOS {
- case "nacl", "plan9":
+ case "fuchsia", "nacl", "plan9":
t.Skipf("not supported on %s", runtime.GOOS)
}
@@ -175,7 +175,7 @@
func TestRawConnControl(t *testing.T) {
switch runtime.GOOS {
- case "nacl", "plan9":
+ case "fuchsia", "nacl", "plan9":
t.Skipf("not supported on %s", runtime.GOOS)
}
diff --git a/src/net/sendfile_test.go b/src/net/sendfile_test.go
index 3b98277..67d2a46 100644
--- a/src/net/sendfile_test.go
+++ b/src/net/sendfile_test.go
@@ -13,6 +13,7 @@
"fmt"
"io"
"os"
+ "runtime"
"testing"
)
@@ -23,6 +24,10 @@
)
func TestSendfile(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
ln, err := newLocalListener("tcp")
if err != nil {
t.Fatal(err)
@@ -93,6 +98,11 @@
}
func TestSendfileParts(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
+
ln, err := newLocalListener("tcp")
if err != nil {
t.Fatal(err)
@@ -151,6 +161,11 @@
}
func TestSendfileSeeked(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
+
ln, err := newLocalListener("tcp")
if err != nil {
t.Fatal(err)
diff --git a/src/net/server_test.go b/src/net/server_test.go
index 1608beb..4bec5ae 100644
--- a/src/net/server_test.go
+++ b/src/net/server_test.go
@@ -8,6 +8,7 @@
import (
"os"
+ "runtime"
"testing"
)
@@ -53,6 +54,10 @@
// TestTCPServer tests concurrent accept-read-write servers.
func TestTCPServer(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
const N = 3
for i, tt := range tcpServerTests {
@@ -137,6 +142,10 @@
// TestUnixAndUnixpacketServer tests concurrent accept-read-write
// servers
func TestUnixAndUnixpacketServer(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
const N = 3
for i, tt := range unixAndUnixpacketServerTests {
@@ -251,6 +260,10 @@
}
func TestUDPServer(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
for i, tt := range udpServerTests {
if !testableListenArgs(tt.snet, tt.saddr, tt.taddr) {
t.Logf("skipping %s test", tt.snet+" "+tt.saddr+"<-"+tt.taddr)
@@ -329,6 +342,10 @@
}
func TestUnixgramServer(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
for i, tt := range unixgramServerTests {
if !testableListenArgs("unixgram", tt.saddr, "") {
t.Logf("skipping %s test", "unixgram "+tt.saddr+"<-"+tt.caddr)
diff --git a/src/net/sock_stub.go b/src/net/sock_stub.go
index 38fc819..1a09ecf 100644
--- a/src/net/sock_stub.go
+++ b/src/net/sock_stub.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// +build nacl js,wasm solaris
+// +build nacl js,wasm solaris fuchsia
package net
diff --git a/src/net/sockopt_stub.go b/src/net/sockopt_stub.go
index bc06675..7240cac 100644
--- a/src/net/sockopt_stub.go
+++ b/src/net/sockopt_stub.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// +build nacl js,wasm
+// +build nacl js,wasm fuchsia
package net
diff --git a/src/net/tcpsock_fuchsia.go b/src/net/tcpsock_fuchsia.go
new file mode 100644
index 0000000..447e9a9
--- /dev/null
+++ b/src/net/tcpsock_fuchsia.go
@@ -0,0 +1,85 @@
+// Copyright 2016 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 net
+
+import (
+ "context"
+ "io"
+ "os"
+ "syscall"
+ "syscall/zx/mxnet"
+)
+
+func (a *TCPAddr) encode() ([]byte, error) { // TODO remove
+ b := make([]byte, mxnet.SockaddrLen)
+ _, err := mxnet.EncodeSockaddr(b, mxnet.Addr(a.IP), uint16(a.Port))
+ return b, err
+}
+
+func (a *TCPAddr) family() int {
+ if a == nil || len(a.IP) <= IPv4len {
+ return syscall.AF_INET
+ }
+ if a.IP.To4() != nil {
+ return syscall.AF_INET
+ }
+ return syscall.AF_INET6
+}
+
+func (a *TCPAddr) sockaddr(family int) (addr mxnet.Addr, port uint16, err error) {
+ if a == nil {
+ return "", 0, nil
+ }
+ return ipToSockaddr(family, a.IP, a.Port, a.Zone)
+}
+
+func (c *TCPConn) readFrom(r io.Reader) (int64, error) {
+ return genericReadFrom(c, r)
+}
+
+func (sd *sysDialer) dialTCP(ctx context.Context, laddr, raddr *TCPAddr) (*TCPConn, error) {
+ if testHookDialTCP != nil {
+ return testHookDialTCP(ctx, sd.network, laddr, raddr)
+ }
+ return sd.doDialTCP(ctx, laddr, raddr)
+}
+
+func (sd *sysDialer) doDialTCP(ctx context.Context, laddr, raddr *TCPAddr) (*TCPConn, error) {
+ switch sd.network {
+ case "tcp", "tcp4", "tcp6":
+ default:
+ return nil, UnknownNetworkError(sd.network)
+ }
+ if raddr == nil {
+ return nil, errMissingAddress
+ }
+ fd, err := dialFuchsia(ctx, sd.network, laddr, raddr)
+ if err != nil {
+ return nil, err
+ }
+ return newTCPConn(fd), nil
+}
+
+func (ln *TCPListener) ok() bool { return ln != nil && ln.fd != nil }
+
+func (ln *TCPListener) accept() (*TCPConn, error) {
+ fd, err := ln.fd.accept()
+ if err != nil {
+ return nil, err
+ }
+ return newTCPConn(fd), nil
+}
+
+func (ln *TCPListener) close() error { return ln.fd.Close() }
+
+func (ln *TCPListener) file() (*os.File, error) { return ln.fd.dup() }
+
+func (sl *sysListener) listenTCP(ctx context.Context, laddr *TCPAddr) (*TCPListener, error) {
+ fd, err := dialFuchsia(ctx, sl.network, laddr, nil)
+ if err != nil {
+ return nil, err
+ }
+ return &TCPListener{fd}, nil
+}
diff --git a/src/net/tcpsock_test.go b/src/net/tcpsock_test.go
index c2f26b1..e5bf8d8 100644
--- a/src/net/tcpsock_test.go
+++ b/src/net/tcpsock_test.go
@@ -328,6 +328,10 @@
}
func TestResolveTCPAddr(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
origTestHookLookupIP := testHookLookupIP
defer func() { testHookLookupIP = origTestHookLookupIP }()
testHookLookupIP = lookupLocalhost
@@ -428,6 +432,11 @@
}
func TestTCPConcurrentAccept(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
+
defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(4))
ln, err := Listen("tcp", "127.0.0.1:0")
if err != nil {
@@ -470,6 +479,10 @@
}
func TestTCPReadWriteAllocs(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
switch runtime.GOOS {
case "plan9":
// The implementation of asynchronous cancelable
@@ -543,6 +556,10 @@
}
func TestTCPStress(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
const conns = 2
const msgLen = 512
msgs := int(1e4)
@@ -625,6 +642,10 @@
}
func TestTCPSelfConnect(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
if runtime.GOOS == "windows" {
// TODO(brainman): do not know why it hangs.
t.Skip("known-broken test on windows")
@@ -674,6 +695,10 @@
// Test that >32-bit reads work on 64-bit systems.
// On 32-bit systems this tests that maxint reads work.
func TestTCPBig(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
if !*testTCPBig {
t.Skip("test disabled; use -tcpbig to enable")
}
@@ -727,6 +752,11 @@
}
func TestCopyPipeIntoTCP(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
+
ln, err := newLocalListener("tcp")
if err != nil {
t.Fatal(err)
diff --git a/src/net/tcpsock_unix_test.go b/src/net/tcpsock_unix_test.go
index 2bd591b..65d0a96 100644
--- a/src/net/tcpsock_unix_test.go
+++ b/src/net/tcpsock_unix_test.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// +build !js,!plan9,!windows
+// +build !fuchsia,!js,!plan9,!windows
package net
diff --git a/src/net/tcpsockopt_stub.go b/src/net/tcpsockopt_stub.go
index fd7f579..7e23c1f 100644
--- a/src/net/tcpsockopt_stub.go
+++ b/src/net/tcpsockopt_stub.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// +build nacl js,wasm
+// +build nacl js,wasm fuchsia
package net
diff --git a/src/net/timeout_test.go b/src/net/timeout_test.go
index 7c7d0c8..868890c 100644
--- a/src/net/timeout_test.go
+++ b/src/net/timeout_test.go
@@ -39,6 +39,10 @@
}
func TestDialTimeout(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
// Cannot use t.Parallel - modifies global hooks.
origTestHookDialChannel := testHookDialChannel
defer func() { testHookDialChannel = origTestHookDialChannel }()
@@ -46,7 +50,7 @@
for i, tt := range dialTimeoutTests {
switch runtime.GOOS {
- case "plan9", "windows":
+ case "plan9", "windows", "fuchsia":
testHookDialChannel = func() { time.Sleep(tt.guard) }
if runtime.GOOS == "plan9" {
break
@@ -102,9 +106,17 @@
}
func TestDialTimeoutMaxDuration(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
if runtime.GOOS == "openbsd" {
testenv.SkipFlaky(t, 15157)
}
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
ln, err := newLocalListener("tcp")
if err != nil {
@@ -154,6 +166,10 @@
}
func TestAcceptTimeout(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
testenv.SkipFlaky(t, 17948)
t.Parallel()
@@ -211,6 +227,10 @@
}
func TestAcceptTimeoutMustReturn(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
t.Parallel()
switch runtime.GOOS {
@@ -257,6 +277,10 @@
}
func TestAcceptTimeoutMustNotReturn(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
t.Parallel()
switch runtime.GOOS {
@@ -308,6 +332,10 @@
}
func TestReadTimeout(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
handler := func(ls *localServer, ln Listener) {
c, err := ln.Accept()
if err != nil {
@@ -362,6 +390,10 @@
}
func TestReadTimeoutMustNotReturn(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
t.Parallel()
switch runtime.GOOS {
@@ -432,6 +464,10 @@
}
func TestReadFromTimeout(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
switch runtime.GOOS {
case "nacl":
t.Skipf("not supported on %s", runtime.GOOS) // see golang.org/issue/8916
@@ -505,6 +541,10 @@
}
func TestWriteTimeout(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
t.Parallel()
ln, err := newLocalListener("tcp")
@@ -548,6 +588,10 @@
}
func TestWriteTimeoutMustNotReturn(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
t.Parallel()
switch runtime.GOOS {
@@ -619,6 +663,10 @@
}
func TestWriteToTimeout(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
t.Parallel()
switch runtime.GOOS {
@@ -672,6 +720,10 @@
}
func TestReadTimeoutFluctuation(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
t.Parallel()
ln, err := newLocalListener("tcp")
@@ -705,6 +757,10 @@
}
func TestReadFromTimeoutFluctuation(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
t.Parallel()
c1, err := newLocalPacketListener("udp")
@@ -738,6 +794,10 @@
}
func TestWriteTimeoutFluctuation(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
t.Parallel()
switch runtime.GOOS {
@@ -780,11 +840,19 @@
}
func TestVariousDeadlines(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
t.Parallel()
testVariousDeadlines(t)
}
func TestVariousDeadlines1Proc(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
// Cannot use t.Parallel - modifies global GOMAXPROCS.
if testing.Short() {
t.Skip("skipping in short mode")
@@ -794,6 +862,10 @@
}
func TestVariousDeadlines4Proc(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
// Cannot use t.Parallel - modifies global GOMAXPROCS.
if testing.Short() {
t.Skip("skipping in short mode")
@@ -925,6 +997,10 @@
// TestReadWriteProlongedTimeout tests concurrent deadline
// modification. Known to cause data races in the past.
func TestReadWriteProlongedTimeout(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
t.Parallel()
switch runtime.GOOS {
@@ -1005,6 +1081,10 @@
}
func TestReadWriteDeadlineRace(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
t.Parallel()
switch runtime.GOOS {
diff --git a/src/net/udpsock_fuchsia.go b/src/net/udpsock_fuchsia.go
new file mode 100644
index 0000000..b97e1ef
--- /dev/null
+++ b/src/net/udpsock_fuchsia.go
@@ -0,0 +1,92 @@
+// Copyright 2016 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 net
+
+import (
+ "context"
+ "syscall"
+ "syscall/zx/mxnet"
+)
+
+func (a *UDPAddr) encode() ([]byte, error) {
+ b := make([]byte, mxnet.SockaddrLen)
+ _, err := mxnet.EncodeSockaddr(b, mxnet.Addr(a.IP), uint16(a.Port))
+ return b, err
+}
+
+func (a *UDPAddr) family() int {
+ if a == nil || len(a.IP) <= IPv4len {
+ return syscall.AF_INET
+ }
+ if a.IP.To4() != nil {
+ return syscall.AF_INET
+ }
+ return syscall.AF_INET6
+}
+
+func (a *UDPAddr) sockaddr(family int) (addr mxnet.Addr, port uint16, err error) {
+ if a == nil {
+ return "", 0, nil
+ }
+ return ipToSockaddr(family, a.IP, a.Port, a.Zone)
+}
+
+func (c *UDPConn) readFrom(b []byte) (n int, addr *UDPAddr, err error) {
+ panic("TODO readFrom")
+}
+
+func (c *UDPConn) readMsg(b, oob []byte) (n, oobn, flags int, addr *UDPAddr, err error) {
+ n, flags, addrstr, port, err := c.fd.readMsg(b)
+ if err != nil {
+ return 0, 0, 0, nil, err
+ }
+ addr = &UDPAddr{
+ IP: IP(addrstr),
+ Port: int(port),
+ }
+ return n, 0, flags, addr, nil
+}
+
+func (c *UDPConn) writeTo(b []byte, addr *UDPAddr) (int, error) {
+ panic("TODO writeTo")
+}
+
+func (c *UDPConn) writeMsg(b, oob []byte, addr *UDPAddr) (n, oobn int, err error) {
+ if len(oob) > 0 {
+ return 0, 0, syscall.EFUCHSIA
+ }
+ n, err = c.fd.sendMsg(b, string(addr.IP), uint16(addr.Port))
+ return n, 0, err
+}
+
+func (sd *sysDialer) dialUDP(ctx context.Context, laddr, raddr *UDPAddr) (*UDPConn, error) {
+ switch sd.network {
+ case "udp", "udp4", "udp6":
+ default:
+ return nil, UnknownNetworkError(sd.network)
+ }
+ if raddr == nil {
+ return nil, errMissingAddress
+ }
+ var laddrif sockaddr
+ if laddr != nil {
+ laddrif = laddr
+ }
+ fd, err := dialFuchsia(ctx, sd.network, laddrif, raddr)
+ if err != nil {
+ return nil, err
+ }
+ return newUDPConn(fd), nil
+}
+
+const udpHeaderSize = 16*3 + 2*2
+
+func (sl *sysListener) listenUDP(ctx context.Context, laddr *UDPAddr) (*UDPConn, error) {
+ panic("TODO listenUDP")
+}
+
+func (sl *sysListener) listenMulticastUDP(ctx context.Context, ifi *Interface, gaddr *UDPAddr) (*UDPConn, error) {
+ return nil, syscall.EFUCHSIA
+}
diff --git a/src/net/udpsock_test.go b/src/net/udpsock_test.go
index 4940644..977b2a8 100644
--- a/src/net/udpsock_test.go
+++ b/src/net/udpsock_test.go
@@ -15,6 +15,10 @@
)
func BenchmarkUDP6LinkLocalUnicast(b *testing.B) {
+ if runtime.GOOS == "fuchsia" {
+ b.Skip("Fuchsia doesn't implement UDP")
+ }
+
testHookUninstaller.Do(uninstallTestHooks)
if !supportsIPv6() {
@@ -88,6 +92,10 @@
}
func TestResolveUDPAddr(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
origTestHookLookupIP := testHookLookupIP
defer func() { testHookLookupIP = origTestHookLookupIP }()
testHookLookupIP = lookupLocalhost
@@ -108,6 +116,10 @@
}
func TestWriteToUDP(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
switch runtime.GOOS {
case "plan9":
t.Skipf("not supported on %s", runtime.GOOS)
@@ -124,6 +136,10 @@
}
func testWriteToConn(t *testing.T, raddr string) {
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("Fuchsia doesn't implement UDP")
+ }
+
c, err := Dial("udp", raddr)
if err != nil {
t.Fatal(err)
@@ -173,6 +189,10 @@
}
func testWriteToPacketConn(t *testing.T, raddr string) {
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("Fuchsia doesn't implement UDP")
+ }
+
c, err := ListenPacket("udp", "127.0.0.1:0")
if err != nil {
t.Fatal(err)
@@ -241,6 +261,10 @@
}
func TestUDPConnLocalAndRemoteNames(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
for _, laddr := range []string{"", "127.0.0.1:0"} {
c1, err := ListenPacket("udp", "127.0.0.1:0")
if err != nil {
@@ -334,6 +358,10 @@
}
func TestUDPZeroBytePayload(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
switch runtime.GOOS {
case "nacl", "plan9":
t.Skipf("not supported on %s", runtime.GOOS)
@@ -371,6 +399,10 @@
}
func TestUDPZeroByteBuffer(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
switch runtime.GOOS {
case "nacl", "plan9":
t.Skipf("not supported on %s", runtime.GOOS)
@@ -409,7 +441,7 @@
func TestUDPReadSizeError(t *testing.T) {
switch runtime.GOOS {
- case "nacl", "plan9":
+ case "fuchsia", "nacl", "plan9":
t.Skipf("not supported on %s", runtime.GOOS)
}
diff --git a/src/net/unixsock_fuchsia.go b/src/net/unixsock_fuchsia.go
new file mode 100644
index 0000000..1ed9304
--- /dev/null
+++ b/src/net/unixsock_fuchsia.go
@@ -0,0 +1,51 @@
+// Copyright 2016 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 net
+
+import (
+ "context"
+ "os"
+ "syscall"
+)
+
+func (c *UnixConn) readFrom(b []byte) (int, *UnixAddr, error) {
+ return 0, nil, syscall.EFUCHSIA
+}
+
+func (c *UnixConn) readMsg(b, oob []byte) (n, oobn, flags int, addr *UnixAddr, err error) {
+ return 0, 0, 0, nil, syscall.EFUCHSIA
+}
+
+func (c *UnixConn) writeTo(b []byte, addr *UnixAddr) (int, error) {
+ return 0, syscall.EFUCHSIA
+}
+
+func (c *UnixConn) writeMsg(b, oob []byte, addr *UnixAddr) (n, oobn int, err error) {
+ return 0, 0, syscall.EFUCHSIA
+}
+
+func (sd *sysDialer) dialUnix(ctx context.Context, laddr, raddr *UnixAddr) (*UnixConn, error) {
+ return nil, syscall.EFUCHSIA
+}
+
+func (ln *UnixListener) accept() (*UnixConn, error) {
+ return nil, syscall.EFUCHSIA
+}
+
+func (ln *UnixListener) close() error {
+ return syscall.EFUCHSIA
+}
+
+func (ln *UnixListener) file() (*os.File, error) {
+ return nil, syscall.EFUCHSIA
+}
+
+func (sl *sysListener) listenUnix(ctx context.Context, laddr *UnixAddr) (*UnixListener, error) {
+ return nil, syscall.EFUCHSIA
+}
+
+func (sl *sysListener) listenUnixgram(ctx context.Context, laddr *UnixAddr) (*UnixConn, error) {
+ return nil, syscall.EFUCHSIA
+}
diff --git a/src/net/unixsock_test.go b/src/net/unixsock_test.go
index 4828990..b725be5 100644
--- a/src/net/unixsock_test.go
+++ b/src/net/unixsock_test.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// +build !js,!nacl,!plan9,!windows
+// +build !js,!nacl,!plan9,!windows,!fuchsia
package net
diff --git a/src/net/writev_test.go b/src/net/writev_test.go
index c43be84..933c826 100644
--- a/src/net/writev_test.go
+++ b/src/net/writev_test.go
@@ -19,6 +19,10 @@
)
func TestBuffers_read(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
const story = "once upon a time in Gopherland ... "
buffers := Buffers{
[]byte("once "),
@@ -41,6 +45,10 @@
}
func TestBuffers_consume(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
tests := []struct {
in Buffers
consume int64
@@ -92,6 +100,10 @@
}
func TestBuffers_WriteTo(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
for _, name := range []string{"WriteTo", "Copy"} {
for _, size := range []int{0, 10, 1023, 1024, 1025} {
t.Run(fmt.Sprintf("%s/%d", name, size), func(t *testing.T) {
@@ -183,6 +195,10 @@
}
func TestWritevError(t *testing.T) {
+ // TODO(TC-149): disabled without further triage. Needs work.
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("network test disabled for GOOS=fuchsia")
+ }
if runtime.GOOS == "windows" {
t.Skipf("skipping the test: windows does not have problem sending large chunks of data")
}
diff --git a/src/os/dir_unix.go b/src/os/dir_unix.go
index 79d61c7..604f0c2 100644
--- a/src/os/dir_unix.go
+++ b/src/os/dir_unix.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// +build darwin dragonfly freebsd js,wasm linux nacl netbsd openbsd solaris
+// +build darwin dragonfly freebsd fuchsia js,wasm linux nacl netbsd openbsd solaris
package os
diff --git a/src/os/error_fuchsia.go b/src/os/error_fuchsia.go
new file mode 100644
index 0000000..2572f7e
--- /dev/null
+++ b/src/os/error_fuchsia.go
@@ -0,0 +1,50 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build fuchsia
+
+package os
+
+import (
+ "syscall"
+ "syscall/zx"
+)
+
+func isExist(err error) bool {
+ err = underlyingError(err)
+ switch err := err.(type) {
+ case zx.Error:
+ return err.Status == zx.ErrAlreadyExists
+ }
+ return err == syscall.EEXIST || err == syscall.ENOTEMPTY || err == ErrExist
+}
+
+func isNotExist(err error) bool {
+ err = underlyingError(err)
+ switch err := err.(type) {
+ case zx.Error:
+ return err.Status == zx.ErrNotFound
+ }
+ return err == syscall.ENOENT || err == ErrNotExist
+}
+
+func isPermission(err error) bool {
+ err = underlyingError(err)
+ switch err := err.(type) {
+ case zx.Error:
+ return err.Status == zx.ErrAccessDenied
+ }
+ return err == syscall.EACCES || err == syscall.EPERM || err == ErrPermission
+}
+
+func wrapSyscallError(name string, err error) error {
+ if zerr, ok := err.(zx.Error); ok {
+ text := name
+ if zerr.Text != "" {
+ text = text + ": " + zerr.Text
+ }
+ err = zx.Error{Status: zerr.Status, Text: zerr.Text}
+ }
+ return err
+}
diff --git a/src/os/exec/exec_test.go b/src/os/exec/exec_test.go
index 7bb2308..aad9500 100644
--- a/src/os/exec/exec_test.go
+++ b/src/os/exec/exec_test.go
@@ -537,7 +537,7 @@
func TestExtraFiles(t *testing.T) {
testenv.MustHaveExec(t)
- if runtime.GOOS == "windows" {
+ if runtime.GOOS == "windows" || runtime.GOOS == "fuchsia" {
t.Skipf("skipping test on %q", runtime.GOOS)
}
@@ -612,7 +612,7 @@
}
func TestExtraFilesRace(t *testing.T) {
- if runtime.GOOS == "windows" {
+ if runtime.GOOS == "windows" || runtime.GOOS == "fuchsia" {
t.Skip("no operating system support; skipping")
}
listen := func() net.Listener {
diff --git a/src/os/exec/lp_unix.go b/src/os/exec/lp_unix.go
index e098ff8..97b5b72 100644
--- a/src/os/exec/lp_unix.go
+++ b/src/os/exec/lp_unix.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// +build darwin dragonfly freebsd linux nacl netbsd openbsd solaris
+// +build darwin dragonfly freebsd fuchsia linux nacl netbsd openbsd solaris
package exec
diff --git a/src/os/exec_fuchsia.go b/src/os/exec_fuchsia.go
new file mode 100644
index 0000000..87d6020
--- /dev/null
+++ b/src/os/exec_fuchsia.go
@@ -0,0 +1,83 @@
+// Copyright 2016 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
+
+import (
+ "errors"
+ "syscall/zx"
+ "time"
+)
+
+type ProcessState struct {
+ retCode int
+}
+
+func (p *ProcessState) exited() bool {
+ panic("TODO os.Exited")
+}
+
+func (p *ProcessState) Pid() int {
+ panic("TODO os.Pid")
+}
+
+func (p *ProcessState) String() string {
+ if p == nil {
+ return "<nil>"
+ }
+ return "exit status " + itoa(p.retCode)
+}
+
+func (p *ProcessState) success() bool {
+ return p.retCode == 0
+}
+
+func (p *ProcessState) sys() interface{} {
+ panic("TODO os.sys")
+}
+
+func (p *ProcessState) sysUsage() interface{} {
+ panic("TODO os.sysUsage")
+}
+
+func (p *ProcessState) systemTime() time.Duration {
+ panic("TODO os.systemTime")
+}
+
+func (p *ProcessState) userTime() time.Duration {
+ panic("TODO os.userTime")
+}
+
+func (p *Process) release() error {
+ procHandle := zx.Handle(p.handle)
+ return procHandle.Close()
+}
+
+func (p *Process) signal(sig Signal) error {
+ panic("TODO os.Process.signal")
+}
+
+func findProcess(pid int) (p *Process, err error) {
+ panic("TODO os.findProcess")
+}
+
+func startProcess(name string, argv []string, attr *ProcAttr) (p *Process, err error) {
+ h, err := fdioStartProcess(name, argv, attr)
+ if err != nil {
+ return nil, err
+ }
+ pid := 1 // TODO: what does this even mean for us?
+ return newProcess(pid, uintptr(h)), nil
+}
+
+func hostname() (name string, err error) {
+ return "", errors.New("os.hostname unimplemented")
+}
+
+type signal string
+
+func (s signal) String() string { return string(s) }
+func (s signal) Signal() {}
+
+var Interrupt = signal("signal_interrupt")
diff --git a/src/os/exec_fuchsia_cgo.go b/src/os/exec_fuchsia_cgo.go
new file mode 100644
index 0000000..7297daa
--- /dev/null
+++ b/src/os/exec_fuchsia_cgo.go
@@ -0,0 +1,206 @@
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build fuchsia
+
+package os
+
+// #cgo fuchsia CFLAGS: -I${SRCDIR}/../../../../../zircon/system/ulib/fdio/include
+// #cgo fuchsia LDFLAGS: -lfdio
+//
+// #include <zircon/syscalls/object.h>
+// #include <zircon/types.h>
+// #include <lib/fdio/spawn.h>
+// #include <lib/fdio/util.h>
+// #include <stdlib.h>
+//
+// static int fsa_get_local_fd(fdio_spawn_action_t *fsa) { return fsa->fd.local_fd; }
+// static int fsa_get_target_fd(fdio_spawn_action_t *fsa) { return fsa->fd.target_fd; }
+//
+// static void fsa_set_local_fd(fdio_spawn_action_t *fsa, int fd) { fsa->fd.local_fd = fd; }
+// static void fsa_set_target_fd(fdio_spawn_action_t *fsa, int fd) { fsa->fd.target_fd = fd; }
+import "C"
+
+import (
+ "errors"
+ "strings"
+ "syscall"
+ "syscall/zx"
+ "syscall/zx/fdio"
+ "syscall/zx/zxwait"
+ "unsafe"
+)
+
+func makeCStringArray(s []string) []*C.char {
+ ret := make([]*C.char, len(s)+1)
+ for i, s := range s {
+ ret[i] = (*C.char)(C.CString(s))
+ }
+ ret[len(ret)-1] = nil
+ return ret
+}
+
+func freeCStringArray(a []*C.char) {
+ for i := range a {
+ if a[i] != nil {
+ C.free(unsafe.Pointer(a[i]))
+ }
+ }
+}
+
+// asLibfdioFD returns a File as a libfdio file descriptor.
+func asLibfdioFD(f *File) (int, error) {
+ m := syscall.FDIOForFD(int(f.Fd()))
+ if m == nil {
+ return -1, ErrInvalid
+ }
+
+ var fdioType C.uint32_t
+ switch m.(type) {
+ case *fdio.Object, *fdio.Node, *fdio.File, *fdio.Directory:
+ fdioType = fdio.HandleTypeRemote
+ case *fdio.Pipe:
+ fdioType = fdio.HandleTypePipe
+ case *fdio.Logger:
+ fdioType = fdio.HandleTypeLogger
+ default:
+ return -1, ErrInvalid
+ }
+
+ mCopy, err := m.Clone()
+ if err != nil {
+ return -1, err
+ }
+ handles := mCopy.Handles()
+
+ var handlesC [fdio.MaxUnderlyingHandles]C.zx_handle_t
+ var typesC [fdio.MaxUnderlyingHandles]C.uint32_t
+ for i, h := range handles {
+ handlesC[i] = C.zx_handle_t(h)
+ typesC[i] = C.uint32_t(fdioType)
+ }
+
+ var fd C.int
+ status := zx.Status(C.fdio_create_fd(&handlesC[0], &typesC[0], C.size_t(len(handles)), &fd))
+ if status != zx.ErrOk {
+ mCopy.Close()
+ return -1, errors.New("fdio_create_fd failed")
+ }
+ return int(fd), nil
+}
+
+func fdioSpawnActions(attr *ProcAttr) (actions []C.fdio_spawn_action_t, err error) {
+ defer func() {
+ if err != nil {
+ for _, action := range actions {
+ C.close(C.fsa_get_local_fd(&action))
+ }
+ }
+ }()
+
+ for i, f := range attr.Files {
+ if f == nil {
+ continue
+ }
+ fd, err := asLibfdioFD(f)
+ if err != nil {
+ return nil, err
+ }
+ action := C.fdio_spawn_action_t{action: C.FDIO_SPAWN_ACTION_TRANSFER_FD}
+ C.fsa_set_local_fd(&action, C.int(fd))
+ C.fsa_set_target_fd(&action, C.int(i))
+ actions = append(actions, action)
+ }
+
+ return actions, nil
+}
+
+func fdioStartProcess(name string, argv []string, attr *ProcAttr) (zx.Handle, error) {
+ env := attr.Env
+ if env == nil {
+ env = Environ()
+ }
+ if attr.Dir != "" {
+ found := false
+ for i, s := range env {
+ if strings.HasPrefix(s, "PWD=") {
+ found = true
+ env[i] = "PWD=" + attr.Dir
+ break
+ }
+ }
+ if !found {
+ env = append(env, "PWD="+attr.Dir)
+ }
+ }
+
+ nameC := C.CString(name)
+ defer C.free(unsafe.Pointer(nameC))
+ argvC := makeCStringArray(argv)
+ defer freeCStringArray(argvC)
+ envC := makeCStringArray(env)
+ defer freeCStringArray(envC)
+
+ actions, err := fdioSpawnActions(attr)
+ if err != nil {
+ return 0, err
+ }
+
+ var actions0 *C.fdio_spawn_action_t
+ if len(actions) > 0 {
+ actions0 = &actions[0]
+ }
+
+ var h C.zx_handle_t
+ var errmsg [C.FDIO_SPAWN_ERR_MSG_MAX_LENGTH]C.char
+ status := zx.Status(C.fdio_spawn_etc(
+ C.ZX_HANDLE_INVALID,
+ C.FDIO_SPAWN_CLONE_JOB | C.FDIO_SPAWN_CLONE_LDSVC | C.FDIO_SPAWN_CLONE_NAMESPACE, // TODO(mdempsky): Flags.
+ nameC,
+ &argvC[0],
+ &envC[0],
+ C.size_t(len(actions)),
+ actions0,
+ &h,
+ &errmsg[0],
+ ))
+ if status != zx.ErrOk {
+ return 0, errors.New("fdio_spawn_etc: " + itoa(int(status)) + ": " + charsAsString(errmsg[:]))
+ }
+ return zx.Handle(h), nil
+}
+
+func charsAsString(s []C.char) string {
+ var x []byte
+ for _, c := range s {
+ if c == 0 {
+ break
+ }
+ x = append(x, byte(c))
+ }
+ return string(x)
+}
+
+func (p *Process) kill() error {
+ procHandle := zx.Handle(p.handle)
+ status := zx.Sys_task_kill(procHandle)
+ if status != zx.ErrOk {
+ return errors.New("kill error: " + itoa(int(status)))
+ }
+ return nil
+}
+
+func (p *Process) wait() (ps *ProcessState, err error) {
+ procHandle := zx.Handle(p.handle)
+ _, err = zxwait.Wait(procHandle, zx.SignalTaskTerminated, zx.TimensecInfinite)
+ if err != nil {
+ return nil, err
+ }
+ procInfo := C.zx_info_process_t{}
+ status := zx.Sys_object_get_info(procHandle, zx.ObjectInfoProcess, unsafe.Pointer(&procInfo), C.sizeof_zx_info_process_t, nil, nil)
+ if status != zx.ErrOk {
+ return nil, errors.New("error retreiving process info: " + itoa(int(status)))
+ }
+ return &ProcessState{int(procInfo.return_code)}, nil
+}
diff --git a/src/os/executable_procfs.go b/src/os/executable_procfs.go
index 5bb63b9..3c35f23 100644
--- a/src/os/executable_procfs.go
+++ b/src/os/executable_procfs.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// +build linux netbsd dragonfly nacl js,wasm
+// +build linux netbsd dragonfly nacl js,wasm fuchsia
package os
diff --git a/src/os/executable_test.go b/src/os/executable_test.go
index 4a9a883..125d1a3 100644
--- a/src/os/executable_test.go
+++ b/src/os/executable_test.go
@@ -20,6 +20,9 @@
testenv.MustHaveExec(t) // will also exclude nacl, which doesn't support Executable anyway
ep, err := os.Executable()
if err != nil {
+ if runtime.GOOS == "fuchsia" {
+ t.Skipf("Executable failed on %s: %v, expected", runtime.GOOS, err) // TODO(dhobsd): rebase
+ }
t.Fatalf("Executable failed: %v", err)
}
// we want fn to be of the form "dir/prog"
diff --git a/src/os/file_fuchsia.go b/src/os/file_fuchsia.go
new file mode 100644
index 0000000..31ff6af
--- /dev/null
+++ b/src/os/file_fuchsia.go
@@ -0,0 +1,152 @@
+// Copyright 2016 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
+
+import (
+ "errors"
+ "internal/poll"
+ "syscall"
+ "syscall/zx/fdio"
+ "time"
+)
+
+func (f *File) Truncate(size int64) error {
+ if err := f.checkValid("truncate"); err != nil {
+ return err
+ }
+ return syscall.Ftruncate(f.pfd.Sysfd, size)
+}
+
+func (f *File) Sync() error {
+ if f == nil {
+ return ErrInvalid
+ }
+ return syscall.Fsync(f.pfd.Sysfd)
+}
+
+func syscallMode(i FileMode) (o uint32) {
+ o |= uint32(i.Perm())
+ // TODO i&ModeSetuid != 0
+ // TODO i&ModeSetgid != 0
+ // TODO i&ModeSticky != 0
+ return o
+}
+
+func (f *File) chmod(mode FileMode) error {
+ return errors.New("os: Chmod unimplemented on fuchsia")
+}
+
+func (f *File) Chown(uid, gid int) error {
+ return errors.New("os: Chown unimplemented on fuchsia")
+}
+
+func chmod(name string, mode FileMode) error {
+ return errors.New("os: chmod unimplemented on fuchsia")
+}
+
+func Chown(name string, uid, gid int) error {
+ return errors.New("os: Chown unimplemented on fuchsia")
+}
+
+func Chtimes(name string, atime time.Time, mtime time.Time) error {
+ var utimes [2]syscall.Timespec
+ utimes[0] = syscall.NsecToTimespec(atime.UnixNano())
+ utimes[1] = syscall.NsecToTimespec(mtime.UnixNano())
+ if e := syscall.UtimesNano(fixLongPath(name), utimes[0:]); e != nil {
+ return &PathError{"chtimes", name, e}
+ }
+ return nil
+}
+
+func Readlink(name string) (string, error) {
+ return "", errors.New("Readlink unimplemented")
+}
+
+func Pipe() (r *File, w *File, err error) {
+ p0, p1, err := fdio.NewPipes()
+ if err != nil {
+ return nil, nil, err
+ }
+ r = NewFile(uintptr(syscall.OpenFDIO(p0)), "|0")
+ w = NewFile(uintptr(syscall.OpenFDIO(p1)), "|1")
+ // TODO CloseOnExec equivalent
+ return r, w, nil
+}
+
+// Chdir changes the current working directory to the file,
+// which must be a directory.
+// If there is an error, it will be of type *PathError.
+func (f *File) Chdir() error {
+ if err := f.checkValid("chdir"); err != nil {
+ return err
+ }
+ if e := syscall.Fchdir(f.pfd.Sysfd); e != nil {
+ return &PathError{"chdir", f.name, e}
+ }
+ return nil
+}
+
+func sigpipe() // implemented in package runtime
+
+var supportsCloseOnExec = true
+
+func fillFileStatFromSys(fs *fileStat, name string) {
+ fs.name = basename(name)
+ fs.size = int64(fs.sys.Size)
+ // For now, pretend files have all bits. This should really be:
+ // fs.mode = FileMode(fs.sys.Dev & 0777)
+ // but we don't really set file modes properly and testing for executables
+ // in $PATH fails without the x bit set.
+ fs.mode = FileMode(0766)
+
+ switch fs.sys.Dev & 0xf000 {
+ case 0x4000:
+ fs.mode = fs.mode | ModeDir
+ case 0x2000:
+ fs.mode = fs.mode | ModeCharDevice
+ case 0xa000:
+ fs.mode = fs.mode | ModeSymlink
+ case 0xc000:
+ fs.mode = fs.mode | ModeSocket
+ }
+ fs.modTime = time.Unix(int64(fs.sys.ModifyTime), 0)
+}
+
+func atime(fi FileInfo) time.Time {
+ // TODO: fdio doesn't have atime yet
+ return time.Time{}
+}
+
+// setDeadline sets the read and write deadline.
+func (f *File) setDeadline(time.Time) error {
+ if err := f.checkValid("SetDeadline"); err != nil {
+ return err
+ }
+ return poll.ErrNoDeadline
+}
+
+// setReadDeadline sets the read deadline.
+func (f *File) setReadDeadline(time.Time) error {
+ if err := f.checkValid("SetReadDeadline"); err != nil {
+ return err
+ }
+ return poll.ErrNoDeadline
+}
+
+// setWriteDeadline sets the write deadline.
+func (f *File) setWriteDeadline(time.Time) error {
+ if err := f.checkValid("SetWriteDeadline"); err != nil {
+ return err
+ }
+ return poll.ErrNoDeadline
+}
+
+// checkValid checks whether f is valid for use.
+func (f *File) checkValid(op string) error {
+ if f == nil {
+ return ErrInvalid
+ }
+ return nil
+}
diff --git a/src/os/file_unix.go b/src/os/file_unix.go
index cb90b70..9451be1 100644
--- a/src/os/file_unix.go
+++ b/src/os/file_unix.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// +build darwin dragonfly freebsd js,wasm linux nacl netbsd openbsd solaris
+// +build darwin dragonfly freebsd fuchsia js,wasm linux nacl netbsd openbsd solaris
package os
diff --git a/src/os/getwd.go b/src/os/getwd.go
index 6d25466..39a4fd2 100644
--- a/src/os/getwd.go
+++ b/src/os/getwd.go
@@ -24,7 +24,7 @@
// reached via multiple paths (due to symbolic links),
// Getwd may return any one of them.
func Getwd() (dir string, err error) {
- if runtime.GOOS == "windows" || runtime.GOOS == "plan9" {
+ if runtime.GOOS == "windows" || runtime.GOOS == "plan9" || runtime.GOOS == "fuchsia" {
return syscall.Getwd()
}
diff --git a/src/os/os_test.go b/src/os/os_test.go
index 894105a..459b90e 100644
--- a/src/os/os_test.go
+++ b/src/os/os_test.go
@@ -26,15 +26,45 @@
"time"
)
-var dot = []string{
- "dir_unix.go",
- "env.go",
- "error.go",
- "file.go",
- "os_test.go",
- "types.go",
- "stat_darwin.go",
- "stat_linux.go",
+var dot = func() []string {
+ switch runtime.GOOS {
+ case "fuchsia":
+ return []string{
+ "go_os_test_foo",
+ "go_os_test_bar",
+ "go_os_test_baz",
+ }
+ default:
+ return []string{
+ "dir_unix.go",
+ "env.go",
+ "error.go",
+ "file.go",
+ "os_test.go",
+ "types.go",
+ "stat_darwin.go",
+ "stat_linux.go",
+ }
+ }
+}()
+
+func init() { flag.CommandLine.Set("test.v", "true") }
+
+func tmpInit(t *testing.T) {
+ if runtime.GOOS == "fuchsia" {
+ dir, err := ioutil.TempDir("", "")
+ if err != nil {
+ t.Fatalf("tempdir: %v", err)
+ }
+ for _, fname := range dot {
+ if err := MkdirAll(filepath.Join(dir, fname), ModePerm); err != nil {
+ t.Fatalf("Initializing tmp: %v", err)
+ }
+ }
+ if err := Chdir(dir); err != nil {
+ t.Fatalf("chdir: %v", err)
+ }
+ }
}
type sysDir struct {
@@ -44,6 +74,14 @@
var sysdir = func() *sysDir {
switch runtime.GOOS {
+ case "fuchsia":
+ return &sysDir{
+ "/boot/lib",
+ []string{
+ "libfdio.so",
+ "ld.so.1",
+ },
+ }
case "android":
return &sysDir{
"/system/lib",
@@ -175,6 +213,9 @@
}
func TestStatError(t *testing.T) {
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("TODO(dhobsd): fix")
+ }
defer chtmpdir(t)()
path := "no-such-file"
@@ -347,11 +388,13 @@
}
func TestReaddirnames(t *testing.T) {
+ tmpInit(t)
testReaddirnames(".", dot, t)
testReaddirnames(sysdir.name, sysdir.files, t)
}
func TestReaddir(t *testing.T) {
+ tmpInit(t)
testReaddir(".", dot, t)
testReaddir(sysdir.name, sysdir.files, t)
}
@@ -469,6 +512,8 @@
// big directory that doesn't change often.
dir := "/usr/bin"
switch runtime.GOOS {
+ case "fuchsia":
+ dir = "/boot/bin"
case "android":
dir = "/system/bin"
case "darwin":
@@ -1030,6 +1075,8 @@
switch runtime.GOOS {
case "android":
t.Skip("android doesn't have /bin/pwd")
+ case "fuchsia":
+ t.Skip("fuchsia doesn't have /bin/pwd")
case "windows":
cmd = Getenv("COMSPEC")
dir = Getenv("SystemRoot")
@@ -1063,8 +1110,8 @@
}
func TestChmod(t *testing.T) {
- // Chmod is not supported under windows.
- if runtime.GOOS == "windows" {
+ // Chmod is not supported under windows or Fuchsia
+ if runtime.GOOS == "windows" || runtime.GOOS == "fuchsia" {
return
}
f := newFile("TestChmod", t)
@@ -1137,6 +1184,11 @@
// On NFS, timings can be off due to caching of meta-data on
// NFS servers (Issue 848).
func TestChtimes(t *testing.T) {
+ if runtime.GOOS == "fuchsia" {
+ // It passes sometimes, but seems to be flakey
+ t.Skipf("TODO(smklein): Implement")
+ }
+
f := newFile("TestChtimes", t)
defer Remove(f.Name())
@@ -1151,6 +1203,11 @@
// On NFS, timings can be off due to caching of meta-data on
// NFS servers (Issue 848).
func TestChtimesDir(t *testing.T) {
+ if runtime.GOOS == "fuchsia" {
+ // It passes sometimes, but seems to be flakey
+ t.Skipf("TODO(smklein): Implement")
+ }
+
name := newDir("TestChtimes", t)
defer RemoveAll(name)
@@ -1182,7 +1239,7 @@
pmt := postStat.ModTime()
if !pat.Before(at) {
switch runtime.GOOS {
- case "plan9", "nacl":
+ case "plan9", "nacl", "fuchsia":
// Ignore.
// Plan 9, NaCl:
// Mtime is the time of the last change of
@@ -1208,7 +1265,7 @@
func TestChdirAndGetwd(t *testing.T) {
// TODO(brainman): file.Chdir() is not implemented on windows.
- if runtime.GOOS == "windows" {
+ if runtime.GOOS == "windows" || runtime.GOOS == "fuchsia" {
return
}
fd, err := Open(".")
@@ -1439,6 +1496,10 @@
}
func TestOpenError(t *testing.T) {
+ if runtime.GOOS == "fuchsia" {
+ t.Skipf("TODO(smklein): Implement")
+ }
+
for _, tt := range openErrorTests {
f, err := OpenFile(tt.path, tt.mode, 0)
if err == nil {
@@ -1536,6 +1597,10 @@
}
func TestHostname(t *testing.T) {
+ if runtime.GOOS == "fuchsia" {
+ t.Skipf("TODO(dho): Implement")
+ }
+
hostname, err := Hostname()
if err != nil {
t.Fatal(err)
@@ -1760,6 +1825,10 @@
}
func TestSameFile(t *testing.T) {
+ if runtime.GOOS == "fuchsia" {
+ t.Skipf("TODO(smklein): Implement")
+ }
+
defer chtmpdir(t)()
fa, err := Create("a")
if err != nil {
@@ -1810,13 +1879,13 @@
if fi.Size() != 0 {
t.Errorf(pre+"wrong file size have %d want 0", fi.Size())
}
- if fi.Mode()&ModeDevice == 0 {
+ if fi.Mode()&ModeDevice == 0 && runtime.GOOS != "fuchsia" {
t.Errorf(pre+"wrong file mode %q: ModeDevice is not set", fi.Mode())
}
if fi.Mode()&ModeCharDevice == 0 {
t.Errorf(pre+"wrong file mode %q: ModeCharDevice is not set", fi.Mode())
}
- if fi.Mode().IsRegular() {
+ if fi.Mode().IsRegular() && runtime.GOOS != "fuchsia" {
t.Errorf(pre+"wrong file mode %q: IsRegular returns true", fi.Mode())
}
}
@@ -1873,6 +1942,10 @@
}
func TestStatDirModeExec(t *testing.T) {
+ if runtime.GOOS == "fuchsia" {
+ t.Skipf("TODO(smklein): Implement")
+ }
+
const mode = 0111
path, err := ioutil.TempDir("", "go-build")
@@ -1896,7 +1969,8 @@
func TestStatStdin(t *testing.T) {
switch runtime.GOOS {
- case "android", "plan9":
+ case "android", "plan9", "fuchsia":
+ // TODO(smklein): Implement on Fuchsia
t.Skipf("%s doesn't have /bin/sh", runtime.GOOS)
}
@@ -2012,6 +2086,10 @@
}
func TestLongPath(t *testing.T) {
+ if runtime.GOOS == "fuchsia" {
+ t.Skipf("no chmod support on fuchsia")
+ }
+
tmpdir := newDir("TestLongPath", t)
defer func(d string) {
if err := RemoveAll(d); err != nil {
@@ -2068,9 +2146,11 @@
if dir.Size() != filesize || filesize != wantSize {
t.Errorf("Size(%q) is %d, len(ReadFile()) is %d, want %d", path, dir.Size(), filesize, wantSize)
}
- err = Chmod(path, dir.Mode())
- if err != nil {
- t.Fatalf("Chmod(%q) failed: %v", path, err)
+ if testenv.HasChmod() {
+ err = Chmod(path, dir.Mode())
+ if err != nil {
+ t.Fatalf("Chmod(%q) failed: %v", path, err)
+ }
}
}
if err := Truncate(sizedTempDir+"/bar.txt", 0); err != nil {
@@ -2123,6 +2203,9 @@
// TODO: golang.org/issue/8206
t.Skipf("skipping test on plan9; see issue 8206")
}
+ if runtime.GOOS == "fuchsia" {
+ t.Skipf("TODO(smklein): Implement")
+ }
testenv.MustHaveExec(t)
@@ -2148,6 +2231,10 @@
}
func TestKillFindProcess(t *testing.T) {
+ if runtime.GOOS == "fuchsia" {
+ t.Skipf("TODO(smklein): Implement")
+ }
+
testKillProcess(t, func(p *Process) {
p2, err := FindProcess(p.Pid)
if err != nil {
@@ -2183,6 +2270,10 @@
// Test that all File methods give ErrInvalid if the receiver is nil.
func TestNilFileMethods(t *testing.T) {
+ if runtime.GOOS == "fuchsia" {
+ t.Skipf("TODO(smklein): Implement")
+ }
+
for _, tt := range nilFileMethodTests {
var file *File
got := tt.f(file)
@@ -2254,6 +2345,8 @@
t.Skip("skipping on Plan 9; does not support runtime poller")
case "js":
t.Skip("skipping on js; no support for os.Pipe")
+ case "fuchsia":
+ t.Skip("skipping on fuchsia; TODO")
}
threads := 100
diff --git a/src/os/path_test.go b/src/os/path_test.go
index f58c7e7..9ab3f14 100644
--- a/src/os/path_test.go
+++ b/src/os/path_test.go
@@ -230,7 +230,7 @@
func TestMkdirAllAtSlash(t *testing.T) {
switch runtime.GOOS {
- case "android", "plan9", "windows":
+ case "android", "fuchsia", "plan9", "windows":
t.Skipf("skipping on %s", runtime.GOOS)
case "darwin":
switch runtime.GOARCH {
diff --git a/src/os/path_unix.go b/src/os/path_unix.go
index b2e0bca..9d81f61 100644
--- a/src/os/path_unix.go
+++ b/src/os/path_unix.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// +build darwin dragonfly freebsd js,wasm linux nacl netbsd openbsd solaris
+// +build darwin dragonfly freebsd fuchsia js,wasm linux nacl netbsd openbsd solaris
package os
diff --git a/src/os/pipe_test.go b/src/os/pipe_test.go
index 59d31e5..ec81d8f 100644
--- a/src/os/pipe_test.go
+++ b/src/os/pipe_test.go
@@ -3,7 +3,7 @@
// license that can be found in the LICENSE file.
// Test broken pipes on Unix systems.
-// +build !windows,!plan9,!nacl,!js
+// +build !windows,!plan9,!nacl,!js,!fuchsia
package os_test
@@ -397,6 +397,10 @@
}
func TestFdReadRace(t *testing.T) {
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("deadlines are TODO on fuchsia")
+ }
+
t.Parallel()
r, w, err := os.Pipe()
diff --git a/src/os/signal/signal_fuchsia.go b/src/os/signal/signal_fuchsia.go
new file mode 100644
index 0000000..c27eba3
--- /dev/null
+++ b/src/os/signal/signal_fuchsia.go
@@ -0,0 +1,25 @@
+// Copyright 2016 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 signal
+
+import "os"
+
+const numSig = 65
+
+func signum(sig os.Signal) int {
+ panic("TODO")
+}
+
+func enableSignal(sig int) {
+ panic("TODO")
+}
+
+func disableSignal(sig int) {
+ panic("TODO")
+}
+
+func ignoreSignal(sig int) {
+ panic("TODO")
+}
diff --git a/src/os/stat_unix.go b/src/os/stat_unix.go
index 856b499..85af8d7 100644
--- a/src/os/stat_unix.go
+++ b/src/os/stat_unix.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// +build darwin dragonfly freebsd js,wasm linux nacl netbsd openbsd solaris
+// +build darwin dragonfly freebsd fuchsia js,wasm linux nacl netbsd openbsd solaris
package os
diff --git a/src/os/timeout_test.go b/src/os/timeout_test.go
index 1886acc..4ac191d 100644
--- a/src/os/timeout_test.go
+++ b/src/os/timeout_test.go
@@ -62,6 +62,10 @@
}
func TestReadTimeout(t *testing.T) {
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("deadlines are TODO on fuchsia")
+ }
+
t.Parallel()
r, w, err := os.Pipe()
@@ -102,6 +106,9 @@
}
func TestReadTimeoutMustNotReturn(t *testing.T) {
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("file read timeouts are TODO on fuchsia")
+ }
t.Parallel()
r, w, err := os.Pipe()
@@ -153,6 +160,10 @@
}
func TestWriteTimeout(t *testing.T) {
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("deadlines are TODO on fuchsia")
+ }
+
t.Parallel()
for i, tt := range writeTimeoutTests {
@@ -190,6 +201,10 @@
}
func TestWriteTimeoutMustNotReturn(t *testing.T) {
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("deadlines are TODO on fuchsia")
+ }
+
t.Parallel()
r, w, err := os.Pipe()
@@ -256,6 +271,10 @@
}
func TestReadTimeoutFluctuation(t *testing.T) {
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("deadlines are TODO on fuchsia")
+ }
+
t.Parallel()
r, w, err := os.Pipe()
@@ -307,6 +326,10 @@
}
func TestWriteTimeoutFluctuation(t *testing.T) {
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("deadlines are TODO on fuchsia")
+ }
+
t.Parallel()
r, w, err := os.Pipe()
@@ -365,6 +388,10 @@
}
func testVariousDeadlines(t *testing.T) {
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("deadlines are TODO on fuchsia")
+ }
+
type result struct {
n int64
err error
@@ -458,6 +485,10 @@
}
func TestReadWriteDeadlineRace(t *testing.T) {
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("deadlines are TODO on fuchsia")
+ }
+
t.Parallel()
N := 1000
@@ -514,6 +545,10 @@
// TestRacyRead tests that it is safe to mutate the input Read buffer
// immediately after cancelation has occurred.
func TestRacyRead(t *testing.T) {
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("deadlines are TODO on fuchsia")
+ }
+
t.Parallel()
r, w, err := os.Pipe()
@@ -553,6 +588,10 @@
// TestRacyWrite tests that it is safe to mutate the input Write buffer
// immediately after cancelation has occurred.
func TestRacyWrite(t *testing.T) {
+ if runtime.GOOS == "fuchsia" {
+ t.Skip("deadlines are TODO on fuchsia")
+ }
+
t.Parallel()
r, w, err := os.Pipe()
diff --git a/src/os/user/lookup_fuchsia.go b/src/os/user/lookup_fuchsia.go
new file mode 100644
index 0000000..80fa82c
--- /dev/null
+++ b/src/os/user/lookup_fuchsia.go
@@ -0,0 +1,38 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build fuchsia
+
+package user
+
+import "errors"
+
+func init() {
+ userImplemented = false
+ groupImplemented = false
+}
+
+func current() (*User, error) {
+ return nil, errors.New("user: Current not implemented on fuchsia")
+}
+
+func lookupUser(string) (*User, error) {
+ return nil, errors.New("user: Lookup not implemented on fuchsia")
+}
+
+func lookupUserId(string) (*User, error) {
+ return nil, errors.New("user: LookupId not implemented on fuchsia")
+}
+
+func lookupGroup(string) (*Group, error) {
+ return nil, errors.New("user: LookupGroup not implemented on fuchsia")
+}
+
+func lookupGroupId(string) (*Group, error) {
+ return nil, errors.New("user: LookupGroupId not implemented on fuchsia")
+}
+
+func listGroups(*User) ([]string, error) {
+ return nil, errors.New("user: GroupIds not implemented on fuchsia")
+}
diff --git a/src/os/user/lookup_stubs.go b/src/os/user/lookup_stubs.go
index f7d138f..71638de 100644
--- a/src/os/user/lookup_stubs.go
+++ b/src/os/user/lookup_stubs.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// +build !cgo,!windows,!plan9 android osusergo,!windows,!plan9
+// +build !cgo,!windows,!plan9 android osusergo,!windows,!plan9,!fuchsia
package user
diff --git a/src/path/filepath/path_unix.go b/src/path/filepath/path_unix.go
index 349dea7..66644d8 100644
--- a/src/path/filepath/path_unix.go
+++ b/src/path/filepath/path_unix.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// +build darwin dragonfly freebsd js,wasm linux nacl netbsd openbsd solaris
+// +build darwin dragonfly freebsd fuchsia js,wasm linux nacl netbsd openbsd solaris
package filepath
diff --git a/src/runtime/asm_amd64.s b/src/runtime/asm_amd64.s
index 6902ce2..97d2a4e 100644
--- a/src/runtime/asm_amd64.s
+++ b/src/runtime/asm_amd64.s
@@ -161,8 +161,8 @@
JMP ok
#endif
- LEAQ runtime·m0+m_tls(SB), DI
- CALL runtime·settls(SB)
+ LEAQ runtime·m0+m_tls(SB), DI
+ CALL runtime·settls(SB)
// store through it, to make sure it works
get_tls(BX)
diff --git a/src/runtime/cgo/cgo.go b/src/runtime/cgo/cgo.go
index 241a821..bd1cd0e 100644
--- a/src/runtime/cgo/cgo.go
+++ b/src/runtime/cgo/cgo.go
@@ -16,6 +16,7 @@
#cgo darwin,arm64 LDFLAGS: -framework CoreFoundation
#cgo dragonfly LDFLAGS: -lpthread
#cgo freebsd LDFLAGS: -lpthread
+#cgo fuchsia LDFLAGS: -lpthread -lfdio
#cgo android LDFLAGS: -llog
#cgo !android,linux LDFLAGS: -lpthread
#cgo netbsd LDFLAGS: -lpthread
diff --git a/src/runtime/cgo/fdio.go b/src/runtime/cgo/fdio.go
new file mode 100644
index 0000000..d843125
--- /dev/null
+++ b/src/runtime/cgo/fdio.go
@@ -0,0 +1,15 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build fuchsia
+
+package cgo
+
+import _ "unsafe" // for go:linkname
+
+//go:cgo_import_static x_cgo_get_initial_handles
+//go:linkname x_cgo_get_initial_handles x_cgo_get_initial_handles
+//go:linkname _cgo_get_initial_handles runtime._cgo_get_initial_handles
+var x_cgo_get_initial_handles byte
+var _cgo_get_initial_handles = &x_cgo_get_initial_handles
diff --git a/src/runtime/cgo/gcc_fatalf.c b/src/runtime/cgo/gcc_fatalf.c
index fdcf6f5..1f416b5 100644
--- a/src/runtime/cgo/gcc_fatalf.c
+++ b/src/runtime/cgo/gcc_fatalf.c
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// +build !android,linux freebsd
+// +build !android,linux freebsd fuchsia
#include <stdarg.h>
#include <stdio.h>
diff --git a/src/runtime/cgo/gcc_fdio.c b/src/runtime/cgo/gcc_fdio.c
new file mode 100644
index 0000000..db21dcb
--- /dev/null
+++ b/src/runtime/cgo/gcc_fdio.c
@@ -0,0 +1,81 @@
+// 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.
+
+// +build cgo
+// +build fuchsia
+
+#include "libcgo.h"
+
+#include <stdlib.h>
+#include <zircon/process.h>
+#include <zircon/processargs.h>
+#include <lib/fdio/io.h>
+#include <lib/fdio/namespace.h>
+#include <lib/fdio/util.h>
+
+extern char **environ;
+
+// fdio_init matches a Go struct of the same name in os_fuchsia.go.
+struct fdio_init {
+ zx_handle_t stdioClones[3 * FDIO_MAX_HANDLES];
+ uint32_t stdioCloneNumHandles[3];
+ uint32_t stdioCloneTypes[3];
+ zx_handle_t processSelf;
+ zx_handle_t vmarRootSelf;
+ int32_t unused;
+ int32_t envlen;
+ char** environ;
+ int32_t unused2;
+ int32_t rootNSNumHandles;
+ zx_handle_t *rootNSHandles;
+ char** rootNSPaths;
+};
+
+void
+x_cgo_get_initial_handles(struct fdio_init *handles)
+{
+ // When running with cgo support, there are two FDIO libraries in the
+ // same process. We let the C FDIO start first, then clone its root
+ // and use that for Go.
+ // TODO: there is some small amount of fdio library state we
+ // have to share between Go and C, in particular, cwd.
+ // Work out how.
+
+ // fdio may have initialized std{in,out,err} with a single fd if the FDIO_FLAG_USE_FOR_STDIO
+ // flag was set, or have separate in/out/err fds. We clone fds {0,1,2} to separate fds for use
+ // in the Go runtime. The cloned fds aren't installed into fdio's fd table so they are only
+ // usable from Go's table.
+ zx_status_t r;
+ for (int i = 0; i < 3; ++i) {
+ uint32_t handle_types[FDIO_MAX_HANDLES];
+ r = fdio_clone_fd(i, 0, &handles->stdioClones[i * FDIO_MAX_HANDLES], handle_types);
+ if (r <= 0) {
+ printf("runtime/cgo: fdio_clone_fd of stdio[%d] failed: %d\n", i, r);
+ handles->stdioCloneNumHandles[i] = 0;
+ } else {
+ handles->stdioCloneNumHandles[i] = r;
+ handles->stdioCloneTypes[i] = PA_HND_TYPE(handle_types[0]);
+ }
+ }
+
+ handles->processSelf = zx_process_self();
+ handles->vmarRootSelf = zx_vmar_root_self();
+
+ for (char** env = environ; *env; env++) {
+ handles->envlen++;
+ }
+ handles->environ = environ;
+
+ fdio_flat_namespace_t* rootNS;
+ r = fdio_ns_export_root(&rootNS);
+ if (r < 0) {
+ handles->rootNSNumHandles = 0;
+ handles->rootNSHandles = NULL;
+ handles->rootNSPaths = NULL;
+ } else {
+ handles->rootNSNumHandles = (int32_t)rootNS->count;
+ handles->rootNSHandles = rootNS->handle;
+ handles->rootNSPaths = (char**)rootNS->path;
+ }
+}
diff --git a/src/runtime/cgo/gcc_fuchsia_amd64.c b/src/runtime/cgo/gcc_fuchsia_amd64.c
new file mode 100644
index 0000000..ae65662
--- /dev/null
+++ b/src/runtime/cgo/gcc_fuchsia_amd64.c
@@ -0,0 +1,52 @@
+// Copyright 2010 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 <pthread.h>
+#include <errno.h>
+#include <string.h> // strerror
+#include <signal.h>
+#include <stdlib.h>
+#include "libcgo.h"
+
+static void* threadentry(void*);
+static void (*setg_gcc)(void*);
+
+void
+x_cgo_init(G* g, void (*setg)(void*))
+{
+ setg_gcc = setg;
+}
+
+void
+_cgo_sys_thread_start(ThreadStart *ts)
+{
+ // TODO: switch to threads.h.
+ pthread_attr_t attr;
+ pthread_t p;
+ size_t size;
+ int err;
+
+ pthread_attr_init(&attr);
+ pthread_attr_getstacksize(&attr, &size);
+ // leave stacklo=0 and set stackhi=size; mstack will do the rest.
+ ts->g->stackhi = size;
+ err = pthread_create(&p, &attr, threadentry, ts);
+
+ if (err != 0) {
+ fatalf("pthread_create failed: %s", strerror(err));
+ }
+}
+
+static void*
+threadentry(void *v)
+{
+ ThreadStart ts;
+
+ ts = *(ThreadStart*)v;
+ free(v);
+ setg_gcc((void*)ts.g);
+
+ crosscall_amd64(ts.fn);
+ return 0;
+}
diff --git a/src/runtime/cgo/gcc_fuchsia_arm64.c b/src/runtime/cgo/gcc_fuchsia_arm64.c
new file mode 100644
index 0000000..e79d192
--- /dev/null
+++ b/src/runtime/cgo/gcc_fuchsia_arm64.c
@@ -0,0 +1,53 @@
+// Copyright 2016 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 <pthread.h>
+#include <errno.h>
+#include <string.h> // strerror
+#include <signal.h>
+#include <stdlib.h>
+#include "libcgo.h"
+
+#include <stdio.h>
+
+static void* threadentry(void*);
+static void (*setg_gcc)(void*);
+
+void
+x_cgo_init(G* g, void (*setg)(void*))
+{
+ setg_gcc = setg;
+}
+
+void
+_cgo_sys_thread_start(ThreadStart *ts)
+{
+ pthread_attr_t attr;
+ pthread_t p;
+ size_t size;
+ int err;
+
+ pthread_attr_init(&attr);
+ pthread_attr_getstacksize(&attr, &size);
+ // leave stacklo=0 and set stackhi=size; mstack will do the rest.
+ ts->g->stackhi = size;
+ err = pthread_create(&p, &attr, threadentry, ts);
+
+ if (err != 0) {
+ fatalf("pthread_create failed: %s", strerror(err));
+ }
+}
+
+extern void crosscall1(void (*fn)(void), void (*setg_gcc)(void*), void *g);
+static void*
+threadentry(void *v)
+{
+ ThreadStart ts;
+
+ ts = *(ThreadStart*)v;
+ free(v);
+
+ crosscall1(ts.fn, setg_gcc, (void*)ts.g);
+ return 0;
+}
diff --git a/src/runtime/cgo/gcc_libinit.c b/src/runtime/cgo/gcc_libinit.c
index 3dc5bde..5a6d8fa 100644
--- a/src/runtime/cgo/gcc_libinit.c
+++ b/src/runtime/cgo/gcc_libinit.c
@@ -3,7 +3,7 @@
// license that can be found in the LICENSE file.
// +build cgo
-// +build darwin dragonfly freebsd linux netbsd openbsd solaris
+// +build darwin dragonfly freebsd fuchsia linux netbsd openbsd solaris
#include <pthread.h>
#include <errno.h>
diff --git a/src/runtime/cgo/gcc_setenv.c b/src/runtime/cgo/gcc_setenv.c
index ed5d203..2f2581d 100644
--- a/src/runtime/cgo/gcc_setenv.c
+++ b/src/runtime/cgo/gcc_setenv.c
@@ -3,7 +3,7 @@
// license that can be found in the LICENSE file.
// +build cgo
-// +build darwin dragonfly freebsd linux netbsd openbsd solaris
+// +build darwin dragonfly freebsd fuchsia linux netbsd openbsd solaris
#include "libcgo.h"
diff --git a/src/runtime/cgo/setenv.go b/src/runtime/cgo/setenv.go
index fab4339..7fe251a 100644
--- a/src/runtime/cgo/setenv.go
+++ b/src/runtime/cgo/setenv.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// +build darwin dragonfly freebsd linux netbsd openbsd solaris
+// +build darwin dragonfly freebsd fuchsia linux netbsd openbsd solaris
package cgo
diff --git a/src/runtime/env_posix.go b/src/runtime/env_posix.go
index 032e712..afd5fce 100644
--- a/src/runtime/env_posix.go
+++ b/src/runtime/env_posix.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// +build darwin dragonfly freebsd js,wasm linux nacl netbsd openbsd solaris windows
+// +build darwin dragonfly freebsd fuchsia js,wasm linux nacl netbsd openbsd solaris windows
package runtime
diff --git a/src/runtime/internal/sys/zgoos_android.go b/src/runtime/internal/sys/zgoos_android.go
index bfdc377..de8cdee 100644
--- a/src/runtime/internal/sys/zgoos_android.go
+++ b/src/runtime/internal/sys/zgoos_android.go
@@ -12,6 +12,7 @@
const GoosFreebsd = 0
const GoosJs = 0
const GoosLinux = 0
+const GoosFuchsia = 0
const GoosNacl = 0
const GoosNetbsd = 0
const GoosOpenbsd = 0
diff --git a/src/runtime/internal/sys/zgoos_darwin.go b/src/runtime/internal/sys/zgoos_darwin.go
index 1c4667f..f569e9d 100644
--- a/src/runtime/internal/sys/zgoos_darwin.go
+++ b/src/runtime/internal/sys/zgoos_darwin.go
@@ -12,6 +12,7 @@
const GoosFreebsd = 0
const GoosJs = 0
const GoosLinux = 0
+const GoosFuchsia = 0
const GoosNacl = 0
const GoosNetbsd = 0
const GoosOpenbsd = 0
diff --git a/src/runtime/internal/sys/zgoos_dragonfly.go b/src/runtime/internal/sys/zgoos_dragonfly.go
index 728bf6a..40988a4 100644
--- a/src/runtime/internal/sys/zgoos_dragonfly.go
+++ b/src/runtime/internal/sys/zgoos_dragonfly.go
@@ -12,6 +12,7 @@
const GoosFreebsd = 0
const GoosJs = 0
const GoosLinux = 0
+const GoosFuchsia = 0
const GoosNacl = 0
const GoosNetbsd = 0
const GoosOpenbsd = 0
diff --git a/src/runtime/internal/sys/zgoos_freebsd.go b/src/runtime/internal/sys/zgoos_freebsd.go
index a8d6591..4a2120d 100644
--- a/src/runtime/internal/sys/zgoos_freebsd.go
+++ b/src/runtime/internal/sys/zgoos_freebsd.go
@@ -12,6 +12,7 @@
const GoosFreebsd = 1
const GoosJs = 0
const GoosLinux = 0
+const GoosFuchsia = 0
const GoosNacl = 0
const GoosNetbsd = 0
const GoosOpenbsd = 0
diff --git a/src/runtime/internal/sys/zgoos_fuchsia.go b/src/runtime/internal/sys/zgoos_fuchsia.go
new file mode 100644
index 0000000..22de240
--- /dev/null
+++ b/src/runtime/internal/sys/zgoos_fuchsia.go
@@ -0,0 +1,18 @@
+// generated by gengoos.go using 'go generate'
+
+package sys
+
+const GOOS = `fuchsia`
+
+const GoosAndroid = 0
+const GoosDarwin = 0
+const GoosDragonfly = 0
+const GoosFreebsd = 0
+const GoosLinux = 0
+const GoosFuchsia = 1
+const GoosNacl = 0
+const GoosNetbsd = 0
+const GoosOpenbsd = 0
+const GoosPlan9 = 0
+const GoosSolaris = 0
+const GoosWindows = 0
diff --git a/src/runtime/internal/sys/zgoos_linux.go b/src/runtime/internal/sys/zgoos_linux.go
index 289400c..f9a4922 100644
--- a/src/runtime/internal/sys/zgoos_linux.go
+++ b/src/runtime/internal/sys/zgoos_linux.go
@@ -13,6 +13,7 @@
const GoosFreebsd = 0
const GoosJs = 0
const GoosLinux = 1
+const GoosFuchsia = 0
const GoosNacl = 0
const GoosNetbsd = 0
const GoosOpenbsd = 0
diff --git a/src/runtime/internal/sys/zgoos_nacl.go b/src/runtime/internal/sys/zgoos_nacl.go
index 3fedb0a..b3c2c01 100644
--- a/src/runtime/internal/sys/zgoos_nacl.go
+++ b/src/runtime/internal/sys/zgoos_nacl.go
@@ -12,6 +12,7 @@
const GoosFreebsd = 0
const GoosJs = 0
const GoosLinux = 0
+const GoosFuchsia = 0
const GoosNacl = 1
const GoosNetbsd = 0
const GoosOpenbsd = 0
diff --git a/src/runtime/internal/sys/zgoos_netbsd.go b/src/runtime/internal/sys/zgoos_netbsd.go
index 3346e37..83f33b3 100644
--- a/src/runtime/internal/sys/zgoos_netbsd.go
+++ b/src/runtime/internal/sys/zgoos_netbsd.go
@@ -12,6 +12,7 @@
const GoosFreebsd = 0
const GoosJs = 0
const GoosLinux = 0
+const GoosFuchsia = 0
const GoosNacl = 0
const GoosNetbsd = 1
const GoosOpenbsd = 0
diff --git a/src/runtime/internal/sys/zgoos_openbsd.go b/src/runtime/internal/sys/zgoos_openbsd.go
index 13c0323..114ea61 100644
--- a/src/runtime/internal/sys/zgoos_openbsd.go
+++ b/src/runtime/internal/sys/zgoos_openbsd.go
@@ -12,6 +12,7 @@
const GoosFreebsd = 0
const GoosJs = 0
const GoosLinux = 0
+const GoosFuchsia = 0
const GoosNacl = 0
const GoosNetbsd = 0
const GoosOpenbsd = 1
diff --git a/src/runtime/internal/sys/zgoos_plan9.go b/src/runtime/internal/sys/zgoos_plan9.go
index 6b2e977..53282e9 100644
--- a/src/runtime/internal/sys/zgoos_plan9.go
+++ b/src/runtime/internal/sys/zgoos_plan9.go
@@ -12,6 +12,7 @@
const GoosFreebsd = 0
const GoosJs = 0
const GoosLinux = 0
+const GoosFuchsia = 0
const GoosNacl = 0
const GoosNetbsd = 0
const GoosOpenbsd = 0
diff --git a/src/runtime/internal/sys/zgoos_solaris.go b/src/runtime/internal/sys/zgoos_solaris.go
index cbf70f0..dcadcc2 100644
--- a/src/runtime/internal/sys/zgoos_solaris.go
+++ b/src/runtime/internal/sys/zgoos_solaris.go
@@ -12,6 +12,7 @@
const GoosFreebsd = 0
const GoosJs = 0
const GoosLinux = 0
+const GoosFuchsia = 0
const GoosNacl = 0
const GoosNetbsd = 0
const GoosOpenbsd = 0
diff --git a/src/runtime/internal/sys/zgoos_windows.go b/src/runtime/internal/sys/zgoos_windows.go
index 70839ca..20fef09 100644
--- a/src/runtime/internal/sys/zgoos_windows.go
+++ b/src/runtime/internal/sys/zgoos_windows.go
@@ -12,6 +12,7 @@
const GoosFreebsd = 0
const GoosJs = 0
const GoosLinux = 0
+const GoosFuchsia = 0
const GoosNacl = 0
const GoosNetbsd = 0
const GoosOpenbsd = 0
diff --git a/src/runtime/lock_futex.go b/src/runtime/lock_futex.go
index b590c4b..129b1ef 100644
--- a/src/runtime/lock_futex.go
+++ b/src/runtime/lock_futex.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// +build dragonfly freebsd linux
+// +build dragonfly freebsd fuchsia linux
package runtime
diff --git a/src/runtime/mem_fuchsia.go b/src/runtime/mem_fuchsia.go
new file mode 100644
index 0000000..e74883a
--- /dev/null
+++ b/src/runtime/mem_fuchsia.go
@@ -0,0 +1,81 @@
+// Copyright 2016 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 runtime
+
+import (
+ "syscall/zx"
+ "unsafe"
+)
+
+//go:nosplit
+func sysAlloc(n uintptr, sysStat *uint64) unsafe.Pointer {
+ var p unsafe.Pointer
+ sysMmap(unsafe.Pointer(&p), n, zx.VMFlagPermRead|zx.VMFlagPermWrite)
+ if uintptr(p) < 4096 {
+ println("runtime: sysMmap failed n=", n)
+ exit(2)
+ }
+ mSysStatInc(sysStat, n)
+ return p
+}
+
+func sysUnused(v unsafe.Pointer, n uintptr) {
+ // TODO(dho): Implement this based on ZX_VMO_OP_DECOMMIT
+}
+
+func sysUsed(v unsafe.Pointer, n uintptr) {
+ // TODO(dho): Maybe implement this based on ZX_VMO_OP_COMMIT
+}
+
+//go:nosplit
+func sysFree(v unsafe.Pointer, n uintptr, sysStat *uint64) {
+ mSysStatDec(sysStat, n)
+ if status := zx.Sys_vmar_unmap(zx.Handle(zx.VMARRoot), zx.Vaddr(v), uint64(n)); status != zx.ErrOk {
+ println("runtime: zx.Sys_vmar_unmap failed: ", status.String())
+ }
+}
+
+func sysMmap(ptr unsafe.Pointer, sz uintptr, flags zx.VMFlag) {
+ var h zx.Handle
+ if status := zx.Sys_vmo_create(uint64(sz), 0, &h); status != zx.ErrOk {
+ println("runtime: zx.Sys_vmo_create failed: ", status.String())
+ exit(2)
+ }
+
+ prop := []byte("go-sys-mmap")
+ if status := zx.Sys_object_set_property(h, zx.PropName, unsafe.Pointer(&prop[0]), uint(len(prop))); status != zx.ErrOk {
+ println("runtime: zx.Sys_object_set_property failed: ", status.String())
+ exit(2)
+ }
+
+ if status := zx.Sys_vmar_map(zx.Handle(zx.VMARRoot), 0, h, 0, uint64(sz), uint32(flags), (*zx.Vaddr)(ptr)); status != zx.ErrOk {
+ println("runtime: zx.Sys_vmar_map failed: ", status.String())
+ exit(2)
+ }
+
+ if status := zx.Sys_handle_close(h); status != zx.ErrOk {
+ println("runtime: zx.Sys_handle_close failed: ", status.String())
+ exit(2)
+ }
+}
+
+func sysReserve(v unsafe.Pointer, n uintptr) unsafe.Pointer {
+ p := v
+ sysMmap(unsafe.Pointer(&p), n, 0)
+ return p
+}
+
+func sysFault(v unsafe.Pointer, n uintptr) {
+ println("TODO sysFault")
+}
+
+func sysMap(v unsafe.Pointer, n uintptr, sysStat *uint64) {
+ mSysStatInc(sysStat, n)
+
+ if status := zx.Sys_vmar_protect(zx.Handle(zx.VMARRoot), zx.Vaddr(v), uint64(n), uint32(zx.VMFlagPermRead|zx.VMFlagPermWrite)); status != zx.ErrOk {
+ println("runtime: zx.Sys_vmar_protect failed: ", status.String())
+ exit(2)
+ }
+}
diff --git a/src/runtime/netpoll_stub.go b/src/runtime/netpoll_stub.go
index a4d6b46..03bd97d 100644
--- a/src/runtime/netpoll_stub.go
+++ b/src/runtime/netpoll_stub.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// +build plan9
+// +build fuchsia plan9
package runtime
diff --git a/src/runtime/os_fuchsia.go b/src/runtime/os_fuchsia.go
new file mode 100644
index 0000000..7a33e81
--- /dev/null
+++ b/src/runtime/os_fuchsia.go
@@ -0,0 +1,317 @@
+// Copyright 2016 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 runtime
+
+import (
+ "syscall/zx"
+ "unsafe"
+)
+
+type mOS struct{}
+
+type sigset struct{}
+
+//go:nosplit
+func getRandomData(r []byte) {
+ zx.RandRead(r)
+}
+
+//go:nosplit
+func futexsleep(addr *uint32, val uint32, ns int64) {
+ deadline := zx.Sys_deadline_after(zx.Duration(ns))
+ if ns < 0 {
+ deadline = zx.Time(zx.TimensecInfinite)
+ }
+ zx.Sys_futex_wait((*int)(unsafe.Pointer(addr)), int32(val), deadline)
+}
+
+//go:nosplit
+func futexwakeup(addr *uint32, cnt uint32) {
+ zx.Sys_futex_wake((*int)(unsafe.Pointer(addr)), cnt)
+}
+
+//go:nosplit
+func osyield() {
+ zx.Sys_nanosleep(0)
+}
+
+// cgocallm0 calls a C function on the current stack.
+//
+// It is intended for use inside functions like osinit that run
+// before mstart directly on an OS thread stack.
+//
+// If in doubt, do not use.
+func cgocallm0(fn, arg unsafe.Pointer)
+
+func osinit() {
+ if _cgo_get_initial_handles != nil {
+ cgocallm0(_cgo_get_initial_handles, unsafe.Pointer(&fdioHandles))
+ for i := 0; i < 3; i = i + 1 {
+ for j := 0; j < int(fdioHandles.stdioCloneNumHandles[i]); j = j + 1 {
+ zx.StdioHandles[i][j] = fdioHandles.stdioClones[i*3+j]
+ }
+ zx.StdioHandleTypes[i] = int(fdioHandles.stdioCloneTypes[i])
+ }
+ zx.ProcHandle = zx.Handle(fdioHandles.processSelf)
+ zx.VMARRoot = zx.VMAR(fdioHandles.vmarRootSelf)
+ } else {
+ // TODO: implement cgo-less init
+ println("runtime: no fuchsia process handle without cgo yet")
+ exit(2)
+ }
+
+ ncpu = int32(zx.Sys_system_get_num_cpus())
+ physPageSize = 4096
+}
+
+func parseRootNS() {
+ if fdioHandles.rootNSNumHandles > 0 {
+ const maxHandleCount = 1 << 20 // arbitrary
+ paths := (*(*[maxHandleCount]*byte)(unsafe.Pointer(fdioHandles.rootNSPaths)))[:fdioHandles.rootNSNumHandles]
+ handles := (*(*[maxHandleCount]zx.Handle)(unsafe.Pointer(fdioHandles.rootNSHandles)))[:fdioHandles.rootNSNumHandles]
+ zx.RootNSMap = make(map[string]zx.Handle)
+ for i, p := range paths {
+ zx.RootNSMap[gostring(p)] = handles[i]
+ }
+ }
+}
+
+// Filled in by runtime/cgo when linked into binary.
+var _cgo_get_initial_handles unsafe.Pointer // pointer to C function
+
+func minit() {
+}
+
+//go:nosplit
+func unminit() {
+ // TODO
+}
+
+func sigpanic() {
+ // TODO
+}
+
+func mpreinit(mp *m) {
+ // TODO
+}
+
+//go:nosplit
+func msigsave(mp *m) {
+ // TODO
+}
+
+//go:nosplit
+func msigrestore(sigmask sigset) {
+ // TODO
+}
+
+func initsig(preinit bool) {
+ // TODO
+}
+
+//go:nosplit
+func sigblock() {
+ // TODO
+}
+
+func sigenable(sig uint32) {
+ // TODO
+}
+
+func sigdisable(sig uint32) {
+ // TODO
+}
+
+func sigignore(sig uint32) {
+ // TODO
+}
+
+func crash() {
+ *(*int32)(nil) = 0
+}
+
+func threadinit(mp *m)
+
+var gothreadname = []byte("gothread")
+
+//go:nowritebarrier
+func newosproc(mp *m) {
+ stk := unsafe.Pointer(mp.g0.stack.hi)
+ p := zx.Handle(0) // TODO: only works due to temporary hack in zircon
+ var h zx.Handle
+ status := zx.Sys_thread_create(p, &gothreadname[0], uint(len(gothreadname)), 0, &h)
+ if status < 0 {
+ println("runtime: newosproc zx.Sys_thread_create failed:", h)
+ exit(2)
+ }
+
+ status = zx.Sys_thread_start(h, zx.Vaddr(funcPC(threadinit)), zx.Vaddr(stk), uintptr(unsafe.Pointer(mp)), 0)
+ if status < 0 {
+ println("runtime: newosproc zx.Sys_thread_start failed:", h)
+ exit(2)
+ }
+}
+
+type zx_proc_args struct {
+ protocol uint32
+ version uint32
+ handle_info_off uint32
+ args_off uint32
+ args_num uint32
+}
+
+type zx_proc_info struct {
+ magic uint32
+ version uint32
+ next_tls_slot uint32
+ proc_args *zx_proc_args
+ handle *zx.Handle
+ handle_info *uint32
+ handle_count int32
+ argv **byte
+ argc int32
+}
+
+type zx_tls_root struct {
+ self *zx_tls_root
+ proc *zx_proc_info
+ magic uint32
+ flags uint16
+ maxslots uint16
+ slots [8]uintptr // has length maxslots
+}
+
+func resetcpuprofiler(hz int32) {
+ // TODO
+}
+
+// fdio_init matches a Go struct of the same name in gcc_fdio.c.
+type fdio_init struct {
+ stdioClones [9]zx.Handle // 3 * fdio.MaxHandles
+ stdioCloneNumHandles [3]uint32
+ stdioCloneTypes [3]uint32
+ processSelf zx.Handle
+ vmarRootSelf zx.Handle
+ _ int32
+ envlen int32
+ environ **byte
+ _ int32
+ rootNSNumHandles int32
+ rootNSHandles *zx.Handle
+ rootNSPaths **byte
+}
+
+var fdioHandles fdio_init
+
+func goenvs() {
+ if _cgo_get_initial_handles != nil {
+ const maxEnvSize = 1 << 20 // arbitrary
+ envp := (*(*[maxEnvSize]*byte)(unsafe.Pointer(fdioHandles.environ)))[:fdioHandles.envlen]
+ envs = make([]string, len(envp))
+ for i, e := range envp {
+ envs[i] = gostring(e)
+ }
+ // TODO: find a better place to call this
+ parseRootNS()
+ } else {
+ // TODO: implement cgo-less init
+ println("runtime: no fuchsia process handle without cgo yet")
+ exit(2)
+ }
+}
+
+const _NSIG = 65 // TODO
+
+//go:nosplit
+func nanotime() int64 {
+ const ZX_CLOCK_MONOTONIC = 0
+ return int64(zx.Sys_clock_get(ZX_CLOCK_MONOTONIC))
+}
+
+//go:linkname time_now time.now
+//go:nosplit
+func time_now() (sec int64, nsec int32, mono int64) {
+ const ZX_CLOCK_UTC = 1
+ x := int64(zx.Sys_clock_get(ZX_CLOCK_UTC))
+ return int64(x / 1e9), int32(x % 1e9), nanotime() - startNano
+}
+
+func unixnanotime() int64 {
+ return nanotime()
+}
+
+var logger zx.Handle
+var logBufferArray [1024]byte
+var logBufferN int
+
+//go:nosplit
+func write(fd uintptr, buf unsafe.Pointer, n int32) int32 {
+ if fd == 1 || fd == 2 {
+ // This initialization mechanism is not thread-safe, but if the only calls to 'write' with
+ // these file descriptors come from print, they will already be serialized by a lock in
+ // print's implementation.
+ if logger <= 0 {
+ zx.Sys_debuglog_create(0, 0, &logger)
+ logBufferN = 0
+ }
+ if logger > 0 {
+ // Sys_log_write adds a newline to output buffers. To prevent fragmented logs, we buffer
+ // output until a newline character is encountered.
+ logBufferN += copy(logBufferArray[logBufferN:], (*[1 << 30]byte)(buf)[:n])
+ if logBufferArray[logBufferN-1] == '\n' {
+ status := zx.Sys_log_write(logger, uint32(logBufferN), unsafe.Pointer(&logBufferArray[0]), 0)
+ // Flush buffer, regardless of status returned from write
+ logBufferN = 0
+ if status < 0 {
+ return int32(status)
+ }
+ }
+ }
+ }
+ // TODO
+ return n
+}
+
+//go:nosplit
+func exit(code int32) {
+ zx.Sys_process_exit(int64(code))
+}
+
+//go:nosplit
+func usleep(usec uint32) {
+ zx.Sys_nanosleep(zx.Sys_deadline_after(zx.Duration(usec * 1000)))
+}
+
+func signame(sig uint32) string {
+ return "unknown_sig" // TODO
+}
+
+// zircon_mktls
+//go:nosplit
+func zircon_mktls() {
+ // TODO
+}
+
+//go:nosplit
+func zircon_settls(val uintptr) {
+ // TODO: should call zx_set_object_property with property ZX_PROP_REGISTER_FS in amd64 or
+ // ZX_PROP_REGISTER_CP15 on arm.
+}
+
+//go:linkname os_sigpipe os.sigpipe
+func os_sigpipe() {
+ // TODO
+}
+
+// gsignalStack is unused on fuchsia
+type gsignalStack struct{}
+
+func exitThread(wait *uint32) {}
+func setProcessCPUProfiler(hz int32) {}
+func setThreadCPUProfiler(hz int32) {}
+
+//go:nosplit
+//go:nowritebarrierrec
+func clearSignalHandlers() {}
diff --git a/src/runtime/os_fuchsia_arm64.go b/src/runtime/os_fuchsia_arm64.go
new file mode 100644
index 0000000..143fe39
--- /dev/null
+++ b/src/runtime/os_fuchsia_arm64.go
@@ -0,0 +1,12 @@
+// Copyright 2016 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 runtime
+
+import "syscall/zx"
+
+//go:nosplit
+func cputicks() int64 {
+ return int64(zx.Sys_ticks_get())
+}
diff --git a/src/runtime/rt0_fuchsia_amd64.s b/src/runtime/rt0_fuchsia_amd64.s
new file mode 100644
index 0000000..40c92a3
--- /dev/null
+++ b/src/runtime/rt0_fuchsia_amd64.s
@@ -0,0 +1,8 @@
+// Copyright 2016 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 _rt0_amd64_fuchsia(SB),NOSPLIT,$-8
+ JMP _rt0_amd64(SB)
diff --git a/src/runtime/rt0_fuchsia_arm64.s b/src/runtime/rt0_fuchsia_arm64.s
new file mode 100644
index 0000000..f28e28d
--- /dev/null
+++ b/src/runtime/rt0_fuchsia_arm64.s
@@ -0,0 +1,14 @@
+// Copyright 2016 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 _rt0_arm64_fuchsia(SB),NOSPLIT,$-8
+ MOVD 0(RSP), R0 // argc
+ ADD $8, RSP, R1 // argv
+ BL main(SB)
+
+TEXT main(SB),NOSPLIT,$-8
+ MOVD $runtime·rt0_go(SB), R2
+ BL R2
diff --git a/src/runtime/stubs2.go b/src/runtime/stubs2.go
index 02249d0..d91b8c4 100644
--- a/src/runtime/stubs2.go
+++ b/src/runtime/stubs2.go
@@ -8,6 +8,7 @@
// +build !nacl
// +build !js
// +build !darwin
+// +build !fuchsia
package runtime
diff --git a/src/runtime/stubs3.go b/src/runtime/stubs3.go
index 5c0786e..777fce2 100644
--- a/src/runtime/stubs3.go
+++ b/src/runtime/stubs3.go
@@ -8,6 +8,7 @@
// +build !nacl
// +build !freebsd
// +build !darwin
+// +build !fuchsia
package runtime
diff --git a/src/runtime/sys_manual_fuchsia_amd64.s b/src/runtime/sys_manual_fuchsia_amd64.s
new file mode 100644
index 0000000..81e9c90
--- /dev/null
+++ b/src/runtime/sys_manual_fuchsia_amd64.s
@@ -0,0 +1,71 @@
+// Copyright 2016 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 "go_asm.h"
+#include "go_tls.h"
+#include "textflag.h"
+
+TEXT runtime·threadinit(SB),NOSPLIT,$0
+ MOVQ DI, R8
+
+ MOVQ m_g0(R8), DX // g
+ MOVQ R8, g_m(DX)
+
+ // Layout new m scheduler stack on os stack.
+ // TODO: which os stack? do we need to make a new vmo?
+ LEAQ (-8*1024+104)(SP), BX
+ MOVQ BX, g_stackguard0(DX)
+ MOVQ BX, g_stackguard1(DX)
+ MOVQ BX, (g_stack+stack_lo)(DX)
+ MOVQ SP, (g_stack+stack_hi)(DX)
+
+ PUSHQ R8
+
+ // Set up tls.
+ LEAQ m_tls(R8), DI
+ CALL runtime·settls(SB)
+
+ get_tls(CX)
+
+ POPQ R8
+ MOVQ m_g0(R8), DX
+ MOVQ DX, g(CX)
+
+ CLD // convention is D is always left cleared
+ CALL runtime·stackcheck(SB) // clobbers AX,CX
+ CALL runtime·mstart(SB)
+ // TODO CALL syscall/zx·Sys_zircon_thread_exit(SB)
+ RET
+
+// set tls base to DI
+// Note that this code is only used when CGO_ENABLED=0.
+// Not using syscall/zx so we can avoid setting up a G.
+//
+// TODO: make VSDO call directly here, avoid the syscall.
+TEXT runtime·settls(SB),NOSPLIT,$8
+ ADDQ $8, DI // ELF wants to use -8(FS)
+ PUSHQ DI
+ LEAQ 0(SP), DX // prctl on zircon takes a pointer, not the value
+ MOVQ $0, DI
+ MOVQ $0, SI
+ MOVQ $0xff00ff00000035, AX // ZIRCON_SYSCALL_MAGIC | thread_arch_prctl (53)
+ SYSCALL
+ CMPQ AX, $0xfffffffffffff001
+ JLS 2(PC)
+ MOVL $0xf1, 0xf1 // crash
+ POPQ DI
+ RET
+
+TEXT ·cgocallm0(SB),NOSPLIT,$0-20
+ MOVQ fn+0(FP), AX
+ MOVQ arg+8(FP), DI
+
+ MOVQ SP, BP // BP is callee-save in the x86-64 ABI
+
+ ANDQ $~15, SP
+ CALL AX
+
+ MOVQ BP, SP
+ get_tls(CX)
+ RET
diff --git a/src/runtime/sys_manual_fuchsia_arm64.s b/src/runtime/sys_manual_fuchsia_arm64.s
new file mode 100644
index 0000000..36b8107
--- /dev/null
+++ b/src/runtime/sys_manual_fuchsia_arm64.s
@@ -0,0 +1,42 @@
+// Copyright 2016 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 "go_asm.h"
+#include "funcdata.h"
+#include "textflag.h"
+
+TEXT runtime·threadinit(SB),NOSPLIT,$0
+ // Layout new m scheduler stack on os stack.
+ // TODO: which os stack? do we need to make a new vmo?
+
+ MOVD m_g0(R0), g
+ MOVD R0, g_m(g)
+
+ MOVD RSP, R7
+ MOVD $(-64*1024)(R7), R0
+ MOVD R0, g_stackguard0(g)
+ MOVD R0, g_stackguard1(g)
+ MOVD R0, (g_stack+stack_lo)(g)
+ MOVD R7, (g_stack+stack_hi)(g)
+
+ BL runtime·mstart(SB)
+ MOVD $0, R0
+ MOVD R0, (R0) // boom
+ UNDEF
+
+TEXT ·cgocallm0(SB),NOSPLIT,$0-20
+ MOVD fn+0(FP), R1
+ MOVD arg+8(FP), R0
+
+ MOVD RSP, R19 // R19 is callee-save by C
+ MOVD g, R21 // R21 is callee-save by C
+ MOVD RSP, R7
+ ADD $-32, R7, R7
+ AND $~15, R7
+ MOVD R7, RSP // align stack for C
+ BL R1
+
+ MOVD R19, RSP // restore SP
+ MOVD R21, g // restore g
+ RET
diff --git a/src/runtime/timestub.go b/src/runtime/timestub.go
index f9230da..2c73258 100644
--- a/src/runtime/timestub.go
+++ b/src/runtime/timestub.go
@@ -6,6 +6,7 @@
// indirectly, in terms of walltime and nanotime assembly.
// +build !windows
+// +build !fuchsia
package runtime
diff --git a/src/runtime/tls_arm64.h b/src/runtime/tls_arm64.h
index c29fa7f..c2480d7 100644
--- a/src/runtime/tls_arm64.h
+++ b/src/runtime/tls_arm64.h
@@ -9,6 +9,9 @@
#ifdef GOOS_linux
#define TLS_linux
#endif
+#ifdef GOOS_fuchsia
+#define TLS_linux
+#endif
#ifdef TLS_linux
#define TPIDR TPIDR_EL0
#define MRS_TPIDR_R0 WORD $0xd53bd040 // MRS TPIDR_EL0, R0
diff --git a/src/syscall/dirent.go b/src/syscall/dirent.go
index 26cbbbc..a85c818 100644
--- a/src/syscall/dirent.go
+++ b/src/syscall/dirent.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// +build darwin dragonfly freebsd js,wasm linux nacl netbsd openbsd solaris
+// +build darwin dragonfly freebsd fuchsia js,wasm linux nacl netbsd openbsd solaris
package syscall
diff --git a/src/syscall/env_unix.go b/src/syscall/env_unix.go
index 1ebc0b1..f4e1f65 100644
--- a/src/syscall/env_unix.go
+++ b/src/syscall/env_unix.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// +build darwin dragonfly freebsd js,wasm linux nacl netbsd openbsd solaris
+// +build darwin dragonfly freebsd fuchsia js,wasm linux nacl netbsd openbsd solaris
// Unix environment variables.
diff --git a/src/syscall/exec_fuchsia.go b/src/syscall/exec_fuchsia.go
new file mode 100644
index 0000000..3904808
--- /dev/null
+++ b/src/syscall/exec_fuchsia.go
@@ -0,0 +1,10 @@
+// Copyright 2016 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 syscall
+
+import ()
+
+type SysProcAttr struct {
+}
diff --git a/src/syscall/syscall_fuchsia.go b/src/syscall/syscall_fuchsia.go
new file mode 100644
index 0000000..68c138b
--- /dev/null
+++ b/src/syscall/syscall_fuchsia.go
@@ -0,0 +1,686 @@
+// Copyright 2016 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 syscall
+
+import (
+ "errors"
+ "io"
+ "path"
+ "strings"
+ "sync"
+ "unsafe"
+
+ "syscall/zx"
+ "syscall/zx/fdio"
+ "syscall/zx/fidl"
+ fidlIo "syscall/zx/io"
+)
+
+var (
+ Stdin = 0
+ Stdout = 1
+ Stderr = 2
+)
+
+const (
+ FsRightReadable = 0x00000001
+ FsRightWritable = 0x00000002
+ FsRightAdmin = 0x00000004
+ FsRightRight = 0x0000FFFF
+ FsFlagCreate = 0x00010000
+ FsFlagExclusive = 0x00020000
+ FsFlagTruncate = 0x00040000
+ FsFlagDirectory = 0x00080000
+ FsFlagAppend = 0x00100000
+ FsFlagNoRemote = 0x00200000
+ FsFlagPath = 0x00400000
+ FsFlagDescribe = 0x00800000
+)
+
+const (
+ O_RDONLY = 0x0
+ O_WRONLY = 0x1
+ O_RDWR = 0x2
+ O_PIPELINE = 0x80000000
+
+ // Flags which align with ZXIO_FS_*
+ O_ADMIN = FsRightAdmin
+ O_CREAT = FsFlagCreate
+ O_EXCL = FsFlagExclusive
+ O_TRUNC = FsFlagTruncate
+ O_DIRECTORY = FsFlagDirectory
+ O_APPEND = FsFlagAppend
+ O_NOREMOTE = FsFlagNoRemote
+ O_PATH = FsFlagPath
+
+ FdioAlignedFlags = O_ADMIN | O_CREAT | O_EXCL | O_TRUNC | O_DIRECTORY | O_APPEND |
+ O_NOREMOTE | O_PATH
+
+ // Flags which do not align with ZXIO_FS_*
+ O_NONBLOCK = 0x00000010
+ O_DSYNC = 0x00000020
+ O_SYNC = 0x00000040 | O_DSYNC
+ O_RSYNC = O_SYNC
+ O_NOFOLLOW = 0x00000080
+ O_CLOEXEC = 0x00000100
+ O_NOCTTY = 0x00000200
+ O_ASYNC = 0x00000400
+ O_DIRECT = 0x00000800
+ O_LARGEFILE = 0x00001000
+ O_NOATIME = 0x00002000
+ O_TMPFILE = 0x00004000
+)
+
+func FdioFlagsToZxio(flags uint32) (zflags uint32) {
+ perms := uint32(O_RDONLY | O_WRONLY | O_RDWR)
+ switch flags & perms {
+ case O_RDONLY:
+ zflags |= FsRightReadable
+ case O_WRONLY:
+ zflags |= FsRightWritable
+ case O_RDWR:
+ zflags |= FsRightReadable | FsRightWritable
+ }
+
+ if (flags & O_PIPELINE) == 0 {
+ zflags |= FsFlagDescribe
+ }
+
+ zflags |= (flags & FdioAlignedFlags)
+ return zflags
+}
+
+const (
+ S_IFMT = 0000170000
+ S_IFDIR = 0000040000
+ S_IFREG = 0000100000
+ S_IFIFO = 0000010000
+)
+
+// TODO(crawshaw): generate a zerrors file once cgo is working
+const (
+ EPERM = Errno(0x01)
+ ENOENT = Errno(0x02)
+ EINTR = Errno(0x04)
+ EIO = Errno(0x05)
+ EBADF = Errno(0x09)
+ EACCES = Errno(0x0d)
+ EEXIST = Errno(0x11)
+ ENOTDIR = Errno(0x14)
+ EISDIR = Errno(0x15)
+ EINVAL = Errno(0x16)
+ EMFILE = Errno(0x18)
+ ESPIPE = Errno(0x1d)
+ ENAMETOOLONG = Errno(0x24)
+ ENOTEMPTY = Errno(0x27)
+ ENOPROTOOPT = Errno(0x5c)
+ EOPNOTSUPP = Errno(0x5f)
+ ENOTSUP = EOPNOTSUPP
+ EADDRINUSE = Errno(0x62)
+ EADDRNOTAVAIL = Errno(0x63)
+ ETIMEDOUT = Errno(0x6e)
+ ECONNABORTED = Errno(0x67)
+ EHOSTUNREACH = Errno(0x71)
+ EFUCHSIA = Errno(0xfa)
+)
+
+var EPIPE error = Errno(0x20)
+
+const (
+ SOMAXCONN = 0x80
+)
+
+const (
+ PathMax = 4096
+)
+
+type Stat_t struct {
+ Dev uint64
+ Ino uint64
+ Size uint64
+ CreateTime uint64
+ ModifyTime uint64
+ Mode uint64
+}
+
+func Getpid() (pid int) {
+ // TODO: is ProcHandle process-wide or OS-wide?
+ return int(zx.ProcHandle)
+}
+
+func Getppid() (ppid int) {
+ return 0
+}
+
+func Getuid() (uid int) {
+ return 0
+}
+
+func Geteuid() (uid int) {
+ return 0
+}
+
+func Getgid() (uid int) {
+ return 0
+}
+
+func Getegid() (uid int) {
+ return 0
+}
+
+func Getgroups() (gids []int, err error) {
+ return nil, errors.New("Getgroups unimplemented")
+}
+
+//func Exit(code int) {
+//zx.Sys_process_exit(int64(code))
+//}
+
+const ImplementsGetwd = true
+
+func Getwd() (wd string, err error) {
+ cwdMu.Lock()
+ wd = cwdStr
+ cwdMu.Unlock()
+ return wd, nil
+}
+
+func Chdir(dir string) (err error) {
+ // TODO: if cgo enabled, change the working directory there too.
+ f, err := OpenPath(dir, 0, 0)
+ if err != nil {
+ return err
+ }
+ cwdMu.Lock()
+ var old fdio.FDIO
+ old, cwd = cwd, f
+ // cwd starts as a reference to root, which should remain open.
+ if old != nil && old != root {
+ defer old.Close()
+ }
+ if path.IsAbs(dir) {
+ cwdStr = path.Clean(dir)
+ } else {
+ cwdStr = path.Join(cwdStr, dir)
+ }
+ cwdMu.Unlock()
+ return nil
+}
+
+func Mkdir(path string, mode uint32) (err error) {
+ f, err := OpenPath(path, O_CREAT|O_EXCL|O_RDWR, mode&0777|S_IFDIR)
+ if err != nil {
+ return err
+ }
+ f.Close()
+ return nil
+}
+
+func Rmdir(path string) error {
+ return Unlink(path)
+}
+
+func Unlink(p string) error {
+ dir, relp := fdioPath(path.Clean(p))
+ return dir.Unlink(relp)
+}
+
+func makeAbs(paths ...string) []string {
+ cwdMu.Lock()
+ dir := cwdStr
+ cwdMu.Unlock()
+ for i := range paths {
+ if !path.IsAbs(paths[i]) {
+ paths[i] = path.Join(dir, paths[i])
+ }
+ }
+ return paths
+}
+
+func Rename(oldpath, newpath string) error {
+ abs := makeAbs(oldpath, newpath)
+ rootMu.Lock()
+ r := root
+ rootMu.Unlock()
+ return r.Rename(abs[0][1:], abs[1][1:])
+}
+
+func Link(oldpath, newpath string) error {
+ abs := makeAbs(oldpath, newpath)
+ rootMu.Lock()
+ r := root
+ rootMu.Unlock()
+ return r.Link(abs[0][1:], abs[1][1:])
+}
+
+func Fsync(fd int) error {
+ fdsMu.Lock()
+ f := fds[fd-fdsOff]
+ fdsMu.Unlock()
+ return f.Sync()
+}
+
+func Fchdir(fd int) (err error) {
+ return errors.New("Fchdir unimplemented")
+}
+
+func CloseOnExec(r int) {
+ panic("syscall.CloseOnExec TODO")
+}
+
+func SetNonblock(fd int, nonblocking bool) (err error) {
+ if nonblocking {
+ return errors.New("syscall.SetNonblock: non-blocking not supported on fuchsia")
+ }
+ return nil
+}
+
+var (
+ rootMu sync.Mutex
+ root fdio.FDIO
+)
+
+var (
+ cwdMu sync.Mutex
+ cwd fdio.FDIO
+ cwdStr string
+)
+
+var (
+ nsMu sync.Mutex
+ ns *fdio.NS
+)
+
+var (
+ stdioMu sync.Mutex
+ stdin fdio.FDIO
+ stdout fdio.FDIO
+ stderr fdio.FDIO
+)
+
+const fdsOff = 1e6 // move outside the fd range of unistd.c FDIO
+
+var (
+ fdsMu sync.Mutex
+ fds []fdio.FDIO
+)
+
+func Read(fd int, p []byte) (n int, err error) {
+ if fd == Stdin {
+ stdioMu.Lock()
+ n, err = stdin.Read(p)
+ stdioMu.Unlock()
+ } else {
+ if fd < fdsOff {
+ return 0, EINVAL
+ }
+ fdsMu.Lock()
+ f := fds[fd-fdsOff]
+ fdsMu.Unlock()
+
+ n, err = f.Read(p)
+ }
+ // An io.Reader can return n < len(p) and io.EOF.
+ // But this is the POSIX syscall read(3), which
+ // returns nil on eof.
+ if err == io.EOF {
+ err = nil
+ }
+ return n, err
+}
+
+func init() {
+ EPIPE = zx.EPIPE
+
+ var err error
+
+ nsMu.Lock()
+ ns, err = fdio.NewNSFromMap(zx.RootNSMap)
+ nsMu.Unlock()
+ if err != nil {
+ println("syscall: failed to create namespace: ", err.Error())
+ }
+
+ rootMu.Lock()
+ root, err = ns.OpenRoot()
+ rootMu.Unlock()
+ if err != nil {
+ println("syscall: failed to create root directory from namespace: ", err.Error())
+ }
+
+ cwdMu.Lock()
+ var found bool
+ cwdStr, found = Getenv("PWD")
+ if !found {
+ cwdStr = "/"
+ } else {
+ // Ensure the incoming cwd is absolute and cleaned
+ cwdStr = path.Join("/", cwdStr)
+ }
+ cwd = root
+ if cwdStr != "/" {
+ cwd, err = OpenPath(cwdStr, 0, 0)
+ }
+ cwdMu.Unlock()
+ if err != nil {
+ println("syscall: failed to create fdio cwd: ", err.Error())
+ }
+
+ initStdio := func(i int) (fdio.FDIO, error) {
+ switch zx.StdioHandleTypes[i] {
+ case 0:
+ return nil, EINVAL
+ case fdio.HandleTypeRemote:
+ obj := (*fidlIo.ObjectInterface)(&fidl.Proxy{Channel: zx.Channel(zx.StdioHandles[i][0])})
+ return &fdio.File{Node: fdio.Node{Object: fdio.Object{obj}}}, nil
+ case fdio.HandleTypePipe:
+ return fdio.NewPipe(zx.Socket(zx.StdioHandles[i][0])), nil
+ case fdio.HandleTypeLogger:
+ return fdio.NewLogger(zx.Log(zx.StdioHandles[i][0])), nil
+ default:
+ println("syscall: unknown handle type for stdio: " + itoa(zx.StdioHandleTypes[i]))
+ return nil, EINVAL
+ }
+ }
+ stdioMu.Lock()
+ stdin, err = initStdio(0)
+ if err != nil {
+ println("syscall: failed to create fdio stdin: ", err.Error())
+ }
+ stdout, err = initStdio(1)
+ if err != nil {
+ println("syscall: failed to create fdio stdiout: ", err.Error())
+ }
+ stderr, err = initStdio(2)
+ if err != nil {
+ println("syscall: failed to create fdio stderr: ", err.Error())
+ }
+ stdioMu.Unlock()
+}
+
+func Write(fd int, p []byte) (n int, err error) {
+ switch fd {
+ case Stdout:
+ stdioMu.Lock()
+ n, err := stdout.Write(p)
+ stdioMu.Unlock()
+ return n, err
+ case Stderr:
+ stdioMu.Lock()
+ n, err := stderr.Write(p)
+ stdioMu.Unlock()
+ return n, err
+ default:
+ fdsMu.Lock()
+ f := fds[fd-fdsOff]
+ fdsMu.Unlock()
+ return f.Write(p)
+ }
+ return 0, EINVAL
+}
+
+func Seek(fd int, offset int64, whence int) (off int64, err error) {
+ fdsMu.Lock()
+ f := fds[fd-fdsOff]
+ fdsMu.Unlock()
+ off, err = f.Seek(offset, whence)
+ if err != nil {
+ if status, isStatus := err.(zx.Error); isStatus {
+ if status.Status == zx.ErrNotSupported {
+ if _, isPipe := f.(*fdio.Pipe); isPipe {
+ return off, ESPIPE
+ }
+ }
+ }
+ }
+ return off, err
+}
+
+func Close(fd int) (err error) {
+ if fd < fdsOff {
+ return EINVAL
+ }
+ fdsMu.Lock()
+ if fd-fdsOff > len(fds) {
+ fdsMu.Unlock()
+ return EINVAL
+ }
+ f := fds[fd-fdsOff]
+ fds[fd-fdsOff] = nil
+ fdsMu.Unlock()
+ return f.Close()
+}
+
+func fdioPath(p string) (fdio.FDIO, string) {
+ if path.IsAbs(p) {
+ rootMu.Lock()
+ r := root
+ rootMu.Unlock()
+ return r, p[1:]
+ }
+ cwdMu.Lock()
+ c := cwd
+ cwdMu.Unlock()
+ return c, p
+}
+
+func OpenPath(p string, mode int, perm uint32) (f fdio.FDIO, err error) {
+ if strings.Contains(p, "\x00") {
+ return nil, EINVAL
+ }
+ dir, relp := fdioPath(path.Clean(p))
+ return dir.Open(relp, FdioFlagsToZxio(uint32(mode)), perm)
+}
+
+func Open(path string, mode int, perm uint32) (fd int, err error) {
+ if path == "" {
+ return -1, EINVAL
+ }
+ f, err := OpenPath(path, mode, perm)
+ if err != nil {
+ return -1, err
+ }
+ return OpenFDIO(f), nil
+}
+
+func OpenAt(fdParent int, path string, mode int, perm uint32) (fd int, err error) {
+ parent := FDIOForFD(fdParent)
+ if parent == nil {
+ return -1, EBADF
+ }
+ f, err := parent.Open(path, FdioFlagsToZxio(uint32(mode)), perm)
+ if err != nil {
+ return -1, err
+ }
+ return OpenFDIO(f), nil
+}
+
+func FDIOForFD(fd int) fdio.FDIO {
+ switch fd {
+ case Stdin:
+ return stdin
+ case Stdout:
+ return stdout
+ case Stderr:
+ return stderr
+ }
+ if fd < fdsOff {
+ return nil
+ }
+ fdsMu.Lock()
+ if fd-fdsOff > len(fds) {
+ fdsMu.Unlock()
+ return nil
+ }
+ f := fds[fd-fdsOff]
+ fdsMu.Unlock()
+ return f
+}
+
+func OpenFDIO(f fdio.FDIO) (fd int) {
+ fdsMu.Lock()
+ i := -1
+ for i = 0; i < len(fds); i++ {
+ if fds[i] == nil {
+ fds[i] = f
+ break
+ }
+ }
+ if i == len(fds) {
+ fds = append(fds, f)
+ }
+ fdsMu.Unlock()
+
+ return i + fdsOff
+}
+
+func Ioctl(fd int, op uint32, max uint64, in []byte, handles []zx.Handle) ([]byte, []zx.Handle, error) {
+ fdsMu.Lock()
+ f := fds[fd-fdsOff]
+ fdsMu.Unlock()
+ return f.Ioctl(op, max, in, handles)
+}
+
+func Fstat(fd int, stat *Stat_t) (err error) {
+ fdsMu.Lock()
+ f := fds[fd-fdsOff]
+ fdsMu.Unlock()
+
+ attr, err := f.GetAttr()
+ if err != nil {
+ return err
+ }
+ stat.Dev = uint64(attr.Mode)
+ stat.Ino = attr.Id
+ stat.Size = attr.ContentSize
+ stat.CreateTime = attr.CreationTime
+ stat.ModifyTime = attr.ModificationTime
+ return nil
+}
+
+func Stat(path string, stat *Stat_t) (err error) {
+ fd, err := Open(path, O_RDONLY, 0)
+ if err != nil {
+ return err
+ }
+ err = Fstat(fd, stat)
+ if err2 := Close(fd); err == nil {
+ err = err2
+ }
+ return err
+}
+
+func Lstat(path string, stat *Stat_t) (err error) {
+ // TODO: adjust when there are symlinks
+ return Stat(path, stat)
+}
+
+func Pread(fd int, p []byte, offset int64) (n int, err error) {
+ if fd == Stdout || fd == Stderr {
+ return 0, ESPIPE
+ }
+
+ fdsMu.Lock()
+ f := fds[fd-fdsOff]
+ fdsMu.Unlock()
+
+ // An io.Reader can return n < len(p) and io.EOF.
+ // But this is the POSIX syscall read(3), which
+ // returns nil on eof.
+ n, err = f.ReadAt(p, offset)
+ if err == io.EOF {
+ err = nil
+ }
+ return n, err
+}
+
+func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
+ if fd == Stdout || fd == Stderr {
+ return 0, ESPIPE
+ }
+
+ fdsMu.Lock()
+ f := fds[fd-fdsOff]
+ fdsMu.Unlock()
+ return f.WriteAt(p, offset)
+}
+
+func Ftruncate(fd int, length int64) (err error) {
+ fdsMu.Lock()
+ f := fds[fd-fdsOff]
+ fdsMu.Unlock()
+ return f.Truncate(uint64(length))
+}
+
+func Truncate(path string, length int64) (err error) {
+ fd, err := Open(path, O_WRONLY, 0)
+ if err != nil {
+ return err
+ }
+ err = Ftruncate(fd, length)
+ if err2 := Close(fd); err == nil {
+ err = err2
+ }
+ return err
+}
+
+func Symlink(oldpath string, newpath string) (err error) {
+ return EOPNOTSUPP // no fuchsia support yet
+}
+
+func UtimesNano(path string, ts []Timespec) (err error) {
+ f, err := OpenPath(path, 0, 0)
+ if err != nil {
+ return err
+ }
+ defer f.Close()
+ return f.SetAttr(fidlIo.KNodeAttributeFlagModificationTime, fidlIo.NodeAttributes{
+ ModificationTime: uint64(TimespecToNsec(ts[1])),
+ })
+}
+
+func clen(n []byte) int {
+ for i := 0; i < len(n); i++ {
+ if n[i] == 0 {
+ return i
+ }
+ }
+ return len(n)
+}
+
+func ReadDirent(fd int, buf []byte) (n int, err error) {
+ fdsMu.Lock()
+ f := fds[fd-fdsOff]
+ fdsMu.Unlock()
+ dirent, err := f.ReadDirents(uint64(len(buf)))
+ if err != nil {
+ return 0, err
+ }
+ return copy(buf, dirent), nil
+}
+
+func direntIno(buf []byte) (uint64, bool) {
+ // Inodes aren't exposed through Fuchsia; just lie.
+ // Use '1' instead of '0', since '0' means "entry not filled" on some operating systems.
+ return 1, true
+}
+
+func direntReclen(buf []byte) (uint64, bool) {
+ return readInt(buf, unsafe.Offsetof(Dirent{}.Size), unsafe.Sizeof(Dirent{}.Size))
+}
+
+func direntNamlen(buf []byte) (uint64, bool) {
+ reclen, ok := direntReclen(buf)
+ if !ok {
+ return 0, false
+ }
+ return reclen - uint64(unsafe.Offsetof(Dirent{}.Name)), true
+}
+
+type Dirent struct {
+ Size uint32
+ Type uint32
+ Name [1]byte
+}
diff --git a/src/syscall/timestruct.go b/src/syscall/timestruct.go
index 84a00a7..6bdc1a1 100644
--- a/src/syscall/timestruct.go
+++ b/src/syscall/timestruct.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// +build darwin dragonfly freebsd js,wasm linux nacl netbsd openbsd solaris
+// +build darwin dragonfly freebsd fuchsia js,wasm linux nacl netbsd openbsd solaris
package syscall
diff --git a/src/syscall/types_fuchsia.go b/src/syscall/types_fuchsia.go
new file mode 100644
index 0000000..9098a4a
--- /dev/null
+++ b/src/syscall/types_fuchsia.go
@@ -0,0 +1,29 @@
+// Copyright 2016 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 syscall
+
+type Errno uintptr
+
+func (e Errno) Error() string {
+ return "errno(" + itoa(int(e)) + ")"
+}
+
+type Timespec struct {
+ Sec int64
+ Nsec int64
+}
+
+type Timeval struct {
+ Sec int64
+ Usec int64
+}
+
+func setTimespec(sec, nsec int64) Timespec {
+ return Timespec{Sec: sec, Nsec: nsec}
+}
+
+func setTimeval(sec, usec int64) Timeval {
+ return Timeval{Sec: sec, Usec: usec}
+}
diff --git a/src/syscall/zerrors_fuchsia.go b/src/syscall/zerrors_fuchsia.go
new file mode 100644
index 0000000..cdd22ca
--- /dev/null
+++ b/src/syscall/zerrors_fuchsia.go
@@ -0,0 +1,72 @@
+// Copyright 2017 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 syscall
+
+const (
+ SOCK_STREAM = 1
+ SOCK_DGRAM = 2
+ SOCK_RAW = 3
+)
+
+const (
+ IPPROTO_IP = 0
+ IPPROTO_ICMP = 1
+ IPPROTO_TCP = 6
+ IPPROTO_UDP = 17
+ IPPROTO_ICMPV6 = 58
+)
+
+const (
+ AF_INET = 0x2
+ AF_INET6 = 0xa
+)
+
+const (
+ SOL_SOCKET = 0x1
+ SOL_TCP = 0x6
+)
+
+const (
+ SO_ACCEPTCONN = 0x1e
+ SO_BROADCAST = 0x6
+ SO_BSDCOMPAT = 0xe
+ SO_DEBUG = 0x1
+ SO_DOMAIN = 0x27
+ SO_DONTROUTE = 0x5
+ SO_ERROR = 0x4
+ SO_KEEPALIVE = 0x9
+ SO_LINGER = 0xd
+ SO_NO_CHECK = 0xb
+ SO_PASSCRED = 0x10
+ SO_PEERCRED = 0x11
+ SO_PRIORITY = 0xc
+ SO_PROTOCOL = 0x26
+ SO_RCVBUF = 0x8
+ SO_RCVBUFFORCE = 0x21
+ SO_RCVLOWAT = 0x12
+ SO_RCVTIMEO = 0x14
+ SO_REUSEADDR = 0x2
+ SO_REUSEPORT = 0xf
+ SO_SNDBUF = 0x7
+ SO_SNDBUFFORCE = 0x20
+ SO_SNDLOWAT = 0x13
+ SO_SNDTIMEO = 0x15
+ SO_TYPE = 0x3
+)
+
+const (
+ TCP_NODELAY = 1
+ TCP_MAXSEG = 2
+ TCP_CORK = 3
+ TCP_KEEPIDLE = 4
+ TCP_KEEPINTVL = 5
+ TCP_KEEPCNT = 6
+ TCP_SYNCNT = 7
+ TCP_LINGER2 = 8
+ TCP_DEFER_ACCEPT = 9
+ TCP_WINDOW_CLAMP = 10
+ TCP_INFO = 11
+ TCP_QUICKACK = 12
+)
diff --git a/src/syscall/ztypes_fuchsia_amd64.go b/src/syscall/ztypes_fuchsia_amd64.go
new file mode 100644
index 0000000..2f79cde
--- /dev/null
+++ b/src/syscall/ztypes_fuchsia_amd64.go
@@ -0,0 +1,28 @@
+// Copyright 2017 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 syscall
+
+// +build amd64,fuchsia
+
+type RawSockaddrInet4 struct {
+ Family uint16
+ Port uint16
+ Addr [4]byte /* in_addr */
+ Zero [8]uint8
+}
+
+type RawSockaddrInet6 struct {
+ Family uint16
+ Port uint16
+ Flowinfo uint32
+ Addr [16]byte /* in6_addr */
+ Scope_id uint32
+}
+
+const (
+ SizeofSockaddrInet4 = 0x10
+ SizeofSockaddrInet6 = 0x1c
+ SizeofSockaddrAny = 0x70
+)
diff --git a/src/syscall/ztypes_fuchsia_arm64.go b/src/syscall/ztypes_fuchsia_arm64.go
new file mode 100644
index 0000000..0cca414
--- /dev/null
+++ b/src/syscall/ztypes_fuchsia_arm64.go
@@ -0,0 +1,28 @@
+// Copyright 2017 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 syscall
+
+// +build arm64,fuchsia
+
+type RawSockaddrInet4 struct {
+ Family uint16
+ Port uint16
+ Addr [4]byte /* in_addr */
+ Zero [8]uint8
+}
+
+type RawSockaddrInet6 struct {
+ Family uint16
+ Port uint16
+ Flowinfo uint32
+ Addr [16]byte /* in6_addr */
+ Scope_id uint32
+}
+
+const (
+ SizeofSockaddrInet4 = 0x10
+ SizeofSockaddrInet6 = 0x1c
+ SizeofSockaddrAny = 0x70
+)
diff --git a/src/syscall/zx/dispatch/dispatcher.go b/src/syscall/zx/dispatch/dispatcher.go
new file mode 100644
index 0000000..df92757
--- /dev/null
+++ b/src/syscall/zx/dispatch/dispatcher.go
@@ -0,0 +1,225 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build fuchsia
+
+package dispatch
+
+import (
+ "strconv"
+ "sync"
+ "syscall/zx"
+)
+
+// WaitResult represents a wait result that is returned by the callback.
+// WaitResult determines whether the wait should be re-queued.
+type WaitResult int
+
+const (
+ WaitFinished WaitResult = iota
+ WaitAgain
+)
+
+// WaitID is a monotonically increasing ID which corresponds to a particular
+// call to BeginWait. Note that it may become invalidated if a wait is dequeued.
+type WaitID uint64
+
+// WaitFlags represents the collection of certain options for waiting.
+type WaitFlags uint32
+
+const (
+ HandleShutdown WaitFlags = 1 << 0 // Calls the callback on shutdown.
+)
+
+// Handler is the callback that will be called when the wait is complete.
+type Handler func(*Dispatcher, zx.Status, *zx.PacketSignal) WaitResult
+
+// waitContext is a bookkeeping structure for in-progress waits.
+type waitContext struct {
+ object zx.Handle
+ callback Handler
+ trigger zx.Signals
+ flags WaitFlags
+}
+
+// Dispatcher can read messages from a handle and assign them to a callback.
+type Dispatcher struct {
+ // port is the underlying port used to wait on signals and dispatch.
+ port zx.Port
+
+ // objects is a map that manages wait contexts.
+ mu sync.RWMutex
+ objects map[WaitID]*waitContext
+ nextWaitID WaitID
+
+ // handling is a map that manages which wait IDs that are current being
+ // handled. It is also protected by mu.
+ handling map[WaitID]struct{}
+
+ // shutdown is whether the dispatcher has shut down.
+ shutdown bool
+}
+
+// New creates a new dispatcher.
+func NewDispatcher() (*Dispatcher, error) {
+ port, err := zx.NewPort(0)
+ if err != nil {
+ return nil, err
+ }
+ return &Dispatcher{
+ port: port,
+ objects: make(map[WaitID]*waitContext),
+ handling: make(map[WaitID]struct{}),
+ }, nil
+}
+
+func assertWaitResult(result WaitResult, status zx.Status) {
+ if !(result == WaitFinished || (result == WaitAgain && status == zx.ErrOk)) {
+ panic("expected " + strconv.Itoa(int(result)) + " for status " + strconv.Itoa(int(status)))
+ }
+}
+
+// Closes a dispatcher, shutting down all handles added to the dispatcher.
+func (d *Dispatcher) Close() {
+ d.mu.Lock()
+ defer d.mu.Unlock()
+ d.port.Close()
+ for _, obj := range d.objects {
+ if obj != nil && (obj.flags&HandleShutdown) != 0 {
+ // Ignore the result; we won't be waiting again.
+ result := obj.callback(d, zx.ErrCanceled, nil)
+ assertWaitResult(result, zx.ErrCanceled)
+ }
+ }
+ d.objects = make(map[WaitID]*waitContext)
+ d.shutdown = true
+}
+
+func (d *Dispatcher) getWaitID() WaitID {
+ _, ok := d.objects[d.nextWaitID]
+ for ok {
+ d.nextWaitID++
+ _, ok = d.objects[d.nextWaitID]
+ }
+ return d.nextWaitID
+}
+
+// BeginWait creates a new wait on the handle h for signals t. The new wait
+// will respect the flags f, and call the handler c on wait completion.
+func (d *Dispatcher) BeginWait(h zx.Handle, t zx.Signals, f WaitFlags, c Handler) (WaitID, error) {
+ d.mu.Lock()
+ defer d.mu.Unlock()
+
+ // If we've shut down, just notify that we're in a bad state.
+ if d.shutdown {
+ return 0, zx.Error{Status: zx.ErrBadState}
+ }
+
+ // Register the wait.
+ id := d.getWaitID()
+ d.objects[id] = &waitContext{
+ object: h,
+ callback: c,
+ trigger: t,
+ flags: f,
+ }
+
+ // Schedule the wait on the port.
+ err := d.port.WaitAsync(h, uint64(id), t, zx.PortWaitAsyncOnce)
+
+ // If we fail, make sure to de-register the wait.
+ if err != nil {
+ delete(d.objects, id)
+ }
+ return id, err
+}
+
+// CancelWait cancels the wait with the given WaitID.
+func (d *Dispatcher) CancelWait(id WaitID) error {
+ d.mu.Lock()
+ defer d.mu.Unlock()
+
+ // Look up the wait context.
+ wc := d.objects[id]
+ if wc == nil {
+ return zx.Error{Status: zx.ErrNotFound}
+ }
+
+ // If we're currently handling it, it's not being waited on, so there's nothing
+ // to cancel.
+ _, ok := d.handling[id]
+ if ok {
+ return zx.Error{Status: zx.ErrNotFound}
+ }
+
+ // Deregister no matter what here. Due to stack semantics of defer, this will always
+ // execute before the lock is released.
+ defer delete(d.objects, id)
+
+ // Cancel the actual wait.
+ return d.port.Cancel(wc.object, uint64(id))
+}
+
+func (d *Dispatcher) dispatch(id WaitID, wc *waitContext, signals *zx.PacketSignal) {
+ // Deregister the handler before invoking it.
+ d.mu.Lock()
+ d.handling[id] = struct{}{}
+ d.mu.Unlock()
+
+ // Call the handler.
+ result := wc.callback(d, zx.ErrOk, signals)
+ assertWaitResult(result, zx.ErrOk)
+ switch result {
+ case WaitAgain:
+ // Re-arm the handler, as the handler requested. Use a fresh ID since there's a
+ // chance the old ID has already been re-used.
+ d.mu.Lock()
+ delete(d.handling, id)
+ err := d.port.WaitAsync(wc.object, uint64(id), wc.trigger, zx.PortWaitAsyncOnce)
+ d.mu.Unlock()
+
+ // If we fail to re-arm, notify the handler of what happened.
+ if err != nil {
+ zxErr := err.(zx.Error)
+ result = wc.callback(d, zxErr.Status, nil)
+ assertWaitResult(result, zxErr.Status)
+ }
+ case WaitFinished:
+ d.mu.Lock()
+ delete(d.handling, id)
+ delete(d.objects, id)
+ d.mu.Unlock()
+ }
+}
+
+// Serve runs indefinitely, waiting for the port to return a packet and dispatches
+// the relevant handlers.
+func (d *Dispatcher) Serve() {
+ for {
+ // Wait for any handler to be ready
+ var packet zx.Packet
+ err := d.port.Wait(&packet, zx.TimensecInfinite)
+ if err != nil {
+ d.Close()
+ return
+ }
+ id := WaitID(packet.Hdr.Key)
+
+ // Get the object for dispatching.
+ d.mu.RLock()
+ wc := d.objects[id]
+ d.mu.RUnlock()
+
+ // If handler was removed while this packet was in the queue,
+ // just go back to waiting.
+ if wc == nil {
+ continue
+ }
+
+ // Dispatch to the appropriate handler.
+ if packet.Hdr.Type == zx.PortPacketTypeSignalOne {
+ d.dispatch(id, wc, packet.Signal())
+ }
+ }
+}
diff --git a/src/syscall/zx/dispatch/dispatcher_test.go b/src/syscall/zx/dispatch/dispatcher_test.go
new file mode 100644
index 0000000..9c1975b
--- /dev/null
+++ b/src/syscall/zx/dispatch/dispatcher_test.go
@@ -0,0 +1,231 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build fuchsia
+
+package dispatch_test
+
+import (
+ "sync/atomic"
+ "syscall/zx"
+ . "syscall/zx/dispatch"
+ "testing"
+ "time"
+)
+
+func dispatcherTest(t *testing.T, name string, f func(d *Dispatcher) error) {
+ t.Run(name, func(t *testing.T) {
+ d, err := NewDispatcher()
+ if err != nil {
+ t.Fatal("creating dispatcher: ", err)
+ }
+ go d.Serve()
+ if err := f(d); err != nil {
+ t.Fatal("executing test: ", err)
+ }
+ d.Close()
+ })
+}
+
+func TestWait(t *testing.T) {
+ t.Parallel()
+ dispatcherTest(t, "WaitOnce", func(d *Dispatcher) error {
+ h0, h1, err := zx.NewChannel(0)
+ if err != nil {
+ return err
+ }
+ defer h0.Close()
+
+ done := make(chan struct{}, 1)
+ defer close(done)
+
+ handler := func(d *Dispatcher, s zx.Status, p *zx.PacketSignal) WaitResult {
+ done <- struct{}{}
+ return WaitFinished
+ }
+
+ _, err = d.BeginWait(zx.Handle(h0), zx.SignalChannelPeerClosed, 0, handler)
+ if err != nil {
+ return err
+ }
+
+ h1.Close()
+
+ select {
+ case <-done:
+ return nil
+ case <-time.After(5 * time.Second):
+ t.Fatal("timed out, handler never executed")
+ }
+ return nil
+ })
+ dispatcherTest(t, "WaitMultipleTimes", func(d *Dispatcher) error {
+ h0, h1, err := zx.NewChannel(0)
+ if err != nil {
+ return err
+ }
+ defer h0.Close()
+ defer h1.Close()
+
+ done := make(chan struct{}, 1)
+ defer close(done)
+
+ handler := func(d *Dispatcher, s zx.Status, p *zx.PacketSignal) WaitResult {
+ var b [zx.ChannelMaxMessageBytes]byte
+ var h [zx.ChannelMaxMessageHandles]zx.Handle
+ bn, hn, err := h0.Read(b[:], h[:], 0)
+ if err != nil {
+ t.Fatal("error reading: ", err)
+ }
+ if bn != 1 || hn != 0 {
+ t.Fatalf("unexpected read %d bytes %d handles", bn, hn)
+ }
+ if b[0] == 1 {
+ return WaitAgain
+ }
+ done <- struct{}{}
+ return WaitFinished
+ }
+
+ _, err = d.BeginWait(zx.Handle(h0), zx.SignalChannelReadable, 0, handler)
+ if err != nil {
+ return err
+ }
+
+ for i := 0; i < 5; i++ {
+ if err := h1.Write([]byte{1}, nil, 0); err != nil {
+ return err
+ }
+ }
+ if err := h1.Write([]byte{0}, nil, 0); err != nil {
+ return err
+ }
+
+ select {
+ case <-done:
+ return nil
+ case <-time.After(5 * time.Second):
+ t.Fatal("timed out, handler never executed")
+ }
+ return nil
+ })
+ dispatcherTest(t, "CancelWaitHandleShutdown", func(d *Dispatcher) error {
+ h0, h1, err := zx.NewChannel(0)
+ if err != nil {
+ return err
+ }
+ defer h0.Close()
+ defer h1.Close()
+
+ var i uint32
+ handler := func(d *Dispatcher, s zx.Status, p *zx.PacketSignal) WaitResult {
+ atomic.AddUint32(&i, 1)
+ return WaitFinished
+ }
+
+ id, err := d.BeginWait(zx.Handle(h0), zx.SignalChannelPeerClosed, HandleShutdown, handler)
+ if err != nil {
+ return err
+ }
+
+ if err := d.CancelWait(id); err != nil {
+ return err
+ }
+ d.Close()
+ if i != 0 {
+ t.Fatal("handler ran unexpectedly")
+ }
+ return nil
+ })
+ dispatcherTest(t, "Shutdown", func(d *Dispatcher) error {
+ h0, h1, err := zx.NewChannel(0)
+ if err != nil {
+ return err
+ }
+ defer h0.Close()
+ defer h1.Close()
+
+ handler := func(d *Dispatcher, s zx.Status, p *zx.PacketSignal) WaitResult {
+ return WaitFinished
+ }
+ d.Close()
+
+ _, err = d.BeginWait(zx.Handle(h0), zx.SignalChannelPeerClosed, 0, handler)
+ if err == nil {
+ t.Fatal("unexpected success for BeginWait on shut down dispatcher")
+ }
+ return nil
+ })
+ dispatcherTest(t, "HandleShutdown", func(d *Dispatcher) error {
+ h0, h1, err := zx.NewChannel(0)
+ if err != nil {
+ return err
+ }
+ defer h0.Close()
+ defer h1.Close()
+
+ done := make(chan struct{}, 1)
+ defer close(done)
+
+ handler := func(d *Dispatcher, s zx.Status, p *zx.PacketSignal) WaitResult {
+ done <- struct{}{}
+ return WaitFinished
+ }
+
+ _, err = d.BeginWait(zx.Handle(h0), zx.SignalChannelPeerClosed, HandleShutdown, handler)
+ if err != nil {
+ return err
+ }
+ d.Close()
+
+ select {
+ case <-done:
+ return nil
+ case <-time.After(5 * time.Second):
+ t.Fatal("timed out, handler never executed")
+ }
+ return nil
+ })
+ dispatcherTest(t, "MultipleGoroutines", func(d *Dispatcher) error {
+ // Spin up 5 goroutines all serving the dispatcher.
+ for i := 0; i < 5; i++ {
+ go d.Serve()
+ }
+
+ done := make(chan struct{}, 20)
+ defer close(done)
+
+ var ends []zx.Channel
+ for i := 0; i < 20; i++ {
+ h0, h1, err := zx.NewChannel(0)
+ if err != nil {
+ return err
+ }
+ defer h0.Close()
+
+ handler := func(d *Dispatcher, s zx.Status, p *zx.PacketSignal) WaitResult {
+ done <- struct{}{}
+ return WaitFinished
+ }
+
+ _, err = d.BeginWait(zx.Handle(h0), zx.SignalChannelPeerClosed, 0, handler)
+ if err != nil {
+ return err
+ }
+ ends = append(ends, h1)
+ }
+ for _, e := range ends {
+ e.Close()
+ }
+ for i := 0; i < 20; i++ {
+ select {
+ case <-done:
+ continue
+ case <-time.After(3 * time.Second):
+ t.Fatal("timed out, some handler never executed")
+ }
+ }
+ return nil
+ })
+}
diff --git a/src/syscall/zx/fdio/client.go b/src/syscall/zx/fdio/client.go
new file mode 100644
index 0000000..f7af0dc
--- /dev/null
+++ b/src/syscall/zx/fdio/client.go
@@ -0,0 +1,38 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build fuchsia
+
+package fdio
+
+import (
+ "syscall/zx"
+ "syscall/zx/fidl"
+ "syscall/zx/io"
+)
+
+func ServiceConnect(svcpath string, h zx.Handle) error {
+ // Otherwise attempt to connect through the root namespace.
+ ns, err := NewNSFromMap(zx.RootNSMap)
+ if err == nil {
+ return ns.Connect(svcpath, h)
+ }
+ h.Close()
+ return zx.Error{Status: zx.ErrNotFound, Text: "fdio.ServiceConnect"}
+}
+
+func ServiceConnectAt(dir zx.Handle, path string, h zx.Handle) error {
+ if !dir.IsValid() || !h.IsValid() {
+ return zx.Error{Status: zx.ErrInvalidArgs, Text: "fdio.ServiceConnectAt"}
+ }
+ // Open the path on the remote.
+ iface := (*io.DirectoryInterface)(&fidl.Proxy{Channel: zx.Channel(dir)})
+ req := io.ObjectInterfaceRequest(fidl.InterfaceRequest{Channel: zx.Channel(h)})
+ err := iface.Open(io.KOpenRightReadable|io.KOpenRightWritable, 0755, path, req)
+ if err != nil {
+ h.Close()
+ return err
+ }
+ return nil
+}
diff --git a/src/syscall/zx/fdio/directory.go b/src/syscall/zx/fdio/directory.go
new file mode 100644
index 0000000..1b0dcd4
--- /dev/null
+++ b/src/syscall/zx/fdio/directory.go
@@ -0,0 +1,182 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build fuchsia
+
+package fdio
+
+import (
+ "path"
+ "syscall/zx"
+ "syscall/zx/fidl"
+ "syscall/zx/io"
+)
+
+// Directory is a wrapper around a DirectoryInterface which implements FDIO.
+type Directory struct {
+ Node
+}
+
+func (d *Directory) getToken() (zx.Handle, error) {
+ status, token, err := d.DirectoryInterface().GetToken()
+ if err != nil {
+ return zx.HandleInvalid, err
+ } else if status != zx.ErrOk {
+ return zx.HandleInvalid, zx.Error{Status: status, Text: "io.directory"}
+ }
+ return token, nil
+}
+
+// DirectoryInterface returns the underlying Directory FIDL interface.
+func (d *Directory) DirectoryInterface() *io.DirectoryInterface {
+ return (*io.DirectoryInterface)(d.Node.Object.ObjectInterface)
+}
+
+// Close closes the Directory object.
+func (d *Directory) Close() error {
+ defer ((*fidl.Proxy)(d.Node.Object.ObjectInterface)).Close()
+ if status, err := d.Node.Object.ObjectInterface.Close(); err != nil {
+ return err
+ } else if status != zx.ErrOk {
+ return zx.Error{Status: status, Text: "io.directory"}
+ }
+ return nil
+}
+
+// Open opens an FDIO at path with the given flags and mode relative to this
+// Directory.
+func (d *Directory) Open(pathname string, flags uint32, mode uint32) (FDIO, error) {
+ req, obj, err := io.NewObjectInterfaceRequest()
+ if err != nil {
+ return nil, err
+ }
+ err = d.DirectoryInterface().Open(flags|io.KOpenFlagDescribe, mode, pathname, req)
+ if err != nil {
+ return nil, err
+ }
+ status, info, err := obj.ExpectOnOpen()
+ if err != nil {
+ return nil, err
+ } else if status != zx.ErrOk {
+ return nil, zx.Error{Status: status, Text: "io.directory"}
+ }
+ return objectFromInfo(info, obj)
+}
+
+func (d *Directory) openParent(pathname string) (FDIO, string, error) {
+ dirpath, name := path.Split(pathname)
+ parent, err := d.Open(path.Dir(dirpath), io.KOpenRightReadable, io.KOpenFlagDirectory)
+ if err != nil {
+ return nil, "", err
+ }
+ return parent, name, err
+}
+
+// Link creates a link between two paths under this Directory.
+func (d *Directory) Link(oldpath, newpath string) error {
+ oldparent, oldname, err := d.openParent(oldpath)
+ if err != nil {
+ return err
+ }
+ defer oldparent.Close()
+ newparent, newname, err := d.openParent(newpath)
+ if err != nil {
+ return err
+ }
+ defer newparent.Close()
+ olddir, ok := oldparent.(*Directory)
+ if !ok {
+ return zx.Error{Status: zx.ErrNotSupported, Text: "io.directory"}
+ }
+ newdir, ok := newparent.(*Directory)
+ if !ok {
+ return zx.Error{Status: zx.ErrNotSupported, Text: "io.directory"}
+ }
+ token, err := newdir.getToken()
+ if err != nil {
+ return err
+ }
+ status, err := olddir.DirectoryInterface().Link(oldname, token, newname)
+ if err != nil {
+ return err
+ } else if status != zx.ErrOk {
+ return zx.Error{Status: status, Text: "io.directory"}
+ }
+ return nil
+}
+
+// Rename renames an object at one path to another under this Directory.
+func (d *Directory) Rename(oldpath, newpath string) error {
+ oldf, oldname, err := d.openParent(oldpath)
+ if err != nil {
+ return err
+ }
+ defer oldf.Close()
+ newf, newname, err := d.openParent(newpath)
+ if err != nil {
+ return err
+ }
+ defer newf.Close()
+ olddir, ok := oldf.(*Directory)
+ if !ok {
+ return zx.Error{Status: zx.ErrNotSupported, Text: "io.directory"}
+ }
+ newdir, ok := newf.(*Directory)
+ if !ok {
+ return zx.Error{Status: zx.ErrNotSupported, Text: "io.directory"}
+ }
+ token, err := newdir.getToken()
+ if err != nil {
+ return err
+ }
+ status, err := olddir.DirectoryInterface().Rename(oldname, token, newname)
+ if err != nil {
+ return err
+ } else if status != zx.ErrOk {
+ return zx.Error{Status: status, Text: "io.directory"}
+ }
+ return nil
+}
+
+// Unlink unlinks an object at a pauth under this Directory.
+func (d *Directory) Unlink(pathname string) error {
+ parent, name, err := d.openParent(pathname)
+ if err != nil {
+ return err
+ }
+ defer parent.Close()
+ parentdir, ok := parent.(*Directory)
+ if !ok {
+ return zx.Error{Status: zx.ErrNotSupported, Text: "io.directory"}
+ }
+ if status, err := parentdir.DirectoryInterface().Unlink(name); err != nil {
+ return err
+ } else if status != zx.ErrOk {
+ return zx.Error{Status: status, Text: "io.directory"}
+ }
+ return nil
+}
+
+// ReadDirents returns up to max-worth bytes of byte-encoded dirents which represent
+// objects under this Directory. Repeated calls to ReadDirents continues giving back
+// objects.
+func (d *Directory) ReadDirents(max uint64) ([]byte, error) {
+ status, dirents, err := d.DirectoryInterface().ReadDirents(max)
+ if err != nil {
+ return nil, err
+ } else if status != zx.ErrOk {
+ return nil, zx.Error{Status: status, Text: "io.file"}
+ }
+ return dirents, nil
+}
+
+// Rewind resets the ReadDirents' counter.
+func (d *Directory) Rewind() error {
+ if status, err := d.DirectoryInterface().Rewind(); err != nil {
+ return err
+ } else if status != zx.ErrOk {
+ return zx.Error{Status: status, Text: "io.directory"}
+ }
+ return nil
+}
diff --git a/src/syscall/zx/fdio/fdio.go b/src/syscall/zx/fdio/fdio.go
new file mode 100644
index 0000000..eca6eb7
--- /dev/null
+++ b/src/syscall/zx/fdio/fdio.go
@@ -0,0 +1,225 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build fuchsia
+
+// Package fdio provides unix-style IO, implementing Zircon's "system/ulib/fdio"
+package fdio
+
+import (
+ "syscall/zx"
+ "syscall/zx/io"
+)
+
+const (
+ // MaxUnderlyingHandles is the maximum number of handles which are
+ // necessary to implement any FDIO object.
+ MaxUnderlyingHandles = 2
+)
+
+// FDIO provides classic unix-style IO over various transports
+type FDIO interface {
+ Handles() []zx.Handle
+
+ Clone() (FDIO, error)
+ Close() error
+
+ Sync() error
+ GetAttr() (io.NodeAttributes, error)
+ SetAttr(flags uint32, attr io.NodeAttributes) error
+ Ioctl(op uint32, max uint64, in []byte, handles []zx.Handle) ([]byte, []zx.Handle, error)
+
+ Read(data []byte) (int, error)
+ ReadAt(data []byte, off int64) (int, error)
+ Write(data []byte) (int, error)
+ WriteAt(data []byte, off int64) (int, error)
+ Seek(offset int64, whence int) (int64, error)
+ Truncate(length uint64) error
+
+ Open(path string, flags uint32, mode uint32) (FDIO, error)
+ Link(oldpath, newpath string) error
+ Rename(oldpath, newpath string) error
+ Unlink(path string) error
+ ReadDirents(max uint64) ([]byte, error)
+ Rewind() error
+}
+
+// FDIO Ioctls
+func IoctlNum(kind, family, number uint32) uint32 {
+ return ((kind & 0xF) << 20) | ((family & 0xFF) << 8) | (number & 0xFF)
+}
+func IoctlKind(ioctl uint32) uint32 {
+ return (ioctl >> 20) & 0xF
+}
+func IoctlFamily(ioctl uint32) uint32 {
+ return (ioctl >> 8) & 0xFF
+}
+func IoctlNumber(ioctl uint32) uint32 {
+ return ioctl & 0xFF
+}
+
+const (
+ // IoctlMaxInput is the largest acceptable size for an Ioctl op input.
+ IoctlMaxInput = 1024
+)
+
+const (
+ IoctlKindDefault = 0x0 // IOCTL_KIND_DEFAULT
+ IoctlKindGetHandle = 0x1 // IOCTL_KIND_GET_HANDLE
+ IoctlKindGetTwoHandles = 0x2 // IOCTL_KIND_GET_TWO_HANDLES
+ IoctlKindSetHandle = 0x3 // IOCTL_KIND_SET_HANDLE
+ IoctlKindGetThreeHandles = 0x4 // IOCTL_KIND_GET_THREE_HANDLES
+)
+
+const (
+ IoctlFamilyReserved = 0x00 // IOCTL_FAMILY_RESERVED
+ IoctlFamilyDevice = 0x01 // IOCTL_FAMILY_DEVICE
+ IoctlFamilyVFS = 0x02 // IOCTL_FAMILY_VFS
+ IoctlFamilyDMCTL = 0x03 // IOCTL_FAMILY_DMCTL
+ IoctlFamilyTest = 0x04 // IOCTL_FAMILY_TEST
+)
+
+const (
+ IoctlFamilyBlock = 0x13 // IOCTL_FAMILY_BLOCK
+ IoctlFamilyNetconfig = 0x26 // IOCTL_FAMILY_NETCONFIG
+)
+
+const (
+ IoctlFamilyPower = 0x30 // IOCTL_FAMILY_POWER
+)
+
+var IoctlDeviceBind = IoctlNum(IoctlKindDefault, IoctlFamilyDevice, 0)
+var IoctlDeviceGetEventHandle = IoctlNum(IoctlKindGetHandle, IoctlFamilyDevice, 1)
+var IoctlDeviceGetDriverName = IoctlNum(IoctlKindDefault, IoctlFamilyDevice, 2)
+var IoctlDeviceGetDeviceName = IoctlNum(IoctlKindDefault, IoctlFamilyDevice, 3)
+var IoctlDeviceGetTopoPath = IoctlNum(IoctlKindDefault, IoctlFamilyDevice, 4)
+var IoctlDeviceSync = IoctlNum(IoctlKindDefault, IoctlFamilyDevice, 6)
+var IoctlDeviceDebugSuspend = IoctlNum(IoctlKindDefault, IoctlFamilyDevice, 7)
+var IoctlDeviceDebugResume = IoctlNum(IoctlKindDefault, IoctlFamilyDevice, 8)
+
+var IoctlVFSMountFS = IoctlNum(IoctlKindSetHandle, IoctlFamilyVFS, 0)
+var IoctlVFSUnmountFS = IoctlNum(IoctlKindDefault, IoctlFamilyVFS, 1)
+var IoctlVFSUnmountNode = IoctlNum(IoctlKindGetHandle, IoctlFamilyVFS, 2)
+var IoctlVFSQueryFS = IoctlNum(IoctlKindDefault, IoctlFamilyVFS, 4)
+var IoctlVFSGetTokenFS = IoctlNum(IoctlKindGetHandle, IoctlFamilyVFS, 5)
+var IoctlVFSWatchDir = IoctlNum(IoctlKindSetHandle, IoctlFamilyVFS, 8)
+var IoctlVFSGetDevicePath = IoctlNum(IoctlKindDefault, IoctlFamilyVFS, 9)
+
+var IoctlPowerGetInfo = IoctlNum(IoctlKindDefault, IoctlFamilyPower, 1)
+var IoctlPowerGetBatteryInfo = IoctlNum(IoctlKindDefault, IoctlFamilyPower, 2)
+var IoctlPowerGetStateChangeEvent = IoctlNum(IoctlKindGetHandle, IoctlFamilyPower, 3)
+
+type PowerInfoResult struct {
+ PowerType uint32
+ State uint32
+}
+
+type BatteryInfoResult struct {
+ Unit uint32
+ DesignCapacity uint32
+ LastFullCapacity uint32
+ DesignVoltage uint32
+ CapacityWarning uint32
+ CapacityLow uint32
+ CapacityGranularityLowWarning uint32
+ CapacityGranularityWarningFull uint32
+ PresentRate int32
+ RemainingCapacity uint32
+ PresentVoltage uint32
+}
+
+const (
+ PowerTypeAC = 0
+ PowerTypeBattery = 1
+
+ PowerStateOnline = 1 << 0
+ PowerStateDischarging = 1 << 1
+ PowerStateCharging = 1 << 2
+ PowerStateCritical = 1 << 3
+
+ BatteryUnitMW = 0
+ BatteryUnitMA = 1
+)
+
+type VFSWatchDirRequest struct {
+ H zx.Handle
+ Mask uint32
+ Options uint32
+}
+
+const (
+ VFSWatchEventDeleted = iota
+ VFSWatchEventAdded
+ VFSWatchEventRemoved
+ VFSWatchEventExisting
+ VFSWatchEventIdle
+)
+
+const (
+ VFSWatchMaskDeleted = 1 << iota
+ VFSWatchMaskAdded
+ VFSWatchMaskRemoved
+ VFSWatchMaskExisting
+ VFSWatchMaskIdle
+ VFSWatchMaskAll = 0x1F
+)
+
+type Vnattr struct {
+ Valid uint32
+ Mode Vtype
+ Inode uint64
+ Size uint64
+ Blksize uint64
+ Blkcount uint64
+ Nlink uint64
+ CreateTime uint64
+ ModifyTime uint64
+}
+
+// VnattrBlksize is the size of block used in "Blockcount", which may be distinct from Blksize.
+const VnattrBlksize = 512
+
+const (
+ AttrCtime = 1 << iota
+ AttrMtime
+ AttrAtime
+)
+
+type Vtype uint32
+
+// bit-compatible with POSIX stat
+const (
+ VtypeMask Vtype = 0170000
+ VtypeSock Vtype = 0140000
+ VtypeLink Vtype = 0120000
+ VtypeFile Vtype = 0100000
+ VtypeBdev Vtype = 0060000
+ VtypeDir Vtype = 0040000
+ VtypeCdev Vtype = 0020000
+ VtypePipe Vtype = 0010000
+
+ VtypeISUID Vtype = 0004000
+ VtypeISGID Vtype = 0002000
+ VtypeISVTX Vtype = 0001000
+ VtypeIRWXU Vtype = 0000700
+ VtypeIRUSR Vtype = 0000400
+ VtypeIWUSR Vtype = 0000200
+ VtypeIXUSR Vtype = 0000100
+ VtypeIRWXG Vtype = 0000070
+ VtypeIRGRP Vtype = 0000040
+ VtypeIWGRP Vtype = 0000020
+ VtypeIXGRP Vtype = 0000010
+ VtypeIRWXO Vtype = 0000007
+ VtypeIROTH Vtype = 0000004
+ VtypeIWOTH Vtype = 0000002
+ VtypeIXOTH Vtype = 0000001
+)
+
+const (
+ HandleTypeRemote = 0x32
+ HandleTypePipe = 0x33
+ HandleTypeEvent = 0x34
+ HandleTypeLogger = 0x35
+ HandleTypeSocket = 0x36
+)
diff --git a/src/syscall/zx/fdio/file.go b/src/syscall/zx/fdio/file.go
new file mode 100644
index 0000000..2d847d0
--- /dev/null
+++ b/src/syscall/zx/fdio/file.go
@@ -0,0 +1,152 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build fuchsia
+
+package fdio
+
+import (
+ "syscall/zx"
+ "syscall/zx/io"
+)
+
+// File is a wrapper around a FileInterface which implements FDIO.
+type File struct {
+ Node
+ Event zx.Event
+}
+
+// FileInterface returns the underlying File FIDL interface.
+func (f *File) FileInterface() *io.FileInterface {
+ return (*io.FileInterface)(f.Node.Object.ObjectInterface)
+}
+
+// Handles returns all the underlying handles for this file,
+// which is the control channel and an event.
+func (f *File) Handles() []zx.Handle {
+ return append(f.Node.Handles(), zx.Handle(f.Event))
+}
+
+// Close closes all the control channel and event associated with the file
+// object.
+func (f *File) Close() error {
+ defer f.Event.Close()
+ return f.Node.Close()
+}
+
+// read reads data from a File. If off == -1 then it does a read
+// from whatever the seek offset is.
+func (f *File) read(data []byte, off int64) (int, error) {
+ ptr := 0
+ for ptr < len(data) {
+ bytesToRead := int(io.KMaxBuf)
+ if len(data)-ptr < int(io.KMaxBuf) {
+ bytesToRead = len(data) - ptr
+ }
+ var status zx.Status
+ var out []byte
+ var err error
+ if off == -1 {
+ status, out, err = f.FileInterface().Read(uint64(bytesToRead))
+ } else {
+ status, out, err = f.FileInterface().ReadAt(
+ uint64(bytesToRead),
+ uint64(int64(ptr)+off),
+ )
+ }
+ if err != nil {
+ return ptr, err
+ } else if status != zx.ErrOk {
+ return ptr, zx.Error{Status: status, Text: "io.file"}
+ }
+ if len(out) == 0 {
+ return ptr, nil
+ }
+ copy(data[ptr:ptr+len(out)], out)
+ ptr += len(out)
+ // Stop at short read.
+ if len(out) < bytesToRead {
+ return ptr, nil
+ }
+ }
+ return ptr, nil
+}
+
+// Read reads data from the internally held offset in the File.
+func (f *File) Read(data []byte) (int, error) {
+ return f.read(data, -1)
+}
+
+// ReadAt reads data at an offset in a File.
+func (f *File) ReadAt(data []byte, off int64) (int, error) {
+ return f.read(data, off)
+}
+
+// write writes data to a file. If off == -1 then the write occurs at
+// whatever the seek offset is.
+func (f *File) write(data []byte, off int64) (int, error) {
+ ptr := 0
+ for ptr < len(data) {
+ bytesToWrite := int(io.KMaxBuf)
+ if len(data)-ptr < int(io.KMaxBuf) {
+ bytesToWrite = len(data) - ptr
+ }
+ var status zx.Status
+ var written uint64
+ var err error
+ if off == -1 {
+ status, written, err = f.FileInterface().Write(
+ data[ptr : ptr+bytesToWrite],
+ )
+ } else {
+ status, written, err = f.FileInterface().WriteAt(
+ data[ptr:ptr+bytesToWrite],
+ uint64(int64(ptr)+off),
+ )
+ }
+ if err != nil {
+ return ptr, err
+ } else if status != zx.ErrOk {
+ return ptr, zx.Error{Status: status, Text: "io.file"}
+ }
+ ptr += int(written)
+ // Error on a short write.
+ if int(written) < bytesToWrite {
+ return ptr, zx.Error{Status: zx.ErrIO, Text: "io.file"}
+ }
+ }
+ return ptr, nil
+}
+
+// Write writes data at the internally held offset in the File.
+func (f *File) Write(data []byte) (int, error) {
+ return f.write(data, -1)
+}
+
+// WriteAt writes data at an offset in a File.
+func (f *File) WriteAt(data []byte, off int64) (int, error) {
+ return f.write(data, off)
+}
+
+// Seek moves the read/write head offset of the File.
+func (f *File) Seek(offset int64, whence int) (int64, error) {
+ status, off, err := f.FileInterface().Seek(offset, io.SeekOrigin(whence))
+ if err != nil {
+ return -1, err
+ } else if status != zx.ErrOk {
+ return -1, zx.Error{Status: status, Text: "io.file"}
+ }
+ return int64(off), nil
+}
+
+// Truncate truncates a File.
+func (f *File) Truncate(length uint64) error {
+ status, err := f.FileInterface().Truncate(length)
+ if err != nil {
+ return err
+ } else if status != zx.ErrOk {
+ return zx.Error{Status: status, Text: "io.file"}
+ }
+ return nil
+}
diff --git a/src/syscall/zx/fdio/logger.go b/src/syscall/zx/fdio/logger.go
new file mode 100644
index 0000000..d5723b6
--- /dev/null
+++ b/src/syscall/zx/fdio/logger.go
@@ -0,0 +1,134 @@
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build fuchsia
+
+package fdio
+
+import (
+ "syscall/zx"
+ "syscall/zx/io"
+)
+
+type Logger struct {
+ log zx.Log
+ logBufferArray [1024]byte
+ logBufferN int
+}
+
+func NewLogger(log zx.Log) *Logger {
+ return &Logger{log: log}
+}
+
+// Clone makes a clone of the object.
+func (f *Logger) Clone() (FDIO, error) {
+ logHandle := zx.Handle(f.log)
+ h, err := logHandle.Duplicate(zx.RightSameRights)
+ if err != nil {
+ return nil, err
+ }
+ return NewLogger(zx.Log(h)), nil
+}
+
+// Handle returns the underlying log handle as an untyped handle.
+func (f *Logger) Handles() []zx.Handle {
+ return []zx.Handle{zx.Handle(f.log)}
+}
+
+// Close closes the object.
+func (f *Logger) Close() error {
+ return f.log.Close()
+}
+
+// Sync implements FDIO for Logger.
+func (f *Logger) Sync() error {
+ return zx.Error{Status: zx.ErrNotSupported, Text: "fdio.logger"}
+}
+
+// GetAttr implements FDIO for Logger.
+func (f *Logger) GetAttr() (io.NodeAttributes, error) {
+ return io.NodeAttributes{}, zx.Error{Status: zx.ErrNotSupported, Text: "fdio.logger"}
+}
+
+// SetAttr implements FDIO for Logger.
+func (f *Logger) SetAttr(flags uint32, attr io.NodeAttributes) error {
+ return zx.Error{Status: zx.ErrNotSupported, Text: "fdio.logger"}
+}
+
+// Ioctl implements FDIO for Logger.
+func (f *Logger) Ioctl(op uint32, max uint64, in []byte, handles []zx.Handle) ([]byte, []zx.Handle, error) {
+ return nil, nil, zx.Error{Status: zx.ErrNotSupported, Text: "fdio.logger"}
+}
+
+// Read implements FDIO for Logger.
+func (f *Logger) Read(data []byte) (int, error) {
+ return 0, zx.Error{Status: zx.ErrNotSupported, Text: "fdio.logger"}
+}
+
+// ReadAt implements FDIO for Logger.
+func (f *Logger) ReadAt(data []byte, off int64) (int, error) {
+ return 0, zx.Error{Status: zx.ErrNotSupported, Text: "fdio.logger"}
+}
+
+// Write implements FDIO for Logger.
+func (f *Logger) Write(data []byte) (int, error) {
+ // Sys_log_write adds a newline to output buffers. To prevent fragmented logs, we buffer
+ // output until a newline character is encountered.
+ f.logBufferN += copy(f.logBufferArray[f.logBufferN:], data)
+ if f.logBufferArray[f.logBufferN-1] == '\n' {
+ n, err := f.log.Write(f.logBufferArray[:f.logBufferN])
+ // Flush buffer, regardless of status returned from write
+ f.logBufferN = 0
+ if err != nil {
+ return len(data), nil
+ }
+ return n, err
+ }
+ return len(data), nil
+}
+
+// WriteAt implements FDIO for Logger.
+func (f *Logger) WriteAt(data []byte, off int64) (int, error) {
+ return 0, zx.Error{Status: zx.ErrNotSupported, Text: "fdio.logger"}
+}
+
+// Seek implements FDIO for Logger.
+func (f *Logger) Seek(offset int64, whence int) (int64, error) {
+ return 0, zx.Error{Status: zx.ErrNotSupported, Text: "fdio.logger"}
+}
+
+// Truncate implements FDIO for Logger.
+func (f *Logger) Truncate(length uint64) error {
+ return zx.Error{Status: zx.ErrNotSupported, Text: "fdio.logger"}
+}
+
+// Open implements FDIO for Logger.
+func (f *Logger) Open(path string, flags uint32, mode uint32) (FDIO, error) {
+ return nil, zx.Error{Status: zx.ErrNotSupported, Text: "fdio.logger"}
+}
+
+// Link implements FDIO for Logger.
+func (f *Logger) Link(oldpath, newpath string) error {
+ return zx.Error{Status: zx.ErrNotSupported, Text: "fdio.logger"}
+}
+
+// Rename implements FDIO for Logger.
+func (f *Logger) Rename(oldpath, newpath string) error {
+ return zx.Error{Status: zx.ErrNotSupported, Text: "fdio.logger"}
+}
+
+// Unlink implements FDIO for Logger.
+func (f *Logger) Unlink(path string) error {
+ return zx.Error{Status: zx.ErrNotSupported, Text: "fdio.logger"}
+}
+
+// ReadDirents implements FDIO for Logger.
+func (f *Logger) ReadDirents(max uint64) ([]byte, error) {
+ return nil, zx.Error{Status: zx.ErrNotSupported, Text: "fdio.logger"}
+}
+
+// Rewind implements FDIO for Logger.
+func (f *Logger) Rewind() error {
+ return zx.Error{Status: zx.ErrNotSupported, Text: "fdio.logger"}
+}
diff --git a/src/syscall/zx/fdio/message.go b/src/syscall/zx/fdio/message.go
new file mode 100644
index 0000000..f5c55a3
--- /dev/null
+++ b/src/syscall/zx/fdio/message.go
@@ -0,0 +1,74 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build fuchsia
+
+package fdio
+
+const (
+ OpFlagOneHandle = uint32(0x100 + iota)
+ OpFlagTwoHandles
+ OpFlagThreeHandles
+)
+
+// Values for op. Each one will signify a request for a different operation.
+const (
+ _ = uint32(iota)
+ OpClose
+ OpClone = uint32(iota) | OpFlagOneHandle
+ OpOpen = uint32(iota) | OpFlagOneHandle
+ OpMisc = uint32(iota)
+ OpRead
+ OpWrite
+ OpSeek
+ OpStat
+ OpReaddir
+ OpIoctl
+ OpUnlink
+ OpReadAt
+ OpWriteAt
+ OpTruncate
+ OpRename = uint32(iota) | OpFlagOneHandle
+ OpConnect = uint32(iota)
+ OpBind
+ OpListen
+ OpGetSockname
+ OpGetPeerName
+ OpGetSockOpt
+ OpSetSockOpt
+ OpGetAddrInfo
+ OpSetAttr
+ OpSync
+ OpLink = uint32(iota) | OpFlagOneHandle
+ OpMmap = uint32(iota)
+ OpFcntl
+ OpAccept
+ OpNumOps = uint32(iota) // The total number of operations
+)
+
+// Control ordinal operations. Sent from server to client without
+// necessarily having an accompanying request message.
+const (
+ OpOnOpen = uint32(0x80000007)
+)
+
+const (
+ OpenFlagDescribe = 0x00800000
+)
+
+const (
+ OpOpenFlagReadable = 1
+ OpOpenFlagWritable = 2
+ OpOpenFlagRDWR = OpOpenFlagReadable | OpOpenFlagWritable
+)
+
+// Ops which correspond to a previously listed operation, but have a different number of handles
+const (
+ OpIoctlOneHandle = OpIoctl | OpFlagOneHandle
+)
+
+const (
+ OpFcntlCmdGetFL = uint32(iota + 3)
+ OpFcntlCmdSetFL
+)
diff --git a/src/syscall/zx/fdio/mxc/mxc.go b/src/syscall/zx/fdio/mxc/mxc.go
new file mode 100644
index 0000000..5997cbfa
--- /dev/null
+++ b/src/syscall/zx/fdio/mxc/mxc.go
@@ -0,0 +1,19 @@
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build fuchsia
+
+package mxc
+
+import "syscall"
+
+func ExtractCFDIO(fd int) (uintptr, error) {
+ // Extract the 'C' fdio
+ f, err := transferFDIOFromCFD(fd)
+ if err != nil {
+ return 0, err
+ }
+ // Convert it to a 'Go' fdio
+ return uintptr(syscall.OpenFDIO(f)), nil
+}
diff --git a/src/syscall/zx/fdio/mxc/mxc_cgo.go b/src/syscall/zx/fdio/mxc/mxc_cgo.go
new file mode 100644
index 0000000..dd6795c
--- /dev/null
+++ b/src/syscall/zx/fdio/mxc/mxc_cgo.go
@@ -0,0 +1,59 @@
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build fuchsia
+// +build cgo
+
+package mxc
+
+// #cgo fuchsia LDFLAGS: -lfdio
+// #include <zircon/types.h>
+// #include <zircon/syscalls.h>
+// #include <stdlib.h>
+// #include <lib/fdio/util.h>
+import "C"
+import (
+ "errors"
+ "syscall/zx"
+ "syscall/zx/fdio"
+ "syscall/zx/fidl"
+ "syscall/zx/io"
+)
+
+func transferFDIOFromCFD(fd int) (fdio.FDIO, error) {
+ handlesC := make([]C.zx_handle_t, fdio.MaxUnderlyingHandles)
+ typesC := make([]C.uint32_t, fdio.MaxUnderlyingHandles)
+ status := C.fdio_transfer_fd(C.int(fd), 0, (*C.zx_handle_t)(&handlesC[0]), (*C.uint32_t)(&typesC[0]))
+ if status < 0 {
+ return nil, zx.Error{Status: zx.Status(status), Text: "mxc"}
+ } else if status == 0 || fdio.MaxUnderlyingHandles < status {
+ return nil, errors.New("Invalid handle from fdio_transfer_fd")
+ }
+ handles := make([]zx.Handle, int(status))
+ for i := 0; i < int(status); i++ {
+ handles[i] = zx.Handle(handlesC[i])
+ }
+ switch zx.HandleInfo(typesC[0]).Type() {
+ case fdio.HandleTypeRemote:
+ obj := (*io.ObjectInterface)(&fidl.Proxy{Channel: zx.Channel(handles[0])})
+ if len(handles) > 1 {
+ for _, h := range handles[1:] {
+ h.Close()
+ }
+ }
+ return &fdio.File{Node: fdio.Node{Object: fdio.Object{obj}}}, nil
+ case fdio.HandleTypePipe:
+ if len(handles) > 1 {
+ for _, h := range handles[1:] {
+ h.Close()
+ }
+ }
+ return fdio.NewPipe(zx.Socket(handles[0])), nil
+ default:
+ for _, h := range handles {
+ h.Close()
+ }
+ return nil, errors.New("Unexpected C handle type")
+ }
+}
diff --git a/src/syscall/zx/fdio/mxc/mxc_no_cgo.go b/src/syscall/zx/fdio/mxc/mxc_no_cgo.go
new file mode 100644
index 0000000..ef30d35
--- /dev/null
+++ b/src/syscall/zx/fdio/mxc/mxc_no_cgo.go
@@ -0,0 +1,17 @@
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build fuchsia
+// +build !cgo
+
+package mxc
+
+import (
+ "syscall/zx"
+ "syscall/zx/fdio"
+)
+
+func transferFDIOFromCFD(fd int) (fdio.FDIO, error) {
+ return nil, zx.ErrNotSupported
+}
diff --git a/src/syscall/zx/fdio/namespace.go b/src/syscall/zx/fdio/namespace.go
new file mode 100644
index 0000000..7dbf635
--- /dev/null
+++ b/src/syscall/zx/fdio/namespace.go
@@ -0,0 +1,391 @@
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build fuchsia
+
+package fdio
+
+import (
+ "path"
+ "strings"
+ "sync"
+ "syscall/zx"
+ "syscall/zx/fidl"
+ "syscall/zx/io"
+)
+
+func splitPath(path string) (name string, remaining string) {
+ slash := strings.IndexByte(path, '/')
+ if slash == 0 || slash == len(path)-1 {
+ return "", ""
+ } else if slash == -1 {
+ return path, ""
+ } else {
+ return path[:slash], path[slash+1:]
+ }
+}
+
+type NS struct {
+ mu sync.Mutex
+ m map[string]zx.Handle
+}
+
+func NewNS() *NS {
+ return &NS{m: make(map[string]zx.Handle)}
+}
+
+func NewNSFromMap(m map[string]zx.Handle) (*NS, error) {
+ if m == nil {
+ return nil, zx.Error{Status: zx.ErrInvalidArgs, Text: "namespace.NewFromNSMAP"}
+ }
+ ns := &NS{m: make(map[string]zx.Handle)}
+ for k, v := range m {
+ ns.m[k] = v
+ }
+ return ns, nil
+}
+
+func (ns *NS) Bind(p string, h zx.Handle) {
+ ns.mu.Lock()
+ ns.m[p] = h
+ ns.mu.Unlock()
+}
+
+func (ns *NS) Connect(p string, h zx.Handle) error {
+ if p[0] != '/' {
+ h.Close()
+ return zx.Error{Status: zx.ErrNotFound, Text: "namespace.Connect"}
+ }
+ node := p
+ for {
+ ns.mu.Lock()
+ svcHandle := ns.m[node]
+ ns.mu.Unlock()
+ if svcHandle.IsValid() {
+ rest := strings.TrimPrefix(p, node)
+ rest = strings.TrimPrefix(rest, "/")
+ return ServiceConnectAt(svcHandle, rest, h)
+ }
+ if node == "/" {
+ break
+ }
+ node = path.Dir(node)
+ }
+ h.Close()
+ return zx.Error{Status: zx.ErrNotFound, Text: "namespace.Connect"}
+}
+
+func (ns *NS) OpenRoot() (FDIO, error) {
+ root := &vnode{}
+ ns.mu.Lock()
+ defer ns.mu.Unlock()
+ for path, h := range ns.m {
+ if path == "" || path[0] != '/' {
+ return nil, zx.Error{Status: zx.ErrBadPath, Text: "fdio.OpenRoot"}
+ }
+ vn := root
+ path = path[1:]
+ for path != "" {
+ name, remaining := splitPath(path)
+ vn = vn.getOrAddChild(name)
+ path = remaining
+ }
+ if vn.remote.IsValid() {
+ return nil, zx.Error{Status: zx.ErrAlreadyExists, Text: "fdio.OpenRoot"}
+ }
+ obj := (*io.ObjectInterface)(&fidl.Proxy{Channel: zx.Channel(h)})
+ vn.remote = Directory{Node: Node{Object: Object{obj}}}
+ }
+ return &dir{root}, nil
+}
+
+// vnode is a virtual node in the namespace "filesystem".
+type vnode struct {
+ child *vnode
+ parent *vnode
+ next *vnode
+ remote Directory
+ name string
+}
+
+func (vn *vnode) getOrAddChild(name string) *vnode {
+ child := vn.getChild(name)
+ if child == nil {
+ child = &vnode{
+ parent: vn,
+ next: vn.child,
+ name: name,
+ }
+ vn.child = child
+ }
+ return child
+}
+
+func (vn *vnode) getChild(name string) *vnode {
+ for vn = vn.child; vn != nil; vn = vn.next {
+ if vn.name == name {
+ return vn
+ }
+ }
+ return nil
+}
+
+// dir represents a directory in the namespace.
+type dir struct {
+ vn *vnode
+}
+
+// Handle returns the underlying handle as an untyped handle.
+func (d *dir) Handles() []zx.Handle {
+ return d.vn.remote.Handles()
+}
+
+// Clone makes a clone of the dir, if possible.
+func (d *dir) Clone() (FDIO, error) {
+ if !d.vn.remote.IsValid() {
+ return nil, zx.Error{Status: zx.ErrNotSupported, Text: "fdio.ns.dir"}
+ }
+ return d.vn.remote.Clone()
+}
+
+// Close closes the dir.
+func (d *dir) Close() error {
+ return d.vn.remote.Close()
+}
+
+// Sync implements FDIO for dir.
+func (d *dir) Sync() error {
+ return zx.Error{Status: zx.ErrNotSupported, Text: "fdio.ns.dir"}
+}
+
+// GetAttr implements FDIO for dir.
+func (d *dir) GetAttr() (io.NodeAttributes, error) {
+ return io.NodeAttributes{
+ Mode: uint32(io.KModeTypeDirectory) | uint32(VtypeIRUSR),
+ Id: 1,
+ LinkCount: 1,
+ }, nil
+}
+
+// SetAttr implements FDIO for dir.
+func (d *dir) SetAttr(flags uint32, attr io.NodeAttributes) error {
+ return zx.Error{Status: zx.ErrNotSupported, Text: "fdio.ns.dir"}
+}
+
+// Ioctl implements FDIO for dir.
+func (d *dir) Ioctl(op uint32, max uint64, in []byte, handles []zx.Handle) ([]byte, []zx.Handle, error) {
+ return nil, nil, zx.Error{Status: zx.ErrNotSupported, Text: "fdio.ns.dir"}
+}
+
+func (d *dir) Read(data []byte) (int, error) {
+ return 0, zx.Error{Status: zx.ErrNotSupported, Text: "fdio.dir"}
+}
+
+func (d *dir) ReadAt(data []byte, off int64) (int, error) {
+ return 0, zx.Error{Status: zx.ErrNotSupported, Text: "fdio.dir"}
+}
+
+func (d *dir) Write(data []byte) (n int, err error) {
+ return 0, zx.Error{Status: zx.ErrNotSupported, Text: "fdio.dir"}
+}
+
+func (d *dir) WriteAt(data []byte, off int64) (int, error) {
+ return 0, zx.Error{Status: zx.ErrNotSupported, Text: "fdio.dir"}
+}
+
+func (d *dir) Seek(offset int64, whence int) (int64, error) {
+ return 0, zx.Error{Status: zx.ErrNotSupported, Text: "fdio.dir"}
+}
+
+// Truncate implements FDIO for dir.
+func (d *dir) Truncate(length uint64) error {
+ return zx.Error{Status: zx.ErrNotSupported, Text: "fdio.ns.dir"}
+}
+
+func (d *dir) getVnode(path string) (vn *vnode, rpath string, isRemote bool, err error) {
+ vn = d.vn
+
+ if path == "." || path == "" {
+ if vn.remote.IsValid() {
+ return vn, ".", true, nil
+ }
+ return vn, "", false, nil
+ }
+
+ originalPath := path
+
+ var savedVn *vnode
+ var savedPath string
+
+ for {
+ name, remaining := splitPath(path)
+
+ if name == "" {
+ return nil, "", false, zx.Error{Status: zx.ErrBadPath, Text: path}
+ }
+
+ child := vn.getChild(name)
+
+ if child != nil {
+ if remaining == "" {
+ // We've resolved all the path segments and found the vnode we're
+ // looking for.
+ if child.remote.IsValid() {
+ return child, ".", true, nil
+ } else {
+ return child, "", false, nil
+ }
+ } else {
+ // We've got more path to resolve.
+ vn = child
+ path = remaining
+
+ // If this child has a remote file system, we might hand off to
+ // this remote if we don't find anything more specific below
+ // this vnode.
+ if child.remote.IsValid() {
+ savedVn = vn
+ savedPath = path
+ }
+
+ continue
+ }
+ }
+
+ // We've reached the end of our local vnode structure with more
+ // path to resolve.
+
+ if vn.remote.IsValid() {
+ // We've got a remote file system at this vnode. We can hand off
+ // directly to that file system.
+ return vn, path, true, nil
+ }
+
+ // We saw a remote file system earlier in our walk that might have this
+ // path. Let's hand off to it.
+ if savedVn != nil {
+ return savedVn, savedPath, true, nil
+ }
+
+ // There is no remote file system to resolve the path against,
+ // which means we failed to find what we were looking for.
+ return nil, "", false, zx.Error{Status: zx.ErrNotFound, Text: originalPath}
+ }
+}
+
+// Open implements FDIO for dir.
+func (d *dir) Open(pathname string, flags uint32, mode uint32) (FDIO, error) {
+ vn, relp, isRemote, err := d.getVnode(pathname)
+ if err != nil {
+ return nil, err
+ }
+ if isRemote {
+ return vn.remote.Open(relp, flags, mode)
+ }
+ return &dir{vn}, nil
+}
+
+func (d *dir) openParent(pathname string) (FDIO, string, error) {
+ dirpath, name := path.Split(pathname)
+ parent, err := d.Open(path.Dir(dirpath), io.KOpenRightReadable, io.KOpenFlagDirectory)
+ if err != nil {
+ return nil, "", err
+ }
+ return parent, name, err
+}
+
+// Link implements FDIO for dir.
+func (d *dir) Link(oldpath, newpath string) error {
+ oldparent, oldname, err := d.openParent(oldpath)
+ if err != nil {
+ return err
+ }
+ defer oldparent.Close()
+ newparent, newname, err := d.openParent(newpath)
+ if err != nil {
+ return err
+ }
+ defer newparent.Close()
+ olddir, ok := oldparent.(*Directory)
+ if !ok {
+ return zx.Error{Status: zx.ErrNotSupported, Text: "fdio.ns.dir"}
+ }
+ newdir, ok := newparent.(*Directory)
+ if !ok {
+ return zx.Error{Status: zx.ErrNotSupported, Text: "fdio.ns.dir"}
+ }
+ token, err := newdir.getToken()
+ if err != nil {
+ return err
+ }
+ status, err := olddir.DirectoryInterface().Link(oldname, token, newname)
+ if err != nil {
+ return err
+ } else if status != zx.ErrOk {
+ return zx.Error{Status: status, Text: "fdio.ns.dir"}
+ }
+ return nil
+}
+
+// Rename implements FDIO for dir.
+func (d *dir) Rename(oldpath, newpath string) error {
+ oldf, oldname, err := d.openParent(oldpath)
+ if err != nil {
+ return err
+ }
+ defer oldf.Close()
+ newf, newname, err := d.openParent(newpath)
+ if err != nil {
+ return err
+ }
+ defer newf.Close()
+ olddir, ok := oldf.(*Directory)
+ if !ok {
+ return zx.Error{Status: zx.ErrNotSupported, Text: "fdio.ns.dir"}
+ }
+ newdir, ok := newf.(*Directory)
+ if !ok {
+ return zx.Error{Status: zx.ErrNotSupported, Text: "fdio.ns.dir"}
+ }
+ token, err := newdir.getToken()
+ if err != nil {
+ return err
+ }
+ status, err := olddir.DirectoryInterface().Rename(oldname, token, newname)
+ if err != nil {
+ return err
+ } else if status != zx.ErrOk {
+ return zx.Error{Status: status, Text: "fdio.ns.dir"}
+ }
+ return nil
+}
+
+// Unlink implements FDIO for dir.
+func (d *dir) Unlink(pathname string) error {
+ parent, name, err := d.openParent(pathname)
+ if err != nil {
+ return err
+ }
+ defer parent.Close()
+ parentdir, ok := parent.(*Directory)
+ if !ok {
+ return zx.Error{Status: zx.ErrNotSupported, Text: "fdio.ns.dir"}
+ }
+ if status, err := parentdir.DirectoryInterface().Unlink(name); err != nil {
+ return err
+ } else if status != zx.ErrOk {
+ return zx.Error{Status: status, Text: "fdio.ns.dir"}
+ }
+ return nil
+}
+
+// ReadDirents implements FDIO for dir.
+func (d *dir) ReadDirents(max uint64) ([]byte, error) {
+ return nil, zx.Error{Status: zx.ErrNotSupported, Text: "fdio.ns.dir"}
+}
+
+// Rewind implements FDIO for dir.
+func (d *dir) Rewind() error {
+ return zx.Error{Status: zx.ErrNotSupported, Text: "fdio.ns.dir"}
+}
diff --git a/src/syscall/zx/fdio/node.go b/src/syscall/zx/fdio/node.go
new file mode 100644
index 0000000..5bdca5b
--- /dev/null
+++ b/src/syscall/zx/fdio/node.go
@@ -0,0 +1,64 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build fuchsia
+
+package fdio
+
+import (
+ "syscall/zx"
+ "syscall/zx/io"
+)
+
+// Node is a wrapper around a NodeInterface which implements FDIO.
+type Node struct {
+ Object
+}
+
+// NodeInterface returns the underlying Node FIDL interface.
+func (n *Node) NodeInterface() (*io.NodeInterface) {
+ return (*io.NodeInterface)(n.Object.ObjectInterface)
+}
+
+// Sync performs a sync operation on a Node.
+func (n *Node) Sync() error {
+ if status, err := n.NodeInterface().Sync(); err != nil {
+ return err
+ } else if status != zx.ErrOk {
+ return zx.Error{Status: status, Text: "io.node"}
+ }
+ return nil
+}
+
+// GetAttr returns the attributes for the Node.
+func (n *Node) GetAttr() (io.NodeAttributes, error) {
+ status, attrs, err := n.NodeInterface().GetAttr()
+ if err != nil {
+ return io.NodeAttributes{}, err
+ } else if status != zx.ErrOk {
+ return io.NodeAttributes{}, zx.Error{Status: status, Text: "io.node"}
+ }
+ return attrs, nil
+}
+
+// SetAttr sets the attributes for Node as defined by flags.
+func (n *Node) SetAttr(flags uint32, attr io.NodeAttributes) error {
+ if status, err := n.NodeInterface().SetAttr(flags, attr); err != nil {
+ return err
+ } else if status != zx.ErrOk {
+ return zx.Error{Status: status, Text: "io.node"}
+ }
+ return nil
+}
+
+// Ioctl calls an ioctl on Node.
+func (n *Node) Ioctl(op uint32, max uint64, in []byte, handles []zx.Handle) ([]byte, []zx.Handle, error) {
+ status, h, b, err := n.NodeInterface().Ioctl(op, max, handles, in)
+ if err != nil {
+ return nil, nil, err
+ } else if status != zx.ErrOk {
+ return nil, nil, zx.Error{Status: status, Text: "io.node"}
+ }
+ return b, h, nil
+}
diff --git a/src/syscall/zx/fdio/object.go b/src/syscall/zx/fdio/object.go
new file mode 100644
index 0000000..6e41440
--- /dev/null
+++ b/src/syscall/zx/fdio/object.go
@@ -0,0 +1,179 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build fuchsia
+
+package fdio
+
+import (
+ "syscall/zx"
+ "syscall/zx/fidl"
+ "syscall/zx/io"
+)
+
+func objectFromInfo(info *io.ObjectInfo, obj *io.ObjectInterface) (result FDIO, err error) {
+ if info == nil {
+ return nil, zx.Error{Status: zx.ErrNotSupported, Text: "io.object"}
+ }
+ switch info.ObjectInfoTag {
+ case io.ObjectInfoService:
+ // TODO(mknyszek): Figure out the correct type to return here.
+ result = &Object{ObjectInterface: obj}
+ case io.ObjectInfoFile:
+ result = &File{
+ Node: Node{Object: Object{ObjectInterface: obj}},
+ Event: info.File.Event,
+ }
+ case io.ObjectInfoDevice:
+ result = &File{
+ Node: Node{Object: Object{ObjectInterface: obj}},
+ Event: info.Device.Event,
+ }
+ case io.ObjectInfoDirectory:
+ result = &Directory{Node: Node{Object: Object{ObjectInterface: obj}}}
+ case io.ObjectInfoPipe:
+ result = NewPipe(info.Pipe.Socket)
+ case io.ObjectInfoVmofile:
+ result, err = NewVMOFile(
+ info.Vmofile.Vmo,
+ info.Vmofile.Offset,
+ info.Vmofile.Length,
+ )
+ if err != nil {
+ return nil, err
+ }
+ default:
+ return nil, zx.Error{Status: zx.ErrNotSupported, Text: "io.object"}
+ }
+ return result, nil
+}
+
+// Object is a wrapper around an ObjectInterface which implements FDIO.
+type Object struct {
+ *io.ObjectInterface
+}
+
+// IsValid returns true if the Object is valid.
+func (o *Object) IsValid() bool {
+ if o.ObjectInterface == nil {
+ return false
+ }
+ return ((*fidl.Proxy)(o.ObjectInterface)).IsValid()
+}
+
+// Handle returns the underlying channel as an untyped zx handle.
+func (o *Object) Handles() []zx.Handle {
+ return []zx.Handle{
+ zx.Handle(((*fidl.Proxy)(o.ObjectInterface)).Channel),
+ }
+}
+
+// Clone makes a clone of the object.
+func (o *Object) Clone() (FDIO, error) {
+ req, newObj, err := io.NewObjectInterfaceRequest()
+ if err != nil {
+ return nil, err
+ }
+ if err := o.ObjectInterface.Clone(io.KOpenFlagDescribe, req); err != nil {
+ return nil, err
+ }
+ status, info, err := newObj.ExpectOnOpen()
+ if err != nil {
+ return nil, err
+ } else if status != zx.ErrOk {
+ return nil, zx.Error{Status: status, Text: "io.object"}
+ }
+ return objectFromInfo(info, newObj)
+}
+
+// Close closes the object.
+func (o *Object) Close() error {
+ defer ((*fidl.Proxy)(o.ObjectInterface)).Close()
+ if status, err := o.ObjectInterface.Close(); err != nil {
+ return err
+ } else if status != zx.ErrOk {
+ return zx.Error{Status: status, Text: "io.object"}
+ }
+ return nil
+}
+
+// Sync implements FDIO for Object.
+func (o *Object) Sync() error {
+ return zx.Error{Status: zx.ErrNotSupported, Text: "io.object"}
+}
+
+// GetAttr implements FDIO for Object.
+func (o *Object) GetAttr() (io.NodeAttributes, error) {
+ return io.NodeAttributes{}, zx.Error{Status: zx.ErrNotSupported, Text: "io.object"}
+}
+
+// SetAttr implements FDIO for Object.
+func (o *Object) SetAttr(flags uint32, attr io.NodeAttributes) error {
+ return zx.Error{Status: zx.ErrNotSupported, Text: "io.object"}
+}
+
+// Ioctl implements FDIO for Object.
+func (o *Object) Ioctl(op uint32, max uint64, in []byte, handles []zx.Handle) ([]byte, []zx.Handle, error) {
+ return nil, nil, zx.Error{Status: zx.ErrNotSupported, Text: "io.object"}
+}
+
+// Read implements FDIO for Object.
+func (o *Object) Read(data []byte) (int, error) {
+ return 0, zx.Error{Status: zx.ErrNotSupported, Text: "io.object"}
+}
+
+// ReadAt implements FDIO for Object.
+func (o *Object) ReadAt(data []byte, off int64) (int, error) {
+ return 0, zx.Error{Status: zx.ErrNotSupported, Text: "io.object"}
+}
+
+// Write implements FDIO for Object.
+func (o *Object) Write(data []byte) (int, error) {
+ return 0, zx.Error{Status: zx.ErrNotSupported, Text: "io.object"}
+}
+
+// WriteAt implements FDIO for Object.
+func (o *Object) WriteAt(data []byte, off int64) (int, error) {
+ return 0, zx.Error{Status: zx.ErrNotSupported, Text: "io.object"}
+}
+
+// Seek implements FDIO for Object.
+func (o *Object) Seek(offset int64, whence int) (int64, error) {
+ return 0, zx.Error{Status: zx.ErrNotSupported, Text: "io.object"}
+}
+
+// Truncate implements FDIO for Object.
+func (o *Object) Truncate(length uint64) error {
+ return zx.Error{Status: zx.ErrNotSupported, Text: "io.object"}
+}
+
+// Open implements FDIO for Object.
+func (o *Object) Open(path string, flags uint32, mode uint32) (FDIO, error) {
+ return nil, zx.Error{Status: zx.ErrNotSupported, Text: "io.object"}
+}
+
+// Link implements FDIO for Object.
+func (o *Object) Link(oldpath, newpath string) error {
+ return zx.Error{Status: zx.ErrNotSupported, Text: "io.object"}
+}
+
+// Rename implements FDIO for Object.
+func (o *Object) Rename(oldpath, newpath string) error {
+ return zx.Error{Status: zx.ErrNotSupported, Text: "io.object"}
+}
+
+// Unlink implements FDIO for Object.
+func (o *Object) Unlink(path string) error {
+ return zx.Error{Status: zx.ErrNotSupported, Text: "io.object"}
+}
+
+// ReadDirents implements FDIO for Object.
+func (o *Object) ReadDirents(max uint64) ([]byte, error) {
+ return nil, zx.Error{Status: zx.ErrNotSupported, Text: "io.object"}
+}
+
+// Rewind implements FDIO for Object.
+func (o *Object) Rewind() error {
+ return zx.Error{Status: zx.ErrNotSupported, Text: "io.object"}
+}
diff --git a/src/syscall/zx/fdio/pipe.go b/src/syscall/zx/fdio/pipe.go
new file mode 100644
index 0000000..139a642
--- /dev/null
+++ b/src/syscall/zx/fdio/pipe.go
@@ -0,0 +1,172 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build fuchsia
+
+package fdio
+
+import (
+ "syscall/zx"
+ "syscall/zx/io"
+ "syscall/zx/zxwait"
+)
+
+type Pipe struct {
+ s zx.Socket
+}
+
+func NewPipes() (*Pipe, *Pipe, error) {
+ s0, s1, err := zx.NewSocket(0)
+ if err != nil {
+ return nil, nil, err
+ }
+ return &Pipe{s0}, &Pipe{s1}, nil
+}
+
+func NewPipe(s zx.Socket) *Pipe {
+ return &Pipe{s}
+}
+
+func (f *Pipe) Wait(signals zx.Signals, timeout zx.Time) (observed zx.Signals, err error) {
+ return zxwait.Wait(zx.Handle(f.s), signals, timeout)
+}
+
+func (f *Pipe) Handles() []zx.Handle {
+ return []zx.Handle{zx.Handle(f.s)}
+}
+
+func (f *Pipe) Clone() (FDIO, error) {
+ h, err := f.s.Handle().Duplicate(zx.RightSameRights)
+ if err != nil {
+ return nil, err
+ }
+ return NewPipe(zx.Socket(h)), nil
+}
+
+func (f *Pipe) Close() error {
+ if err := f.s.Close(); err != nil {
+ return err
+ }
+ f.s = zx.Socket(zx.HandleInvalid)
+ return nil
+}
+
+func (f *Pipe) Sync() error {
+ return zx.Error{Status: zx.ErrNotSupported, Text: "fdio.Pipe"}
+}
+
+func (f *Pipe) GetAttr() (io.NodeAttributes, error) {
+ return io.NodeAttributes{}, zx.Error{Status: zx.ErrNotSupported, Text: "fdio.Pipe"}
+}
+
+func (f *Pipe) SetAttr(flags uint32, attr io.NodeAttributes) error {
+ return zx.Error{Status: zx.ErrNotSupported, Text: "fdio.Pipe"}
+}
+
+func (f *Pipe) Ioctl(op uint32, max uint64, in []byte, handles []zx.Handle) ([]byte, []zx.Handle, error) {
+ return nil, nil, zx.Error{Status: zx.ErrNotSupported, Text: "fdio.Pipe"}
+}
+
+func (f *Pipe) Read(data []byte) (n int, err error) {
+ for {
+ n, err = f.s.Read(data, 0)
+ if err == nil {
+ return n, nil
+ }
+ mxerr, ok := err.(zx.Error)
+ if !ok {
+ return n, err
+ }
+ switch mxerr.Status {
+ case zx.ErrPeerClosed:
+ return 0, zx.EOF
+ case zx.ErrShouldWait:
+ pending, err := f.Wait(zx.SignalSocketReadable|zx.SignalSocketPeerClosed, zx.TimensecInfinite)
+ if err != nil {
+ return 0, err
+ }
+ if pending&zx.SignalSocketReadable != 0 {
+ continue
+ }
+ if pending&zx.SignalSocketPeerClosed != 0 {
+ return 0, zx.EOF
+ }
+ // impossible
+ return 0, zx.Error{Status: zx.ErrInternal, Text: "fdio.Pipe"}
+ }
+ return 0, err
+ }
+}
+
+func (f *Pipe) ReadAt(data []byte, off int64) (int, error) {
+ return 0, zx.Error{Status: zx.ErrNotSupported, Text: "fdio.Pipe"}
+}
+
+func (f *Pipe) Write(data []byte) (n int, err error) {
+ for {
+ n, err = f.s.Write(data, 0)
+ if err == nil {
+ return n, nil
+ }
+ mxerr, ok := err.(zx.Error)
+ if !ok {
+ return n, err
+ }
+ switch mxerr.Status {
+ case zx.ErrPeerClosed:
+ return 0, zx.EOF
+ return 0, zx.EPIPE
+ case zx.ErrShouldWait:
+ pending, err := f.Wait(zx.SignalSocketWritable|zx.SignalSocketPeerClosed, zx.TimensecInfinite)
+ if err != nil {
+ return 0, err
+ }
+ if pending&zx.SignalSocketWritable != 0 {
+ continue
+ }
+ if pending&zx.SignalSocketPeerClosed != 0 {
+ return 0, zx.EPIPE
+ }
+ // impossible
+ return 0, zx.Error{Status: zx.ErrInternal, Text: "fdio.Pipe"}
+ }
+ return 0, err
+ }
+}
+
+func (f *Pipe) WriteAt(data []byte, off int64) (int, error) {
+ return 0, zx.Error{Status: zx.ErrNotSupported, Text: "fdio.Pipe"}
+}
+
+func (f *Pipe) Seek(offset int64, whence int) (int64, error) {
+ return 0, zx.Error{Status: zx.ErrNotSupported, Text: "fdio.Pipe"}
+}
+
+func (f *Pipe) Truncate(length uint64) error {
+ return zx.Error{Status: zx.ErrNotSupported, Text: "fdio.Pipe"}
+}
+
+func (f *Pipe) Open(path string, flags uint32, mode uint32) (FDIO, error) {
+ return nil, zx.Error{Status: zx.ErrNotSupported, Text: "fdio.Pipe"}
+}
+
+func (f *Pipe) Link(oldpath, newpath string) error {
+ return zx.Error{Status: zx.ErrNotSupported, Text: "fdio.Pipe"}
+}
+
+func (f *Pipe) Rename(oldpath, newpath string) error {
+ return zx.Error{Status: zx.ErrNotSupported, Text: "fdio.Pipe"}
+}
+
+func (f *Pipe) Unlink(path string) error {
+ return zx.Error{Status: zx.ErrNotSupported, Text: "fdio.Pipe"}
+}
+
+func (f *Pipe) ReadDirents(max uint64) ([]byte, error) {
+ return nil, zx.Error{Status: zx.ErrNotSupported, Text: "fdio.Pipe"}
+}
+
+func (f *Pipe) Rewind() error {
+ return zx.Error{Status: zx.ErrNotSupported, Text: "fdio.Pipe"}
+}
diff --git a/src/syscall/zx/fdio/vmo.go b/src/syscall/zx/fdio/vmo.go
new file mode 100644
index 0000000..d51094a
--- /dev/null
+++ b/src/syscall/zx/fdio/vmo.go
@@ -0,0 +1,161 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build fuchsia
+
+package fdio
+
+import (
+ "syscall/zx"
+ "syscall/zx/io"
+)
+
+type VMOFile struct {
+ h zx.VMO
+ off int64
+ len int64
+ end int64
+ at int64
+}
+
+func NewVMOFile(handle zx.VMO, offset uint64, length uint64) (*VMOFile, error) {
+ // fdio_vmofile_create
+ f := &VMOFile{
+ h: handle,
+ off: int64(offset),
+ len: int64(length),
+ }
+ f.end = f.off + f.len
+ f.at = f.off
+ return f, nil
+}
+
+func (f *VMOFile) Handles() []zx.Handle {
+ return []zx.Handle{zx.Handle(f.h)}
+}
+
+func (f *VMOFile) Clone() (FDIO, error) {
+ return nil, zx.Error{Status: zx.ErrNotSupported, Text: "fdio.VMOFile"}
+}
+
+func (f *VMOFile) Close() error {
+ if err := f.h.Close(); err != nil {
+ return err
+ }
+ f.h = 0
+ return nil
+}
+
+func (f *VMOFile) Sync() error {
+ return zx.Error{Status: zx.ErrNotSupported, Text: "fdio.VMOFile"}
+}
+
+func (f *VMOFile) GetAttr() (io.NodeAttributes, error) {
+ return io.NodeAttributes{
+ ContentSize: uint64(f.len),
+ StorageSize: uint64(f.len),
+ Mode: uint32(io.KModeTypeFile) | uint32(VtypeIRUSR),
+ }, nil
+}
+
+func (f *VMOFile) SetAttr(flags uint32, attr io.NodeAttributes) error {
+ return zx.Error{Status: zx.ErrNotSupported, Text: "fdio.VMOFile"}
+}
+
+func (f *VMOFile) Ioctl(op uint32, max uint64, in []byte, handles []zx.Handle) ([]byte, []zx.Handle, error) {
+ return nil, nil, zx.Error{Status: zx.ErrNotSupported, Text: "fdio.VMOFile"}
+}
+
+func (f *VMOFile) Read(data []byte) (n int, err error) {
+ if int64(len(data)) > f.end-f.at {
+ data = data[:f.end-f.at]
+ err = zx.EOF
+ }
+ if len(data) == 0 {
+ return 0, err
+ }
+ if err2 := f.h.Read(data, uint64(f.at)); err2 != nil {
+ return 0, err2
+ }
+ n = len(data)
+ f.at += int64(n)
+ return
+}
+
+func (f *VMOFile) ReadAt(data []byte, off int64) (n int, err error) {
+ if off < 0 {
+ return 0, zx.Error{Status: zx.ErrInvalidArgs, Text: "fdio.VMOFile.ReadAt"}
+ }
+ if off >= f.end {
+ return 0, zx.EOF
+ }
+ if len(data) == 0 {
+ return 0, zx.EOF
+ }
+ n = len(data)
+ max := int(f.end - off)
+ if max < n {
+ n = max
+ err = zx.EOF
+ }
+ data = data[:n]
+ if err2 := f.h.Read(data, uint64(off)); err2 != nil {
+ return 0, err2
+ }
+ return
+}
+
+func (f *VMOFile) Write(data []byte) (int, error) {
+ return 0, zx.Error{Status: zx.ErrNotSupported, Text: "fdio.VMOFile"}
+}
+
+func (f *VMOFile) WriteAt(data []byte, off int64) (int, error) {
+ return 0, zx.Error{Status: zx.ErrNotSupported, Text: "fdio.VMOFile"}
+}
+
+func (f *VMOFile) Seek(offset int64, whence int) (int64, error) {
+ var at int64
+ switch whence {
+ case 0: // SEEK_SET
+ at = offset
+ case 1: // SEEK_CUR
+ at = f.at - f.off + offset
+ case 2: // SEEK_END
+ at = f.end - f.off + offset
+ }
+
+ if at > f.end-f.off {
+ return 0, zx.Error{Status: zx.ErrOutOfRange, Text: "fdio.VMOFile"}
+ }
+ f.at = f.off + at
+ return at, nil
+}
+
+func (f *VMOFile) Truncate(length uint64) error {
+ return zx.Error{Status: zx.ErrNotSupported, Text: "fdio.VMOFile"}
+}
+
+func (f *VMOFile) Open(path string, flags uint32, mode uint32) (FDIO, error) {
+ return nil, zx.Error{Status: zx.ErrNotSupported, Text: "fdio.VMOFile"}
+}
+
+func (f *VMOFile) Link(oldpath, newpath string) error {
+ return zx.Error{Status: zx.ErrNotSupported, Text: "fdio.VMOFile"}
+}
+
+func (f *VMOFile) Rename(oldpath, newpath string) error {
+ return zx.Error{Status: zx.ErrNotSupported, Text: "fdio.VMOFile"}
+}
+
+func (f *VMOFile) Unlink(path string) error {
+ return zx.Error{Status: zx.ErrNotSupported, Text: "fdio.VMOFile"}
+}
+
+func (f *VMOFile) ReadDirents(max uint64) ([]byte, error) {
+ return nil, zx.Error{Status: zx.ErrNotSupported, Text: "fdio.VMOFile"}
+}
+
+func (f *VMOFile) Rewind() error {
+ return zx.Error{Status: zx.ErrNotSupported, Text: "fdio.VMOFile"}
+}
diff --git a/src/syscall/zx/fidl/bindings.go b/src/syscall/zx/fidl/bindings.go
new file mode 100644
index 0000000..f1e5c83
--- /dev/null
+++ b/src/syscall/zx/fidl/bindings.go
@@ -0,0 +1,306 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build fuchsia
+
+package fidl
+
+import (
+ "sync"
+ "syscall/zx"
+ "syscall/zx/dispatch"
+)
+
+const prefix = "zx/fidl: "
+
+// d is a process-local dispatcher.
+var d *dispatch.Dispatcher
+
+func init() {
+ disp, err := dispatch.NewDispatcher()
+ if err != nil {
+ panic(prefix + "failed to create dispatcher: " + err.Error())
+ }
+ d = disp
+}
+
+// Serve is a blocking call to the process-local dispatcher's serve method.
+func Serve() {
+ d.Serve()
+}
+
+type bindingState int32
+
+const (
+ idle bindingState = iota
+ handling
+ cleanup
+)
+
+// Binding binds the implementation of a Stub to a Channel.
+//
+// A Binding listens for incoming messages on the Channel, decodes them, and
+// asks the Stub to dispatch to the appropriate implementation of the interface.
+// If the message expects a reply, the Binding will also encode the reply and
+// send it back over the Channel.
+type Binding struct {
+ // Stub is a wrapper around an implementation of a FIDL interface which
+ // knows how to dispatch to a method by ordinal.
+ Stub Stub
+
+ // Channel is the Channel primitive to which the Stub is bound.
+ Channel zx.Channel
+
+ // id is an identifier for this waiter in the process-local dispatcher.
+ id *dispatch.WaitID
+
+ // errHandler is called with connection errors, when encountered.
+ errHandler func(error)
+
+ // handling is an atomically-updated signal which represents the state of the
+ // binding.
+ stateMu sync.Mutex
+ state bindingState
+}
+
+// Init initializes a Binding.
+func (b *Binding) Init(errHandler func(error)) error {
+ // Declare the wait handler as a closure.
+ h := func(d *dispatch.Dispatcher, s zx.Status, sigs *zx.PacketSignal) (result dispatch.WaitResult) {
+ b.stateMu.Lock()
+ if b.state == cleanup {
+ b.close()
+ b.stateMu.Unlock()
+ return dispatch.WaitFinished
+ }
+ b.state = handling
+ b.stateMu.Unlock()
+ defer func() {
+ b.stateMu.Lock()
+ defer b.stateMu.Unlock()
+ if b.state == cleanup {
+ b.close()
+ result = dispatch.WaitFinished
+ }
+ b.state = idle
+ }()
+ if s != zx.ErrOk {
+ b.errHandler(zx.Error{Status: s})
+ return dispatch.WaitFinished
+ }
+ if sigs.Observed&zx.SignalChannelReadable != 0 {
+ for i := uint64(0); i < sigs.Count; i++ {
+ shouldWait, err := b.dispatch()
+ if err != nil {
+ b.errHandler(err)
+ return dispatch.WaitFinished
+ }
+ if shouldWait {
+ return dispatch.WaitAgain
+ }
+ }
+ return dispatch.WaitAgain
+ }
+ b.errHandler(zx.Error{Status: zx.ErrPeerClosed})
+ return dispatch.WaitFinished
+ }
+
+ b.stateMu.Lock()
+ b.state = idle
+ b.stateMu.Unlock()
+
+ b.errHandler = errHandler
+
+ // Start the wait on the Channel.
+ id, err := d.BeginWait(
+ zx.Handle(b.Channel),
+ zx.SignalChannelReadable|zx.SignalChannelPeerClosed,
+ 0,
+ h,
+ )
+ if err != nil {
+ return err
+ }
+ b.id = &id
+ return nil
+}
+
+// dispatch reads from the underlying Channel and dispatches into the Stub.
+//
+// Returns true if the channel should be waited, or false if there is more data to be read.
+func (b *Binding) dispatch() (shouldWait bool, err error) {
+ respb := messageBytesPool.Get().([]byte)
+ resph := messageHandlesPool.Get().([]zx.Handle)
+
+ defer messageBytesPool.Put(respb)
+ defer messageHandlesPool.Put(resph)
+
+ nb, nh, err := b.Channel.Read(respb[:], resph[:], 0)
+ if err != nil {
+ zxErr, ok := err.(zx.Error)
+ if ok && zxErr.Status == zx.ErrShouldWait {
+ return true, nil
+ }
+ return false, err
+ }
+ var header MessageHeader
+ if err := UnmarshalHeader(respb[:], &header); err != nil {
+ return false, err
+ }
+ start := MessageHeaderSize
+ p, err := b.Stub.Dispatch(header.Ordinal, respb[start:int(nb)], resph[:nh])
+ switch {
+ case err == ErrUnknownOrdinal:
+ // If we couldn't determine the ordinal, we still own the
+ // handles, so we should close them all.
+ for _, h := range resph[:nh] {
+ h.Close()
+ }
+ fallthrough
+ case err != nil:
+ return false, err
+ }
+ // Message has no response.
+ if p == nil {
+ return false, nil
+ }
+ cnb, cnh, err := MarshalMessage(&header, p, respb[:], resph[:])
+ if err != nil {
+ return false, err
+ }
+ if err := b.Channel.Write(respb[:cnb], resph[:cnh], 0); err != nil {
+ return false, err
+ }
+ return false, nil
+}
+
+// Close cancels any outstanding waits, resets the Binding's state, and closes
+// the bound Channel once any out-standing requests are finished being handled.
+func (b *Binding) Close() error {
+ b.stateMu.Lock()
+ defer b.stateMu.Unlock()
+ if zx.Handle(b.Channel) == zx.HandleInvalid || b.state == cleanup {
+ panic(prefix + "double binding close")
+ }
+ switch b.state {
+ case idle:
+ return b.close()
+ case handling:
+ b.state = cleanup
+ }
+ return nil
+}
+
+// close cancels any outstanding waits, resets the Binding's state, and
+// closes the bound Channel. This method is not thread-safe, and should be
+// called with the binding's mutex set.
+func (b *Binding) close() error {
+ if err := d.CancelWait(*b.id); err != nil {
+ zxErr, ok := err.(zx.Error)
+ // If it just says that the ID isn't found, there are cases where this is
+ // a reasonable error (particularly when we're in the middle of handling
+ // a signal from the dispatcher).
+ if !ok || zxErr.Status != zx.ErrNotFound {
+ // Attempt to close the channel if we hit a more serious error.
+ b.Channel.Close()
+ return err
+ }
+ }
+ b.id = nil
+ b.state = idle
+ return b.Channel.Close()
+}
+
+// BindingKey is a key which maps to a specific binding.
+//
+// It is only valid for the BindingSet that produced it.
+type BindingKey uint64
+
+// BindingSet is a managed set of Bindings which know how to unbind and
+// remove themselves in the event of a connection error.
+type BindingSet struct {
+ nextKey BindingKey
+ mu sync.Mutex
+ Bindings map[BindingKey]*Binding
+}
+
+// Add creates a new Binding, initializes it, and adds it to the set.
+//
+// onError is an optional handler than may be passed which will be called after
+// the binding between the Stub and the Channel is successfully closed.
+func (b *BindingSet) Add(s Stub, c zx.Channel, onError func(error)) (BindingKey, error) {
+ binding := &Binding{
+ Stub: s,
+ Channel: c,
+ }
+ b.mu.Lock()
+ defer b.mu.Unlock()
+ if b.Bindings == nil {
+ b.Bindings = make(map[BindingKey]*Binding)
+ }
+ key := b.nextKey
+ err := binding.Init(func(err error) {
+ if b.Remove(key) && onError != nil {
+ onError(err)
+ }
+ })
+ if err != nil {
+ return 0, err
+ }
+ b.Bindings[key] = binding
+ b.nextKey += 1
+ return key, nil
+}
+
+// ProxyFor returns an event proxy created from the channel of the binding referred
+// to by key.
+func (b *BindingSet) ProxyFor(key BindingKey) (*Proxy, bool) {
+ b.mu.Lock()
+ defer b.mu.Unlock()
+ if binding, ok := b.Bindings[key]; ok {
+ return &Proxy{Channel: binding.Channel}, true
+ }
+ return nil, false
+}
+
+// Remove removes a Binding from the set when it is next idle.
+//
+// Note that this method invalidates the key, and it will never remove a Binding
+// while it is actively being handled.
+//
+// Returns true if a Binding was found and removed.
+func (b *BindingSet) Remove(key BindingKey) bool {
+ b.mu.Lock()
+ if binding, ok := b.Bindings[key]; ok {
+ delete(b.Bindings, key)
+ b.mu.Unlock()
+
+ // Close the binding before calling the callback.
+ if err := binding.Close(); err != nil {
+ // Just panic. The only reason this can fail is if the handle
+ // is bad, which it shouldn't be if we're tracking things. If
+ // it does fail, better to fail fast.
+ panic(prefix + err.Error())
+ }
+ return true
+ }
+ b.mu.Unlock()
+ return false
+}
+
+// Close removes all the bindings from the set.
+func (b *BindingSet) Close() {
+ // Lock, close all the bindings, and clear the map.
+ b.mu.Lock()
+ for _, binding := range b.Bindings {
+ if err := binding.Close(); err != nil {
+ // Just panic. The only reason this can fail is if the handle
+ // is bad, which it shouldn't be if we're tracking things. If
+ // it does fail, better to fail fast.
+ panic(prefix + err.Error())
+ }
+ }
+ b.Bindings = make(map[BindingKey]*Binding)
+ b.mu.Unlock()
+}
diff --git a/src/syscall/zx/fidl/bindings_test.go b/src/syscall/zx/fidl/bindings_test.go
new file mode 100644
index 0000000..faa44b6
--- /dev/null
+++ b/src/syscall/zx/fidl/bindings_test.go
@@ -0,0 +1,84 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build fuchsia
+
+package fidl_test
+
+import (
+ "syscall/zx"
+ "testing"
+ "time"
+
+ . "fidl/bindings"
+ . "fuchsia/go/go_fidl_bindings_test"
+)
+
+type Test1Impl struct{}
+
+func (t *Test1Impl) Echo(s *string) (*string, error) {
+ return s, nil
+}
+
+func TestEcho(t *testing.T) {
+ t.Parallel()
+
+ ch, sh, err := zx.NewChannel(0)
+ if err != nil {
+ t.Fatal(err)
+ }
+ client := Test1Interface(Proxy{Channel: ch})
+ server := Test1Service{}
+ clientKey, err := server.Add(&Test1Impl{}, sh, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+ go Serve()
+
+ t.Run("Basic", func(t *testing.T) {
+ str := "Hello World!"
+ r, err := client.Echo(&str)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if r == nil {
+ t.Fatal("unexpected nil result")
+ }
+ if *r != str {
+ t.Fatalf("expected %s, got %s", str, *r)
+ }
+ })
+
+ t.Run("Event", func(t *testing.T) {
+ str := "Surprise!"
+ done := make(chan struct{})
+ // Spin up goroutine with waiting client.
+ go func() {
+ s, err := client.ExpectSurprise()
+ if err != nil {
+ t.Fatal(err)
+ }
+ if s != str {
+ t.Fatalf("expected %s, got %s", str, s)
+ }
+ done <- struct{}{}
+ }()
+ // Spin up server goroutine which makes the call.
+ go func() {
+ pxy, ok := server.EventProxyFor(clientKey)
+ if !ok {
+ t.Fatalf("could not create proxy for key %d", clientKey)
+ }
+ if err := pxy.Surprise(str); err != nil {
+ t.Fatal(err)
+ }
+ }()
+ select {
+ case <-done:
+ return
+ case <-time.After(5 * time.Second):
+ t.Fatalf("test timed out")
+ }
+ })
+}
diff --git a/src/syscall/zx/fidl/bindings_test/test.fidl b/src/syscall/zx/fidl/bindings_test/test.fidl
new file mode 100644
index 0000000..cf0aeed
--- /dev/null
+++ b/src/syscall/zx/fidl/bindings_test/test.fidl
@@ -0,0 +1,145 @@
+// Copyright 2018 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.
+
+library go_fidl_bindings_test;
+
+struct TestSimple {
+ int64 x;
+};
+
+struct TestSimpleBool {
+ bool x;
+};
+
+struct TestAlignment1 {
+ int8 x;
+ int8 y;
+ uint32 z;
+};
+
+struct TestAlignment2 {
+ uint32 a;
+ uint32 b;
+ int8 c;
+ int8 d;
+ int8 e;
+ uint8 f;
+ uint32 g;
+ uint16 h;
+ uint16 i;
+};
+
+struct TestFloat1 {
+ float32 a;
+};
+
+struct TestFloat2 {
+ float64 a;
+};
+
+struct TestFloat3 {
+ float32 a;
+ float64 b;
+ uint64 c;
+ float32 d;
+};
+
+struct TestArray1 {
+ array<int8>:5 a;
+};
+
+struct TestArray2 {
+ float64 a;
+ array<float32>:1 b;
+};
+
+struct TestArray3 {
+ int32 a;
+ array<uint16>:3 b;
+ uint64 c;
+};
+
+struct TestArray4 {
+ array<bool>:9 a;
+};
+
+struct TestString1 {
+ string a;
+ string? b;
+};
+
+struct TestString2 {
+ array<string>:2 a;
+};
+
+struct TestString3 {
+ array<string:4>:2 a;
+ array<string:4?>:2 b;
+};
+
+struct TestVector1 {
+ vector<int8> a;
+ vector<int16>? b;
+ vector<int32>:2 c;
+ vector<int64>:2? d;
+};
+
+struct TestVector2 {
+ array<vector<int8>>:2 a;
+ vector<vector<int8>>:2 b;
+ vector<vector<string:5>:2?>:2 c;
+};
+
+struct TestStruct1 {
+ TestSimple a;
+ TestSimple? b;
+};
+
+struct TestStruct2 {
+ TestArray1 a;
+ TestFloat1 b;
+ TestVector1 c;
+ TestString1? d;
+};
+
+union Union1 {
+ array<int8>:3 a;
+ TestSimple b;
+ TestSimple? c;
+ float32 d;
+};
+
+struct TestUnion1 {
+ Union1 a;
+ Union1? b;
+};
+
+struct TestUnion2 {
+ vector<Union1> a;
+ vector<Union1?> b;
+};
+
+struct TestHandle1 {
+ handle a;
+ handle? b;
+ handle<vmo> c;
+ handle<vmo>? d;
+};
+
+struct TestHandle2 {
+ vector<handle>:1 a;
+ vector<handle<vmo>?>:1 b;
+};
+
+interface Test1 {
+ 10: Echo(string? in) -> (string? out);
+ 11: -> Surprise(string foo);
+};
+
+struct TestInterface1 {
+ Test1 a;
+ Test1? b;
+ request<Test1> c;
+ request<Test1>? d;
+};
diff --git a/src/syscall/zx/fidl/encoding.go b/src/syscall/zx/fidl/encoding.go
new file mode 100644
index 0000000..bba6e0d
--- /dev/null
+++ b/src/syscall/zx/fidl/encoding.go
@@ -0,0 +1,1017 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build fuchsia
+
+package fidl
+
+import (
+ "errors"
+ "math"
+ "reflect"
+ "strconv"
+ "strings"
+ "syscall/zx"
+)
+
+const (
+ allocPresent uint64 = math.MaxUint64
+ noAlloc = 0
+)
+
+const (
+ handlePresent uint32 = math.MaxUint32
+ noHandle = 0
+)
+
+var (
+ // TODO(mknyszek): Add support here for process, thread, job, resource,
+ // interrupt, eventpair, fifo, guest, and time once these are actually
+ // supported in the Go runtime.
+ handleType reflect.Type = reflect.TypeOf(zx.Handle(0))
+ channelType = reflect.TypeOf(zx.Channel(0))
+ logType = reflect.TypeOf(zx.Log(0))
+ portType = reflect.TypeOf(zx.Port(0))
+ vmoType = reflect.TypeOf(zx.VMO(0))
+ eventType = reflect.TypeOf(zx.Event(0))
+ socketType = reflect.TypeOf(zx.Socket(0))
+ vmarType = reflect.TypeOf(zx.VMAR(0))
+ interfaceRequestType = reflect.TypeOf(InterfaceRequest{})
+ proxyType = reflect.TypeOf(Proxy{})
+)
+
+// isUnionType returns true if the reflected type is a FIDL union type.
+func isUnionType(t reflect.Type) bool {
+ // This is a safe way to check if it's a union type because the generated
+ // code inserts a "dummy" field (of type struct{}) at the beginning as a
+ // marker that the struct should be treated as a FIDL union. Because all FIDL
+ // fields are exported, there's no potential for name collision either, and a
+ // struct accidentally being treated as a union.
+ return t.Kind() == reflect.Struct && t.NumField() > 1 && t.Field(0).Tag.Get("fidl") == "tag"
+}
+
+// isHandleType returns true if the reflected type is a Fuchsia handle type.
+func isHandleType(t reflect.Type) bool {
+ switch t {
+ case handleType:
+ fallthrough
+ case channelType:
+ fallthrough
+ case logType:
+ fallthrough
+ case portType:
+ fallthrough
+ case vmoType:
+ fallthrough
+ case eventType:
+ fallthrough
+ case socketType:
+ fallthrough
+ case vmarType:
+ return true
+ }
+ return false
+}
+
+// isInterfaceType returns true if the reflected type is a FIDL interface type.
+func isInterfaceType(t reflect.Type) bool {
+ // FIDL interfaces are represented as aliases over Proxy.
+ return t.ConvertibleTo(proxyType)
+}
+
+// isInterfaceRequestType returns true if the reflected type is a FIDL interface
+// request type.
+func isInterfaceRequestType(t reflect.Type) bool {
+ // FIDL interfaces are represented as aliases over InterfaceRequest.
+ return t.ConvertibleTo(interfaceRequestType)
+}
+
+// getSize returns the size of the type. Occasionally this requires the value,
+// particularly for a struct.
+func getSize(t reflect.Type, v reflect.Value) (int, error) {
+ switch t.Kind() {
+ case reflect.Array:
+ if v.Len() == 0 {
+ return 0, nil
+ }
+ s, err := getSize(t.Elem(), v.Index(0))
+ if err != nil {
+ return 0, err
+ }
+ return v.Len() * s, nil
+ case reflect.Bool, reflect.Int8, reflect.Uint8:
+ return 1, nil
+ case reflect.Int16, reflect.Uint16:
+ return 2, nil
+ case reflect.Int32, reflect.Uint32, reflect.Float32:
+ return 4, nil
+ case reflect.Int64, reflect.Uint64, reflect.Float64:
+ return 8, nil
+ case reflect.Ptr:
+ i := t.Elem()
+ switch i.Kind() {
+ case reflect.Slice:
+ return 16, nil
+ case reflect.String:
+ return 16, nil
+ case reflect.Struct:
+ // Handles both structs and unions.
+ return 8, nil
+ }
+ return 0, newValueError(ErrInvalidPointerType, t.Name())
+ case reflect.String:
+ return 16, nil
+ case reflect.Slice:
+ return 16, nil
+ case reflect.Struct:
+ // Handles both structs and unions.
+ return getPayloadSize(t, v)
+ }
+ return 0, newValueError(ErrInvalidInlineType, t.Name())
+}
+
+func structAsPayload(t reflect.Type, v reflect.Value) (Payload, error) {
+ // Get the size and alignment for the struct.
+ //
+ // Note that Addr can fail if the originally derived value is not "addressable",
+ // meaning the root ValueOf() call was on a struct value, not a pointer. However,
+ // we guarantee the struct is addressable by forcing a Payload to be passed in
+ // (a struct value will never cast as an interface).
+ //
+ // We avoid using Implements(), MethodByName(), and Call() here because they're
+ // very slow.
+ payload, ok := v.Addr().Interface().(Payload)
+ if !ok {
+ return nil, ErrStructIsNotPayload
+ }
+ return payload, nil
+}
+
+func getPayloadSize(t reflect.Type, v reflect.Value) (int, error) {
+ p, err := structAsPayload(t, v)
+ if err != nil {
+ return 0, err
+ }
+ return p.InlineSize(), nil
+}
+
+func getPayloadAlignment(t reflect.Type, v reflect.Value) (int, error) {
+ p, err := structAsPayload(t, v)
+ if err != nil {
+ return 0, err
+ }
+ return p.InlineAlignment(), nil
+}
+
+// fieldData contains metadata for a single struct field for use during encoding and
+// decoding. It is derived from a struct field tag, and generally contains facilities
+// for managing state in a recursive context (since even the type in a single struct field
+// may be recursively defined).
+type nestedTypeData struct {
+ // maxElems represents the maximum number of elements allowed for a
+ // container type. "nil" means there is no maximum. It is represented
+ // as a slice because FIDL container types may be nested arbitrarily
+ // deeply. The lower the index, the more deeply nested the type is.
+ maxElems []*int
+
+ // nullable reflects whether the innermost type for a struct field is nullable.
+ // This is only used for types where nullability is non-obvious, which is only
+ // handles for now.
+ nullable bool
+}
+
+// Unnest attempts to unnest the nestedTypeData one level. If it succeeds, it returns the type
+// data for that nesting level, and modifies the data structure for the next nested container.
+func (n *nestedTypeData) Unnest() *int {
+ if len(n.maxElems) == 0 {
+ return nil
+ }
+ v := n.maxElems[len(n.maxElems)-1]
+ n.maxElems = n.maxElems[:len(n.maxElems)-1]
+ return v
+}
+
+// FromTag derives metadata from data serialized into a golang struct field
+// tag.
+func (n *nestedTypeData) FromTag(tag reflect.StructTag) error {
+ raw, ok := tag.Lookup("fidl")
+ if !ok {
+ return nil
+ }
+ split := strings.Split(raw, ",")
+ if split[0] == "*" {
+ n.nullable = true
+ split = split[1:]
+ }
+ var maxElems []*int
+ for _, e := range split {
+ if e == "" {
+ maxElems = append(maxElems, nil)
+ continue
+ }
+ i, err := strconv.ParseInt(e, 0, 64)
+ if err != nil {
+ return err
+ }
+ val := int(i)
+ maxElems = append(maxElems, &val)
+ }
+ n.maxElems = maxElems
+ return nil
+}
+
+// align increases size such that size is aligned to bytes, and returns the new size.
+//
+// bytes must be a power of 2.
+func align(size, bytes int) int {
+ offset := size & (bytes - 1)
+ // If we're not currently aligned to |bytes| bytes, add padding.
+ if offset != 0 {
+ size += (bytes - offset)
+ }
+ return size
+}
+
+// encoder represents the encoding context that is necessary to maintain across
+// recursive calls within the same FIDL object.
+type encoder struct {
+ // head is the index into buffer at which new data will be written to for the current
+ // object. It must be updated before writing to a new out-of-line object, and then
+ // fixed when that object is finished.
+ head int
+
+ // buffer represents the output buffer that the encoder writes into.
+ buffer []byte
+
+ // handles are the handles discovered when traversing the FIDL data
+ // structure. They are referenced from within the serialized data
+ // structure in buffer.
+ handles []zx.Handle
+}
+
+func (e *encoder) newObject(size int) int {
+ size = align(size, 8)
+ start := len(e.buffer)
+ e.buffer = append(e.buffer, make([]byte, size)...)
+ return start
+}
+
+// writeInt writes an integer of byte-width size to the buffer.
+//
+// Before writing, it pads the buffer such that the integer is aligned to
+// its own byte-width.
+//
+// size must be a power of 2 <= 8.
+func (e *encoder) writeInt(val int64, size int) {
+ e.writeUint(uint64(val), size)
+}
+
+// writeUint writes an unsigned integer of byte-width size to the buffer.
+//
+// Before writing, it pads the buffer such that the integer is aligned to
+// its own byte-width.
+//
+// size must be a power of 2 <= 8.
+func (e *encoder) writeUint(val uint64, size int) {
+ e.head = align(e.head, size)
+ for i := e.head; i < e.head+size; i++ {
+ e.buffer[i] = byte(val & 0xFF)
+ val >>= 8
+ }
+ e.head += size
+}
+
+// marshalStructOrUnionInline first aligns head to the struct's or union's alignment
+// factor, and then writes its field(s) inline.
+//
+// Expects the Type t and Value v to refer to a golang struct value, not a pointer.
+func (e *encoder) marshalStructOrUnionInline(t reflect.Type, v reflect.Value) error {
+ a, err := getPayloadAlignment(t, v)
+ if err != nil {
+ return err
+ }
+ e.head = align(e.head, a)
+ if isUnionType(t) {
+ err = e.marshalUnion(t, v, a)
+ } else {
+ err = e.marshalStructFields(t, v)
+ }
+ if err != nil {
+ return err
+ }
+ e.head = align(e.head, a)
+ return nil
+}
+
+// marshalStructOrUnionPointer marshals a nullable struct's or union's reference, and then
+// marshals the value itself out-of-line.
+//
+// Expects the Type t and Value v to refer to a pointer to a golang struct.
+func (e *encoder) marshalStructOrUnionPointer(t reflect.Type, v reflect.Value) error {
+ if v.IsNil() {
+ e.writeUint(noAlloc, 8)
+ return nil
+ }
+ e.writeUint(allocPresent, 8)
+ et := t.Elem()
+ ev := v.Elem()
+ // Encode the value out-of-line.
+ payload, err := structAsPayload(et, ev)
+ if err != nil {
+ return err
+ }
+ oldHead := e.head
+ e.head = e.newObject(align(payload.InlineSize(), 8))
+ if isUnionType(et) {
+ err = e.marshalUnion(et, ev, payload.InlineAlignment())
+ } else {
+ err = e.marshalStructFields(et, ev)
+ }
+ if err != nil {
+ return err
+ }
+ e.head = oldHead
+ return nil
+}
+
+// marshalStructFields marshals the fields of a struct inline without any alignment.
+//
+// Expects the Type t and Value v to refer to a struct value, not a pointer.
+//
+// It marshals only exported struct fields.
+func (e *encoder) marshalStructFields(t reflect.Type, v reflect.Value) error {
+ for i := 0; i < t.NumField(); i++ {
+ f := t.Field(i)
+ // If it's an unexported field, ignore it.
+ if f.PkgPath != "" {
+ continue
+ }
+ var n nestedTypeData
+ if err := n.FromTag(f.Tag); err != nil {
+ return err
+ }
+ if err := e.marshal(f.Type, v.Field(i), n); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+// marshalUnion marshals a FIDL union represented as a golang struct inline,
+// without any external alignment.
+//
+// Expects the Type t and Value v to refer to a golang struct value, not a
+// pointer. The alignment field is used to align the union's field.
+func (e *encoder) marshalUnion(t reflect.Type, v reflect.Value, alignment int) error {
+ kind := v.Field(0).Uint()
+
+ // Index into the fields of the struct, adding 1 for the tag.
+ fieldIndex := int(kind) + 1
+ if fieldIndex >= t.NumField() {
+ return newValueError(ErrInvalidUnionTag, kind)
+ }
+ // Save the head for proper padding.
+ head := e.head
+ e.writeUint(kind, 4)
+
+ f := t.Field(fieldIndex)
+ var n nestedTypeData
+ if err := n.FromTag(f.Tag); err != nil {
+ return err
+ }
+ // Re-align to the union's alignment before writing its field.
+ e.head = align(e.head, alignment)
+ if err := e.marshal(f.Type, v.Field(fieldIndex), n); err != nil {
+ return err
+ }
+ s, err := getPayloadSize(t, v)
+ if err != nil {
+ return err
+ }
+ e.head = head + s
+ return nil
+}
+
+// marshalArray marshals a FIDL array inline.
+func (e *encoder) marshalArray(t reflect.Type, v reflect.Value, n nestedTypeData) error {
+ elemType := t.Elem()
+ for i := 0; i < t.Len(); i++ {
+ if err := e.marshal(elemType, v.Index(i), n); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+// marshalInline marshals a number of different supported FIDL types inline.
+func (e *encoder) marshalInline(t reflect.Type, v reflect.Value, n nestedTypeData) error {
+ switch t.Kind() {
+ case reflect.Array:
+ return e.marshalArray(t, v, n)
+ case reflect.Bool:
+ i := uint64(0)
+ if v.Bool() {
+ i = 1
+ }
+ e.writeUint(i, 1)
+ case reflect.Int8:
+ e.writeInt(v.Int(), 1)
+ case reflect.Int16:
+ e.writeInt(v.Int(), 2)
+ case reflect.Int32:
+ e.writeInt(v.Int(), 4)
+ case reflect.Int64:
+ e.writeInt(v.Int(), 8)
+ case reflect.Uint8:
+ e.writeUint(v.Uint(), 1)
+ case reflect.Uint16:
+ e.writeUint(v.Uint(), 2)
+ case reflect.Uint32:
+ e.writeUint(v.Uint(), 4)
+ case reflect.Uint64:
+ e.writeUint(v.Uint(), 8)
+ case reflect.Float32:
+ e.writeUint(uint64(math.Float32bits(float32(v.Float()))), 4)
+ case reflect.Float64:
+ e.writeUint(math.Float64bits(v.Float()), 8)
+ case reflect.Struct:
+ return e.marshalStructOrUnionInline(t, v)
+ default:
+ return newValueError(ErrInvalidInlineType, t.Name())
+ }
+ return nil
+}
+
+// marshalVector writes the vector metadata inline and the elements of the vector in a new
+// out-of-line object. Expects the value to be a regular string value, i.e. of type string.
+func (e *encoder) marshalVector(t reflect.Type, v reflect.Value, n nestedTypeData) error {
+ if !v.IsValid() {
+ e.writeUint(0, 8)
+ e.writeUint(noAlloc, 8)
+ return nil
+ }
+ max := n.Unnest()
+ if max != nil && v.Len() > *max {
+ return newExpectError(ErrVectorTooLong, *max, v.Len())
+ }
+ e.writeUint(uint64(v.Len()), 8)
+ e.writeUint(allocPresent, 8)
+ // Don't bother creating the out-of-line struct if its length is 0.
+ if v.Len() == 0 {
+ return nil
+ }
+ elemType := t.Elem()
+ elemSize, err := getSize(elemType, v.Index(0))
+ if err != nil {
+ return err
+ }
+ // Encode in the out-of-line object.
+ oldHead := e.head
+ e.head = e.newObject(v.Len() * elemSize)
+
+ if elemType.Kind() == reflect.Uint8 {
+ // optimize the fdio case of a vector of bytes
+ copy(e.buffer[e.head:], v.Bytes())
+ } else {
+ for i := 0; i < v.Len(); i++ {
+ if err := e.marshal(elemType, v.Index(i), n); err != nil {
+ return err
+ }
+ }
+ }
+ e.head = oldHead
+ return nil
+}
+
+// marshalString writes the string metadata inline and the bytes of the string in a new
+// out-of-line object. Expects the value to be a regular string value, i.e. of type string.
+func (e *encoder) marshalString(v reflect.Value, n nestedTypeData) error {
+ if !v.IsValid() {
+ e.writeUint(0, 8)
+ e.writeUint(noAlloc, 8)
+ return nil
+ }
+ s := v.String()
+ max := n.Unnest()
+ if max != nil && len(s) > *max {
+ return newExpectError(ErrStringTooLong, *max, len(s))
+ }
+ e.writeUint(uint64(len(s)), 8)
+ e.writeUint(allocPresent, 8)
+
+ // Create a new out-of-line object and write bytes of the string.
+ head := e.newObject(len(s))
+ for i := 0; i < len(s); i++ {
+ e.buffer[head+i] = s[i]
+ }
+ return nil
+}
+
+// marshalHandle marshals a Fuchsia handle type, and ensures that the handle is
+// valid if it is not nullable.
+func (e *encoder) marshalHandle(v reflect.Value, n nestedTypeData) error {
+ // The underlying type of all the handles is a uint32, so we're
+ // safe calling Uint(). This will panic if that is no longer true.
+ raw := zx.Handle(v.Uint())
+ if raw == zx.HandleInvalid {
+ if !n.nullable {
+ return ErrUnexpectedNullHandle
+ }
+ e.writeUint(uint64(noHandle), 4)
+ return nil
+ }
+ e.handles = append(e.handles, raw)
+ e.writeUint(uint64(handlePresent), 4)
+ return nil
+}
+
+// marshalPointer marshals nullable FIDL types that are represented by golang pointer
+// indirections. The input type and value should be the dereference of the golang pointers,
+// that is, if we're marshalling *string, we should get string.
+func (e *encoder) marshalPointer(t reflect.Type, v reflect.Value, n nestedTypeData) error {
+ switch t.Elem().Kind() {
+ case reflect.Slice:
+ return e.marshalVector(t.Elem(), v.Elem(), n)
+ case reflect.String:
+ return e.marshalString(v.Elem(), n)
+ case reflect.Struct:
+ return e.marshalStructOrUnionPointer(t, v)
+ }
+ return newValueError(ErrInvalidPointerType, t.Name())
+}
+
+// marshal is the central recursive function core to marshalling, and
+// traverses the tree-like structure of the input type t. v represents
+// the value associated with the type t.
+func (e *encoder) marshal(t reflect.Type, v reflect.Value, n nestedTypeData) error {
+ switch t.Kind() {
+ case reflect.Ptr:
+ return e.marshalPointer(t, v, n)
+ case reflect.Slice:
+ return e.marshalVector(t, v, n)
+ case reflect.String:
+ return e.marshalString(v, n)
+ }
+ if isHandleType(t) {
+ return e.marshalHandle(v, n)
+ }
+ if isInterfaceType(t) || isInterfaceRequestType(t) {
+ // An interface is represented by a Proxy, whose first field is
+ // a zx.Channel, and we can just marshal that. Same goes for an
+ // interface request, which is just an InterfaceRequest whose
+ // first field is a zx.Channel.
+ return e.marshalHandle(v.Field(0), n)
+ }
+ return e.marshalInline(t, v, n)
+}
+
+// MarshalHeader encodes the FIDL message header into the beginning of data.
+func MarshalHeader(header *MessageHeader, data []byte) {
+ // Clear the buffer so we can append to it.
+ e := encoder{buffer: data[:0]}
+ e.head = e.newObject(MessageHeaderSize)
+ e.writeUint(uint64(header.Txid), 4)
+ e.writeUint(uint64(header.Reserved), 4)
+ e.writeUint(uint64(header.Flags), 4)
+ e.writeUint(uint64(header.Ordinal), 4)
+}
+
+// Marshal the FIDL payload in s into data and handles.
+//
+// s must be a pointer to a struct, since the primary object in a FIDL message
+// is always a struct.
+//
+// Marshal traverses the value s recursively, following nested type values via
+// reflection in order to encode the FIDL struct.
+func Marshal(s Payload, data []byte, handles []zx.Handle) (int, int, error) {
+ // First, let's make sure we have the right type in s.
+ t := reflect.TypeOf(s)
+ if t.Kind() != reflect.Ptr {
+ return 0, 0, errors.New("expected a pointer")
+ }
+ t = t.Elem()
+ if t.Kind() != reflect.Struct {
+ return 0, 0, errors.New("primary object must be a struct")
+ }
+
+ // Now, let's get the value of s, marshal the header into a starting
+ // buffer, and then marshal the rest of the payload in s.
+ v := reflect.ValueOf(s).Elem()
+ e := encoder{buffer: data[:0], handles: handles[:0]}
+ e.head = e.newObject(s.InlineSize())
+ if err := e.marshalStructFields(t, v); err != nil {
+ return 0, 0, err
+ }
+ return len(e.buffer), len(e.handles), nil
+}
+
+// decoder represents the decoding context that is necessary to maintain
+// across recursive calls within the same FIDL object.
+type decoder struct {
+ // head is the index into buffer at which new data will be read from for the current
+ // object. It must be updated before reading from a new out-of-line object, and then
+ // fixed when that object is finished.
+ head int
+
+ // nextObject is the byte index of the next out-of-line object in buffer.
+ nextObject int
+
+ // buffer represents the buffer we're decoding from.
+ buffer []byte
+
+ // handles represents the input untyped handled we're decoding.
+ handles []zx.Handle
+}
+
+// readInt reads a signed integer value of byte-width size from the buffer.
+//
+// Before it reads, however, it moves the head forward so as to be naturally
+// aligned with the byte-width of the integer it is reading.
+//
+// size must be a power of 2 <= 8.
+func (d *decoder) readInt(size int) int64 {
+ return int64(d.readUint(size))
+}
+
+// readUint reads an unsigned integer value of byte-width size from the buffer.
+//
+// Before it reads, however, it moves the head forward so as to be naturally
+// aligned with the byte-width of the integer it is reading.
+//
+// size must be a power of 2 <= 8.
+func (d *decoder) readUint(size int) uint64 {
+ d.head = align(d.head, size)
+ var val uint64
+ for i := d.head + size - 1; i >= d.head; i-- {
+ val <<= 8
+ val |= uint64(d.buffer[i])
+ }
+ d.head += size
+ return val
+}
+
+// unmarshalStructOrUnionInline unmarshals a struct or union inline based on Type t
+// into Value v, first aligning head to the alignment of the value.
+//
+// Expects the Type t and Value v to refer to a golang struct value, not a pointer.
+func (d *decoder) unmarshalStructOrUnionInline(t reflect.Type, v reflect.Value) error {
+ a, err := getPayloadAlignment(t, v)
+ if err != nil {
+ return err
+ }
+ d.head = align(d.head, a)
+ if isUnionType(t) {
+ err = d.unmarshalUnion(t, v, a)
+ } else {
+ err = d.unmarshalStructFields(t, v)
+ }
+ if err != nil {
+ return err
+ }
+ d.head = align(d.head, a)
+ return nil
+}
+
+// unmarshalStructOrUnionPointer unmarshals a pointer to a golang struct (i.e. a
+// nullable FIDL struct or union) into the Value v.
+//
+// Expects the Type t and Value v to refer to a pointer to a golang struct.
+func (d *decoder) unmarshalStructOrUnionPointer(t reflect.Type, v reflect.Value) error {
+ if d.readUint(8) == noAlloc {
+ v.Set(reflect.Zero(t))
+ return nil
+ }
+ // Create the new struct.
+ v.Set(reflect.New(t.Elem()))
+ et := t.Elem()
+ ev := v.Elem()
+
+ // Set up the out-of-line space and the head.
+ oldHead := d.head
+ d.head = d.nextObject
+ payload, err := structAsPayload(et, ev)
+ if err != nil {
+ return err
+ }
+ d.nextObject += align(payload.InlineSize(), 8)
+
+ // Unmarshal the value itself out-of-line.
+ if isUnionType(et) {
+ err = d.unmarshalUnion(et, ev, payload.InlineAlignment())
+ } else {
+ err = d.unmarshalStructFields(et, ev)
+ }
+ if err != nil {
+ return err
+ }
+
+ // Fix up head to the old head if it's a nullable struct.
+ d.head = oldHead
+ return nil
+}
+
+// unmarshalStructFields unmarshals the exported fields of the struct at d.head into
+// the Value v.
+//
+// Expects the Type t and Value v to refer to a struct value, not a pointer.
+func (d *decoder) unmarshalStructFields(t reflect.Type, v reflect.Value) error {
+ for i := 0; i < t.NumField(); i++ {
+ f := t.Field(i)
+ // If it's an unexported field, ignore it.
+ if f.PkgPath != "" {
+ continue
+ }
+ var n nestedTypeData
+ if err := n.FromTag(f.Tag); err != nil {
+ return err
+ }
+ if err := d.unmarshal(f.Type, v.Field(i), n); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+// unmarshalUnion unmarshals a FIDL union at d.head into the Value v (a golang
+// struct) without any external alignment.
+//
+// Expects the Type t and Value v to refer to a golang struct value, not a pointer.
+// The alignment field is used to align to the union's field before reading.
+func (d *decoder) unmarshalUnion(t reflect.Type, v reflect.Value, alignment int) error {
+ // Save the head for proper padding.
+ head := d.head
+ kind := d.readUint(4)
+
+ // Index into the fields of the struct, adding 1 for the tag.
+ fieldIndex := int(kind) + 1
+ if fieldIndex >= t.NumField() {
+ return ErrInvalidUnionTag
+ }
+ v.Field(0).SetUint(kind)
+
+ f := t.Field(fieldIndex)
+ var n nestedTypeData
+ if err := n.FromTag(f.Tag); err != nil {
+ return err
+ }
+ d.head = align(d.head, alignment)
+ if err := d.unmarshal(f.Type, v.Field(fieldIndex), n); err != nil {
+ return err
+ }
+ s, err := getPayloadSize(t, v)
+ if err != nil {
+ return err
+ }
+ d.head = head + s
+ return nil
+}
+
+// unmarshalArray unmarshals an array inline based on Type t into Value v, taking into account
+// nestedTypeData n, since an array is a container type.
+func (d *decoder) unmarshalArray(t reflect.Type, v reflect.Value, n nestedTypeData) error {
+ elemType := t.Elem()
+ for i := 0; i < t.Len(); i++ {
+ if err := d.unmarshal(elemType, v.Index(i), n); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+// unmarshalInline unmarshals a variety of types inline, or delegates to their types' specific
+// unmarshalling functions.
+func (d *decoder) unmarshalInline(t reflect.Type, v reflect.Value, n nestedTypeData) error {
+ switch t.Kind() {
+ case reflect.Array:
+ return d.unmarshalArray(t, v, n)
+ case reflect.Bool:
+ i := d.readUint(1)
+ switch i {
+ case 0:
+ v.SetBool(false)
+ case 1:
+ v.SetBool(true)
+ default:
+ return newValueError(ErrInvalidBoolValue, i)
+ }
+ case reflect.Int8:
+ v.SetInt(d.readInt(1))
+ case reflect.Int16:
+ v.SetInt(d.readInt(2))
+ case reflect.Int32:
+ v.SetInt(d.readInt(4))
+ case reflect.Int64:
+ v.SetInt(d.readInt(8))
+ case reflect.Uint8:
+ v.SetUint(d.readUint(1))
+ case reflect.Uint16:
+ v.SetUint(d.readUint(2))
+ case reflect.Uint32:
+ v.SetUint(d.readUint(4))
+ case reflect.Uint64:
+ v.SetUint(d.readUint(8))
+ case reflect.Float32:
+ v.SetFloat(float64(math.Float32frombits(uint32(d.readUint(4)))))
+ case reflect.Float64:
+ v.SetFloat(math.Float64frombits(d.readUint(8)))
+ case reflect.Struct:
+ return d.unmarshalStructOrUnionInline(t, v)
+ default:
+ return newValueError(ErrInvalidInlineType, t.Name())
+ }
+ return nil
+}
+
+// unmarshalVector unmarshals an out-of-line FIDL vector into a golang slice which is placed
+// into v. nestedTypeData is also necessary because a vector can have a maximum size). The
+// expected types and values are either pointers, i.e. *[]int8 or an "inline" vector value
+// i.e. []int8.
+func (d *decoder) unmarshalVector(t reflect.Type, v reflect.Value, n nestedTypeData) error {
+ size := int64(d.readUint(8))
+ if size < 0 {
+ return newExpectError(ErrVectorTooLong, math.MaxInt64, size)
+ }
+ if ptr := d.readUint(8); ptr == noAlloc {
+ if t.Kind() != reflect.Ptr {
+ return newValueError(ErrUnexpectedNullRef, "vector")
+ }
+ v.Set(reflect.Zero(t))
+ return nil
+ }
+ max := n.Unnest()
+ if max != nil && int(size) > *max {
+ return newExpectError(ErrVectorTooLong, *max, size)
+ }
+
+ // Create the slice with reflection.
+ sliceType := t
+ elemType := t.Elem()
+ if t.Kind() == reflect.Ptr {
+ sliceType = elemType
+ elemType = sliceType.Elem()
+ }
+ s := reflect.MakeSlice(sliceType, int(size), int(size))
+
+ // Unmarshal the out-of-line structure.
+ oldHead := d.head
+ d.head = d.nextObject
+ // TODO(mknyszek): Get rid of this extra reflect.New somehow.
+ elemSize, err := getSize(elemType, reflect.New(elemType).Elem())
+ if err != nil {
+ return err
+ }
+ d.nextObject += align(int(size)*elemSize, 8)
+ if elemType.Kind() == reflect.Uint8 {
+ copy(s.Bytes(), d.buffer[d.head:])
+ } else {
+ for i := 0; i < int(size); i++ {
+ if err := d.unmarshal(elemType, s.Index(i), n); err != nil {
+ return err
+ }
+ }
+ }
+ d.head = oldHead
+ if t.Kind() == reflect.Ptr {
+ v.Set(reflect.New(t.Elem()))
+ v.Elem().Set(s)
+ } else {
+ v.Set(s)
+ }
+ return nil
+}
+
+// unmarshalString unmarshals an out-of-line FIDL string into a golang string which is placed
+// into v. nestedTypeData is also necessary because it can have a maximum size). The expected
+// types and values are either pointers, i.e. *string or an "inline" string value. i.e. string.
+// This method uses whether or not the type is a golang pointer type to determine if it is
+// nullable.
+func (d *decoder) unmarshalString(t reflect.Type, v reflect.Value, n nestedTypeData) error {
+ size := int64(d.readUint(8))
+ if size < 0 {
+ return newExpectError(ErrStringTooLong, math.MaxInt64, size)
+ }
+ if ptr := d.readUint(8); ptr == noAlloc {
+ if t.Kind() != reflect.Ptr {
+ return newValueError(ErrUnexpectedNullRef, "string")
+ }
+ v.Set(reflect.Zero(t))
+ return nil
+ }
+ max := n.Unnest()
+ if max != nil && int(size) > *max {
+ return newExpectError(ErrStringTooLong, *max, size)
+ }
+ s := string(d.buffer[d.nextObject : d.nextObject+int(size)])
+ if t.Kind() == reflect.Ptr {
+ v.Set(reflect.New(t.Elem()))
+ v.Elem().Set(reflect.ValueOf(s))
+ } else {
+ v.Set(reflect.ValueOf(s))
+ }
+ d.nextObject += align(int(size), 8)
+ return nil
+}
+
+// unmarshalHandle unmarshals a handle into a value, validating that it is valid if the handle is
+// not nullable.
+func (d *decoder) unmarshalHandle(v reflect.Value, n nestedTypeData) error {
+ h := d.readUint(4)
+ switch h {
+ case uint64(noHandle):
+ if !n.nullable {
+ return ErrUnexpectedNullHandle
+ }
+ v.SetUint(uint64(zx.HandleInvalid))
+ case uint64(handlePresent):
+ if len(d.handles) == 0 {
+ return ErrNotEnoughHandles
+ }
+ v.SetUint(uint64(d.handles[0]))
+ d.handles = d.handles[1:]
+ default:
+ return newValueError(ErrBadHandleEncoding, h)
+ }
+ return nil
+}
+
+// unmarshalPointer unmarshals nullable FIDL types that are represented by golang pointer
+// indirections. The expected types and values t and v are pointers, i.e. they start with *.
+func (d *decoder) unmarshalPointer(t reflect.Type, v reflect.Value, n nestedTypeData) error {
+ switch t.Elem().Kind() {
+ case reflect.Slice:
+ return d.unmarshalVector(t, v, n)
+ case reflect.String:
+ return d.unmarshalString(t, v, n)
+ case reflect.Struct:
+ return d.unmarshalStructOrUnionPointer(t, v)
+ }
+ return newValueError(ErrInvalidPointerType, t.Name())
+}
+
+// unmarshal is the central recursive function core to unmarshalling, and
+// traverses the tree-like structure of the input type t. v represents
+// the value associated with the type t.
+func (d *decoder) unmarshal(t reflect.Type, v reflect.Value, n nestedTypeData) error {
+ switch t.Kind() {
+ case reflect.Ptr:
+ return d.unmarshalPointer(t, v, n)
+ case reflect.Slice:
+ return d.unmarshalVector(t, v, n)
+ case reflect.String:
+ return d.unmarshalString(t, v, n)
+ }
+ if isHandleType(t) {
+ return d.unmarshalHandle(v, n)
+ }
+ if isInterfaceType(t) || isInterfaceRequestType(t) {
+ // An interface is represented by a Proxy, whose first field is
+ // a zx.Channel, and we can just marshal that. Same goes for an
+ // interface request, which is just an InterfaceRequest whose
+ // first field is a zx.Channel.
+ return d.unmarshalHandle(v.Field(0), n)
+ }
+ return d.unmarshalInline(t, v, n)
+}
+
+// UnmarshalHeader parses a FIDL header in the data into m.
+func UnmarshalHeader(data []byte, m *MessageHeader) error {
+ if len(data) < 16 {
+ return ErrMessageTooSmall
+ }
+ d := decoder{buffer: data}
+ m.Txid = uint32(d.readUint(4))
+ m.Reserved = uint32(d.readUint(4))
+ m.Flags = uint32(d.readUint(4))
+ m.Ordinal = uint32(d.readUint(4))
+ return nil
+}
+
+// Unmarshal parses the encoded FIDL payload in data and handles, storing the
+// decoded payload in s.
+//
+// The value pointed to by s must be a pointer to a golang struct which represents
+// the decoded primary object of a FIDL message. The data decode process is guided
+// by the structure of the struct pointed to by s.
+//
+// TODO(mknyszek): More rigorously validate the input.
+func Unmarshal(data []byte, handles []zx.Handle, s Payload) error {
+ // First, let's make sure we have the right type in s.
+ t := reflect.TypeOf(s)
+ if t.Kind() != reflect.Ptr {
+ return errors.New("expected a pointer")
+ }
+ t = t.Elem()
+ if t.Kind() != reflect.Struct {
+ return errors.New("primary object must be a struct")
+ }
+
+ // Get the payload's value and unmarshal it.
+ nextObject := align(s.InlineSize(), 8)
+ d := decoder{
+ buffer: data,
+ handles: handles,
+ nextObject: nextObject,
+ }
+ return d.unmarshalStructFields(t, reflect.ValueOf(s).Elem())
+}
diff --git a/src/syscall/zx/fidl/encoding_test.go b/src/syscall/zx/fidl/encoding_test.go
new file mode 100644
index 0000000..41af868
--- /dev/null
+++ b/src/syscall/zx/fidl/encoding_test.go
@@ -0,0 +1,188 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build fuchsia
+
+package fidl_test
+
+import (
+ "reflect"
+ "syscall/zx"
+ "testing"
+
+ . "fidl/bindings"
+ . "fuchsia/go/go_fidl_bindings_test"
+)
+
+func testIdentity(t *testing.T, input Payload, expectSize int, output Payload) {
+ var respb [zx.ChannelMaxMessageBytes]byte
+ var resph [zx.ChannelMaxMessageHandles]zx.Handle
+ nb, nh, err := Marshal(input, respb[:], resph[:])
+ if err != nil {
+ t.Fatal(err)
+ }
+ if nb != expectSize {
+ t.Fatalf("expected size %d but got %d: %v", expectSize, nb, respb[:nb])
+ }
+ if err := Unmarshal(respb[:nb], resph[:nh], output); err != nil {
+ t.Fatal(err)
+ }
+ if !reflect.DeepEqual(input, output) {
+ t.Fatalf("expected: %v, got: %v", input, output)
+ }
+}
+
+func TestEncodingIdentity(t *testing.T) {
+ t.Run("Header", func(t *testing.T) {
+ var buf [MessageHeaderSize]byte
+ m := MessageHeader{
+ Txid: 1215,
+ Reserved: 0,
+ Flags: 111111,
+ Ordinal: 889,
+ }
+ MarshalHeader(&m, buf[:])
+
+ var header MessageHeader
+ if err := UnmarshalHeader(buf[:], &header); err != nil {
+ t.Fatal(err)
+ }
+ if m != header {
+ t.Fatalf("expected: %v, got: %v", m, header)
+ }
+ })
+ t.Run("Simple", func(t *testing.T) {
+ testIdentity(t, &TestSimple{X: 124}, 8, &TestSimple{})
+ testIdentity(t, &TestSimpleBool{X: true}, 8, &TestSimpleBool{})
+ })
+ t.Run("Alignment", func(t *testing.T) {
+ testIdentity(t, &TestAlignment1{X: -36, Y: -10, Z: 51}, 8, &TestAlignment1{})
+ testIdentity(t, &TestAlignment2{
+ A: 1212141,
+ B: 908935,
+ C: -1,
+ D: 125,
+ E: -22,
+ F: 111,
+ G: 1515,
+ H: 65535,
+ I: 1515,
+ }, 24, &TestAlignment2{})
+ })
+ t.Run("Floats", func(t *testing.T) {
+ testIdentity(t, &TestFloat1{A: -36.0}, 8, &TestFloat1{})
+ testIdentity(t, &TestFloat2{A: -1254918271.0}, 8, &TestFloat2{})
+ testIdentity(t, &TestFloat3{A: 1241.1, B: 0.2141, C: 20, D: 0.0}, 32, &TestFloat3{})
+ })
+ t.Run("Arrays", func(t *testing.T) {
+ testIdentity(t, &TestArray1{A: [5]int8{1, 77, 2, 4, 5}}, 8, &TestArray1{})
+ testIdentity(t, &TestArray2{A: -1.0, B: [1]float32{0.2}}, 16, &TestArray2{})
+ testIdentity(t, &TestArray3{
+ A: -999,
+ B: [3]uint16{11, 12, 13},
+ C: 1021,
+ }, 24, &TestArray3{})
+ testIdentity(t, &TestArray4{
+ A: [9]bool{true, false, false, true, false, true, true, true, true},
+ }, 16, &TestArray4{})
+ })
+ t.Run("Strings", func(t *testing.T) {
+ testIdentity(t, &TestString1{A: "str", B: nil}, 40, &TestString1{})
+ testIdentity(t, &TestString2{A: [2]string{"hello", "g"}}, 48, &TestString2{})
+ s := "bye"
+ testIdentity(t, &TestString3{
+ A: [2]string{"boop", "g"},
+ B: [2]*string{&s, nil},
+ }, 88, &TestString3{})
+ })
+ t.Run("Vectors", func(t *testing.T) {
+ v1 := []int64{-1}
+ testIdentity(t, &TestVector1{
+ A: []int8{1, 2, 3, 4},
+ B: nil,
+ C: []int32{99},
+ D: &v1,
+ }, 88, &TestVector1{})
+ v2 := []string{"x", "hello"}
+ testIdentity(t, &TestVector2{
+ A: [2][]int8{{9, -1}, {}},
+ B: [][]int8{{-111, 41}, {-1, -1, -1, -1}},
+ C: []*[]string{nil, &v2},
+ }, 200, &TestVector2{})
+ })
+ t.Run("Structs", func(t *testing.T) {
+ testIdentity(t, &TestStruct1{
+ A: TestSimple{
+ X: -9999,
+ },
+ B: &TestSimple{
+ X: 1254125,
+ },
+ }, 24, &TestStruct1{})
+ v1 := []int64{101010}
+ testIdentity(t, &TestStruct2{
+ A: TestArray1{
+ A: [5]int8{1, 77, 2, 4, 5},
+ },
+ B: TestFloat1{
+ A: 2.81212,
+ },
+ C: TestVector1{
+ A: []int8{1, 2, 3, 4},
+ B: nil,
+ C: []int32{99},
+ D: &v1,
+ },
+ D: &TestString1{
+ A: "str",
+ B: nil,
+ },
+ }, 152, &TestStruct2{})
+ })
+ t.Run("Unions", func(t *testing.T) {
+ u1 := Union1{}
+ u1.SetB(TestSimple{X: 555})
+ testIdentity(t, &TestUnion1{
+ A: u1,
+ B: nil,
+ }, 24, &TestUnion1{})
+ testIdentity(t, &TestUnion2{
+ A: []Union1{u1, u1, u1},
+ B: []*Union1{&u1, nil, nil},
+ }, 120, &TestUnion2{})
+ })
+ t.Run("Handles", func(t *testing.T) {
+ vmo, err := zx.NewVMO(10, 0)
+ if err != nil {
+ t.Fatalf("failed to create vmo: %v", err)
+ }
+ testIdentity(t, &TestHandle1{
+ A: zx.Handle(22),
+ B: zx.HandleInvalid,
+ C: vmo,
+ D: zx.VMO(zx.HandleInvalid),
+ }, 16, &TestHandle1{})
+ testIdentity(t, &TestHandle2{
+ A: []zx.Handle{zx.Handle(vmo)},
+ B: []zx.VMO{zx.VMO(zx.HandleInvalid)},
+ }, 48, &TestHandle2{})
+ vmo.Close()
+ })
+ t.Run("Interfaces", func(t *testing.T) {
+ h0, h1, err := zx.NewChannel(0)
+ defer h0.Close()
+ defer h1.Close()
+ if err != nil {
+ t.Fatalf("failed to create vmo: %v", err)
+ }
+ testIdentity(t, &TestInterface1{
+ A: Test1Interface(Proxy{Channel: h0}),
+ B: Test1Interface(Proxy{Channel: zx.Channel(zx.HandleInvalid)}),
+ C: Test1InterfaceRequest(InterfaceRequest{Channel: h1}),
+ D: Test1InterfaceRequest(InterfaceRequest{
+ Channel: zx.Channel(zx.HandleInvalid),
+ }),
+ }, 16, &TestInterface1{})
+ })
+}
diff --git a/src/syscall/zx/fidl/errors.go b/src/syscall/zx/fidl/errors.go
new file mode 100644
index 0000000..17f7e8f
--- /dev/null
+++ b/src/syscall/zx/fidl/errors.go
@@ -0,0 +1,149 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build fuchsia
+
+package fidl
+
+import (
+ "reflect"
+ "strconv"
+)
+
+// ValidationError represents an error produced in validating a FIDL structure.
+type ValidationError interface {
+ error
+
+ // Code returns the underlying ErrorCode value, which all ValidationErrors
+ // must have.
+ Code() ErrorCode
+}
+
+// ErrorCode represents a set of machine-readable error codes each ValidationError
+// has.
+type ErrorCode uint32
+
+const (
+ ErrUnknownOrdinal ErrorCode = iota
+ ErrInvalidInlineType
+ ErrInvalidPointerType
+ ErrVectorTooLong
+ ErrStringTooLong
+ ErrUnexpectedOrdinal
+ ErrUnexpectedNullHandle
+ ErrUnexpectedNullRef
+ ErrInvalidBoolValue
+ ErrNotEnoughHandles
+ ErrBadHandleEncoding
+ ErrBadRefEncoding
+ ErrMessageTooSmall
+ ErrStructIsNotPayload
+ ErrInvalidUnionTag
+)
+
+// Error implements error for ErrorCode
+func (e ErrorCode) Error() string {
+ switch e {
+ case ErrUnknownOrdinal:
+ return "unknown ordinal"
+ case ErrInvalidInlineType:
+ return "invalid inline type"
+ case ErrInvalidPointerType:
+ return "invalid pointer type"
+ case ErrVectorTooLong:
+ return "vector exceeds maximum size"
+ case ErrStringTooLong:
+ return "string exceeds maximum size"
+ case ErrUnexpectedOrdinal:
+ return "unexpected ordinal"
+ case ErrUnexpectedNullHandle:
+ return "unexpected null handle"
+ case ErrUnexpectedNullRef:
+ return "unexpected null reference"
+ case ErrInvalidBoolValue:
+ return "unexpected boolean value"
+ case ErrNotEnoughHandles:
+ return "not enough handles"
+ case ErrBadHandleEncoding:
+ return "bad encoding for handle"
+ case ErrBadRefEncoding:
+ return "bad encoding for ref"
+ case ErrMessageTooSmall:
+ return "message too small to have FIDL header"
+ case ErrStructIsNotPayload:
+ return "golang struct type must implement Payload"
+ default:
+ return "unknown error code"
+ }
+}
+
+// Code implements the ValidationError interface.
+func (e ErrorCode) Code() ErrorCode {
+ return e
+}
+
+// stringer is an interface for types for which a string representation
+// may be derived.
+type stringer interface {
+ String() string
+}
+
+// toString generates the string representation for a limited set of types.
+func toString(value interface{}) string {
+ if e, ok := value.(error); ok {
+ return e.Error()
+ }
+ if s, ok := value.(stringer); ok {
+ return s.String()
+ }
+ t := reflect.TypeOf(value)
+ switch t.Kind() {
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ return strconv.FormatInt(reflect.ValueOf(value).Int(), 10)
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+ return strconv.FormatUint(reflect.ValueOf(value).Uint(), 10)
+ case reflect.String:
+ return value.(string)
+ default:
+ return "##BADVALUE##"
+ }
+}
+
+// valueError represents an error that refers to a single value.
+type valueError struct {
+ ErrorCode
+ value interface{}
+}
+
+func newValueError(code ErrorCode, value interface{}) valueError {
+ return valueError{
+ ErrorCode: code,
+ value: value,
+ }
+}
+
+func (e valueError) Error() string {
+ return e.ErrorCode.Error() + ": " + toString(e.value)
+}
+
+// expectError represents an error that refers to the expectation of a
+// certain value, and displays a comparison between the actual value and
+// the expected value.
+type expectError struct {
+ ErrorCode
+ expect interface{}
+ actual interface{}
+}
+
+func newExpectError(code ErrorCode, expect, actual interface{}) expectError {
+ return expectError{
+ ErrorCode: code,
+ expect: expect,
+ actual: actual,
+ }
+}
+
+func (e expectError) Error() string {
+ return e.ErrorCode.Error() + ": expected " + toString(e.expect) + ", got " + toString(e.actual)
+}
diff --git a/src/syscall/zx/fidl/interface.go b/src/syscall/zx/fidl/interface.go
new file mode 100644
index 0000000..e46f959
--- /dev/null
+++ b/src/syscall/zx/fidl/interface.go
@@ -0,0 +1,163 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build fuchsia
+
+package fidl
+
+import (
+ "syscall/zx"
+ "syscall/zx/zxwait"
+)
+
+// ServiceRequest is an abstraction over a FIDL interface request which is
+// intended to be used as part of service discovery.
+type ServiceRequest interface {
+ // Name returns the name of the service being requested.
+ Name() string
+
+ // ToChannel returns the underlying channel of the ServiceRequest.
+ ToChannel() zx.Channel
+}
+
+// InterfaceRequest is a wrapper type around a channel and represents the server side
+// of a FIDL interface, to be sent to a server as a request.
+type InterfaceRequest struct {
+ zx.Channel
+}
+
+// NewInterfaceRequest generates two sides of a channel with one layer of
+// type casts out of the way to minimize the amount of generated code. Semantically,
+// the two sides of the channel represent the interface request and the client
+// side of the interface (the proxy). It returns an error on failure.
+func NewInterfaceRequest() (InterfaceRequest, *Proxy, error) {
+ h0, h1, err := zx.NewChannel(0)
+ if err != nil {
+ return InterfaceRequest{}, nil, err
+ }
+ return InterfaceRequest{Channel: h0}, &Proxy{Channel: h1}, nil
+}
+
+// Proxy represents the client side of a FIDL interface.
+type Proxy struct {
+ // Channel is the underlying channel endpoint for this interface.
+ zx.Channel
+}
+
+// IsValid returns true if the underlying channel is a valid handle.
+func (p Proxy) IsValid() bool {
+ h := zx.Handle(p.Channel)
+ return h.IsValid()
+}
+
+// Send sends the request payload over the channel with the specified ordinal
+// without a response.
+func (p *Proxy) Send(ordinal uint32, req Payload) error {
+ respb := messageBytesPool.Get().([]byte)
+ resph := messageHandlesPool.Get().([]zx.Handle)
+
+ defer messageBytesPool.Put(respb)
+ defer messageHandlesPool.Put(resph)
+
+ // Marshal the message into the buffer.
+ header := MessageHeader{
+ Txid: 0, // Txid == 0 for messages without a response.
+ Ordinal: ordinal,
+ }
+ nb, nh, err := MarshalMessage(&header, req, respb[:], resph[:])
+ if err != nil {
+ return err
+ }
+
+ // Write the encoded bytes to the channel.
+ return p.Channel.Write(respb[:nb], resph[:nh], 0)
+}
+
+// Recv waits for an event and writes the response into the response payload.
+func (p *Proxy) Recv(ordinal uint32, resp Payload) error {
+ respb := messageBytesPool.Get().([]byte)
+ resph := messageHandlesPool.Get().([]zx.Handle)
+
+ defer messageBytesPool.Put(respb)
+ defer messageHandlesPool.Put(resph)
+
+ // Wait on the channel to be readable or close.
+ h := zx.Handle(p.Channel)
+ sigs, err := zxwait.Wait(h,
+ zx.SignalChannelReadable|zx.SignalChannelPeerClosed,
+ zx.TimensecInfinite,
+ )
+ if err != nil {
+ return err
+ }
+ // If it is closed and not readable, let's just report that and stop here.
+ if (sigs&zx.SignalChannelPeerClosed) != 0 && (sigs&zx.SignalChannelReadable) == 0 {
+ return &zx.Error{Status: zx.ErrPeerClosed}
+ }
+ // Otherwise, now we can read!
+ nb, nh, err := p.Channel.Read(respb[:], resph[:], 0)
+ if err != nil {
+ return err
+ }
+
+ // Unmarshal the message.
+ var header MessageHeader
+ if err := UnmarshalMessage(respb[:nb], resph[:nh], &header, resp); err != nil {
+ return err
+ }
+ if header.Ordinal != ordinal {
+ return newExpectError(ErrUnexpectedOrdinal, ordinal, header.Ordinal)
+ }
+ return nil
+}
+
+// Call sends the request payload over the channel with the specified ordinal
+// and synchronously waits for a response. It then writes the response into the
+// response payload.
+func (p *Proxy) Call(ordinal uint32, req Payload, resp Payload) error {
+ respb := messageBytesPool.Get().([]byte)
+ resph := messageHandlesPool.Get().([]zx.Handle)
+
+ defer messageBytesPool.Put(respb)
+ defer messageHandlesPool.Put(resph)
+
+ // Marshal the message into the buffer
+ header := MessageHeader{
+ Ordinal: ordinal,
+ }
+ nb, nh, err := MarshalMessage(&header, req, respb[:], resph[:])
+ if err != nil {
+ return err
+ }
+
+ // Make the IPC call.
+ cnb, cnh, err := p.Channel.Call(0, zx.TimensecInfinite, respb[:nb], resph[:nh], respb[:], resph[:])
+ if err != nil {
+ return err
+ }
+
+ // Unmarshal the message.
+ if err := UnmarshalMessage(respb[:cnb], resph[:cnh], &header, resp); err != nil {
+ return err
+ }
+ if header.Ordinal != ordinal {
+ return newExpectError(ErrUnexpectedOrdinal, ordinal, header.Ordinal)
+ }
+ return nil
+}
+
+// Stub represents a generated type which wraps the server-side implementation of a
+// FIDL interface.
+//
+// It contains logic which is able to dispatch into the correct implementation given
+// the incoming message ordinal and its data.
+type Stub interface {
+ // Dispatch dispatches into the appropriate method implementation for a FIDL
+ // interface by using the ordinal.
+ //
+ // It also takes the data as bytes and transforms it into arguments usable by
+ // the method implementation. It then optionally returns a response if the
+ // method has a response.
+ Dispatch(ordinal uint32, bytes []byte, handles []zx.Handle) (Payload, error)
+}
diff --git a/src/syscall/zx/fidl/message.go b/src/syscall/zx/fidl/message.go
new file mode 100644
index 0000000..d2417df
--- /dev/null
+++ b/src/syscall/zx/fidl/message.go
@@ -0,0 +1,68 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build fuchsia
+
+package fidl
+
+import (
+ "sync"
+
+ "syscall/zx"
+)
+
+// messageBytesPool is a pool of buffers that can fit the data part of any
+// FIDL message.
+var messageBytesPool = sync.Pool{
+ New: func() interface{} {
+ return make([]byte, zx.ChannelMaxMessageBytes)
+ },
+}
+
+// messageHandlesPool is a pool of buffers that can fit the handles part of
+// any FIDL message.
+var messageHandlesPool = sync.Pool{
+ New: func() interface{} {
+ return make([]zx.Handle, zx.ChannelMaxMessageHandles)
+ },
+}
+
+// MessageHeaderSize is the size of the encoded message header.
+const MessageHeaderSize int = 16
+
+// MessageHeader is a header information for a message. This struct
+// corresponds to the C type fidl_message_header_t.
+type MessageHeader struct {
+ Txid uint32
+ Reserved uint32
+ Flags uint32
+ Ordinal uint32
+}
+
+// Payload is an interface implemented by every FIDL structure.
+type Payload interface {
+ // InlineSize returns the inline size of the structure, without any
+ // out-of-line structures.
+ InlineSize() int
+
+ // InlineAlignment returns the alignment of the structure.
+ InlineAlignment() int
+}
+
+// MarshalMessage is a convenience function for marshalling a full FIDL message,
+// that is, header and payload.
+func MarshalMessage(header *MessageHeader, s Payload, data []byte, handles []zx.Handle) (int, int, error) {
+ MarshalHeader(header, data[:MessageHeaderSize])
+ nb, nh, err := Marshal(s, data[MessageHeaderSize:], handles[:])
+ return nb + MessageHeaderSize, nh, err
+}
+
+// UnmarshalMessage is a convenience function for unmarshalling a full FIDL message,
+// that is, header and payload.
+func UnmarshalMessage(data []byte, handles []zx.Handle, header *MessageHeader, s Payload) error {
+ if err := UnmarshalHeader(data[:MessageHeaderSize], header); err != nil {
+ return err
+ }
+ return Unmarshal(data[MessageHeaderSize:], handles[:], s)
+}
diff --git a/src/syscall/zx/handle.go b/src/syscall/zx/handle.go
new file mode 100644
index 0000000..8731eee
--- /dev/null
+++ b/src/syscall/zx/handle.go
@@ -0,0 +1,574 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build fuchsia
+
+package zx
+
+import "unsafe"
+
+// Process-wide FDIO handles.
+var (
+ StdioHandles [3][3]Handle // 3 stdio files, each with up to 3 (fdio.MaxHandles) handles
+ StdioHandleTypes [3]int
+ CwdHandle Handle
+ ProcHandle Handle
+ VMARRoot VMAR
+ RootNSMap map[string]Handle
+)
+
+const ZX_CPRNG_DRAW_MAX_LEN = 256
+
+type HandleInfo uint32
+
+func NewHandleInfo(t, arg uint32) HandleInfo {
+ return HandleInfo((t & 0xFFFF) | ((arg & 0xFFFF) << 16))
+}
+
+func (hi HandleInfo) Type() uint32 {
+ return uint32(hi) & 0xFFFF
+}
+
+func (hi HandleInfo) Arg() uint32 {
+ return (uint32(hi) >> 16) & 0xFFFF
+}
+
+type Socket Handle
+
+func (s *Socket) Handle() *Handle {
+ return (*Handle)(s)
+}
+
+func (s *Socket) Read(data []byte, flags uint32) (n int, err error) {
+ var actual uint
+ var p unsafe.Pointer
+ if len(data) > 0 {
+ p = unsafe.Pointer(&data[0])
+ }
+ status := sys_socket_read(Handle(*s), flags, p, uint(len(data)), &actual)
+ if status != ErrOk {
+ return int(actual), Error{Status: status, Text: "zx.Socket.Read"}
+ }
+ return int(actual), nil
+}
+
+func (s *Socket) Write(data []byte, flags uint32) (n int, err error) {
+ var p unsafe.Pointer
+ if len(data) > 0 {
+ p = unsafe.Pointer(&data[0])
+ }
+ var actual uint
+ status := sys_socket_write(Handle(*s), flags, p, uint(len(data)), &actual)
+ if status != ErrOk {
+ return int(actual), Error{Status: status, Text: "zx.Socket.Write"}
+ }
+ return int(actual), nil
+}
+
+func (s *Socket) Share(h Handle) error {
+ if status := sys_socket_share(Handle(*s), h); status != ErrOk {
+ return Error{Status: status, Text: "zx.Socket.Share"}
+ }
+ return nil
+}
+
+func (s *Socket) Accept(h *Handle) error {
+ if status := sys_socket_accept(Handle(*s), h); status != ErrOk {
+ return Error{Status: status, Text: "zx.Socket.Accept"}
+ }
+ return nil
+}
+
+func (s *Socket) Close() error {
+ h := Handle(*s)
+ err := h.Close()
+ *s = Socket(HandleInvalid)
+ return err
+}
+
+func NewSocket(flags uint32) (s0, s1 Socket, err error) {
+ var h0, h1 Handle
+ if status := sys_socket_create(flags, &h0, &h1); status != ErrOk {
+ return Socket(HandleInvalid), Socket(HandleInvalid), Error{Status: status, Text: "zx.Socket"}
+ }
+ return Socket(h0), Socket(h1), nil
+}
+
+type Event Handle
+
+func NewEvent(options uint32) (e Event, err error) {
+ var h Handle
+ if status := Sys_event_create(options, &h); status != ErrOk {
+ return Event(HandleInvalid), Error{Status: status, Text: "zx.Event"}
+ }
+ return Event(h), nil
+}
+
+func (e *Event) Handle() *Handle {
+ return (*Handle)(e)
+}
+
+func (e *Event) Close() error {
+ h := Handle(*e)
+ err := h.Close()
+ *e = Event(HandleInvalid)
+ return err
+}
+
+func (e *Event) Duplicate(rights Rights) (Event, error) {
+ h := Handle(*e)
+ h, err := h.Duplicate(rights)
+ if err != nil {
+ return Event(HandleInvalid), err
+ }
+ return Event(h), nil
+}
+
+func (h *Handle) Close() error {
+ if status := Sys_handle_close(*h); status != ErrOk {
+ return Error{Status: status, Text: "zx.Handle.Close"}
+ }
+ *h = HandleInvalid
+ return nil
+}
+
+func (h *Handle) Duplicate(rights Rights) (Handle, error) {
+ var dup Handle
+ if status := sys_handle_duplicate(*h, rights, &dup); status != ErrOk {
+ return HandleInvalid, Error{Status: status, Text: "zx.Handle.Duplicate"}
+ }
+ return dup, nil
+}
+
+func (h *Handle) Signal(clearMask, setMask Signals) error {
+ if status := Sys_object_signal(*h, uint32(clearMask), uint32(setMask)); status != ErrOk {
+ return Error{Status: status, Text: "zx.Handle.Signal"}
+ }
+ return nil
+}
+
+func (h *Handle) SignalPeer(clearMask, setMask Signals) error {
+ if status := Sys_object_signal_peer(*h, uint32(clearMask), uint32(setMask)); status != ErrOk {
+ return Error{Status: status, Text: "zx.Handle.SignalPeer"}
+ }
+ return nil
+}
+
+func (h *Handle) SetCookie(scope Handle, cookie uint64) error {
+ if status := Sys_object_set_cookie(*h, scope, cookie); status != ErrOk {
+ return Error{Status: status, Text: "zx.Handle.SetCookie"}
+ }
+ return nil
+}
+
+func (h *Handle) GetCookie(scope Handle) (uint64, error) {
+ var cookie uint64
+ if status := Sys_object_get_cookie(*h, scope, &cookie); status != ErrOk {
+ return 0, Error{Status: status, Text: "zx.Handle.GetCookie"}
+ }
+ return cookie, nil
+}
+
+func (h *Handle) GetProperty(property uint32, data []byte) error {
+ var numBytes = uint(len(data))
+ var dataPtr unsafe.Pointer
+ if numBytes > 0 {
+ dataPtr = unsafe.Pointer(&data[0])
+ }
+ if status := Sys_object_get_property(*h, property, dataPtr, numBytes); status != ErrOk {
+ return Error{Status: status, Text: "zx.Handle.GetProperty"}
+ }
+ return nil
+}
+
+func (h *Handle) SetProperty(property uint32, data []byte) error {
+ var numBytes = uint(len(data))
+ var dataPtr unsafe.Pointer
+ if numBytes > 0 {
+ dataPtr = unsafe.Pointer(&data[0])
+ }
+ if status := Sys_object_set_property(*h, property, dataPtr, numBytes); status != ErrOk {
+ return Error{Status: status, Text: "zx.Handle.SetProperty"}
+ }
+ return nil
+}
+
+func (h *Handle) IsValid() bool {
+ return *h > HandleInvalid
+}
+
+func WaitMany(items []WaitItem, timeout Time) error {
+ if status := sys_object_wait_many(&items[0], uint(len(items)), timeout); status != ErrOk {
+ return Error{Status: status, Text: "zx.Handle.WaitMany"}
+ }
+ return nil
+}
+
+const (
+ ChannelMaxMessageBytes = 65536
+ ChannelMaxMessageHandles = 64
+)
+
+type Channel Handle
+
+func (c *Channel) Handle() *Handle {
+ return (*Handle)(c)
+}
+
+func (c *Channel) Close() error {
+ h := Handle(*c)
+ err := h.Close()
+ *c = Channel(HandleInvalid)
+ return err
+}
+
+func (c *Channel) Read(data []byte, handles []Handle, flags uint32) (numBytes, numHandles uint32, err error) {
+ numBytes = uint32(len(data))
+ numHandles = uint32(len(handles))
+ var dataPtr unsafe.Pointer
+ if len(data) > 0 {
+ dataPtr = unsafe.Pointer(&data[0])
+ }
+ var handlePtr *Handle
+ if len(handles) > 0 {
+ handlePtr = &handles[0]
+ }
+ if status := sys_channel_read(Handle(*c), flags, dataPtr, handlePtr, numBytes, numHandles, &numBytes, &numHandles); status != ErrOk {
+ err = Error{Status: status, Text: "zx.Channel.Read"}
+ }
+ return numBytes, numHandles, err
+}
+
+func (c *Channel) Write(data []byte, handles []Handle, flags uint32) error {
+ var dataPtr unsafe.Pointer
+ if len(data) > 0 {
+ dataPtr = unsafe.Pointer(&data[0])
+ }
+ var handlePtr *Handle
+ if len(handles) > 0 {
+ handlePtr = &handles[0]
+ }
+ status := sys_channel_write(Handle(*c), flags, dataPtr, uint32(len(data)), handlePtr, uint32(len(handles)))
+ if status != ErrOk {
+ return Error{Status: status, Text: "zx.Channel.Write"}
+ }
+ return nil
+}
+
+func (c *Channel) Call(flags uint32, deadline Time, wData []byte, wHandles []Handle, rData []byte, rHandles []Handle) (actualBytes, actualHandles uint32, err error) {
+ var writeDataPtr uintptr
+ if len(wData) > 0 {
+ writeDataPtr = uintptr(unsafe.Pointer(&wData[0]))
+ }
+ var writeHandlePtr *Handle
+ if len(wHandles) > 0 {
+ writeHandlePtr = &wHandles[0]
+ }
+ var readDataPtr uintptr
+ if len(rData) > 0 {
+ readDataPtr = uintptr(unsafe.Pointer(&rData[0]))
+ }
+ var readHandlePtr *Handle
+ if len(rHandles) > 0 {
+ readHandlePtr = &rHandles[0]
+ }
+ args := &ChannelCallArgs{
+ WriteBytes: writeDataPtr,
+ WriteHandles: writeHandlePtr,
+ ReadBytes: readDataPtr,
+ ReadHandles: readHandlePtr,
+ WriteNumBytes: uint32(len(wData)),
+ WriteNumHandles: uint32(len(wHandles)),
+ ReadNumBytes: uint32(len(rData)),
+ ReadNumHandles: uint32(len(rHandles)),
+ }
+
+ status := Sys_channel_call(Handle(*c), flags, deadline, args, &actualBytes, &actualHandles)
+ if status != ErrOk {
+ err = Error{Status: status, Text: "zx.Channel.Call"}
+ }
+ return actualBytes, actualHandles, err
+}
+
+func NewChannel(flags uint32) (c0, c1 Channel, err error) {
+ var h0, h1 Handle
+ if status := sys_channel_create(flags, &h0, &h1); status != ErrOk {
+ return Channel(HandleInvalid), Channel(HandleInvalid), Error{Status: status, Text: "zx.Channel"}
+ }
+ return Channel(h0), Channel(h1), nil
+}
+
+const (
+ PortWaitAsyncOnce = iota
+ PortWaitAsyncRepeating
+)
+
+const (
+ PortPacketTypeUser = iota
+ PortPacketTypeSignalOne
+ PortPacketTypeSignalRepeating
+)
+
+const (
+ PacketHeaderSize = uint(unsafe.Sizeof(PacketHeader{}))
+ PacketMaxSize = uint(unsafe.Sizeof(Packet{}))
+)
+
+type PacketHeader struct {
+ Key uint64
+ Type uint32
+ Extra uint32
+}
+
+// Packet describes the unit of communication via an FDIO protocol
+type Packet struct {
+ Hdr PacketHeader
+ Bytes [32]uint8
+}
+
+func (p *Packet) Signal() *PacketSignal {
+ return (*PacketSignal)(unsafe.Pointer(p))
+}
+
+type PortPacket interface {
+ Header() *PacketHeader
+ Length() int
+}
+
+// PacketSignal describes packets of type PortPacketTypeSignal
+type PacketSignal struct {
+ Hdr PacketHeader
+ Trigger Signals
+ Observed Signals
+ Count uint64
+}
+
+func (s *PacketSignal) Header() *PacketHeader {
+ return &s.Hdr
+}
+
+func (s *PacketSignal) Length() int {
+ return int(unsafe.Sizeof(*s))
+}
+
+type Port Handle
+
+func (p *Port) Handle() *Handle {
+ return (*Handle)(p)
+}
+
+func (p *Port) Close() error {
+ h := Handle(*p)
+ err := h.Close()
+ *p = Port(HandleInvalid)
+ return err
+}
+
+// Queue a PortPacket, which may have a varying size.
+func (p *Port) Queue(packet PortPacket) error {
+ if status := Sys_port_queue(Handle(*p), (*int)(unsafe.Pointer(packet.Header()))); status != ErrOk {
+ return Error{Status: status, Text: "zx.Port.Queue"}
+ }
+ return nil
+}
+
+// Wait for a Packet, which must be as large as the largest
+// possible packet that may be received.
+func (p *Port) Wait(packet *Packet, deadline Time) error {
+ if status := Sys_port_wait(Handle(*p), deadline, (*int)(unsafe.Pointer(packet))); status != ErrOk {
+ return Error{Status: status, Text: "zx.Port.Wait"}
+ }
+ return nil
+}
+
+func (p *Port) Cancel(source Handle, key uint64) error {
+ if status := Sys_port_cancel(Handle(*p), source, key); status != ErrOk {
+ return Error{Status: status, Text: "zx.Port.Cancel"}
+ }
+ return nil
+}
+
+func (p *Port) WaitAsync(handle Handle, key uint64, signals Signals, options uint32) error {
+ if status := Sys_object_wait_async(handle, Handle(*p), key, signals, options); status != ErrOk {
+ return Error{Status: status, Text: "fdio.Port.WaitAsync"}
+ }
+ return nil
+}
+
+func NewPort(options uint32) (Port, error) {
+ var h Handle
+ if status := Sys_port_create(options, &h); status != ErrOk {
+ return Port(HandleInvalid), Error{Status: status, Text: "zx.Port"}
+ }
+ return Port(h), nil
+}
+
+type VMO Handle
+
+func (vmo *VMO) Handle() *Handle {
+ return (*Handle)(vmo)
+}
+
+func (vmo *VMO) Clone(options uint32, offset, size uint64) (VMO, error) {
+ var h Handle
+ if status := Sys_vmo_clone(Handle(*vmo), options, offset, size, &h); status != ErrOk {
+ return VMO(HandleInvalid), Error{Status: status, Text: "zx.VMO.Clone"}
+ }
+ return VMO(h), nil
+}
+
+func (vmo *VMO) Read(b []byte, offset uint64) error {
+ if status := sys_vmo_read(Handle(*vmo), unsafe.Pointer(&b[0]), offset, uint(len(b))); status != ErrOk {
+ return Error{Status: status, Text: "zx.VMO.Read"}
+ }
+ return nil
+}
+
+func (vmo *VMO) Write(b []byte, offset uint64) error {
+ if status := sys_vmo_write(Handle(*vmo), unsafe.Pointer(&b[0]), offset, uint(len(b))); status != ErrOk {
+ return Error{Status: status, Text: "zx.VMO.Write"}
+ }
+ return nil
+}
+
+func (vmo *VMO) Size() (uint64, error) {
+ var size uint64
+ if status := sys_vmo_get_size(Handle(*vmo), &size); status != ErrOk {
+ return size, Error{Status: status, Text: "zx.VMO.Size"}
+ }
+ return size, nil
+}
+
+func (vmo *VMO) SetSize(size uint64) error {
+ if status := sys_vmo_set_size(Handle(*vmo), size); status != ErrOk {
+ return Error{Status: status, Text: "zx.VMO.SetSize"}
+ }
+ return nil
+}
+
+func (vmo *VMO) OpRange(op uint32, offset, size uint64, b []byte) error {
+ if status := sys_vmo_op_range(Handle(*vmo), op, offset, size, unsafe.Pointer(&b[0]), uint(len(b))); status != ErrOk {
+ return Error{Status: status, Text: "zx.VMO.OpRange"}
+ }
+ return nil
+}
+
+func (vmo *VMO) Close() error {
+ h := Handle(*vmo)
+ err := h.Close()
+ *vmo = VMO(HandleInvalid)
+ return err
+}
+
+func NewVMO(size uint64, options VMOOption) (VMO, error) {
+ var h Handle
+ if status := Sys_vmo_create(size, uint32(options), &h); status != ErrOk {
+ return VMO(HandleInvalid), Error{Status: status, Text: "zx.VMO"}
+ }
+ return VMO(h), nil
+}
+
+type VMAR Handle
+
+func (v VMAR) Destroy() error {
+ if status := sys_vmar_destroy(Handle(v)); status != ErrOk {
+ return Error{Status: status, Text: "zx.VMAR.Destroy"}
+ }
+ return nil
+}
+
+var mapErr error = Error{Status: 1, Text: "zx.VMAR.Map"}
+
+func (v VMAR) Map(vmarOffset uint64, vmo VMO, vmoOffset, len uint64, flags VMFlag) (addr uintptr, err error) {
+ status := sys_vmar_map_old(Handle(v), uint64(vmarOffset), Handle(vmo), vmoOffset, uint64(len), uint32(flags), (*Vaddr)(&addr))
+ if status != ErrOk {
+ println("zx.VMAR.Map failed: status: ", status)
+ return 0, mapErr
+ }
+ return addr, nil
+}
+
+var unmapErr error = Error{Status: 1, Text: "zx.VMAR.Unmap"}
+
+func (v VMAR) Unmap(addr uintptr, len uint64) error {
+ status := Sys_vmar_unmap(Handle(v), Vaddr(addr), uint64(len))
+ if status != ErrOk {
+ println(status)
+ return unmapErr
+ }
+ return nil
+}
+
+func (v VMAR) Protect(addr uintptr, len uint64, flags VMFlag) error {
+ status := sys_vmar_protect_old(Handle(v), Vaddr(addr), uint64(len), uint32(flags))
+ if status != ErrOk {
+ return Error{Status: status, Text: "zx.VMAR.Protect"}
+ }
+ return nil
+}
+
+func NewVMAR(parent VMAR, offset, size uint64, flags VMFlag) (child VMAR, addr uintptr, err error) {
+ var childHandle Handle
+ status := sys_vmar_allocate_old(Handle(parent), uint64(offset), uint64(size), uint32(flags), &childHandle, (*Vaddr)(&addr))
+ if status != ErrOk {
+ return 0, 0, Error{Status: status, Text: "zx.NewVMAR"}
+ }
+ return VMAR(childHandle), addr, nil
+}
+
+type Log Handle
+
+func NewLog(options uint32) Log {
+ var h Handle
+ status := Sys_debuglog_create(HandleInvalid, options, &h)
+ if status != ErrOk {
+ return Log(HandleInvalid)
+ }
+ return Log(h)
+}
+
+func (l *Log) Handle() *Handle {
+ return (*Handle)(l)
+}
+
+func (l Log) Write(b []byte) (n int, err error) {
+ status := Sys_log_write(Handle(l), uint32(len(b)), unsafe.Pointer(&b[0]), 0)
+ if status != ErrOk {
+ return 0, Error{Status: status, Text: "zx.Log.Write"}
+ }
+ return len(b), nil
+}
+
+func (l Log) Read(b []byte) (n int, err error) {
+ status := Sys_log_read(Handle(l), uint32(len(b)), unsafe.Pointer(&b[0]), 0)
+ if status != ErrOk {
+ return 0, Error{Status: status, Text: "zx.Log.Read"}
+ }
+ return len(b), nil
+}
+
+func (l *Log) Close() (err error) {
+ h := Handle(*l)
+ err = h.Close()
+ *l = Log(HandleInvalid)
+ return err
+}
+
+func RandRead(b []byte) {
+ Sys_cprng_draw(unsafe.Pointer(&b[0]), uint(len(b)))
+}
+
+// Error is a Status with associated error text.
+// It is used as a Go error.
+type Error struct {
+ Status Status
+ Text string
+}
+
+func (e Error) Error() string {
+ if e.Text == "" {
+ return "zx.Status: " + e.Status.String()
+ }
+ return e.Status.String() + ": " + e.Text
+}
diff --git a/src/syscall/zx/io/impl.go b/src/syscall/zx/io/impl.go
new file mode 100644
index 0000000..26d33bd
--- /dev/null
+++ b/src/syscall/zx/io/impl.go
@@ -0,0 +1,1855 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build fuchsia
+
+package io
+
+import (
+ _bindings "syscall/zx/fidl"
+ _zx "syscall/zx"
+)
+
+const (
+ KOpenRightReadable uint32 = 0x00000001
+ KOpenRightWritable uint32 = 0x00000002
+ KOpenRightAdmin uint32 = 0x00000004
+ KOpenFlagCreate uint32 = 0x00010000
+ KOpenFlagCreateIfAbsent uint32 = 0x00020000
+ KOpenFlagTruncate uint32 = 0x00040000
+ KOpenFlagDirectory uint32 = 0x00080000
+ KOpenFlagAppend uint32 = 0x00100000
+ KOpenFlagNoRemote uint32 = 0x00200000
+ KOpenFlagNodeReference uint32 = 0x00400000
+ KOpenFlagDescribe uint32 = 0x00800000
+ KOpenFlagStatus uint32 = 0x01000000
+ KModeProtectionMask uint32 = 0x00FFF
+ KModeTypeMask uint32 = 0xFF000
+ KModeTypeDirectory uint32 = 0x04000
+ KModeTypeBlockDevice uint32 = 0x06000
+ KModeTypeFile uint32 = 0x08000
+ KModeTypeSocket uint32 = 0x0C000
+ KModeTypeService uint32 = 0x10000
+ KMaxIoctlHandles uint64 = 2
+ KMaxBuf uint64 = 8192
+ KNodeAttributeFlagCreationTime uint32 = 0x00000001
+ KNodeAttributeFlagModificationTime uint32 = 0x00000002
+ KVmoFlagRead uint32 = 0x00000001
+ KVmoFlagWrite uint32 = 0x00000002
+ KVmoFlagExec uint32 = 0x00000004
+ KVmoFlagPrivate uint32 = 0x00010000
+ KDirentTypeUnknown uint32 = 0
+ KDirentTypeDirectory uint32 = 4
+ KDirentTypeBlockDevice uint32 = 6
+ KDirentTypeFile uint32 = 8
+ KDirentTypeSocket uint32 = 12
+ KDirentTypeService uint32 = 16
+)
+
+type SeekOrigin uint32
+const (
+ SeekOriginStart SeekOrigin = 0
+ SeekOriginCurrent SeekOrigin = 1
+ SeekOriginEnd SeekOrigin = 2
+)
+type Service struct {
+ Reserved uint8
+}
+
+// Implements Payload.
+func (_ *Service) InlineAlignment() int {
+ return 1
+}
+
+// Implements Payload.
+func (_ *Service) InlineSize() int {
+ return 1
+}
+type FileObject struct {
+ Event _zx.Event `fidl:"*"`
+}
+
+// Implements Payload.
+func (_ *FileObject) InlineAlignment() int {
+ return 4
+}
+
+// Implements Payload.
+func (_ *FileObject) InlineSize() int {
+ return 4
+}
+type DirectoryObject struct {
+ Reserved uint8
+}
+
+// Implements Payload.
+func (_ *DirectoryObject) InlineAlignment() int {
+ return 1
+}
+
+// Implements Payload.
+func (_ *DirectoryObject) InlineSize() int {
+ return 1
+}
+type Pipe struct {
+ Socket _zx.Socket
+}
+
+// Implements Payload.
+func (_ *Pipe) InlineAlignment() int {
+ return 4
+}
+
+// Implements Payload.
+func (_ *Pipe) InlineSize() int {
+ return 4
+}
+type Vmofile struct {
+ Vmo _zx.VMO
+ Offset uint64
+ Length uint64
+}
+
+// Implements Payload.
+func (_ *Vmofile) InlineAlignment() int {
+ return 8
+}
+
+// Implements Payload.
+func (_ *Vmofile) InlineSize() int {
+ return 24
+}
+type Device struct {
+ Event _zx.Event `fidl:"*"`
+}
+
+// Implements Payload.
+func (_ *Device) InlineAlignment() int {
+ return 4
+}
+
+// Implements Payload.
+func (_ *Device) InlineSize() int {
+ return 4
+}
+type NodeAttributes struct {
+ Mode uint32
+ Id uint64
+ ContentSize uint64
+ StorageSize uint64
+ LinkCount uint64
+ CreationTime uint64
+ ModificationTime uint64
+}
+
+// Implements Payload.
+func (_ *NodeAttributes) InlineAlignment() int {
+ return 8
+}
+
+// Implements Payload.
+func (_ *NodeAttributes) InlineSize() int {
+ return 56
+}
+type ObjectInfoTag uint32
+const (
+ ObjectInfoService ObjectInfoTag = iota
+ ObjectInfoFile ObjectInfoTag = iota
+ ObjectInfoDirectory ObjectInfoTag = iota
+ ObjectInfoPipe ObjectInfoTag = iota
+ ObjectInfoVmofile ObjectInfoTag = iota
+ ObjectInfoDevice ObjectInfoTag = iota
+)
+
+// ObjectInfo is a FIDL union.
+type ObjectInfo struct {
+ ObjectInfoTag `fidl:"tag"`
+ Service Service
+ File FileObject
+ Directory DirectoryObject
+ Pipe Pipe
+ Vmofile Vmofile
+ Device Device
+}
+
+// Implements Payload.
+func (_ *ObjectInfo) InlineAlignment() int {
+ return 8
+}
+
+// Implements Payload.
+func (_ *ObjectInfo) InlineSize() int {
+ return 32
+}
+
+func (u *ObjectInfo) Which() ObjectInfoTag {
+ return u.ObjectInfoTag
+}
+
+func (u *ObjectInfo) SetService(service Service) {
+ u.ObjectInfoTag = ObjectInfoService
+ u.Service = service
+}
+
+func (u *ObjectInfo) SetFile(file FileObject) {
+ u.ObjectInfoTag = ObjectInfoFile
+ u.File = file
+}
+
+func (u *ObjectInfo) SetDirectory(directory DirectoryObject) {
+ u.ObjectInfoTag = ObjectInfoDirectory
+ u.Directory = directory
+}
+
+func (u *ObjectInfo) SetPipe(pipe Pipe) {
+ u.ObjectInfoTag = ObjectInfoPipe
+ u.Pipe = pipe
+}
+
+func (u *ObjectInfo) SetVmofile(vmofile Vmofile) {
+ u.ObjectInfoTag = ObjectInfoVmofile
+ u.Vmofile = vmofile
+}
+
+func (u *ObjectInfo) SetDevice(device Device) {
+ u.ObjectInfoTag = ObjectInfoDevice
+ u.Device = device
+}
+
+// Request for Clone.
+type ObjectCloneRequest struct {
+ Flags uint32
+ Object ObjectInterfaceRequest
+}
+
+// Implements Payload.
+func (_ *ObjectCloneRequest) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *ObjectCloneRequest) InlineSize() int {
+ return 8
+}
+// Clone has no response.
+// Request for Close.
+type ObjectCloseRequest struct {
+}
+
+// Implements Payload.
+func (_ *ObjectCloseRequest) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *ObjectCloseRequest) InlineSize() int {
+ return 0
+}
+// Response for Close.
+type ObjectCloseResponse struct {
+ S _zx.Status
+}
+
+// Implements Payload.
+func (_ *ObjectCloseResponse) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *ObjectCloseResponse) InlineSize() int {
+ return 4
+}
+// Request for ListInterfaces.
+type ObjectListInterfacesRequest struct {
+}
+
+// Implements Payload.
+func (_ *ObjectListInterfacesRequest) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *ObjectListInterfacesRequest) InlineSize() int {
+ return 0
+}
+// Response for ListInterfaces.
+type ObjectListInterfacesResponse struct {
+ Interfaces []string
+}
+
+// Implements Payload.
+func (_ *ObjectListInterfacesResponse) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *ObjectListInterfacesResponse) InlineSize() int {
+ return 16
+}
+// Request for Bind.
+type ObjectBindRequest struct {
+ Iface string
+}
+
+// Implements Payload.
+func (_ *ObjectBindRequest) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *ObjectBindRequest) InlineSize() int {
+ return 16
+}
+// Bind has no response.
+// Request for Describe.
+type ObjectDescribeRequest struct {
+}
+
+// Implements Payload.
+func (_ *ObjectDescribeRequest) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *ObjectDescribeRequest) InlineSize() int {
+ return 0
+}
+// Response for Describe.
+type ObjectDescribeResponse struct {
+ Info ObjectInfo
+}
+
+// Implements Payload.
+func (_ *ObjectDescribeResponse) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *ObjectDescribeResponse) InlineSize() int {
+ return 32
+}
+// Request for OnOpen.
+// OnOpen has no request.
+// Response for OnOpen.
+type ObjectOnOpenResponse struct {
+ S _zx.Status
+ Info *ObjectInfo
+}
+
+// Implements Payload.
+func (_ *ObjectOnOpenResponse) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *ObjectOnOpenResponse) InlineSize() int {
+ return 16
+}
+
+type ObjectInterface _bindings.Proxy
+
+func (p *ObjectInterface) Clone(flags uint32,object ObjectInterfaceRequest) error {
+ req_ := ObjectCloneRequest{
+ Flags: flags,
+ Object: object,
+ }
+ err := ((*_bindings.Proxy)(p)).Send(2147483649, &req_)
+ return err
+}
+func (p *ObjectInterface) Close() (_zx.Status, error) {
+ req_ := ObjectCloseRequest{
+ }
+ resp_ := ObjectCloseResponse{}
+ err := ((*_bindings.Proxy)(p)).Call(2147483650, &req_, &resp_)
+ return resp_.S, err
+}
+func (p *ObjectInterface) ListInterfaces() ([]string, error) {
+ req_ := ObjectListInterfacesRequest{
+ }
+ resp_ := ObjectListInterfacesResponse{}
+ err := ((*_bindings.Proxy)(p)).Call(2147483652, &req_, &resp_)
+ return resp_.Interfaces, err
+}
+func (p *ObjectInterface) Bind(iface string) error {
+ req_ := ObjectBindRequest{
+ Iface: iface,
+ }
+ err := ((*_bindings.Proxy)(p)).Send(2147483653, &req_)
+ return err
+}
+func (p *ObjectInterface) Describe() (ObjectInfo, error) {
+ req_ := ObjectDescribeRequest{
+ }
+ resp_ := ObjectDescribeResponse{}
+ err := ((*_bindings.Proxy)(p)).Call(2147483654, &req_, &resp_)
+ return resp_.Info, err
+}
+func (p *ObjectInterface) ExpectOnOpen() (_zx.Status, *ObjectInfo, error) {
+ resp_ := ObjectOnOpenResponse{}
+ err := ((*_bindings.Proxy)(p)).Recv(2147483655, &resp_)
+ return resp_.S, resp_.Info, err
+}
+
+// Object server interface.
+type Object interface {
+ Clone(flags uint32,object ObjectInterfaceRequest) error
+ Close() (_zx.Status, error)
+ ListInterfaces() ([]string, error)
+ Bind(iface string) error
+ Describe() (ObjectInfo, error)
+}
+
+type ObjectInterfaceRequest _bindings.InterfaceRequest
+
+func NewObjectInterfaceRequest() (ObjectInterfaceRequest, *ObjectInterface, error) {
+ req, cli, err := _bindings.NewInterfaceRequest()
+ return ObjectInterfaceRequest(req), (*ObjectInterface)(cli), err
+}
+
+type ObjectStub struct {
+ Impl Object
+}
+
+func (s *ObjectStub) Dispatch(ord uint32, b_ []byte, h_ []_zx.Handle) (_bindings.Payload, error) {
+ switch ord {
+ case 2147483649:
+ in_ := ObjectCloneRequest{}
+ if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
+ return nil, err_
+ }
+ err_ := s.Impl.Clone(in_.Flags,in_.Object)
+ return nil, err_
+ case 2147483650:
+ in_ := ObjectCloseRequest{}
+ if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
+ return nil, err_
+ }
+ out_ := ObjectCloseResponse{}
+ s, err_ := s.Impl.Close()
+ out_.S = s
+ return &out_, err_
+ case 2147483652:
+ in_ := ObjectListInterfacesRequest{}
+ if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
+ return nil, err_
+ }
+ out_ := ObjectListInterfacesResponse{}
+ interfaces, err_ := s.Impl.ListInterfaces()
+ out_.Interfaces = interfaces
+ return &out_, err_
+ case 2147483653:
+ in_ := ObjectBindRequest{}
+ if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
+ return nil, err_
+ }
+ err_ := s.Impl.Bind(in_.Iface)
+ return nil, err_
+ case 2147483654:
+ in_ := ObjectDescribeRequest{}
+ if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
+ return nil, err_
+ }
+ out_ := ObjectDescribeResponse{}
+ info, err_ := s.Impl.Describe()
+ out_.Info = info
+ return &out_, err_
+ }
+ return nil, _bindings.ErrUnknownOrdinal
+}
+
+type ObjectService struct {
+ _bindings.BindingSet
+}
+
+func (s *ObjectService) Add(impl Object, c _zx.Channel, onError func(error)) (_bindings.BindingKey, error) {
+ return s.BindingSet.Add(&ObjectStub{Impl: impl}, c, onError)
+}
+
+func (s *ObjectService) EventProxyFor(key _bindings.BindingKey) (*ObjectEventProxy, bool) {
+ pxy, err := s.BindingSet.ProxyFor(key)
+ return (*ObjectEventProxy)(pxy), err
+}
+
+type ObjectEventProxy _bindings.Proxy
+
+func (p *ObjectEventProxy) OnOpen(s _zx.Status,info *ObjectInfo) error {
+ event_ := ObjectOnOpenResponse{
+ S: s,
+ Info: info,
+ }
+ return ((*_bindings.Proxy)(p)).Send(2147483655, &event_)
+}
+
+
+
+// Request for Sync.
+type NodeSyncRequest struct {
+}
+
+// Implements Payload.
+func (_ *NodeSyncRequest) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *NodeSyncRequest) InlineSize() int {
+ return 0
+}
+// Response for Sync.
+type NodeSyncResponse struct {
+ S _zx.Status
+}
+
+// Implements Payload.
+func (_ *NodeSyncResponse) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *NodeSyncResponse) InlineSize() int {
+ return 4
+}
+// Request for GetAttr.
+type NodeGetAttrRequest struct {
+}
+
+// Implements Payload.
+func (_ *NodeGetAttrRequest) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *NodeGetAttrRequest) InlineSize() int {
+ return 0
+}
+// Response for GetAttr.
+type NodeGetAttrResponse struct {
+ S _zx.Status
+ Attributes NodeAttributes
+}
+
+// Implements Payload.
+func (_ *NodeGetAttrResponse) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *NodeGetAttrResponse) InlineSize() int {
+ return 64
+}
+// Request for SetAttr.
+type NodeSetAttrRequest struct {
+ Flags uint32
+ Attributes NodeAttributes
+}
+
+// Implements Payload.
+func (_ *NodeSetAttrRequest) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *NodeSetAttrRequest) InlineSize() int {
+ return 64
+}
+// Response for SetAttr.
+type NodeSetAttrResponse struct {
+ S _zx.Status
+}
+
+// Implements Payload.
+func (_ *NodeSetAttrResponse) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *NodeSetAttrResponse) InlineSize() int {
+ return 4
+}
+// Request for Ioctl.
+type NodeIoctlRequest struct {
+ Opcode uint32
+ MaxOut uint64
+ Handles []_zx.Handle `fidl:"2"`
+ In []uint8 `fidl:"8192"`
+}
+
+// Implements Payload.
+func (_ *NodeIoctlRequest) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *NodeIoctlRequest) InlineSize() int {
+ return 48
+}
+// Response for Ioctl.
+type NodeIoctlResponse struct {
+ S _zx.Status
+ Handles []_zx.Handle `fidl:"2"`
+ Out []uint8 `fidl:"8192"`
+}
+
+// Implements Payload.
+func (_ *NodeIoctlResponse) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *NodeIoctlResponse) InlineSize() int {
+ return 40
+}
+
+type NodeInterface _bindings.Proxy
+
+func (p *NodeInterface) Sync() (_zx.Status, error) {
+ req_ := NodeSyncRequest{
+ }
+ resp_ := NodeSyncResponse{}
+ err := ((*_bindings.Proxy)(p)).Call(2164260865, &req_, &resp_)
+ return resp_.S, err
+}
+func (p *NodeInterface) GetAttr() (_zx.Status, NodeAttributes, error) {
+ req_ := NodeGetAttrRequest{
+ }
+ resp_ := NodeGetAttrResponse{}
+ err := ((*_bindings.Proxy)(p)).Call(2164260866, &req_, &resp_)
+ return resp_.S, resp_.Attributes, err
+}
+func (p *NodeInterface) SetAttr(flags uint32,attributes NodeAttributes) (_zx.Status, error) {
+ req_ := NodeSetAttrRequest{
+ Flags: flags,
+ Attributes: attributes,
+ }
+ resp_ := NodeSetAttrResponse{}
+ err := ((*_bindings.Proxy)(p)).Call(2164260867, &req_, &resp_)
+ return resp_.S, err
+}
+func (p *NodeInterface) Ioctl(opcode uint32,maxOut uint64,handles []_zx.Handle,in []uint8) (_zx.Status, []_zx.Handle, []uint8, error) {
+ req_ := NodeIoctlRequest{
+ Opcode: opcode,
+ MaxOut: maxOut,
+ Handles: handles,
+ In: in,
+ }
+ resp_ := NodeIoctlResponse{}
+ err := ((*_bindings.Proxy)(p)).Call(2164260868, &req_, &resp_)
+ return resp_.S, resp_.Handles, resp_.Out, err
+}
+
+// Node server interface.
+type Node interface {
+ Clone(flags uint32,object ObjectInterfaceRequest) error
+ Close() (_zx.Status, error)
+ ListInterfaces() ([]string, error)
+ Bind(iface string) error
+ Describe() (ObjectInfo, error)
+ Sync() (_zx.Status, error)
+ GetAttr() (_zx.Status, NodeAttributes, error)
+ SetAttr(flags uint32,attributes NodeAttributes) (_zx.Status, error)
+ Ioctl(opcode uint32,maxOut uint64,handles []_zx.Handle,in []uint8) (_zx.Status, []_zx.Handle, []uint8, error)
+}
+
+type NodeInterfaceRequest _bindings.InterfaceRequest
+
+func NewNodeInterfaceRequest() (NodeInterfaceRequest, *NodeInterface, error) {
+ req, cli, err := _bindings.NewInterfaceRequest()
+ return NodeInterfaceRequest(req), (*NodeInterface)(cli), err
+}
+
+type NodeStub struct {
+ Impl Node
+}
+
+func (s *NodeStub) Dispatch(ord uint32, b_ []byte, h_ []_zx.Handle) (_bindings.Payload, error) {
+ switch ord {
+ case 2147483649:
+ in_ := ObjectCloneRequest{}
+ if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
+ return nil, err_
+ }
+ err_ := s.Impl.Clone(in_.Flags,in_.Object)
+ return nil, err_
+ case 2147483650:
+ in_ := ObjectCloseRequest{}
+ if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
+ return nil, err_
+ }
+ out_ := ObjectCloseResponse{}
+ s, err_ := s.Impl.Close()
+ out_.S = s
+ return &out_, err_
+ case 2147483652:
+ in_ := ObjectListInterfacesRequest{}
+ if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
+ return nil, err_
+ }
+ out_ := ObjectListInterfacesResponse{}
+ interfaces, err_ := s.Impl.ListInterfaces()
+ out_.Interfaces = interfaces
+ return &out_, err_
+ case 2147483653:
+ in_ := ObjectBindRequest{}
+ if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
+ return nil, err_
+ }
+ err_ := s.Impl.Bind(in_.Iface)
+ return nil, err_
+ case 2147483654:
+ in_ := ObjectDescribeRequest{}
+ if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
+ return nil, err_
+ }
+ out_ := ObjectDescribeResponse{}
+ info, err_ := s.Impl.Describe()
+ out_.Info = info
+ return &out_, err_
+ case 2164260865:
+ in_ := NodeSyncRequest{}
+ if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
+ return nil, err_
+ }
+ out_ := NodeSyncResponse{}
+ s, err_ := s.Impl.Sync()
+ out_.S = s
+ return &out_, err_
+ case 2164260866:
+ in_ := NodeGetAttrRequest{}
+ if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
+ return nil, err_
+ }
+ out_ := NodeGetAttrResponse{}
+ s, attributes, err_ := s.Impl.GetAttr()
+ out_.S = s
+ out_.Attributes = attributes
+ return &out_, err_
+ case 2164260867:
+ in_ := NodeSetAttrRequest{}
+ if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
+ return nil, err_
+ }
+ out_ := NodeSetAttrResponse{}
+ s, err_ := s.Impl.SetAttr(in_.Flags,in_.Attributes)
+ out_.S = s
+ return &out_, err_
+ case 2164260868:
+ in_ := NodeIoctlRequest{}
+ if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
+ return nil, err_
+ }
+ out_ := NodeIoctlResponse{}
+ s, handles, out, err_ := s.Impl.Ioctl(in_.Opcode,in_.MaxOut,in_.Handles,in_.In)
+ out_.S = s
+ out_.Handles = handles
+ out_.Out = out
+ return &out_, err_
+ }
+ return nil, _bindings.ErrUnknownOrdinal
+}
+
+type NodeService struct {
+ _bindings.BindingSet
+}
+
+func (s *NodeService) Add(impl Node, c _zx.Channel, onError func(error)) (_bindings.BindingKey, error) {
+ return s.BindingSet.Add(&NodeStub{Impl: impl}, c, onError)
+}
+
+func (s *NodeService) EventProxyFor(key _bindings.BindingKey) (*NodeEventProxy, bool) {
+ pxy, err := s.BindingSet.ProxyFor(key)
+ return (*NodeEventProxy)(pxy), err
+}
+
+type NodeEventProxy _bindings.Proxy
+
+func (p *NodeEventProxy) OnOpen(s _zx.Status,info *ObjectInfo) error {
+ event_ := ObjectOnOpenResponse{
+ S: s,
+ Info: info,
+ }
+ return ((*_bindings.Proxy)(p)).Send(2147483655, &event_)
+}
+
+
+
+// Request for Read.
+type FileReadRequest struct {
+ Count uint64
+}
+
+// Implements Payload.
+func (_ *FileReadRequest) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *FileReadRequest) InlineSize() int {
+ return 8
+}
+// Response for Read.
+type FileReadResponse struct {
+ S _zx.Status
+ Data []uint8 `fidl:"8192"`
+}
+
+// Implements Payload.
+func (_ *FileReadResponse) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *FileReadResponse) InlineSize() int {
+ return 24
+}
+// Request for ReadAt.
+type FileReadAtRequest struct {
+ Count uint64
+ Offset uint64
+}
+
+// Implements Payload.
+func (_ *FileReadAtRequest) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *FileReadAtRequest) InlineSize() int {
+ return 16
+}
+// Response for ReadAt.
+type FileReadAtResponse struct {
+ S _zx.Status
+ Data []uint8 `fidl:"8192"`
+}
+
+// Implements Payload.
+func (_ *FileReadAtResponse) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *FileReadAtResponse) InlineSize() int {
+ return 24
+}
+// Request for Write.
+type FileWriteRequest struct {
+ Data []uint8 `fidl:"8192"`
+}
+
+// Implements Payload.
+func (_ *FileWriteRequest) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *FileWriteRequest) InlineSize() int {
+ return 16
+}
+// Response for Write.
+type FileWriteResponse struct {
+ S _zx.Status
+ Actual uint64
+}
+
+// Implements Payload.
+func (_ *FileWriteResponse) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *FileWriteResponse) InlineSize() int {
+ return 16
+}
+// Request for WriteAt.
+type FileWriteAtRequest struct {
+ Data []uint8 `fidl:"8192"`
+ Offset uint64
+}
+
+// Implements Payload.
+func (_ *FileWriteAtRequest) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *FileWriteAtRequest) InlineSize() int {
+ return 24
+}
+// Response for WriteAt.
+type FileWriteAtResponse struct {
+ S _zx.Status
+ Actual uint64
+}
+
+// Implements Payload.
+func (_ *FileWriteAtResponse) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *FileWriteAtResponse) InlineSize() int {
+ return 16
+}
+// Request for Seek.
+type FileSeekRequest struct {
+ Offset int64
+ Start SeekOrigin
+}
+
+// Implements Payload.
+func (_ *FileSeekRequest) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *FileSeekRequest) InlineSize() int {
+ return 16
+}
+// Response for Seek.
+type FileSeekResponse struct {
+ S _zx.Status
+ Offset uint64
+}
+
+// Implements Payload.
+func (_ *FileSeekResponse) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *FileSeekResponse) InlineSize() int {
+ return 16
+}
+// Request for Truncate.
+type FileTruncateRequest struct {
+ Length uint64
+}
+
+// Implements Payload.
+func (_ *FileTruncateRequest) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *FileTruncateRequest) InlineSize() int {
+ return 8
+}
+// Response for Truncate.
+type FileTruncateResponse struct {
+ S _zx.Status
+}
+
+// Implements Payload.
+func (_ *FileTruncateResponse) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *FileTruncateResponse) InlineSize() int {
+ return 4
+}
+// Request for GetFlags.
+type FileGetFlagsRequest struct {
+}
+
+// Implements Payload.
+func (_ *FileGetFlagsRequest) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *FileGetFlagsRequest) InlineSize() int {
+ return 0
+}
+// Response for GetFlags.
+type FileGetFlagsResponse struct {
+ S _zx.Status
+ Flags uint32
+}
+
+// Implements Payload.
+func (_ *FileGetFlagsResponse) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *FileGetFlagsResponse) InlineSize() int {
+ return 8
+}
+// Request for SetFlags.
+type FileSetFlagsRequest struct {
+ Flags uint32
+}
+
+// Implements Payload.
+func (_ *FileSetFlagsRequest) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *FileSetFlagsRequest) InlineSize() int {
+ return 4
+}
+// Response for SetFlags.
+type FileSetFlagsResponse struct {
+ S _zx.Status
+}
+
+// Implements Payload.
+func (_ *FileSetFlagsResponse) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *FileSetFlagsResponse) InlineSize() int {
+ return 4
+}
+// Request for GetVmo.
+type FileGetVmoRequest struct {
+ Flags uint32
+}
+
+// Implements Payload.
+func (_ *FileGetVmoRequest) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *FileGetVmoRequest) InlineSize() int {
+ return 4
+}
+// Response for GetVmo.
+type FileGetVmoResponse struct {
+ S _zx.Status
+ Vmo _zx.VMO
+}
+
+// Implements Payload.
+func (_ *FileGetVmoResponse) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *FileGetVmoResponse) InlineSize() int {
+ return 8
+}
+// Request for GetVmoAt.
+type FileGetVmoAtRequest struct {
+ Flags uint32
+ Offset uint64
+ Length uint64
+}
+
+// Implements Payload.
+func (_ *FileGetVmoAtRequest) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *FileGetVmoAtRequest) InlineSize() int {
+ return 24
+}
+// Response for GetVmoAt.
+type FileGetVmoAtResponse struct {
+ S _zx.Status
+ Vmo _zx.VMO
+}
+
+// Implements Payload.
+func (_ *FileGetVmoAtResponse) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *FileGetVmoAtResponse) InlineSize() int {
+ return 8
+}
+
+type FileInterface _bindings.Proxy
+
+func (p *FileInterface) Read(count uint64) (_zx.Status, []uint8, error) {
+ req_ := FileReadRequest{
+ Count: count,
+ }
+ resp_ := FileReadResponse{}
+ err := ((*_bindings.Proxy)(p)).Call(2181038081, &req_, &resp_)
+ return resp_.S, resp_.Data, err
+}
+func (p *FileInterface) ReadAt(count uint64,offset uint64) (_zx.Status, []uint8, error) {
+ req_ := FileReadAtRequest{
+ Count: count,
+ Offset: offset,
+ }
+ resp_ := FileReadAtResponse{}
+ err := ((*_bindings.Proxy)(p)).Call(2181038082, &req_, &resp_)
+ return resp_.S, resp_.Data, err
+}
+func (p *FileInterface) Write(data []uint8) (_zx.Status, uint64, error) {
+ req_ := FileWriteRequest{
+ Data: data,
+ }
+ resp_ := FileWriteResponse{}
+ err := ((*_bindings.Proxy)(p)).Call(2181038083, &req_, &resp_)
+ return resp_.S, resp_.Actual, err
+}
+func (p *FileInterface) WriteAt(data []uint8,offset uint64) (_zx.Status, uint64, error) {
+ req_ := FileWriteAtRequest{
+ Data: data,
+ Offset: offset,
+ }
+ resp_ := FileWriteAtResponse{}
+ err := ((*_bindings.Proxy)(p)).Call(2181038084, &req_, &resp_)
+ return resp_.S, resp_.Actual, err
+}
+func (p *FileInterface) Seek(offset int64,start SeekOrigin) (_zx.Status, uint64, error) {
+ req_ := FileSeekRequest{
+ Offset: offset,
+ Start: start,
+ }
+ resp_ := FileSeekResponse{}
+ err := ((*_bindings.Proxy)(p)).Call(2181038085, &req_, &resp_)
+ return resp_.S, resp_.Offset, err
+}
+func (p *FileInterface) Truncate(length uint64) (_zx.Status, error) {
+ req_ := FileTruncateRequest{
+ Length: length,
+ }
+ resp_ := FileTruncateResponse{}
+ err := ((*_bindings.Proxy)(p)).Call(2181038086, &req_, &resp_)
+ return resp_.S, err
+}
+func (p *FileInterface) GetFlags() (_zx.Status, uint32, error) {
+ req_ := FileGetFlagsRequest{
+ }
+ resp_ := FileGetFlagsResponse{}
+ err := ((*_bindings.Proxy)(p)).Call(2181038087, &req_, &resp_)
+ return resp_.S, resp_.Flags, err
+}
+func (p *FileInterface) SetFlags(flags uint32) (_zx.Status, error) {
+ req_ := FileSetFlagsRequest{
+ Flags: flags,
+ }
+ resp_ := FileSetFlagsResponse{}
+ err := ((*_bindings.Proxy)(p)).Call(2181038088, &req_, &resp_)
+ return resp_.S, err
+}
+func (p *FileInterface) GetVmo(flags uint32) (_zx.Status, _zx.VMO, error) {
+ req_ := FileGetVmoRequest{
+ Flags: flags,
+ }
+ resp_ := FileGetVmoResponse{}
+ err := ((*_bindings.Proxy)(p)).Call(2181038089, &req_, &resp_)
+ return resp_.S, resp_.Vmo, err
+}
+func (p *FileInterface) GetVmoAt(flags uint32,offset uint64,length uint64) (_zx.Status, _zx.VMO, error) {
+ req_ := FileGetVmoAtRequest{
+ Flags: flags,
+ Offset: offset,
+ Length: length,
+ }
+ resp_ := FileGetVmoAtResponse{}
+ err := ((*_bindings.Proxy)(p)).Call(2181038090, &req_, &resp_)
+ return resp_.S, resp_.Vmo, err
+}
+
+// File server interface.
+type File interface {
+ Clone(flags uint32,object ObjectInterfaceRequest) error
+ Close() (_zx.Status, error)
+ ListInterfaces() ([]string, error)
+ Bind(iface string) error
+ Describe() (ObjectInfo, error)
+ Sync() (_zx.Status, error)
+ GetAttr() (_zx.Status, NodeAttributes, error)
+ SetAttr(flags uint32,attributes NodeAttributes) (_zx.Status, error)
+ Ioctl(opcode uint32,maxOut uint64,handles []_zx.Handle,in []uint8) (_zx.Status, []_zx.Handle, []uint8, error)
+ Read(count uint64) (_zx.Status, []uint8, error)
+ ReadAt(count uint64,offset uint64) (_zx.Status, []uint8, error)
+ Write(data []uint8) (_zx.Status, uint64, error)
+ WriteAt(data []uint8,offset uint64) (_zx.Status, uint64, error)
+ Seek(offset int64,start SeekOrigin) (_zx.Status, uint64, error)
+ Truncate(length uint64) (_zx.Status, error)
+ GetFlags() (_zx.Status, uint32, error)
+ SetFlags(flags uint32) (_zx.Status, error)
+ GetVmo(flags uint32) (_zx.Status, _zx.VMO, error)
+ GetVmoAt(flags uint32,offset uint64,length uint64) (_zx.Status, _zx.VMO, error)
+}
+
+type FileInterfaceRequest _bindings.InterfaceRequest
+
+func NewFileInterfaceRequest() (FileInterfaceRequest, *FileInterface, error) {
+ req, cli, err := _bindings.NewInterfaceRequest()
+ return FileInterfaceRequest(req), (*FileInterface)(cli), err
+}
+
+type FileStub struct {
+ Impl File
+}
+
+func (s *FileStub) Dispatch(ord uint32, b_ []byte, h_ []_zx.Handle) (_bindings.Payload, error) {
+ switch ord {
+ case 2147483649:
+ in_ := ObjectCloneRequest{}
+ if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
+ return nil, err_
+ }
+ err_ := s.Impl.Clone(in_.Flags,in_.Object)
+ return nil, err_
+ case 2147483650:
+ in_ := ObjectCloseRequest{}
+ if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
+ return nil, err_
+ }
+ out_ := ObjectCloseResponse{}
+ s, err_ := s.Impl.Close()
+ out_.S = s
+ return &out_, err_
+ case 2147483652:
+ in_ := ObjectListInterfacesRequest{}
+ if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
+ return nil, err_
+ }
+ out_ := ObjectListInterfacesResponse{}
+ interfaces, err_ := s.Impl.ListInterfaces()
+ out_.Interfaces = interfaces
+ return &out_, err_
+ case 2147483653:
+ in_ := ObjectBindRequest{}
+ if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
+ return nil, err_
+ }
+ err_ := s.Impl.Bind(in_.Iface)
+ return nil, err_
+ case 2147483654:
+ in_ := ObjectDescribeRequest{}
+ if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
+ return nil, err_
+ }
+ out_ := ObjectDescribeResponse{}
+ info, err_ := s.Impl.Describe()
+ out_.Info = info
+ return &out_, err_
+ case 2164260865:
+ in_ := NodeSyncRequest{}
+ if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
+ return nil, err_
+ }
+ out_ := NodeSyncResponse{}
+ s, err_ := s.Impl.Sync()
+ out_.S = s
+ return &out_, err_
+ case 2164260866:
+ in_ := NodeGetAttrRequest{}
+ if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
+ return nil, err_
+ }
+ out_ := NodeGetAttrResponse{}
+ s, attributes, err_ := s.Impl.GetAttr()
+ out_.S = s
+ out_.Attributes = attributes
+ return &out_, err_
+ case 2164260867:
+ in_ := NodeSetAttrRequest{}
+ if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
+ return nil, err_
+ }
+ out_ := NodeSetAttrResponse{}
+ s, err_ := s.Impl.SetAttr(in_.Flags,in_.Attributes)
+ out_.S = s
+ return &out_, err_
+ case 2164260868:
+ in_ := NodeIoctlRequest{}
+ if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
+ return nil, err_
+ }
+ out_ := NodeIoctlResponse{}
+ s, handles, out, err_ := s.Impl.Ioctl(in_.Opcode,in_.MaxOut,in_.Handles,in_.In)
+ out_.S = s
+ out_.Handles = handles
+ out_.Out = out
+ return &out_, err_
+ case 2181038081:
+ in_ := FileReadRequest{}
+ if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
+ return nil, err_
+ }
+ out_ := FileReadResponse{}
+ s, data, err_ := s.Impl.Read(in_.Count)
+ out_.S = s
+ out_.Data = data
+ return &out_, err_
+ case 2181038082:
+ in_ := FileReadAtRequest{}
+ if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
+ return nil, err_
+ }
+ out_ := FileReadAtResponse{}
+ s, data, err_ := s.Impl.ReadAt(in_.Count,in_.Offset)
+ out_.S = s
+ out_.Data = data
+ return &out_, err_
+ case 2181038083:
+ in_ := FileWriteRequest{}
+ if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
+ return nil, err_
+ }
+ out_ := FileWriteResponse{}
+ s, actual, err_ := s.Impl.Write(in_.Data)
+ out_.S = s
+ out_.Actual = actual
+ return &out_, err_
+ case 2181038084:
+ in_ := FileWriteAtRequest{}
+ if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
+ return nil, err_
+ }
+ out_ := FileWriteAtResponse{}
+ s, actual, err_ := s.Impl.WriteAt(in_.Data,in_.Offset)
+ out_.S = s
+ out_.Actual = actual
+ return &out_, err_
+ case 2181038085:
+ in_ := FileSeekRequest{}
+ if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
+ return nil, err_
+ }
+ out_ := FileSeekResponse{}
+ s, offset, err_ := s.Impl.Seek(in_.Offset,in_.Start)
+ out_.S = s
+ out_.Offset = offset
+ return &out_, err_
+ case 2181038086:
+ in_ := FileTruncateRequest{}
+ if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
+ return nil, err_
+ }
+ out_ := FileTruncateResponse{}
+ s, err_ := s.Impl.Truncate(in_.Length)
+ out_.S = s
+ return &out_, err_
+ case 2181038087:
+ in_ := FileGetFlagsRequest{}
+ if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
+ return nil, err_
+ }
+ out_ := FileGetFlagsResponse{}
+ s, flags, err_ := s.Impl.GetFlags()
+ out_.S = s
+ out_.Flags = flags
+ return &out_, err_
+ case 2181038088:
+ in_ := FileSetFlagsRequest{}
+ if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
+ return nil, err_
+ }
+ out_ := FileSetFlagsResponse{}
+ s, err_ := s.Impl.SetFlags(in_.Flags)
+ out_.S = s
+ return &out_, err_
+ case 2181038089:
+ in_ := FileGetVmoRequest{}
+ if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
+ return nil, err_
+ }
+ out_ := FileGetVmoResponse{}
+ s, vmo, err_ := s.Impl.GetVmo(in_.Flags)
+ out_.S = s
+ out_.Vmo = vmo
+ return &out_, err_
+ case 2181038090:
+ in_ := FileGetVmoAtRequest{}
+ if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
+ return nil, err_
+ }
+ out_ := FileGetVmoAtResponse{}
+ s, vmo, err_ := s.Impl.GetVmoAt(in_.Flags,in_.Offset,in_.Length)
+ out_.S = s
+ out_.Vmo = vmo
+ return &out_, err_
+ }
+ return nil, _bindings.ErrUnknownOrdinal
+}
+
+type FileService struct {
+ _bindings.BindingSet
+}
+
+func (s *FileService) Add(impl File, c _zx.Channel, onError func(error)) (_bindings.BindingKey, error) {
+ return s.BindingSet.Add(&FileStub{Impl: impl}, c, onError)
+}
+
+func (s *FileService) EventProxyFor(key _bindings.BindingKey) (*FileEventProxy, bool) {
+ pxy, err := s.BindingSet.ProxyFor(key)
+ return (*FileEventProxy)(pxy), err
+}
+
+type FileEventProxy _bindings.Proxy
+
+func (p *FileEventProxy) OnOpen(s _zx.Status,info *ObjectInfo) error {
+ event_ := ObjectOnOpenResponse{
+ S: s,
+ Info: info,
+ }
+ return ((*_bindings.Proxy)(p)).Send(2147483655, &event_)
+}
+
+
+
+// Request for Open.
+type DirectoryOpenRequest struct {
+ Flags uint32
+ Mode uint32
+ Path string
+ Object ObjectInterfaceRequest
+}
+
+// Implements Payload.
+func (_ *DirectoryOpenRequest) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *DirectoryOpenRequest) InlineSize() int {
+ return 32
+}
+// Open has no response.
+// Request for Unlink.
+type DirectoryUnlinkRequest struct {
+ Path string
+}
+
+// Implements Payload.
+func (_ *DirectoryUnlinkRequest) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *DirectoryUnlinkRequest) InlineSize() int {
+ return 16
+}
+// Response for Unlink.
+type DirectoryUnlinkResponse struct {
+ S _zx.Status
+}
+
+// Implements Payload.
+func (_ *DirectoryUnlinkResponse) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *DirectoryUnlinkResponse) InlineSize() int {
+ return 4
+}
+// Request for ReadDirents.
+type DirectoryReadDirentsRequest struct {
+ MaxOut uint64
+}
+
+// Implements Payload.
+func (_ *DirectoryReadDirentsRequest) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *DirectoryReadDirentsRequest) InlineSize() int {
+ return 8
+}
+// Response for ReadDirents.
+type DirectoryReadDirentsResponse struct {
+ S _zx.Status
+ Dirents []uint8 `fidl:"8192"`
+}
+
+// Implements Payload.
+func (_ *DirectoryReadDirentsResponse) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *DirectoryReadDirentsResponse) InlineSize() int {
+ return 24
+}
+// Request for Rewind.
+type DirectoryRewindRequest struct {
+}
+
+// Implements Payload.
+func (_ *DirectoryRewindRequest) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *DirectoryRewindRequest) InlineSize() int {
+ return 0
+}
+// Response for Rewind.
+type DirectoryRewindResponse struct {
+ S _zx.Status
+}
+
+// Implements Payload.
+func (_ *DirectoryRewindResponse) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *DirectoryRewindResponse) InlineSize() int {
+ return 4
+}
+// Request for GetToken.
+type DirectoryGetTokenRequest struct {
+}
+
+// Implements Payload.
+func (_ *DirectoryGetTokenRequest) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *DirectoryGetTokenRequest) InlineSize() int {
+ return 0
+}
+// Response for GetToken.
+type DirectoryGetTokenResponse struct {
+ S _zx.Status
+ Token _zx.Handle
+}
+
+// Implements Payload.
+func (_ *DirectoryGetTokenResponse) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *DirectoryGetTokenResponse) InlineSize() int {
+ return 8
+}
+// Request for Rename.
+type DirectoryRenameRequest struct {
+ Src string
+ DstParentToken _zx.Handle
+ Dst string
+}
+
+// Implements Payload.
+func (_ *DirectoryRenameRequest) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *DirectoryRenameRequest) InlineSize() int {
+ return 40
+}
+// Response for Rename.
+type DirectoryRenameResponse struct {
+ S _zx.Status
+}
+
+// Implements Payload.
+func (_ *DirectoryRenameResponse) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *DirectoryRenameResponse) InlineSize() int {
+ return 4
+}
+// Request for Link.
+type DirectoryLinkRequest struct {
+ Src string
+ DstParentToken _zx.Handle
+ Dst string
+}
+
+// Implements Payload.
+func (_ *DirectoryLinkRequest) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *DirectoryLinkRequest) InlineSize() int {
+ return 40
+}
+// Response for Link.
+type DirectoryLinkResponse struct {
+ S _zx.Status
+}
+
+// Implements Payload.
+func (_ *DirectoryLinkResponse) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *DirectoryLinkResponse) InlineSize() int {
+ return 4
+}
+
+type DirectoryInterface _bindings.Proxy
+
+func (p *DirectoryInterface) Open(flags uint32,mode uint32,path string,object ObjectInterfaceRequest) error {
+ req_ := DirectoryOpenRequest{
+ Flags: flags,
+ Mode: mode,
+ Path: path,
+ Object: object,
+ }
+ err := ((*_bindings.Proxy)(p)).Send(2197815297, &req_)
+ return err
+}
+func (p *DirectoryInterface) Unlink(path string) (_zx.Status, error) {
+ req_ := DirectoryUnlinkRequest{
+ Path: path,
+ }
+ resp_ := DirectoryUnlinkResponse{}
+ err := ((*_bindings.Proxy)(p)).Call(2197815298, &req_, &resp_)
+ return resp_.S, err
+}
+func (p *DirectoryInterface) ReadDirents(maxOut uint64) (_zx.Status, []uint8, error) {
+ req_ := DirectoryReadDirentsRequest{
+ MaxOut: maxOut,
+ }
+ resp_ := DirectoryReadDirentsResponse{}
+ err := ((*_bindings.Proxy)(p)).Call(2197815299, &req_, &resp_)
+ return resp_.S, resp_.Dirents, err
+}
+func (p *DirectoryInterface) Rewind() (_zx.Status, error) {
+ req_ := DirectoryRewindRequest{
+ }
+ resp_ := DirectoryRewindResponse{}
+ err := ((*_bindings.Proxy)(p)).Call(2197815300, &req_, &resp_)
+ return resp_.S, err
+}
+func (p *DirectoryInterface) GetToken() (_zx.Status, _zx.Handle, error) {
+ req_ := DirectoryGetTokenRequest{
+ }
+ resp_ := DirectoryGetTokenResponse{}
+ err := ((*_bindings.Proxy)(p)).Call(2197815301, &req_, &resp_)
+ return resp_.S, resp_.Token, err
+}
+func (p *DirectoryInterface) Rename(src string,dstParentToken _zx.Handle,dst string) (_zx.Status, error) {
+ req_ := DirectoryRenameRequest{
+ Src: src,
+ DstParentToken: dstParentToken,
+ Dst: dst,
+ }
+ resp_ := DirectoryRenameResponse{}
+ err := ((*_bindings.Proxy)(p)).Call(2197815302, &req_, &resp_)
+ return resp_.S, err
+}
+func (p *DirectoryInterface) Link(src string,dstParentToken _zx.Handle,dst string) (_zx.Status, error) {
+ req_ := DirectoryLinkRequest{
+ Src: src,
+ DstParentToken: dstParentToken,
+ Dst: dst,
+ }
+ resp_ := DirectoryLinkResponse{}
+ err := ((*_bindings.Proxy)(p)).Call(2197815303, &req_, &resp_)
+ return resp_.S, err
+}
+
+// Directory server interface.
+type Directory interface {
+ Clone(flags uint32,object ObjectInterfaceRequest) error
+ Close() (_zx.Status, error)
+ ListInterfaces() ([]string, error)
+ Bind(iface string) error
+ Describe() (ObjectInfo, error)
+ Sync() (_zx.Status, error)
+ GetAttr() (_zx.Status, NodeAttributes, error)
+ SetAttr(flags uint32,attributes NodeAttributes) (_zx.Status, error)
+ Ioctl(opcode uint32,maxOut uint64,handles []_zx.Handle,in []uint8) (_zx.Status, []_zx.Handle, []uint8, error)
+ Open(flags uint32,mode uint32,path string,object ObjectInterfaceRequest) error
+ Unlink(path string) (_zx.Status, error)
+ ReadDirents(maxOut uint64) (_zx.Status, []uint8, error)
+ Rewind() (_zx.Status, error)
+ GetToken() (_zx.Status, _zx.Handle, error)
+ Rename(src string,dstParentToken _zx.Handle,dst string) (_zx.Status, error)
+ Link(src string,dstParentToken _zx.Handle,dst string) (_zx.Status, error)
+}
+
+type DirectoryInterfaceRequest _bindings.InterfaceRequest
+
+func NewDirectoryInterfaceRequest() (DirectoryInterfaceRequest, *DirectoryInterface, error) {
+ req, cli, err := _bindings.NewInterfaceRequest()
+ return DirectoryInterfaceRequest(req), (*DirectoryInterface)(cli), err
+}
+
+type DirectoryStub struct {
+ Impl Directory
+}
+
+func (s *DirectoryStub) Dispatch(ord uint32, b_ []byte, h_ []_zx.Handle) (_bindings.Payload, error) {
+ switch ord {
+ case 2147483649:
+ in_ := ObjectCloneRequest{}
+ if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
+ return nil, err_
+ }
+ err_ := s.Impl.Clone(in_.Flags,in_.Object)
+ return nil, err_
+ case 2147483650:
+ in_ := ObjectCloseRequest{}
+ if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
+ return nil, err_
+ }
+ out_ := ObjectCloseResponse{}
+ s, err_ := s.Impl.Close()
+ out_.S = s
+ return &out_, err_
+ case 2147483652:
+ in_ := ObjectListInterfacesRequest{}
+ if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
+ return nil, err_
+ }
+ out_ := ObjectListInterfacesResponse{}
+ interfaces, err_ := s.Impl.ListInterfaces()
+ out_.Interfaces = interfaces
+ return &out_, err_
+ case 2147483653:
+ in_ := ObjectBindRequest{}
+ if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
+ return nil, err_
+ }
+ err_ := s.Impl.Bind(in_.Iface)
+ return nil, err_
+ case 2147483654:
+ in_ := ObjectDescribeRequest{}
+ if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
+ return nil, err_
+ }
+ out_ := ObjectDescribeResponse{}
+ info, err_ := s.Impl.Describe()
+ out_.Info = info
+ return &out_, err_
+ case 2164260865:
+ in_ := NodeSyncRequest{}
+ if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
+ return nil, err_
+ }
+ out_ := NodeSyncResponse{}
+ s, err_ := s.Impl.Sync()
+ out_.S = s
+ return &out_, err_
+ case 2164260866:
+ in_ := NodeGetAttrRequest{}
+ if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
+ return nil, err_
+ }
+ out_ := NodeGetAttrResponse{}
+ s, attributes, err_ := s.Impl.GetAttr()
+ out_.S = s
+ out_.Attributes = attributes
+ return &out_, err_
+ case 2164260867:
+ in_ := NodeSetAttrRequest{}
+ if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
+ return nil, err_
+ }
+ out_ := NodeSetAttrResponse{}
+ s, err_ := s.Impl.SetAttr(in_.Flags,in_.Attributes)
+ out_.S = s
+ return &out_, err_
+ case 2164260868:
+ in_ := NodeIoctlRequest{}
+ if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
+ return nil, err_
+ }
+ out_ := NodeIoctlResponse{}
+ s, handles, out, err_ := s.Impl.Ioctl(in_.Opcode,in_.MaxOut,in_.Handles,in_.In)
+ out_.S = s
+ out_.Handles = handles
+ out_.Out = out
+ return &out_, err_
+ case 2197815297:
+ in_ := DirectoryOpenRequest{}
+ if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
+ return nil, err_
+ }
+ err_ := s.Impl.Open(in_.Flags,in_.Mode,in_.Path,in_.Object)
+ return nil, err_
+ case 2197815298:
+ in_ := DirectoryUnlinkRequest{}
+ if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
+ return nil, err_
+ }
+ out_ := DirectoryUnlinkResponse{}
+ s, err_ := s.Impl.Unlink(in_.Path)
+ out_.S = s
+ return &out_, err_
+ case 2197815299:
+ in_ := DirectoryReadDirentsRequest{}
+ if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
+ return nil, err_
+ }
+ out_ := DirectoryReadDirentsResponse{}
+ s, dirents, err_ := s.Impl.ReadDirents(in_.MaxOut)
+ out_.S = s
+ out_.Dirents = dirents
+ return &out_, err_
+ case 2197815300:
+ in_ := DirectoryRewindRequest{}
+ if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
+ return nil, err_
+ }
+ out_ := DirectoryRewindResponse{}
+ s, err_ := s.Impl.Rewind()
+ out_.S = s
+ return &out_, err_
+ case 2197815301:
+ in_ := DirectoryGetTokenRequest{}
+ if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
+ return nil, err_
+ }
+ out_ := DirectoryGetTokenResponse{}
+ s, token, err_ := s.Impl.GetToken()
+ out_.S = s
+ out_.Token = token
+ return &out_, err_
+ case 2197815302:
+ in_ := DirectoryRenameRequest{}
+ if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
+ return nil, err_
+ }
+ out_ := DirectoryRenameResponse{}
+ s, err_ := s.Impl.Rename(in_.Src,in_.DstParentToken,in_.Dst)
+ out_.S = s
+ return &out_, err_
+ case 2197815303:
+ in_ := DirectoryLinkRequest{}
+ if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
+ return nil, err_
+ }
+ out_ := DirectoryLinkResponse{}
+ s, err_ := s.Impl.Link(in_.Src,in_.DstParentToken,in_.Dst)
+ out_.S = s
+ return &out_, err_
+ }
+ return nil, _bindings.ErrUnknownOrdinal
+}
+
+type DirectoryService struct {
+ _bindings.BindingSet
+}
+
+func (s *DirectoryService) Add(impl Directory, c _zx.Channel, onError func(error)) (_bindings.BindingKey, error) {
+ return s.BindingSet.Add(&DirectoryStub{Impl: impl}, c, onError)
+}
+
+func (s *DirectoryService) EventProxyFor(key _bindings.BindingKey) (*DirectoryEventProxy, bool) {
+ pxy, err := s.BindingSet.ProxyFor(key)
+ return (*DirectoryEventProxy)(pxy), err
+}
+
+type DirectoryEventProxy _bindings.Proxy
+
+func (p *DirectoryEventProxy) OnOpen(s _zx.Status,info *ObjectInfo) error {
+ event_ := ObjectOnOpenResponse{
+ S: s,
+ Info: info,
+ }
+ return ((*_bindings.Proxy)(p)).Send(2147483655, &event_)
+}
+
diff --git a/src/syscall/zx/mkfuchsia.go b/src/syscall/zx/mkfuchsia.go
new file mode 100644
index 0000000..f717a62
--- /dev/null
+++ b/src/syscall/zx/mkfuchsia.go
@@ -0,0 +1,875 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build ignore
+
+// Parses syscalls.abigen of Fuchsia's zircon kernel and produces Go
+// assembly for calling the system calls.
+//
+// Regenerate syscall/zx with:
+//
+// go run mkfuchsia.go -stubs > syscalls_fuchsia.go
+// go run mkfuchsia.go -goarch=amd64 > syscalls_fuchsia_amd64.s
+// go run mkfuchsia.go -goarch=arm64 > syscalls_fuchsia_arm64.s
+// gofmt -w *.go
+package main
+
+import (
+ "bytes"
+ "flag"
+ "fmt"
+ "io/ioutil"
+ "log"
+ "os"
+ "path/filepath"
+ "strings"
+ "unicode/utf8"
+)
+
+var (
+ stubs = flag.Bool("stubs", false, "print only Go function stubs")
+ goarch = flag.String("goarch", "amd64", "arch to print asm for")
+ fuchsiaRoot = flag.String("fuchsia_root", filepath.Join(os.Getenv("HOME"), "fuchsia"), "path to fuchsia root")
+)
+
+func main() {
+ flag.Parse()
+ sdkArch := ""
+ switch *goarch {
+ case "amd64":
+ sdkArch = "x86_64"
+ case "arm64":
+ sdkArch = "aarch64"
+ default:
+ log.Fatalf("GOARCH=%s not supported", *goarch)
+ }
+ _ = sdkArch
+
+ syscallsFile := filepath.Join(*fuchsiaRoot, "/zircon/system/public/zircon/syscalls.abigen")
+ if args := flag.Args(); len(args) != 0 {
+ syscallsFile = args[0]
+ }
+
+ b, err := ioutil.ReadFile(syscallsFile)
+ if err != nil {
+ log.Fatal(err)
+ }
+
+ p := &parser{
+ buf: b,
+ line: 1,
+ name: syscallsFile,
+ }
+ syscalls, err := p.parse()
+ if err != nil {
+ log.Fatal(err)
+ }
+
+ buf := new(bytes.Buffer)
+ if *stubs {
+ fmt.Fprint(buf, stubsHeader[1:])
+ for _, call := range syscalls {
+ fmt.Fprintf(buf, "//go:cgo_import_dynamic vdso_zx_%s zx_%s \"libzircon.so\"\n", call.name, call.name)
+ }
+ fmt.Fprint(buf, "\n")
+ for _, call := range syscalls {
+ fmt.Fprintf(buf, "//go:linkname vdso_zx_%s vdso_zx_%s\n", call.name, call.name)
+ }
+ fmt.Fprint(buf, "\nvar (\n")
+ for _, call := range syscalls {
+ fmt.Fprintf(buf, "\tvdso_zx_%s uintptr\n", call.name)
+ }
+ fmt.Fprint(buf, ")\n\n")
+ for _, call := range syscalls {
+ fmt.Fprint(buf, "//go:noescape\n")
+ fmt.Fprint(buf, "//go:nosplit\n")
+ printStub(buf, call)
+ fmt.Fprint(buf, "\n")
+ }
+ } else {
+ fmt.Fprint(buf, asmHeader[1:])
+ for _, call := range syscalls {
+ fmt.Fprint(buf, "// ")
+ printStub(buf, call)
+ printAsm(buf, call)
+ fmt.Fprint(buf, "\n")
+ }
+ }
+ buf.WriteTo(os.Stdout)
+}
+
+const stubsHeader = `
+// Copyright 2018 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.
+
+// Zircon system calls for the Fuchsia OS.
+// Generated by mkfuchsia.go, do not edit.
+
+package zx
+
+import "unsafe"
+
+`
+
+const asmHeader = `
+// Copyright 2016 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.
+
+// Zircon system calls for the Fuchsia OS.
+// Generated by mkfuchsia.go, do not edit.
+
+#include "textflag.h"
+
+`
+
+func printStub(buf *bytes.Buffer, call zirconSyscallDef) {
+ fmt.Fprintf(buf, "func %s(", call.sysname())
+ for i, arg := range call.args {
+ if arg.atype == (zirconType{}) {
+ continue
+ }
+ if i > 0 {
+ fmt.Fprint(buf, ", ")
+ }
+ fmt.Fprintf(buf, "%s ", arg.aname)
+ printGoType(buf, arg.atype)
+ }
+ fmt.Fprint(buf, ")")
+ if call.ret != (zirconType{}) {
+ fmt.Fprint(buf, " ")
+ printGoType(buf, call.ret)
+ }
+ fmt.Fprint(buf, "\n")
+}
+
+// amd64RegArgs is the amd64 registers in function argument calling convention order
+var amd64RegArgs = []string{"DI", "SI", "DX", "CX", "R8", "R9", "R12", "R13"}
+
+// arm64RegArgs is the arm64 registers in function argument calling convention order
+var arm64RegArgs = []string{"R0", "R1", "R2", "R3", "R4", "R5", "R6", "R7"}
+
+// blockingSyscalls is a map of known syscalls which may block.
+var blockingSyscalls = map[string]bool{
+ "port_wait": true,
+ "object_wait_one": true,
+ "object_wait_many": true,
+}
+
+const ZIRCON_SYSCALL_MAGIC = 0x00ff00ff00000000
+
+func printAsm(buf *bytes.Buffer, call zirconSyscallDef) {
+ // The summed size of all arguments
+ argSize := 0
+ for _, arg := range call.args {
+ sz := typeSize(arg.atype)
+ if *goarch == "arm64" && sz == 1 {
+ sz = 8
+ }
+ for argSize%sz != 0 {
+ // Add padding until the 'argSize' is aligned to the type we are adding
+ argSize++
+ }
+ argSize += sz
+ }
+ if argSize%8 == 4 {
+ // Force the return argument on the stack to be 8-byte aligned, not 4-byte aligned
+ argSize += 4
+ }
+ retSize := typeSize(call.ret)
+
+ var frameSize int
+ var regArgs []string
+ var callIns, retReg, suffix4, suffix8 string
+ switch *goarch {
+ case "amd64":
+ regArgs = amd64RegArgs
+ callIns = "CALL"
+ retReg = "AX"
+ suffix8 = "Q"
+ suffix4 = "L"
+ switch len(call.args) {
+ case 7:
+ frameSize = 16 + 8
+ case 8:
+ frameSize = 16 + 2*8
+ }
+ case "arm64":
+ regArgs = arm64RegArgs
+ callIns = "BL"
+ retReg = "R0"
+ suffix8 = "D"
+ suffix4 = "W"
+ default:
+ panic(fmt.Sprintf("goarch=%s not supported", *goarch))
+ }
+
+ fmt.Fprintf(buf, "TEXT ·%s(SB),NOSPLIT,$%d-%d\n", call.sysname(), frameSize, argSize+retSize)
+
+ if _, ok := blockingSyscalls[call.name]; ok {
+ fmt.Fprintf(buf, "\tCALL runtime·entersyscall(SB)\n")
+ }
+ off := 0
+ for i, arg := range call.args {
+ name := arg.aname
+ suffix := suffix8
+ t := arg.atype
+ if typeSize(t) == 4 {
+ suffix = suffix4
+ }
+ sz := typeSize(t)
+ if *goarch == "arm64" && sz == 1 {
+ sz = 8
+ }
+ for off%sz != 0 {
+ // Add padding until the offset is aligned to the type we are accessing
+ off++
+ }
+
+ fmt.Fprintf(buf, "\tMOV%s %s+%d(FP), %s\n", suffix, name, off, regArgs[i])
+ off += sz
+ }
+ switch *goarch {
+ case "amd64":
+ if len(call.args) >= 7 {
+ fmt.Fprintf(buf, "\tMOVQ SP, BP // BP is preserved across vsdo call by the x86-64 ABI\n")
+ fmt.Fprintf(buf, "\tANDQ $~15, SP // stack alignment for x86-64 ABI\n")
+ if len(call.args) == 8 {
+ fmt.Fprintf(buf, "\tPUSHQ R13\n")
+ }
+ fmt.Fprintf(buf, "\tPUSHQ R12\n")
+ }
+ fmt.Fprintf(buf, "\tMOVQ vdso_zx_%s(SB), AX\n", call.name)
+ fmt.Fprintf(buf, "\tCALL AX\n")
+ if len(call.args) >= 7 {
+ fmt.Fprintf(buf, "\tPOPQ R12\n")
+ if len(call.args) == 8 {
+ fmt.Fprintf(buf, "\tPOPQ R13\n")
+ }
+ fmt.Fprintf(buf, "\tMOVQ BP, SP\n")
+ }
+ case "arm64":
+ fmt.Fprintf(buf, "\tBL vdso_zx_%s(SB)\n", call.name)
+ }
+ if retSize := typeSize(call.ret); retSize > 0 {
+ suffix := suffix8
+ if retSize == 4 {
+ suffix = suffix4
+ }
+ fmt.Fprintf(buf, "\tMOV%s %s, ret+%d(FP)\n", suffix, retReg, argSize)
+ }
+ if _, ok := blockingSyscalls[call.name]; ok {
+ fmt.Fprintf(buf, "\t%s runtime·exitsyscall(SB)\n", callIns)
+ }
+ fmt.Fprintf(buf, "\tRET\n")
+}
+
+func typeSize(t zirconType) int {
+ regSize := 8
+ if *goarch == "arm" {
+ regSize = 4
+ }
+ if t.isArray {
+ return regSize
+ }
+ switch t.named {
+ case zx_function_pointer:
+ return regSize
+ case zx_void:
+ return 0
+ case zx_any:
+ return 0
+ case zx_bool:
+ return 1
+ case zx_int, zx_uint, zx_uintptr_t, zx_size_t:
+ return regSize
+ case zx_char, zx_uint8_t:
+ return 1
+ case zx_int16_t, zx_uint16_t:
+ return 2
+ case zx_int32_t, zx_uint32_t:
+ return 4
+ case zx_int64_t, zx_uint64_t:
+ return 8
+ case zx_status_t:
+ return 4
+ case zx_clock_t:
+ return 4
+ case zx_time_t:
+ return 8
+ case zx_duration_t:
+ return 8
+ case zx_koid_t:
+ return 8
+ case zx_handle_t:
+ return 4
+ case zx_signals_t:
+ return 4
+ case zx_rights_t:
+ return 4
+ case zx_vaddr_t, zx_paddr_t:
+ return regSize
+ case zx_process_info_t:
+ panic("cannot pass zx_process_info_t")
+ case zx_exception_status_t, zx_exception_behaviour_t:
+ return 4
+ default:
+ panic(fmt.Sprintf("UNKNOWN(%s)", t.named))
+ }
+}
+
+func printGoType(buf *bytes.Buffer, t zirconType) {
+ if t.isArray {
+ if t.named == zx_any {
+ fmt.Fprint(buf, "unsafe.Pointer")
+ return
+ }
+ fmt.Fprint(buf, "*")
+ }
+ switch t.named {
+ case zx_void:
+ fmt.Fprint(buf, "BAD(void)")
+ case zx_any:
+ fmt.Fprint(buf, "BAD(any)")
+ case zx_bool:
+ fmt.Fprint(buf, "bool")
+ case zx_uint:
+ fmt.Fprint(buf, "uint")
+ case zx_int:
+ fmt.Fprint(buf, "int")
+ case zx_char, zx_uint8_t:
+ fmt.Fprint(buf, "uint8")
+ case zx_int16_t:
+ fmt.Fprint(buf, "int16")
+ case zx_uint16_t:
+ fmt.Fprint(buf, "uint16")
+ case zx_int32_t:
+ fmt.Fprint(buf, "int32")
+ case zx_uint32_t:
+ fmt.Fprint(buf, "uint32")
+ case zx_int64_t:
+ fmt.Fprint(buf, "int64")
+ case zx_uint64_t:
+ fmt.Fprint(buf, "uint64")
+ case zx_uintptr_t:
+ fmt.Fprint(buf, "uintptr")
+ case zx_status_t:
+ fmt.Fprint(buf, "Status")
+ case zx_clock_t:
+ fmt.Fprint(buf, "Clock")
+ case zx_time_t:
+ fmt.Fprint(buf, "Time")
+ case zx_duration_t:
+ fmt.Fprint(buf, "Duration")
+ case zx_koid_t:
+ fmt.Fprint(buf, "Koid")
+ case zx_handle_t:
+ fmt.Fprint(buf, "Handle")
+ case zx_signals_t:
+ fmt.Fprint(buf, "Signals")
+ case zx_wait_item_t:
+ fmt.Fprint(buf, "WaitItem")
+ case zx_rights_t:
+ fmt.Fprint(buf, "Rights")
+ case zx_vaddr_t:
+ fmt.Fprint(buf, "Vaddr")
+ case zx_paddr_t:
+ fmt.Fprint(buf, "Paddr")
+ case zx_size_t:
+ fmt.Fprint(buf, "uint")
+ case zx_process_info_t:
+ fmt.Fprint(buf, "ProcessInfo")
+ case zx_exception_status_t:
+ fmt.Fprint(buf, "ExceptionStatus")
+ case zx_exception_behaviour_t:
+ fmt.Fprint(buf, "ExceptionBehaviour")
+ case zx_rrec_t:
+ fmt.Fprint(buf, "Rrec")
+ case zx_channel_call_args_t:
+ fmt.Fprint(buf, "ChannelCallArgs")
+ case zx_fifo_state_t:
+ fmt.Fprint(buf, "FIFOState")
+ case zx_smc_parameters_t:
+ fmt.Fprint(buf, "SMCParameters")
+ case zx_smc_result_t:
+ fmt.Fprint(buf, "SMCResult")
+ default:
+ panic(fmt.Sprintf("UNKNOWN type: %s", t.named))
+ }
+}
+
+func (p *parser) parse() (syscalls []zirconSyscallDef, err error) {
+ if len(p.buf) == 0 {
+ return syscalls, nil
+ }
+
+ p.nextRune()
+ for {
+ t, lit := p.nextToken()
+ if lit == "syscall" {
+ call, err := p.parseSyscall()
+ if err != nil {
+ return nil, err
+ }
+ if strings.Contains(call.name, "_test") {
+ continue
+ }
+ // The PCI syscalls are DDK-only and temporary, so exclude generation of
+ // helpers for them
+ if strings.HasPrefix(call.name, "pci_") {
+ continue
+ }
+ // The hypervisor syscalls have complex parameter and return types. Skip
+ // generation for these until we need them.
+ if strings.HasPrefix(call.name, "guest_") || strings.HasPrefix(call.name, "vcpu_") {
+ continue
+ }
+ syscalls = append(syscalls, call)
+ continue
+ }
+ if t == tokenEOF {
+ return syscalls, nil
+ }
+ if t == tokenBad {
+ return nil, p.errorf("bad token: %s", lit)
+ }
+ return nil, p.errorf("unexpected token: %q (literal %q)", t, lit)
+ }
+}
+
+func (p *parser) expect(want token) {
+ t, lit := p.nextToken()
+ if t != want {
+ p.panicf("expected %q but got %q (literal %q)", want, t, lit)
+ }
+}
+
+func (p *parser) parseAttributes() (attr []string, err error) {
+ for {
+ p.skipWhitespace()
+ if p.r == '(' {
+ return
+ }
+ attr = append(attr, p.nextIdent())
+ p.skipWhitespace()
+ if p.r == ',' {
+ p.nextRune()
+ }
+ }
+}
+
+func (p *parser) parseArg() (arg zirconArg, err error) {
+ if p.r == ')' {
+ return
+ }
+ arg.aname = p.nextIdent()
+ p.expect(':')
+ atype, err := p.parseType()
+ if err != nil {
+ return
+ }
+ arg.atype = atype
+ p.skipWhitespace()
+ if isLetter(p.r) {
+ arg.constraint = p.nextIdent()
+ p.skipWhitespace()
+ }
+ return
+}
+
+func (p *parser) parseSyscall() (call zirconSyscallDef, err error) {
+ call.name = p.nextIdent()
+ attr, err := p.parseAttributes()
+ if err != nil {
+ return zirconSyscallDef{}, err
+ }
+ for _, a := range attr {
+ if a == "vdsocall" {
+ call.vdsocall = true
+ }
+ }
+ call.attr = attr
+ p.expect('(')
+ for {
+ p.skipWhitespace()
+ if p.r == ')' {
+ p.nextRune()
+ break
+ }
+ arg, err := p.parseArg()
+ if err != nil {
+ return zirconSyscallDef{}, err
+ }
+ if arg.aname == "" {
+ break
+ }
+ call.args = append(call.args, arg)
+ if p.r == ',' {
+ p.nextRune()
+ }
+ }
+ p.skipWhitespace()
+ if p.r != ';' {
+ kw := p.nextIdent()
+ if kw != "returns" {
+ p.panicf("expected \"returns\" but got \"%s\"", kw)
+ }
+ p.expect('(')
+ first := true
+ for {
+ p.skipWhitespace()
+ if p.r == ')' {
+ p.nextRune()
+ break
+ }
+ if first {
+ first = false
+ rtype, err := p.parseType()
+ if err != nil {
+ return zirconSyscallDef{}, err
+ }
+ call.ret = rtype
+ } else {
+ arg, err := p.parseArg()
+ if err != nil {
+ return zirconSyscallDef{}, err
+ }
+ // Extra return types are returned as pointers.
+ arg.atype.isArray = true
+ arg.atype.arraySize = "1"
+ call.args = append(call.args, arg)
+ }
+ if p.r == ',' {
+ p.nextRune()
+ }
+ }
+ }
+ p.skipWhitespace()
+ p.expect(';')
+ return call, nil
+}
+
+func (p *parser) parseType() (t zirconType, err error) {
+ ident := p.nextIdent()
+ n, ok := zirconTypeNamedStr[ident]
+ if !ok {
+ return t, p.errorf("unknown type name: %s", ident)
+ }
+ t.named = n
+ p.skipWhitespace()
+ if p.r == '[' {
+ p.nextRune()
+ t.isArray = true
+ t.arraySize = p.nextIdent()
+ p.skipWhitespace()
+ for p.r == '*' {
+ p.nextRune()
+ t.arraySize += " * " + p.nextIdent()
+ }
+ p.expect(']')
+ }
+ return t, nil
+}
+
+type parser struct {
+ buf []byte
+ off int
+ line, col int
+ name string
+
+ r rune
+}
+
+type token rune
+
+const (
+ tokenEOF token = -1
+ tokenBad token = -2
+ tokenIdent token = -3
+ tokenNumber token = -4
+)
+
+func (t token) String() string {
+ switch t {
+ case tokenEOF:
+ return "token(EOF)"
+ case tokenBad:
+ return "token(BAD)"
+ case tokenIdent:
+ return "token(Ident)"
+ case tokenNumber:
+ return "token(Number)"
+ default:
+ return "token(" + string(t) + ")"
+ }
+}
+
+func (p *parser) nextToken() (t token, lit string) {
+ p.skipWhitespace()
+
+ if isLetter(p.r) {
+ lit = p.nextIdent()
+ return tokenIdent, lit
+ }
+ if isNumber(p.r) {
+ lit = p.nextNumber()
+ return tokenNumber, lit
+ }
+
+ r := p.r
+ p.nextRune()
+ switch r {
+ case -1:
+ return tokenEOF, ""
+ case '(', ')', '*', ',', ';', ':', '[', ']':
+ return token(r), ""
+ case '#':
+ p.skipComment()
+ return p.nextToken()
+ }
+ return tokenBad, fmt.Sprintf("%q", r)
+}
+
+func (p *parser) nextIdent() string {
+ p.skipWhitespace()
+ if !isLetter(p.r) && !isNumber(p.r) {
+ p.panicf("expected ident but got %q", p.r)
+ }
+ off := p.off - 1
+ for isLetter(p.r) || isNumber(p.r) {
+ p.nextRune()
+ }
+ r := string(p.buf[off : p.off-1])
+ if r == "type" {
+ // "type" is a reserved word in Go.
+ return "typ"
+ }
+ return r
+}
+
+func (p *parser) nextNumber() string {
+ p.skipWhitespace()
+ if !isNumber(p.r) {
+ p.panicf("expected number but got %q", p.r)
+ }
+ off := p.off - 1
+ for isNumber(p.r) {
+ p.nextRune()
+ }
+ return string(p.buf[off : p.off-1])
+}
+
+func (p *parser) skipWhitespace() {
+ for p.r == ' ' || p.r == '\t' || p.r == '\n' {
+ p.nextRune()
+ }
+}
+
+func (p *parser) skipComment() {
+ // skip until end of line
+ p.nextRune()
+ for p.r != '\n' && p.r >= 0 {
+ p.nextRune()
+ }
+}
+
+func (p *parser) nextRune() {
+ if p.off >= len(p.buf) {
+ p.r = -1
+ return
+ }
+ if p.r == '\n' {
+ p.line++
+ p.col = 0
+ } else {
+ p.col += utf8.RuneLen(p.r)
+ }
+
+ r, w := utf8.DecodeRune(p.buf[p.off:])
+ if r == utf8.RuneError && w == 1 {
+ p.r = -1
+ p.panicf("input is not UTF-8")
+ return
+ }
+ p.r = r
+ p.off += w
+}
+
+func (p *parser) panicf(format string, args ...interface{}) {
+ panic(parsePanic{err: p.errorf(format, args...)})
+}
+
+func (p *parser) errorf(format string, args ...interface{}) error {
+ return fmt.Errorf("%s:%d:%d: %s", p.name, p.line, p.col, fmt.Sprintf(format, args...))
+}
+
+func isLetter(r rune) bool { return 'a' <= r && r <= 'z' || 'A' <= r && r <= 'Z' || r == '_' }
+func isNumber(r rune) bool { return '0' <= r && r <= '9' }
+
+type parsePanic struct {
+ err error
+}
+
+func (pp parsePanic) String() string { return pp.err.Error() }
+
+type zirconArg struct {
+ aname string
+ atype zirconType
+ constraint string
+}
+
+type zirconSyscallDef struct {
+ name string
+ ret zirconType
+ attr []string
+ args []zirconArg
+ vdsocall bool
+}
+
+func (call zirconSyscallDef) sysname() string {
+ if call.exported() {
+ return "Sys_" + call.name
+ }
+ return "sys_" + call.name
+}
+
+func (call zirconSyscallDef) exported() bool {
+ switch call.name {
+ case "handle_duplicate",
+ "object_set_profile",
+ "object_wait_many",
+ "channel_create",
+ "channel_read",
+ "channel_read_etc",
+ "channel_write",
+ "pci_get_bar",
+ "pci_map_interrupt",
+ "pci_query_irq_mode",
+ "pci_set_irq_mode",
+ "pci_init",
+ "pci_add_subtract_to_range",
+ "socket_create",
+ "socket_read",
+ "socket_write",
+ "socket_accept",
+ "socket_share",
+ "system_get_dcache_line_size",
+ "system_get_features",
+ "vmar_allocate",
+ "vmar_allocate_old",
+ "vmar_destroy",
+ "vmar_map_old",
+ "vmar_protect_old",
+ "vmo_read",
+ "vmo_write",
+ "vmo_get_size",
+ "vmo_set_size",
+ "vmo_op_range":
+ return false
+ default:
+ return true
+ }
+}
+
+type zirconType struct {
+ named zirconTypeNamed
+ isArray bool
+ arraySize string
+}
+
+type zirconTypeNamed int
+
+const (
+ zx_void zirconTypeNamed = iota
+ zx_any
+ zx_bool
+ zx_uint
+ zx_int
+ zx_char
+ zx_uint8_t
+ zx_int16_t
+ zx_uint16_t
+ zx_int32_t
+ zx_uint32_t
+ zx_int64_t
+ zx_uint64_t
+ zx_uintptr_t
+ zx_size_t
+ zx_status_t
+ zx_clock_t
+ zx_time_t
+ zx_duration_t
+ zx_koid_t
+ zx_handle_t
+ zx_signals_t
+ zx_signals_state_t
+ zx_smc_parameters_t
+ zx_smc_result_t
+ zx_wait_item_t
+ zx_rights_t
+ zx_vaddr_t
+ zx_paddr_t
+ zx_process_info_t
+ zx_exception_status_t
+ zx_exception_behaviour_t
+ zx_function_pointer
+ zx_rrec_t
+ zx_channel_call_args_t
+ zx_fifo_state_t
+)
+
+var zirconTypeNamedStr = map[string]zirconTypeNamed{
+ "any": zx_any,
+ "void": zx_void,
+ "bool": zx_bool,
+ "unsigned int": zx_uint,
+ "int": zx_int,
+ "char": zx_char,
+ "uint8_t": zx_uint8_t,
+ "int16_t": zx_int16_t,
+ "int32_t": zx_int32_t,
+ "int64_t": zx_int64_t,
+ "uint16_t": zx_uint16_t,
+ "uint32_t": zx_uint32_t,
+ "uint64_t": zx_uint64_t,
+ "uintptr_t": zx_uintptr_t,
+ "size_t": zx_size_t,
+ "zx_status_t": zx_status_t, // int32_t
+ "zx_clock_t": zx_uint32_t,
+ "zx_time_t": zx_time_t, // uint64_t monotonic time
+ "zx_duration_t": zx_duration_t, // uint64_t nanoseconds
+ "zx_koid_t": zx_koid_t,
+ "zx_handle_t": zx_handle_t, // int32_t
+ "zx_futex_t": zx_int,
+ "zx_signals_t": zx_signals_t,
+ "zx_signals_state_t": zx_signals_state_t,
+ "zx_wait_item_t": zx_wait_item_t,
+ "zx_rights_t": zx_rights_t,
+ "zx_vaddr_t": zx_vaddr_t,
+ "zx_paddr_t": zx_paddr_t,
+ "zx_smc_parameters_t": zx_smc_parameters_t,
+ "zx_smc_result_t": zx_smc_result_t,
+ "zx_process_info_t": zx_process_info_t,
+ "zx_exception_status_t": zx_exception_status_t,
+ "zx_exception_behaviour_t": zx_exception_behaviour_t,
+ "zx_function_pointer": zx_function_pointer,
+ "zx_rrec_t": zx_rrec_t,
+ "zx_channel_call_args_t": zx_channel_call_args_t,
+ "zx_fifo_state_t": zx_fifo_state_t,
+ // TODO(smklein): Remove the following temporary types. They could be blacklisted, but this is
+ // easier.
+ "zx_cache_policy_t": zx_int,
+ "zx_port_packet_t": zx_int,
+ "zx_pci_init_arg_t": zx_int,
+ "zx_pci_irq_mode_t": zx_int,
+ "zx_pci_resource_t": zx_int,
+ "zx_pcie_device_info_t": zx_int,
+ "zx_pcie_get_nth_info_t": zx_int,
+ "zx_vcpu_create_args_t": zx_int,
+ "zx_system_powerctl_arg_t": zx_int,
+ "zx_handle_info_t": zx_int,
+ "zx_profile_info_t": zx_int,
+ "zx_pci_bar_t": zx_int,
+}
diff --git a/src/syscall/zx/mxerror/mxerror.go b/src/syscall/zx/mxerror/mxerror.go
new file mode 100644
index 0000000..87d0437
--- /dev/null
+++ b/src/syscall/zx/mxerror/mxerror.go
@@ -0,0 +1,46 @@
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build fuchsia
+
+package mxerror
+
+import (
+ "fmt"
+ "syscall/zx"
+)
+
+// Status extracts an zx.Status from an error.
+func Status(err error) zx.Status {
+ if err == nil {
+ return zx.ErrOk
+ }
+ if s, hasStatus := err.(zx.Error); hasStatus {
+ return s.Status
+ }
+ return zx.ErrInternal
+}
+
+// Prependf prepends a format string onto an error.
+// If the error is an zx.Error, the status code is retained.
+func Prependf(err error, format string, args ...interface{}) error {
+ str := fmt.Sprintf(format, args...)
+ if e, isError := err.(zx.Error); isError {
+ if e.Text == "" {
+ e.Text = str
+ } else {
+ e.Text = str + ": " + e.Text
+ }
+ return e
+ }
+ return fmt.Errorf("%s: %v", str, err)
+}
+
+// Errorf creates an error with an zx.Status code.
+func Errorf(s zx.Status, format string, args ...interface{}) error {
+ return zx.Error{
+ Status: s,
+ Text: fmt.Sprintf(format, args...),
+ }
+}
diff --git a/src/syscall/zx/mxnet/ctypes.go b/src/syscall/zx/mxnet/ctypes.go
new file mode 100644
index 0000000..5c1c6c9
--- /dev/null
+++ b/src/syscall/zx/mxnet/ctypes.go
@@ -0,0 +1,153 @@
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build fuchsia
+
+package mxnet
+
+// Types from <lib/fdio/socket.h>.
+// These were extracted from cgo by building the program:
+//
+// package typesextract
+//
+// // #include <arpa/inet.h>
+// // #include <netdb.h>
+// // #include <netinet/in.h>
+// // #include <netinet/tcp.h>
+// // #include <sys/ioctl.h>
+// // #include <sys/socket.h>
+// // #include <sys/types.h>
+// // #include <lib/fdio/socket.h>
+// import "C"
+//
+// func F() {
+// _ = C.struct_addrinfo{}
+// _ = C.struct_sockaddr_in{}
+// _ = C.struct_sockaddr_in6{}
+// _ = C.struct_mxrio_gai_req{}
+// _ = C.struct_mxrio_gai_reply{}
+// _ = C.struct_mxrio_sockaddr_reply{}
+// _ = C.struct_mxrio_sockopt_req_reply{}
+// _ = C.struct_fdio_socket_msg{}
+// _ = C.AF_INET
+// _ = C.AF_INET6
+// _ = C.MXRIO_GAI_REQ_NODE_MAXLEN
+// _ = C.MXRIO_GAI_REQ_SERVICE_MAXLEN
+// _ = C.MXRIO_GAI_REPLY_MAX
+// }
+//
+// Then the names were cleaned up manually, with commands like:
+// s/_t$//
+// s/_Ctype_struct_/c_/
+// s/_Ctype_/c_/
+// ...
+//
+// Two big changes are c_in_port and c_in_addr, which for historcical
+// UNIX reasons have terrible type representations, so we treat them
+// as byte arrays.
+//
+// This will probably all be FIDL one day.
+
+const SOCK_STREAM = 1
+const SOCK_DGRAM = 2
+
+const AF_INET = 2
+const AF_INET6 = 10
+
+const MXRIO_GAI_REQ_NODE_MAXLEN = 256
+const MXRIO_GAI_REQ_SERVICE_MAXLEN = 256
+const MXRIO_GAI_REPLY_MAX = 4
+
+type c_socklen uint32
+type c_in_port [2]byte // uint16 in C, but stored in network order
+type c_sa_family uint16
+type c_in_addr [4]byte // uint32 in C, but stored in network order
+type c_ulong uint64
+
+type c_addrinfo struct {
+ ai_flags int32
+ ai_family int32
+ ai_socktype int32
+ ai_protocol int32
+ ai_addrlen c_socklen
+ _ [4]byte
+ // The following pointers are unused on the wire.
+ ai_addr uintptr // *c_sockaddr
+ ai_canonname uintptr // *int8
+ ai_next uintptr // *c_addrinfo
+}
+
+type c_mxrio_gai_reply struct {
+ res [MXRIO_GAI_REPLY_MAX]struct {
+ ai c_addrinfo
+ addr c_sockaddr_storage
+ }
+ nres int32
+ retval int32
+}
+
+type c_mxrio_gai_req struct {
+ node_is_null uint8
+ service_is_null uint8
+ hints_is_null uint8
+ reserved uint8
+ reserved2 uint32
+ node [MXRIO_GAI_REQ_NODE_MAXLEN]uint8
+ service [MXRIO_GAI_REQ_SERVICE_MAXLEN]uint8
+ hints c_addrinfo
+}
+
+type c_mxrio_sockaddr_reply struct {
+ addr c_sockaddr_storage
+ len c_socklen
+ _ [4]byte
+}
+
+type c_mxrio_sockopt_req_reply struct {
+ level int32
+ optname int32
+ optval [8]uint8
+ optlen c_socklen
+}
+
+type c_sockaddr struct {
+ sa_family c_sa_family
+ sa_data [14]uint8
+}
+
+type c_sockaddr_in struct {
+ sin_family c_sa_family
+ sin_port c_in_port // network order
+ sin_addr c_in_addr
+ sin_zero [8]uint8
+}
+
+type c_in6_addr [16]byte
+
+type c_sockaddr_in6 struct {
+ sin6_family c_sa_family
+ sin6_port c_in_port // network order
+ sin6_flowinfo uint32
+ sin6_addr c_in6_addr
+ sin6_scope_id uint32
+}
+
+type c_sockaddr_storage struct {
+ ss_family c_sa_family
+ _ [6]byte
+ __ss_align c_ulong
+ __ss_padding [112]uint8
+}
+
+type c_fdio_socket_msg_hdr struct {
+ addr c_sockaddr_storage
+ addrlen c_socklen
+ flags int32
+}
+
+type c_fdio_socket_msg struct {
+ hdr c_fdio_socket_msg_hdr
+ data [1]uint8
+ _ [7]byte
+}
diff --git a/src/syscall/zx/mxnet/mxnet.go b/src/syscall/zx/mxnet/mxnet.go
new file mode 100644
index 0000000..2c81b01
--- /dev/null
+++ b/src/syscall/zx/mxnet/mxnet.go
@@ -0,0 +1,154 @@
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build fuchsia
+
+// Package mxnet contains types for talking to Fuchsia's fdio net interface.
+package mxnet
+
+import (
+ "syscall/zx"
+ "unsafe"
+)
+
+const ZX_SOCKET_HALF_CLOSE = 1
+const ZX_SOCKET_READABLE = zx.SignalObject0
+const ZX_SOCKET_WRITABLE = zx.SignalObject1
+const ZX_SOCKET_PEER_CLOSED = zx.SignalObject2
+const MXSIO_SIGNAL_INCOMING = zx.SignalUser0
+const MXSIO_SIGNAL_OUTGOING = zx.SignalUser1
+const MXSIO_SIGNAL_CONNECTED = zx.SignalUser3
+const MXSIO_SIGNAL_HALFCLOSED = zx.SignalUser4
+
+// Addr is an IP address.
+// It has either len == 4 (if it is IPv4) or len == 16 (IPv6).
+type Addr string
+
+// TODO(crawshaw): consider cleaning up these interfaces by migrating to
+// an address type that captures everything:
+//
+// type Address struct {
+// Addr [16]byte
+// IPv4 bool
+// Port uint16
+// }
+
+const SockaddrLen = c_sockaddr_in6_len
+const SockmsgHdrLen = c_fdio_socket_msg_hdr_len
+const SockaddrReplyLen = c_mxrio_sockaddr_reply_len
+
+func EncodeSockmsgHdr(dst []byte, addr Addr, port uint16, flags int) (err error) {
+ if len(dst) < SockmsgHdrLen {
+ return errString("mxnet.EncodeSockmsgHdr: dst too short")
+ }
+ var n int
+ if addr != "" || port != 0 {
+ n, err = EncodeSockaddr(dst, addr, port)
+ if err != nil {
+ return err
+ }
+ }
+ hdr := (*c_fdio_socket_msg_hdr)(unsafe.Pointer(&dst[0]))
+ hdr.addrlen = c_socklen(n)
+ hdr.flags = int32(flags)
+ return nil
+}
+
+func DecodeSockmsgHdr(src []byte) (addr Addr, port uint16, flags int, err error) {
+ if len(src) < SockmsgHdrLen {
+ return "", 0, 0, errString("mxnet.DecodeSockmsgHdr: src too short")
+ }
+ addr, port, err = DecodeSockaddr(src)
+ if err != nil {
+ return "", 0, 0, err
+ }
+ hdr := (*c_fdio_socket_msg_hdr)(unsafe.Pointer(&src[0]))
+ flags = int(hdr.flags)
+ return addr, port, flags, nil
+}
+
+func DecodeSockaddr(data []byte) (addr Addr, port uint16, err error) {
+ if len(data) < 2 {
+ return "", 0, errString("mxnet:DecodeSockaddr: data too short")
+ }
+ family := uint16(data[0]) | uint16(data[1])<<8
+ switch family {
+ case AF_INET:
+ if len(data) < int(unsafe.Sizeof(c_sockaddr_in{})) {
+ return "", 0, errString("mxnet:DecodeSockaddr: data too short for ipv4")
+ }
+ v := (*c_sockaddr_in)(unsafe.Pointer(&data[0]))
+ port = uint16(data[3]) | uint16(data[2])<<8
+ if !isZeros(v.sin_addr[:]) {
+ addr = Addr(v.sin_addr[:])
+ }
+ return addr, port, nil
+ case AF_INET6:
+ if len(data) < int(unsafe.Sizeof(c_sockaddr_in6{})) {
+ return "", 0, errString("mxnet:DecodeSockaddr: data too short for ipv6")
+ }
+ v := (*c_sockaddr_in6)(unsafe.Pointer(&data[0]))
+ port = uint16(data[3]) | uint16(data[2])<<8
+ if !isZeros(v.sin6_addr[:]) {
+ addr = Addr(v.sin6_addr[:])
+ }
+ return addr, port, nil
+ default:
+ return "", 0, errString("mxnet:DecodeSockaddr: unknown family")
+ }
+}
+
+func EncodeSockaddr(dst []byte, addr Addr, port uint16) (int, error) {
+ switch len(addr) {
+ case 0, 4:
+ if len(dst) < c_sockaddr_in_len {
+ return 0, errString("mxnet: dst too small for c_sockaddr_in")
+ }
+ sockaddr := c_sockaddr_in{sin_family: AF_INET}
+ sockaddr.sin_port.setPort(port)
+ copy(sockaddr.sin_addr[:], addr)
+ srcb := (*[unsafe.Sizeof(sockaddr)]byte)(unsafe.Pointer(&sockaddr))[:]
+ return copy(dst, srcb), nil
+ case 16:
+ if len(dst) < c_sockaddr_in_len {
+ return 0, errString("mxnet: dst too small for c_sockaddr_in6")
+ }
+ sockaddr := c_sockaddr_in6{sin6_family: AF_INET6}
+ sockaddr.sin6_port.setPort(port)
+ copy(sockaddr.sin6_addr[:], addr)
+ srcb := (*[unsafe.Sizeof(sockaddr)]byte)(unsafe.Pointer(&sockaddr))[:]
+ return copy(dst, srcb), nil
+ default:
+ return 0, errString("mxnet: bad address length")
+ }
+}
+
+type errString string
+
+func (err errString) Error() string { return string(err) }
+
+const (
+ c_sockaddr_in_len = int(unsafe.Sizeof(c_sockaddr_in{}))
+ c_sockaddr_in6_len = int(unsafe.Sizeof(c_sockaddr_in6{}))
+ c_fdio_socket_msg_hdr_len = int(unsafe.Sizeof(c_fdio_socket_msg_hdr{}))
+ c_mxrio_sockaddr_reply_len = int(unsafe.Sizeof(c_mxrio_sockaddr_reply{}))
+)
+
+func (v c_in_port) port() uint16 {
+ return uint16(v[0])<<8 | uint16(v[1])
+}
+
+func (v *c_in_port) setPort(port uint16) {
+ v[0] = uint8(port >> 8)
+ v[1] = uint8(port)
+}
+
+func isZeros(buf []byte) bool {
+ for i := 0; i < len(buf); i++ {
+ if buf[i] != 0 {
+ return false
+ }
+ }
+ return true
+}
diff --git a/src/syscall/zx/mxruntime/mxruntime.go b/src/syscall/zx/mxruntime/mxruntime.go
new file mode 100644
index 0000000..39d3a4b
--- /dev/null
+++ b/src/syscall/zx/mxruntime/mxruntime.go
@@ -0,0 +1,29 @@
+// Copyright 2016 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// +build fuchsia
+
+// Package mxruntime provides access to FDIO process state.
+package mxruntime
+
+// TODO: move process handle globals from mx into mxruntime.
+
+import "syscall/zx"
+
+type HandleType uint16
+
+const (
+ HandleUser0 HandleType = 0xF0
+ HandleUser1 HandleType = 0xF1
+ HandleUser2 HandleType = 0xF2
+)
+
+type HandleInfo struct {
+ Type HandleType
+ Arg uint16
+}
+
+func GetStartupHandle(info HandleInfo) zx.Handle {
+ return getStartupHandle(info)
+}
diff --git a/src/syscall/zx/mxruntime/mxruntime_cgo.go b/src/syscall/zx/mxruntime/mxruntime_cgo.go
new file mode 100644
index 0000000..af77ab1
--- /dev/null
+++ b/src/syscall/zx/mxruntime/mxruntime_cgo.go
@@ -0,0 +1,18 @@
+// Copyright 2016 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// +build fuchsia
+
+package mxruntime
+
+import "syscall/zx"
+
+// #include "zircon/process.h"
+import "C"
+
+func getStartupHandle(info HandleInfo) zx.Handle {
+ id := uint32(info.Arg)<<16 | uint32(info.Type)
+ h := C.zx_take_startup_handle(C.uint32_t(id))
+ return zx.Handle(h)
+}
diff --git a/src/syscall/zx/mxruntime/mxruntime_stubs.go b/src/syscall/zx/mxruntime/mxruntime_stubs.go
new file mode 100644
index 0000000..3edf16d
--- /dev/null
+++ b/src/syscall/zx/mxruntime/mxruntime_stubs.go
@@ -0,0 +1,12 @@
+// Copyright 2016 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// +build fuchsia
+// +build !cgo
+
+package mxruntime
+
+func getStartupHandle(info HandleInfo) zx.Handle {
+ panic("mxruntime.GetStartupHandle not implemented")
+}
diff --git a/src/syscall/zx/net/impl.go b/src/syscall/zx/net/impl.go
new file mode 100644
index 0000000..0934a9b
--- /dev/null
+++ b/src/syscall/zx/net/impl.go
@@ -0,0 +1,447 @@
+// Copyright 2018 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.
+//
+// WARNING: This file is machine generated by fidlgen.
+
+// +build fuchsia
+
+package net
+
+import (
+ _bindings "syscall/zx/fidl"
+ _zx "syscall/zx"
+)
+
+const (
+)
+
+type SocketDomain uint32
+const (
+ SocketDomainInet SocketDomain = 2
+ SocketDomainInet6 SocketDomain = 10
+)
+type SocketType uint32
+const (
+ SocketTypeStream SocketType = 1
+ SocketTypeDgram SocketType = 2
+)
+type SocketProtocol uint32
+const (
+ SocketProtocolIp SocketProtocol = 0
+ SocketProtocolIcmp SocketProtocol = 1
+ SocketProtocolTcp SocketProtocol = 6
+ SocketProtocolUdp SocketProtocol = 17
+ SocketProtocolIpv6 SocketProtocol = 41
+ SocketProtocolIcmpv6 SocketProtocol = 58
+)
+type AddrInfoStatus uint32
+const (
+ AddrInfoStatusOk AddrInfoStatus = 0
+ AddrInfoStatusBadFlags AddrInfoStatus = 1
+ AddrInfoStatusNoName AddrInfoStatus = 2
+ AddrInfoStatusAgain AddrInfoStatus = 3
+ AddrInfoStatusFail AddrInfoStatus = 4
+ AddrInfoStatusNoData AddrInfoStatus = 5
+ AddrInfoStatusBufferOverflow AddrInfoStatus = 6
+ AddrInfoStatusSystemError AddrInfoStatus = 7
+)
+type IPv4Address struct {
+ Addr [4]uint8
+}
+
+// Implements Payload.
+func (_ *IPv4Address) InlineAlignment() int {
+ return 1
+}
+
+// Implements Payload.
+func (_ *IPv4Address) InlineSize() int {
+ return 4
+}
+type IPv6Address struct {
+ Addr [16]uint8
+}
+
+// Implements Payload.
+func (_ *IPv6Address) InlineAlignment() int {
+ return 1
+}
+
+// Implements Payload.
+func (_ *IPv6Address) InlineSize() int {
+ return 16
+}
+type Subnet struct {
+ Addr IpAddress
+ PrefixLen uint8
+}
+
+// Implements Payload.
+func (_ *Subnet) InlineAlignment() int {
+ return 4
+}
+
+// Implements Payload.
+func (_ *Subnet) InlineSize() int {
+ return 24
+}
+type MacAddress struct {
+ Addr [6]uint8
+}
+
+// Implements Payload.
+func (_ *MacAddress) InlineAlignment() int {
+ return 1
+}
+
+// Implements Payload.
+func (_ *MacAddress) InlineSize() int {
+ return 6
+}
+type String struct {
+ Val [256]uint8
+ Len uint32
+}
+
+// Implements Payload.
+func (_ *String) InlineAlignment() int {
+ return 4
+}
+
+// Implements Payload.
+func (_ *String) InlineSize() int {
+ return 260
+}
+type AddrInfoHints struct {
+ Flags int32
+ Family int32
+ SockType int32
+ Protocol int32
+}
+
+// Implements Payload.
+func (_ *AddrInfoHints) InlineAlignment() int {
+ return 4
+}
+
+// Implements Payload.
+func (_ *AddrInfoHints) InlineSize() int {
+ return 16
+}
+type AddrStorage struct {
+ Val [16]uint8
+ Len uint32
+}
+
+// Implements Payload.
+func (_ *AddrStorage) InlineAlignment() int {
+ return 4
+}
+
+// Implements Payload.
+func (_ *AddrStorage) InlineSize() int {
+ return 20
+}
+type AddrInfo struct {
+ Flags int32
+ Family int32
+ SockType int32
+ Protocol int32
+ IpAddr AddrStorage
+ Port uint16
+}
+
+// Implements Payload.
+func (_ *AddrInfo) InlineAlignment() int {
+ return 4
+}
+
+// Implements Payload.
+func (_ *AddrInfo) InlineSize() int {
+ return 40
+}
+type IpAddressTag uint32
+const (
+ IpAddressIpv4 IpAddressTag = iota
+ IpAddressIpv6 IpAddressTag = iota
+)
+
+// IpAddress is a FIDL union.
+type IpAddress struct {
+ IpAddressTag `fidl:"tag"`
+ Ipv4 IPv4Address
+ Ipv6 IPv6Address
+}
+
+// Implements Payload.
+func (_ *IpAddress) InlineAlignment() int {
+ return 4
+}
+
+// Implements Payload.
+func (_ *IpAddress) InlineSize() int {
+ return 20
+}
+
+func (u *IpAddress) Which() IpAddressTag {
+ return u.IpAddressTag
+}
+
+func (u *IpAddress) SetIpv4(ipv4 IPv4Address) {
+ u.IpAddressTag = IpAddressIpv4
+ u.Ipv4 = ipv4
+}
+
+func (u *IpAddress) SetIpv6(ipv6 IPv6Address) {
+ u.IpAddressTag = IpAddressIpv6
+ u.Ipv6 = ipv6
+}
+const (
+ ConnectivityOnNetworkReachableOrdinal uint32 = 1
+)
+// Request for OnNetworkReachable.
+// OnNetworkReachable has no request.
+// Response for OnNetworkReachable.
+type ConnectivityOnNetworkReachableResponse struct {
+ Reachable bool
+}
+
+// Implements Payload.
+func (_ *ConnectivityOnNetworkReachableResponse) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *ConnectivityOnNetworkReachableResponse) InlineSize() int {
+ return 4
+}
+
+type ConnectivityInterface _bindings.Proxy
+
+func (p *ConnectivityInterface) ExpectOnNetworkReachable() (bool, error) {
+ resp_ := ConnectivityOnNetworkReachableResponse{}
+ err := ((*_bindings.Proxy)(p)).Recv(ConnectivityOnNetworkReachableOrdinal, &resp_)
+ return resp_.Reachable, err
+}
+
+// Connectivity server interface.
+type Connectivity interface {
+}
+
+type ConnectivityInterfaceRequest _bindings.InterfaceRequest
+
+func NewConnectivityInterfaceRequest() (ConnectivityInterfaceRequest, *ConnectivityInterface, error) {
+ req, cli, err := _bindings.NewInterfaceRequest()
+ return ConnectivityInterfaceRequest(req), (*ConnectivityInterface)(cli), err
+}
+// Implements ServiceRequest.
+func (_ ConnectivityInterfaceRequest) Name() string {
+ return "fuchsia.net.Connectivity"
+}
+func (c ConnectivityInterfaceRequest) ToChannel() _zx.Channel {
+ return c.Channel
+}
+
+const ConnectivityName = "fuchsia.net.Connectivity"
+
+type ConnectivityStub struct {
+ Impl Connectivity
+}
+
+func (s *ConnectivityStub) Dispatch(ord uint32, b_ []byte, h_ []_zx.Handle) (_bindings.Payload, error) {
+ switch ord {
+ }
+ return nil, _bindings.ErrUnknownOrdinal
+}
+
+type ConnectivityService struct {
+ _bindings.BindingSet
+}
+
+func (s *ConnectivityService) Add(impl Connectivity, c _zx.Channel, onError func(error)) (_bindings.BindingKey, error) {
+ return s.BindingSet.Add(&ConnectivityStub{Impl: impl}, c, onError)
+}
+
+func (s *ConnectivityService) EventProxyFor(key _bindings.BindingKey) (*ConnectivityEventProxy, bool) {
+ pxy, err := s.BindingSet.ProxyFor(key)
+ return (*ConnectivityEventProxy)(pxy), err
+}
+
+type ConnectivityEventProxy _bindings.Proxy
+
+func (p *ConnectivityEventProxy) OnNetworkReachable(reachable bool) error {
+ event_ := ConnectivityOnNetworkReachableResponse{
+ Reachable: reachable,
+ }
+ return ((*_bindings.Proxy)(p)).Send(ConnectivityOnNetworkReachableOrdinal, &event_)
+}
+
+
+const (
+ LegacySocketProviderOpenSocketOrdinal uint32 = 1
+ LegacySocketProviderGetAddrInfoOrdinal uint32 = 2
+)
+// Request for OpenSocket.
+type LegacySocketProviderOpenSocketRequest struct {
+ Domain SocketDomain
+ Type SocketType
+ Protocol SocketProtocol
+}
+
+// Implements Payload.
+func (_ *LegacySocketProviderOpenSocketRequest) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *LegacySocketProviderOpenSocketRequest) InlineSize() int {
+ return 12
+}
+// Response for OpenSocket.
+type LegacySocketProviderOpenSocketResponse struct {
+ S _zx.Socket
+ Status int32
+}
+
+// Implements Payload.
+func (_ *LegacySocketProviderOpenSocketResponse) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *LegacySocketProviderOpenSocketResponse) InlineSize() int {
+ return 8
+}
+// Request for GetAddrInfo.
+type LegacySocketProviderGetAddrInfoRequest struct {
+ Node *String
+ Service *String
+ Hints *AddrInfoHints
+}
+
+// Implements Payload.
+func (_ *LegacySocketProviderGetAddrInfoRequest) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *LegacySocketProviderGetAddrInfoRequest) InlineSize() int {
+ return 24
+}
+// Response for GetAddrInfo.
+type LegacySocketProviderGetAddrInfoResponse struct {
+ Status AddrInfoStatus
+ Nres int32
+ Ai0 *AddrInfo
+ Ai1 *AddrInfo
+ Ai2 *AddrInfo
+ Ai3 *AddrInfo
+}
+
+// Implements Payload.
+func (_ *LegacySocketProviderGetAddrInfoResponse) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *LegacySocketProviderGetAddrInfoResponse) InlineSize() int {
+ return 40
+}
+
+type LegacySocketProviderInterface _bindings.Proxy
+
+func (p *LegacySocketProviderInterface) OpenSocket(domain SocketDomain,type_ SocketType,protocol SocketProtocol) (_zx.Socket, int32, error) {
+ req_ := LegacySocketProviderOpenSocketRequest{
+ Domain: domain,
+ Type: type_,
+ Protocol: protocol,
+ }
+ resp_ := LegacySocketProviderOpenSocketResponse{}
+ err := ((*_bindings.Proxy)(p)).Call(LegacySocketProviderOpenSocketOrdinal, &req_, &resp_)
+ return resp_.S, resp_.Status, err
+}
+func (p *LegacySocketProviderInterface) GetAddrInfo(node *String,service *String,hints *AddrInfoHints) (AddrInfoStatus, int32, *AddrInfo, *AddrInfo, *AddrInfo, *AddrInfo, error) {
+ req_ := LegacySocketProviderGetAddrInfoRequest{
+ Node: node,
+ Service: service,
+ Hints: hints,
+ }
+ resp_ := LegacySocketProviderGetAddrInfoResponse{}
+ err := ((*_bindings.Proxy)(p)).Call(LegacySocketProviderGetAddrInfoOrdinal, &req_, &resp_)
+ return resp_.Status, resp_.Nres, resp_.Ai0, resp_.Ai1, resp_.Ai2, resp_.Ai3, err
+}
+
+// LegacySocketProvider server interface.
+type LegacySocketProvider interface {
+ OpenSocket(domain SocketDomain,type_ SocketType,protocol SocketProtocol) (_zx.Socket, int32, error)
+ GetAddrInfo(node *String,service *String,hints *AddrInfoHints) (AddrInfoStatus, int32, *AddrInfo, *AddrInfo, *AddrInfo, *AddrInfo, error)
+}
+
+type LegacySocketProviderInterfaceRequest _bindings.InterfaceRequest
+
+func NewLegacySocketProviderInterfaceRequest() (LegacySocketProviderInterfaceRequest, *LegacySocketProviderInterface, error) {
+ req, cli, err := _bindings.NewInterfaceRequest()
+ return LegacySocketProviderInterfaceRequest(req), (*LegacySocketProviderInterface)(cli), err
+}
+// Implements ServiceRequest.
+func (_ LegacySocketProviderInterfaceRequest) Name() string {
+ return "fuchsia.net.LegacySocketProvider"
+}
+func (c LegacySocketProviderInterfaceRequest) ToChannel() _zx.Channel {
+ return c.Channel
+}
+
+const LegacySocketProviderName = "fuchsia.net.LegacySocketProvider"
+
+type LegacySocketProviderStub struct {
+ Impl LegacySocketProvider
+}
+
+func (s *LegacySocketProviderStub) Dispatch(ord uint32, b_ []byte, h_ []_zx.Handle) (_bindings.Payload, error) {
+ switch ord {
+ case LegacySocketProviderOpenSocketOrdinal:
+ in_ := LegacySocketProviderOpenSocketRequest{}
+ if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
+ return nil, err_
+ }
+ out_ := LegacySocketProviderOpenSocketResponse{}
+ s, status, err_ := s.Impl.OpenSocket(in_.Domain,in_.Type,in_.Protocol)
+ out_.S = s
+ out_.Status = status
+ return &out_, err_
+ case LegacySocketProviderGetAddrInfoOrdinal:
+ in_ := LegacySocketProviderGetAddrInfoRequest{}
+ if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
+ return nil, err_
+ }
+ out_ := LegacySocketProviderGetAddrInfoResponse{}
+ status, nres, ai0, ai1, ai2, ai3, err_ := s.Impl.GetAddrInfo(in_.Node,in_.Service,in_.Hints)
+ out_.Status = status
+ out_.Nres = nres
+ out_.Ai0 = ai0
+ out_.Ai1 = ai1
+ out_.Ai2 = ai2
+ out_.Ai3 = ai3
+ return &out_, err_
+ }
+ return nil, _bindings.ErrUnknownOrdinal
+}
+
+type LegacySocketProviderService struct {
+ _bindings.BindingSet
+}
+
+func (s *LegacySocketProviderService) Add(impl LegacySocketProvider, c _zx.Channel, onError func(error)) (_bindings.BindingKey, error) {
+ return s.BindingSet.Add(&LegacySocketProviderStub{Impl: impl}, c, onError)
+}
+
+func (s *LegacySocketProviderService) EventProxyFor(key _bindings.BindingKey) (*LegacySocketProviderEventProxy, bool) {
+ pxy, err := s.BindingSet.ProxyFor(key)
+ return (*LegacySocketProviderEventProxy)(pxy), err
+}
+
+type LegacySocketProviderEventProxy _bindings.Proxy
+
+
+
diff --git a/src/syscall/zx/syscalls_fuchsia.go b/src/syscall/zx/syscalls_fuchsia.go
new file mode 100644
index 0000000..7eaa63e
--- /dev/null
+++ b/src/syscall/zx/syscalls_fuchsia.go
@@ -0,0 +1,939 @@
+// Copyright 2018 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.
+
+// Zircon system calls for the Fuchsia OS.
+// Generated by mkfuchsia.go, do not edit.
+
+package zx
+
+import "unsafe"
+
+//go:cgo_import_dynamic vdso_zx_clock_get zx_clock_get "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_clock_get_new zx_clock_get_new "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_clock_get_monotonic zx_clock_get_monotonic "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_nanosleep zx_nanosleep "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_ticks_get zx_ticks_get "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_ticks_per_second zx_ticks_per_second "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_deadline_after zx_deadline_after "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_clock_adjust zx_clock_adjust "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_system_get_dcache_line_size zx_system_get_dcache_line_size "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_system_get_num_cpus zx_system_get_num_cpus "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_system_get_version zx_system_get_version "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_system_get_physmem zx_system_get_physmem "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_system_get_features zx_system_get_features "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_cache_flush zx_cache_flush "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_handle_close zx_handle_close "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_handle_close_many zx_handle_close_many "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_handle_duplicate zx_handle_duplicate "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_handle_replace zx_handle_replace "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_object_wait_one zx_object_wait_one "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_object_wait_many zx_object_wait_many "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_object_wait_async zx_object_wait_async "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_object_signal zx_object_signal "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_object_signal_peer zx_object_signal_peer "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_object_get_property zx_object_get_property "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_object_set_property zx_object_set_property "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_object_set_cookie zx_object_set_cookie "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_object_get_cookie zx_object_get_cookie "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_object_get_info zx_object_get_info "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_object_get_child zx_object_get_child "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_object_set_profile zx_object_set_profile "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_channel_create zx_channel_create "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_channel_read zx_channel_read "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_channel_read_etc zx_channel_read_etc "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_channel_write zx_channel_write "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_channel_call_noretry zx_channel_call_noretry "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_channel_call_finish zx_channel_call_finish "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_channel_call zx_channel_call "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_socket_create zx_socket_create "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_socket_write zx_socket_write "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_socket_read zx_socket_read "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_socket_share zx_socket_share "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_socket_accept zx_socket_accept "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_thread_exit zx_thread_exit "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_thread_create zx_thread_create "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_thread_start zx_thread_start "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_thread_read_state zx_thread_read_state "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_thread_write_state zx_thread_write_state "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_thread_set_priority zx_thread_set_priority "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_process_exit zx_process_exit "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_process_create zx_process_create "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_process_start zx_process_start "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_process_read_memory zx_process_read_memory "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_process_write_memory zx_process_write_memory "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_job_create zx_job_create "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_job_set_policy zx_job_set_policy "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_task_bind_exception_port zx_task_bind_exception_port "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_task_resume zx_task_resume "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_task_suspend zx_task_suspend "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_task_suspend_token zx_task_suspend_token "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_task_resume_from_exception zx_task_resume_from_exception "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_task_kill zx_task_kill "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_event_create zx_event_create "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_eventpair_create zx_eventpair_create "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_futex_wait zx_futex_wait "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_futex_wake zx_futex_wake "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_futex_requeue zx_futex_requeue "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_port_create zx_port_create "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_port_queue zx_port_queue "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_port_wait zx_port_wait "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_port_cancel zx_port_cancel "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_timer_create zx_timer_create "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_timer_set zx_timer_set "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_timer_cancel zx_timer_cancel "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_vmo_create zx_vmo_create "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_vmo_read zx_vmo_read "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_vmo_write zx_vmo_write "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_vmo_get_size zx_vmo_get_size "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_vmo_set_size zx_vmo_set_size "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_vmo_op_range zx_vmo_op_range "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_vmo_clone zx_vmo_clone "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_vmo_set_cache_policy zx_vmo_set_cache_policy "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_vmar_allocate_old zx_vmar_allocate_old "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_vmar_map_old zx_vmar_map_old "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_vmar_protect_old zx_vmar_protect_old "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_vmar_allocate zx_vmar_allocate "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_vmar_destroy zx_vmar_destroy "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_vmar_map zx_vmar_map "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_vmar_unmap zx_vmar_unmap "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_vmar_protect zx_vmar_protect "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_cprng_draw_once zx_cprng_draw_once "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_cprng_draw zx_cprng_draw "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_cprng_draw_new zx_cprng_draw_new "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_cprng_add_entropy zx_cprng_add_entropy "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_fifo_create zx_fifo_create "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_fifo_read zx_fifo_read "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_fifo_write zx_fifo_write "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_profile_create zx_profile_create "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_vmar_unmap_handle_close_thread_exit zx_vmar_unmap_handle_close_thread_exit "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_futex_wake_handle_close_thread_exit zx_futex_wake_handle_close_thread_exit "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_log_write zx_log_write "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_log_read zx_log_read "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_debuglog_create zx_debuglog_create "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_debuglog_write zx_debuglog_write "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_debuglog_read zx_debuglog_read "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_ktrace_read zx_ktrace_read "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_ktrace_control zx_ktrace_control "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_ktrace_write zx_ktrace_write "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_mtrace_control zx_mtrace_control "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_debug_read zx_debug_read "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_debug_write zx_debug_write "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_debug_send_command zx_debug_send_command "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_interrupt_create zx_interrupt_create "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_interrupt_bind zx_interrupt_bind "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_interrupt_wait zx_interrupt_wait "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_interrupt_destroy zx_interrupt_destroy "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_interrupt_ack zx_interrupt_ack "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_interrupt_trigger zx_interrupt_trigger "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_ioports_request zx_ioports_request "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_vmo_create_contiguous zx_vmo_create_contiguous "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_vmo_create_physical zx_vmo_create_physical "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_iommu_create zx_iommu_create "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_bti_create zx_bti_create "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_bti_pin zx_bti_pin "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_bti_release_quarantine zx_bti_release_quarantine "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_pmt_unpin zx_pmt_unpin "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_framebuffer_get_info zx_framebuffer_get_info "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_framebuffer_set_range zx_framebuffer_set_range "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_pc_firmware_tables zx_pc_firmware_tables "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_smc_call zx_smc_call "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_resource_create zx_resource_create "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_system_mexec zx_system_mexec "libzircon.so"
+//go:cgo_import_dynamic vdso_zx_system_powerctl zx_system_powerctl "libzircon.so"
+
+//go:linkname vdso_zx_clock_get vdso_zx_clock_get
+//go:linkname vdso_zx_clock_get_new vdso_zx_clock_get_new
+//go:linkname vdso_zx_clock_get_monotonic vdso_zx_clock_get_monotonic
+//go:linkname vdso_zx_nanosleep vdso_zx_nanosleep
+//go:linkname vdso_zx_ticks_get vdso_zx_ticks_get
+//go:linkname vdso_zx_ticks_per_second vdso_zx_ticks_per_second
+//go:linkname vdso_zx_deadline_after vdso_zx_deadline_after
+//go:linkname vdso_zx_clock_adjust vdso_zx_clock_adjust
+//go:linkname vdso_zx_system_get_dcache_line_size vdso_zx_system_get_dcache_line_size
+//go:linkname vdso_zx_system_get_num_cpus vdso_zx_system_get_num_cpus
+//go:linkname vdso_zx_system_get_version vdso_zx_system_get_version
+//go:linkname vdso_zx_system_get_physmem vdso_zx_system_get_physmem
+//go:linkname vdso_zx_system_get_features vdso_zx_system_get_features
+//go:linkname vdso_zx_cache_flush vdso_zx_cache_flush
+//go:linkname vdso_zx_handle_close vdso_zx_handle_close
+//go:linkname vdso_zx_handle_close_many vdso_zx_handle_close_many
+//go:linkname vdso_zx_handle_duplicate vdso_zx_handle_duplicate
+//go:linkname vdso_zx_handle_replace vdso_zx_handle_replace
+//go:linkname vdso_zx_object_wait_one vdso_zx_object_wait_one
+//go:linkname vdso_zx_object_wait_many vdso_zx_object_wait_many
+//go:linkname vdso_zx_object_wait_async vdso_zx_object_wait_async
+//go:linkname vdso_zx_object_signal vdso_zx_object_signal
+//go:linkname vdso_zx_object_signal_peer vdso_zx_object_signal_peer
+//go:linkname vdso_zx_object_get_property vdso_zx_object_get_property
+//go:linkname vdso_zx_object_set_property vdso_zx_object_set_property
+//go:linkname vdso_zx_object_set_cookie vdso_zx_object_set_cookie
+//go:linkname vdso_zx_object_get_cookie vdso_zx_object_get_cookie
+//go:linkname vdso_zx_object_get_info vdso_zx_object_get_info
+//go:linkname vdso_zx_object_get_child vdso_zx_object_get_child
+//go:linkname vdso_zx_object_set_profile vdso_zx_object_set_profile
+//go:linkname vdso_zx_channel_create vdso_zx_channel_create
+//go:linkname vdso_zx_channel_read vdso_zx_channel_read
+//go:linkname vdso_zx_channel_read_etc vdso_zx_channel_read_etc
+//go:linkname vdso_zx_channel_write vdso_zx_channel_write
+//go:linkname vdso_zx_channel_call_noretry vdso_zx_channel_call_noretry
+//go:linkname vdso_zx_channel_call_finish vdso_zx_channel_call_finish
+//go:linkname vdso_zx_channel_call vdso_zx_channel_call
+//go:linkname vdso_zx_socket_create vdso_zx_socket_create
+//go:linkname vdso_zx_socket_write vdso_zx_socket_write
+//go:linkname vdso_zx_socket_read vdso_zx_socket_read
+//go:linkname vdso_zx_socket_share vdso_zx_socket_share
+//go:linkname vdso_zx_socket_accept vdso_zx_socket_accept
+//go:linkname vdso_zx_thread_exit vdso_zx_thread_exit
+//go:linkname vdso_zx_thread_create vdso_zx_thread_create
+//go:linkname vdso_zx_thread_start vdso_zx_thread_start
+//go:linkname vdso_zx_thread_read_state vdso_zx_thread_read_state
+//go:linkname vdso_zx_thread_write_state vdso_zx_thread_write_state
+//go:linkname vdso_zx_thread_set_priority vdso_zx_thread_set_priority
+//go:linkname vdso_zx_process_exit vdso_zx_process_exit
+//go:linkname vdso_zx_process_create vdso_zx_process_create
+//go:linkname vdso_zx_process_start vdso_zx_process_start
+//go:linkname vdso_zx_process_read_memory vdso_zx_process_read_memory
+//go:linkname vdso_zx_process_write_memory vdso_zx_process_write_memory
+//go:linkname vdso_zx_job_create vdso_zx_job_create
+//go:linkname vdso_zx_job_set_policy vdso_zx_job_set_policy
+//go:linkname vdso_zx_task_bind_exception_port vdso_zx_task_bind_exception_port
+//go:linkname vdso_zx_task_resume vdso_zx_task_resume
+//go:linkname vdso_zx_task_suspend vdso_zx_task_suspend
+//go:linkname vdso_zx_task_suspend_token vdso_zx_task_suspend_token
+//go:linkname vdso_zx_task_resume_from_exception vdso_zx_task_resume_from_exception
+//go:linkname vdso_zx_task_kill vdso_zx_task_kill
+//go:linkname vdso_zx_event_create vdso_zx_event_create
+//go:linkname vdso_zx_eventpair_create vdso_zx_eventpair_create
+//go:linkname vdso_zx_futex_wait vdso_zx_futex_wait
+//go:linkname vdso_zx_futex_wake vdso_zx_futex_wake
+//go:linkname vdso_zx_futex_requeue vdso_zx_futex_requeue
+//go:linkname vdso_zx_port_create vdso_zx_port_create
+//go:linkname vdso_zx_port_queue vdso_zx_port_queue
+//go:linkname vdso_zx_port_wait vdso_zx_port_wait
+//go:linkname vdso_zx_port_cancel vdso_zx_port_cancel
+//go:linkname vdso_zx_timer_create vdso_zx_timer_create
+//go:linkname vdso_zx_timer_set vdso_zx_timer_set
+//go:linkname vdso_zx_timer_cancel vdso_zx_timer_cancel
+//go:linkname vdso_zx_vmo_create vdso_zx_vmo_create
+//go:linkname vdso_zx_vmo_read vdso_zx_vmo_read
+//go:linkname vdso_zx_vmo_write vdso_zx_vmo_write
+//go:linkname vdso_zx_vmo_get_size vdso_zx_vmo_get_size
+//go:linkname vdso_zx_vmo_set_size vdso_zx_vmo_set_size
+//go:linkname vdso_zx_vmo_op_range vdso_zx_vmo_op_range
+//go:linkname vdso_zx_vmo_clone vdso_zx_vmo_clone
+//go:linkname vdso_zx_vmo_set_cache_policy vdso_zx_vmo_set_cache_policy
+//go:linkname vdso_zx_vmar_allocate_old vdso_zx_vmar_allocate_old
+//go:linkname vdso_zx_vmar_map_old vdso_zx_vmar_map_old
+//go:linkname vdso_zx_vmar_protect_old vdso_zx_vmar_protect_old
+//go:linkname vdso_zx_vmar_allocate vdso_zx_vmar_allocate
+//go:linkname vdso_zx_vmar_destroy vdso_zx_vmar_destroy
+//go:linkname vdso_zx_vmar_map vdso_zx_vmar_map
+//go:linkname vdso_zx_vmar_unmap vdso_zx_vmar_unmap
+//go:linkname vdso_zx_vmar_protect vdso_zx_vmar_protect
+//go:linkname vdso_zx_cprng_draw_once vdso_zx_cprng_draw_once
+//go:linkname vdso_zx_cprng_draw vdso_zx_cprng_draw
+//go:linkname vdso_zx_cprng_draw_new vdso_zx_cprng_draw_new
+//go:linkname vdso_zx_cprng_add_entropy vdso_zx_cprng_add_entropy
+//go:linkname vdso_zx_fifo_create vdso_zx_fifo_create
+//go:linkname vdso_zx_fifo_read vdso_zx_fifo_read
+//go:linkname vdso_zx_fifo_write vdso_zx_fifo_write
+//go:linkname vdso_zx_profile_create vdso_zx_profile_create
+//go:linkname vdso_zx_vmar_unmap_handle_close_thread_exit vdso_zx_vmar_unmap_handle_close_thread_exit
+//go:linkname vdso_zx_futex_wake_handle_close_thread_exit vdso_zx_futex_wake_handle_close_thread_exit
+//go:linkname vdso_zx_log_write vdso_zx_log_write
+//go:linkname vdso_zx_log_read vdso_zx_log_read
+//go:linkname vdso_zx_debuglog_create vdso_zx_debuglog_create
+//go:linkname vdso_zx_debuglog_write vdso_zx_debuglog_write
+//go:linkname vdso_zx_debuglog_read vdso_zx_debuglog_read
+//go:linkname vdso_zx_ktrace_read vdso_zx_ktrace_read
+//go:linkname vdso_zx_ktrace_control vdso_zx_ktrace_control
+//go:linkname vdso_zx_ktrace_write vdso_zx_ktrace_write
+//go:linkname vdso_zx_mtrace_control vdso_zx_mtrace_control
+//go:linkname vdso_zx_debug_read vdso_zx_debug_read
+//go:linkname vdso_zx_debug_write vdso_zx_debug_write
+//go:linkname vdso_zx_debug_send_command vdso_zx_debug_send_command
+//go:linkname vdso_zx_interrupt_create vdso_zx_interrupt_create
+//go:linkname vdso_zx_interrupt_bind vdso_zx_interrupt_bind
+//go:linkname vdso_zx_interrupt_wait vdso_zx_interrupt_wait
+//go:linkname vdso_zx_interrupt_destroy vdso_zx_interrupt_destroy
+//go:linkname vdso_zx_interrupt_ack vdso_zx_interrupt_ack
+//go:linkname vdso_zx_interrupt_trigger vdso_zx_interrupt_trigger
+//go:linkname vdso_zx_ioports_request vdso_zx_ioports_request
+//go:linkname vdso_zx_vmo_create_contiguous vdso_zx_vmo_create_contiguous
+//go:linkname vdso_zx_vmo_create_physical vdso_zx_vmo_create_physical
+//go:linkname vdso_zx_iommu_create vdso_zx_iommu_create
+//go:linkname vdso_zx_bti_create vdso_zx_bti_create
+//go:linkname vdso_zx_bti_pin vdso_zx_bti_pin
+//go:linkname vdso_zx_bti_release_quarantine vdso_zx_bti_release_quarantine
+//go:linkname vdso_zx_pmt_unpin vdso_zx_pmt_unpin
+//go:linkname vdso_zx_framebuffer_get_info vdso_zx_framebuffer_get_info
+//go:linkname vdso_zx_framebuffer_set_range vdso_zx_framebuffer_set_range
+//go:linkname vdso_zx_pc_firmware_tables vdso_zx_pc_firmware_tables
+//go:linkname vdso_zx_smc_call vdso_zx_smc_call
+//go:linkname vdso_zx_resource_create vdso_zx_resource_create
+//go:linkname vdso_zx_system_mexec vdso_zx_system_mexec
+//go:linkname vdso_zx_system_powerctl vdso_zx_system_powerctl
+
+var (
+ vdso_zx_clock_get uintptr
+ vdso_zx_clock_get_new uintptr
+ vdso_zx_clock_get_monotonic uintptr
+ vdso_zx_nanosleep uintptr
+ vdso_zx_ticks_get uintptr
+ vdso_zx_ticks_per_second uintptr
+ vdso_zx_deadline_after uintptr
+ vdso_zx_clock_adjust uintptr
+ vdso_zx_system_get_dcache_line_size uintptr
+ vdso_zx_system_get_num_cpus uintptr
+ vdso_zx_system_get_version uintptr
+ vdso_zx_system_get_physmem uintptr
+ vdso_zx_system_get_features uintptr
+ vdso_zx_cache_flush uintptr
+ vdso_zx_handle_close uintptr
+ vdso_zx_handle_close_many uintptr
+ vdso_zx_handle_duplicate uintptr
+ vdso_zx_handle_replace uintptr
+ vdso_zx_object_wait_one uintptr
+ vdso_zx_object_wait_many uintptr
+ vdso_zx_object_wait_async uintptr
+ vdso_zx_object_signal uintptr
+ vdso_zx_object_signal_peer uintptr
+ vdso_zx_object_get_property uintptr
+ vdso_zx_object_set_property uintptr
+ vdso_zx_object_set_cookie uintptr
+ vdso_zx_object_get_cookie uintptr
+ vdso_zx_object_get_info uintptr
+ vdso_zx_object_get_child uintptr
+ vdso_zx_object_set_profile uintptr
+ vdso_zx_channel_create uintptr
+ vdso_zx_channel_read uintptr
+ vdso_zx_channel_read_etc uintptr
+ vdso_zx_channel_write uintptr
+ vdso_zx_channel_call_noretry uintptr
+ vdso_zx_channel_call_finish uintptr
+ vdso_zx_channel_call uintptr
+ vdso_zx_socket_create uintptr
+ vdso_zx_socket_write uintptr
+ vdso_zx_socket_read uintptr
+ vdso_zx_socket_share uintptr
+ vdso_zx_socket_accept uintptr
+ vdso_zx_thread_exit uintptr
+ vdso_zx_thread_create uintptr
+ vdso_zx_thread_start uintptr
+ vdso_zx_thread_read_state uintptr
+ vdso_zx_thread_write_state uintptr
+ vdso_zx_thread_set_priority uintptr
+ vdso_zx_process_exit uintptr
+ vdso_zx_process_create uintptr
+ vdso_zx_process_start uintptr
+ vdso_zx_process_read_memory uintptr
+ vdso_zx_process_write_memory uintptr
+ vdso_zx_job_create uintptr
+ vdso_zx_job_set_policy uintptr
+ vdso_zx_task_bind_exception_port uintptr
+ vdso_zx_task_resume uintptr
+ vdso_zx_task_suspend uintptr
+ vdso_zx_task_suspend_token uintptr
+ vdso_zx_task_resume_from_exception uintptr
+ vdso_zx_task_kill uintptr
+ vdso_zx_event_create uintptr
+ vdso_zx_eventpair_create uintptr
+ vdso_zx_futex_wait uintptr
+ vdso_zx_futex_wake uintptr
+ vdso_zx_futex_requeue uintptr
+ vdso_zx_port_create uintptr
+ vdso_zx_port_queue uintptr
+ vdso_zx_port_wait uintptr
+ vdso_zx_port_cancel uintptr
+ vdso_zx_timer_create uintptr
+ vdso_zx_timer_set uintptr
+ vdso_zx_timer_cancel uintptr
+ vdso_zx_vmo_create uintptr
+ vdso_zx_vmo_read uintptr
+ vdso_zx_vmo_write uintptr
+ vdso_zx_vmo_get_size uintptr
+ vdso_zx_vmo_set_size uintptr
+ vdso_zx_vmo_op_range uintptr
+ vdso_zx_vmo_clone uintptr
+ vdso_zx_vmo_set_cache_policy uintptr
+ vdso_zx_vmar_allocate_old uintptr
+ vdso_zx_vmar_map_old uintptr
+ vdso_zx_vmar_protect_old uintptr
+ vdso_zx_vmar_allocate uintptr
+ vdso_zx_vmar_destroy uintptr
+ vdso_zx_vmar_map uintptr
+ vdso_zx_vmar_unmap uintptr
+ vdso_zx_vmar_protect uintptr
+ vdso_zx_cprng_draw_once uintptr
+ vdso_zx_cprng_draw uintptr
+ vdso_zx_cprng_draw_new uintptr
+ vdso_zx_cprng_add_entropy uintptr
+ vdso_zx_fifo_create uintptr
+ vdso_zx_fifo_read uintptr
+ vdso_zx_fifo_write uintptr
+ vdso_zx_profile_create uintptr
+ vdso_zx_vmar_unmap_handle_close_thread_exit uintptr
+ vdso_zx_futex_wake_handle_close_thread_exit uintptr
+ vdso_zx_log_write uintptr
+ vdso_zx_log_read uintptr
+ vdso_zx_debuglog_create uintptr
+ vdso_zx_debuglog_write uintptr
+ vdso_zx_debuglog_read uintptr
+ vdso_zx_ktrace_read uintptr
+ vdso_zx_ktrace_control uintptr
+ vdso_zx_ktrace_write uintptr
+ vdso_zx_mtrace_control uintptr
+ vdso_zx_debug_read uintptr
+ vdso_zx_debug_write uintptr
+ vdso_zx_debug_send_command uintptr
+ vdso_zx_interrupt_create uintptr
+ vdso_zx_interrupt_bind uintptr
+ vdso_zx_interrupt_wait uintptr
+ vdso_zx_interrupt_destroy uintptr
+ vdso_zx_interrupt_ack uintptr
+ vdso_zx_interrupt_trigger uintptr
+ vdso_zx_ioports_request uintptr
+ vdso_zx_vmo_create_contiguous uintptr
+ vdso_zx_vmo_create_physical uintptr
+ vdso_zx_iommu_create uintptr
+ vdso_zx_bti_create uintptr
+ vdso_zx_bti_pin uintptr
+ vdso_zx_bti_release_quarantine uintptr
+ vdso_zx_pmt_unpin uintptr
+ vdso_zx_framebuffer_get_info uintptr
+ vdso_zx_framebuffer_set_range uintptr
+ vdso_zx_pc_firmware_tables uintptr
+ vdso_zx_smc_call uintptr
+ vdso_zx_resource_create uintptr
+ vdso_zx_system_mexec uintptr
+ vdso_zx_system_powerctl uintptr
+)
+
+//go:noescape
+//go:nosplit
+func Sys_clock_get(clock_id uint32) Time
+
+//go:noescape
+//go:nosplit
+func Sys_clock_get_new(clock_id uint32, out *Time) Status
+
+//go:noescape
+//go:nosplit
+func Sys_clock_get_monotonic() Time
+
+//go:noescape
+//go:nosplit
+func Sys_nanosleep(deadline Time) Status
+
+//go:noescape
+//go:nosplit
+func Sys_ticks_get() uint64
+
+//go:noescape
+//go:nosplit
+func Sys_ticks_per_second() uint64
+
+//go:noescape
+//go:nosplit
+func Sys_deadline_after(nanoseconds Duration) Time
+
+//go:noescape
+//go:nosplit
+func Sys_clock_adjust(handle Handle, clock_id uint32, offset int64) Status
+
+//go:noescape
+//go:nosplit
+func sys_system_get_dcache_line_size() uint32
+
+//go:noescape
+//go:nosplit
+func Sys_system_get_num_cpus() uint32
+
+//go:noescape
+//go:nosplit
+func Sys_system_get_version(version *uint8, version_size uint) Status
+
+//go:noescape
+//go:nosplit
+func Sys_system_get_physmem() uint64
+
+//go:noescape
+//go:nosplit
+func sys_system_get_features(kind uint32, out *uint32) Status
+
+//go:noescape
+//go:nosplit
+func Sys_cache_flush(addr unsafe.Pointer, size uint, options uint32) Status
+
+//go:noescape
+//go:nosplit
+func Sys_handle_close(handle Handle) Status
+
+//go:noescape
+//go:nosplit
+func Sys_handle_close_many(handles *Handle, num_handles uint) Status
+
+//go:noescape
+//go:nosplit
+func sys_handle_duplicate(handle Handle, rights Rights, out *Handle) Status
+
+//go:noescape
+//go:nosplit
+func Sys_handle_replace(handle Handle, rights Rights, out *Handle) Status
+
+//go:noescape
+//go:nosplit
+func Sys_object_wait_one(handle Handle, signals Signals, deadline Time, observed *Signals) Status
+
+//go:noescape
+//go:nosplit
+func sys_object_wait_many(items *WaitItem, count uint, deadline Time) Status
+
+//go:noescape
+//go:nosplit
+func Sys_object_wait_async(handle Handle, port Handle, key uint64, signals Signals, options uint32) Status
+
+//go:noescape
+//go:nosplit
+func Sys_object_signal(handle Handle, clear_mask uint32, set_mask uint32) Status
+
+//go:noescape
+//go:nosplit
+func Sys_object_signal_peer(handle Handle, clear_mask uint32, set_mask uint32) Status
+
+//go:noescape
+//go:nosplit
+func Sys_object_get_property(handle Handle, property uint32, value unsafe.Pointer, value_size uint) Status
+
+//go:noescape
+//go:nosplit
+func Sys_object_set_property(handle Handle, property uint32, value unsafe.Pointer, value_size uint) Status
+
+//go:noescape
+//go:nosplit
+func Sys_object_set_cookie(handle Handle, scope Handle, cookie uint64) Status
+
+//go:noescape
+//go:nosplit
+func Sys_object_get_cookie(handle Handle, scope Handle, cookie *uint64) Status
+
+//go:noescape
+//go:nosplit
+func Sys_object_get_info(handle Handle, topic uint32, buffer unsafe.Pointer, buffer_size uint, actual_count *uint, avail_count *uint) Status
+
+//go:noescape
+//go:nosplit
+func Sys_object_get_child(handle Handle, koid uint64, rights Rights, out *Handle) Status
+
+//go:noescape
+//go:nosplit
+func sys_object_set_profile(handle Handle, profile Handle, options uint32) Status
+
+//go:noescape
+//go:nosplit
+func sys_channel_create(options uint32, out0 *Handle, out1 *Handle) Status
+
+//go:noescape
+//go:nosplit
+func sys_channel_read(handle Handle, options uint32, bytes unsafe.Pointer, handles *Handle, num_bytes uint32, num_handles uint32, actual_bytes *uint32, actual_handles *uint32) Status
+
+//go:noescape
+//go:nosplit
+func sys_channel_read_etc(handle Handle, options uint32, bytes unsafe.Pointer, handles *int, num_bytes uint32, num_handles uint32, actual_bytes *uint32, actual_handles *uint32) Status
+
+//go:noescape
+//go:nosplit
+func sys_channel_write(handle Handle, options uint32, bytes unsafe.Pointer, num_bytes uint32, handles *Handle, num_handles uint32) Status
+
+//go:noescape
+//go:nosplit
+func Sys_channel_call_noretry(handle Handle, options uint32, deadline Time, args *ChannelCallArgs, actual_bytes *uint32, actual_handles *uint32) Status
+
+//go:noescape
+//go:nosplit
+func Sys_channel_call_finish(deadline Time, args *ChannelCallArgs, actual_bytes *uint32, actual_handles *uint32) Status
+
+//go:noescape
+//go:nosplit
+func Sys_channel_call(handle Handle, options uint32, deadline Time, args *ChannelCallArgs, actual_bytes *uint32, actual_handles *uint32) Status
+
+//go:noescape
+//go:nosplit
+func sys_socket_create(options uint32, out0 *Handle, out1 *Handle) Status
+
+//go:noescape
+//go:nosplit
+func sys_socket_write(handle Handle, options uint32, buffer unsafe.Pointer, buffer_size uint, actual *uint) Status
+
+//go:noescape
+//go:nosplit
+func sys_socket_read(handle Handle, options uint32, buffer unsafe.Pointer, buffer_size uint, actual *uint) Status
+
+//go:noescape
+//go:nosplit
+func sys_socket_share(handle Handle, socket_to_share Handle) Status
+
+//go:noescape
+//go:nosplit
+func sys_socket_accept(handle Handle, out_socket *Handle) Status
+
+//go:noescape
+//go:nosplit
+func Sys_thread_exit()
+
+//go:noescape
+//go:nosplit
+func Sys_thread_create(process Handle, name *uint8, name_size uint, options uint32, out *Handle) Status
+
+//go:noescape
+//go:nosplit
+func Sys_thread_start(handle Handle, thread_entry Vaddr, stack Vaddr, arg1 uintptr, arg2 uintptr) Status
+
+//go:noescape
+//go:nosplit
+func Sys_thread_read_state(handle Handle, kind uint32, buffer unsafe.Pointer, buffer_size uint) Status
+
+//go:noescape
+//go:nosplit
+func Sys_thread_write_state(handle Handle, kind uint32, buffer unsafe.Pointer, buffer_size uint) Status
+
+//go:noescape
+//go:nosplit
+func Sys_thread_set_priority(prio int32) Status
+
+//go:noescape
+//go:nosplit
+func Sys_process_exit(retcode int64)
+
+//go:noescape
+//go:nosplit
+func Sys_process_create(job Handle, name *uint8, name_size uint, options uint32, proc_handle *Handle, vmar_handle *Handle) Status
+
+//go:noescape
+//go:nosplit
+func Sys_process_start(handle Handle, thread Handle, entry Vaddr, stack Vaddr, arg1 Handle, arg2 uintptr) Status
+
+//go:noescape
+//go:nosplit
+func Sys_process_read_memory(proc Handle, vaddr Vaddr, buffer unsafe.Pointer, buffer_size uint, actual *uint) Status
+
+//go:noescape
+//go:nosplit
+func Sys_process_write_memory(proc Handle, vaddr Vaddr, buffer unsafe.Pointer, buffer_size uint, actual *uint) Status
+
+//go:noescape
+//go:nosplit
+func Sys_job_create(parent_job Handle, options uint32, out *Handle) Status
+
+//go:noescape
+//go:nosplit
+func Sys_job_set_policy(job Handle, options uint32, topic uint32, policy unsafe.Pointer, count uint32) Status
+
+//go:noescape
+//go:nosplit
+func Sys_task_bind_exception_port(handle Handle, port Handle, key uint64, options uint32) Status
+
+//go:noescape
+//go:nosplit
+func Sys_task_resume(handle Handle, options uint32) Status
+
+//go:noescape
+//go:nosplit
+func Sys_task_suspend(handle Handle, token *Handle) Status
+
+//go:noescape
+//go:nosplit
+func Sys_task_suspend_token(handle Handle, token *Handle) Status
+
+//go:noescape
+//go:nosplit
+func Sys_task_resume_from_exception(handle Handle, port Handle, options uint32) Status
+
+//go:noescape
+//go:nosplit
+func Sys_task_kill(handle Handle) Status
+
+//go:noescape
+//go:nosplit
+func Sys_event_create(options uint32, out *Handle) Status
+
+//go:noescape
+//go:nosplit
+func Sys_eventpair_create(options uint32, out0 *Handle, out1 *Handle) Status
+
+//go:noescape
+//go:nosplit
+func Sys_futex_wait(value_ptr *int, current_value int32, deadline Time) Status
+
+//go:noescape
+//go:nosplit
+func Sys_futex_wake(value_ptr *int, count uint32) Status
+
+//go:noescape
+//go:nosplit
+func Sys_futex_requeue(wake_ptr *int, wake_count uint32, current_value int32, requeue_ptr *int, requeue_count uint32) Status
+
+//go:noescape
+//go:nosplit
+func Sys_port_create(options uint32, out *Handle) Status
+
+//go:noescape
+//go:nosplit
+func Sys_port_queue(handle Handle, packet *int) Status
+
+//go:noescape
+//go:nosplit
+func Sys_port_wait(handle Handle, deadline Time, packet *int) Status
+
+//go:noescape
+//go:nosplit
+func Sys_port_cancel(handle Handle, source Handle, key uint64) Status
+
+//go:noescape
+//go:nosplit
+func Sys_timer_create(options uint32, clock_id uint32, out *Handle) Status
+
+//go:noescape
+//go:nosplit
+func Sys_timer_set(handle Handle, deadline Time, slack Duration) Status
+
+//go:noescape
+//go:nosplit
+func Sys_timer_cancel(handle Handle) Status
+
+//go:noescape
+//go:nosplit
+func Sys_vmo_create(size uint64, options uint32, out *Handle) Status
+
+//go:noescape
+//go:nosplit
+func sys_vmo_read(handle Handle, buffer unsafe.Pointer, offset uint64, buffer_size uint) Status
+
+//go:noescape
+//go:nosplit
+func sys_vmo_write(handle Handle, buffer unsafe.Pointer, offset uint64, buffer_size uint) Status
+
+//go:noescape
+//go:nosplit
+func sys_vmo_get_size(handle Handle, size *uint64) Status
+
+//go:noescape
+//go:nosplit
+func sys_vmo_set_size(handle Handle, size uint64) Status
+
+//go:noescape
+//go:nosplit
+func sys_vmo_op_range(handle Handle, op uint32, offset uint64, size uint64, buffer unsafe.Pointer, buffer_size uint) Status
+
+//go:noescape
+//go:nosplit
+func Sys_vmo_clone(handle Handle, options uint32, offset uint64, size uint64, out *Handle) Status
+
+//go:noescape
+//go:nosplit
+func Sys_vmo_set_cache_policy(handle Handle, cache_policy uint32) Status
+
+//go:noescape
+//go:nosplit
+func sys_vmar_allocate_old(parent_vmar Handle, offset uint64, size uint64, map_flags uint32, child_vmar *Handle, child_addr *Vaddr) Status
+
+//go:noescape
+//go:nosplit
+func sys_vmar_map_old(handle Handle, vmar_offset uint64, vmo Handle, vmo_offset uint64, len uint64, map_flags uint32, mapped_addr *Vaddr) Status
+
+//go:noescape
+//go:nosplit
+func sys_vmar_protect_old(handle Handle, addr Vaddr, len uint64, prot_flags uint32) Status
+
+//go:noescape
+//go:nosplit
+func sys_vmar_allocate(parent_vmar Handle, offset uint64, size uint64, map_flags uint32, child_vmar *Handle, child_addr *Vaddr) Status
+
+//go:noescape
+//go:nosplit
+func sys_vmar_destroy(handle Handle) Status
+
+//go:noescape
+//go:nosplit
+func Sys_vmar_map(handle Handle, vmar_offset uint64, vmo Handle, vmo_offset uint64, len uint64, map_flags uint32, mapped_addr *Vaddr) Status
+
+//go:noescape
+//go:nosplit
+func Sys_vmar_unmap(handle Handle, addr Vaddr, len uint64) Status
+
+//go:noescape
+//go:nosplit
+func Sys_vmar_protect(handle Handle, addr Vaddr, len uint64, prot_flags uint32) Status
+
+//go:noescape
+//go:nosplit
+func Sys_cprng_draw_once(buffer unsafe.Pointer, buffer_size uint) Status
+
+//go:noescape
+//go:nosplit
+func Sys_cprng_draw(buffer unsafe.Pointer, buffer_size uint)
+
+//go:noescape
+//go:nosplit
+func Sys_cprng_draw_new(buffer unsafe.Pointer, data_size uint) Status
+
+//go:noescape
+//go:nosplit
+func Sys_cprng_add_entropy(buffer unsafe.Pointer, len uint) Status
+
+//go:noescape
+//go:nosplit
+func Sys_fifo_create(elem_count uint, elem_size uint, options uint32, out0 *Handle, out1 *Handle) Status
+
+//go:noescape
+//go:nosplit
+func Sys_fifo_read(handle Handle, elem_size uint, data unsafe.Pointer, count uint, actual_count *uint) Status
+
+//go:noescape
+//go:nosplit
+func Sys_fifo_write(handle Handle, elem_size uint, data unsafe.Pointer, count uint, actual_count *uint) Status
+
+//go:noescape
+//go:nosplit
+func Sys_profile_create(resource Handle, profile *int, out *Handle) Status
+
+//go:noescape
+//go:nosplit
+func Sys_vmar_unmap_handle_close_thread_exit(vmar_handle Handle, addr Vaddr, size uint, handle Handle) Status
+
+//go:noescape
+//go:nosplit
+func Sys_futex_wake_handle_close_thread_exit(value_ptr *int, count uint32, new_value int32, handle Handle)
+
+//go:noescape
+//go:nosplit
+func Sys_log_write(handle Handle, len uint32, buffer unsafe.Pointer, options uint32) Status
+
+//go:noescape
+//go:nosplit
+func Sys_log_read(handle Handle, len uint32, buffer unsafe.Pointer, options uint32) Status
+
+//go:noescape
+//go:nosplit
+func Sys_debuglog_create(resource Handle, options uint32, out *Handle) Status
+
+//go:noescape
+//go:nosplit
+func Sys_debuglog_write(handle Handle, options uint32, buffer unsafe.Pointer, buffer_size uint) Status
+
+//go:noescape
+//go:nosplit
+func Sys_debuglog_read(handle Handle, options uint32, buffer unsafe.Pointer, buffer_size uint) Status
+
+//go:noescape
+//go:nosplit
+func Sys_ktrace_read(handle Handle, data unsafe.Pointer, offset uint32, data_size uint, actual *uint) Status
+
+//go:noescape
+//go:nosplit
+func Sys_ktrace_control(handle Handle, action uint32, options uint32, ptr unsafe.Pointer) Status
+
+//go:noescape
+//go:nosplit
+func Sys_ktrace_write(handle Handle, id uint32, arg0 uint32, arg1 uint32) Status
+
+//go:noescape
+//go:nosplit
+func Sys_mtrace_control(handle Handle, kind uint32, action uint32, options uint32, ptr unsafe.Pointer, ptr_size uint) Status
+
+//go:noescape
+//go:nosplit
+func Sys_debug_read(handle Handle, buffer *uint8, buffer_size *uint) Status
+
+//go:noescape
+//go:nosplit
+func Sys_debug_write(buffer *uint8, buffer_size uint) Status
+
+//go:noescape
+//go:nosplit
+func Sys_debug_send_command(resource Handle, buffer *uint8, buffer_size uint) Status
+
+//go:noescape
+//go:nosplit
+func Sys_interrupt_create(src_obj Handle, src_num uint32, options uint32, out *Handle) Status
+
+//go:noescape
+//go:nosplit
+func Sys_interrupt_bind(handle Handle, port Handle, key uint64, options uint32) Status
+
+//go:noescape
+//go:nosplit
+func Sys_interrupt_wait(handle Handle, out_timestamp *Time) Status
+
+//go:noescape
+//go:nosplit
+func Sys_interrupt_destroy(handle Handle) Status
+
+//go:noescape
+//go:nosplit
+func Sys_interrupt_ack(handle Handle) Status
+
+//go:noescape
+//go:nosplit
+func Sys_interrupt_trigger(handle Handle, options uint32, timestamp Time) Status
+
+//go:noescape
+//go:nosplit
+func Sys_ioports_request(resource Handle, io_addr uint16, len uint32) Status
+
+//go:noescape
+//go:nosplit
+func Sys_vmo_create_contiguous(bti Handle, size uint, alignment_log2 uint32, out *Handle) Status
+
+//go:noescape
+//go:nosplit
+func Sys_vmo_create_physical(resource Handle, paddr Paddr, size uint, out *Handle) Status
+
+//go:noescape
+//go:nosplit
+func Sys_iommu_create(resource Handle, typ uint32, desc unsafe.Pointer, desc_size uint, out *Handle) Status
+
+//go:noescape
+//go:nosplit
+func Sys_bti_create(iommu Handle, options uint32, bti_id uint64, out *Handle) Status
+
+//go:noescape
+//go:nosplit
+func Sys_bti_pin(handle Handle, options uint32, vmo Handle, offset uint64, size uint64, addrs *Paddr, addrs_count uint, out *Handle) Status
+
+//go:noescape
+//go:nosplit
+func Sys_bti_release_quarantine(handle Handle) Status
+
+//go:noescape
+//go:nosplit
+func Sys_pmt_unpin(handle Handle) Status
+
+//go:noescape
+//go:nosplit
+func Sys_framebuffer_get_info(resource Handle, format *uint32, width *uint32, height *uint32, stride *uint32) Status
+
+//go:noescape
+//go:nosplit
+func Sys_framebuffer_set_range(resource Handle, vmo Handle, len uint32, format uint32, width uint32, height uint32, stride uint32) Status
+
+//go:noescape
+//go:nosplit
+func Sys_pc_firmware_tables(handle Handle, acpi_rsdp *Paddr, smbios *Paddr) Status
+
+//go:noescape
+//go:nosplit
+func Sys_smc_call(handle Handle, parameters *SMCParameters, out_smc_result *SMCResult) Status
+
+//go:noescape
+//go:nosplit
+func Sys_resource_create(parent_rsrc Handle, options uint32, base uint64, size uint, name *uint8, name_size uint, resource_out *Handle) Status
+
+//go:noescape
+//go:nosplit
+func Sys_system_mexec(resource Handle, kernel Handle, bootimage Handle) Status
+
+//go:noescape
+//go:nosplit
+func Sys_system_powerctl(resource Handle, cmd uint32, arg *int) Status
diff --git a/src/syscall/zx/syscalls_fuchsia_amd64.s b/src/syscall/zx/syscalls_fuchsia_amd64.s
new file mode 100644
index 0000000..f6477d3
--- /dev/null
+++ b/src/syscall/zx/syscalls_fuchsia_amd64.s
@@ -0,0 +1,1421 @@
+// Copyright 2016 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.
+
+// Zircon system calls for the Fuchsia OS.
+// Generated by mkfuchsia.go, do not edit.
+
+#include "textflag.h"
+
+// func Sys_clock_get(clock_id uint32) Time
+TEXT ·Sys_clock_get(SB),NOSPLIT,$0-16
+ MOVL clock_id+0(FP), DI
+ MOVQ vdso_zx_clock_get(SB), AX
+ CALL AX
+ MOVQ AX, ret+8(FP)
+ RET
+
+// func Sys_clock_get_new(clock_id uint32, out *Time) Status
+TEXT ·Sys_clock_get_new(SB),NOSPLIT,$0-20
+ MOVL clock_id+0(FP), DI
+ MOVQ out+8(FP), SI
+ MOVQ vdso_zx_clock_get_new(SB), AX
+ CALL AX
+ MOVL AX, ret+16(FP)
+ RET
+
+// func Sys_clock_get_monotonic() Time
+TEXT ·Sys_clock_get_monotonic(SB),NOSPLIT,$0-8
+ MOVQ vdso_zx_clock_get_monotonic(SB), AX
+ CALL AX
+ MOVQ AX, ret+0(FP)
+ RET
+
+// func Sys_nanosleep(deadline Time) Status
+TEXT ·Sys_nanosleep(SB),NOSPLIT,$0-12
+ MOVQ deadline+0(FP), DI
+ MOVQ vdso_zx_nanosleep(SB), AX
+ CALL AX
+ MOVL AX, ret+8(FP)
+ RET
+
+// func Sys_ticks_get() uint64
+TEXT ·Sys_ticks_get(SB),NOSPLIT,$0-8
+ MOVQ vdso_zx_ticks_get(SB), AX
+ CALL AX
+ MOVQ AX, ret+0(FP)
+ RET
+
+// func Sys_ticks_per_second() uint64
+TEXT ·Sys_ticks_per_second(SB),NOSPLIT,$0-8
+ MOVQ vdso_zx_ticks_per_second(SB), AX
+ CALL AX
+ MOVQ AX, ret+0(FP)
+ RET
+
+// func Sys_deadline_after(nanoseconds Duration) Time
+TEXT ·Sys_deadline_after(SB),NOSPLIT,$0-16
+ MOVQ nanoseconds+0(FP), DI
+ MOVQ vdso_zx_deadline_after(SB), AX
+ CALL AX
+ MOVQ AX, ret+8(FP)
+ RET
+
+// func Sys_clock_adjust(handle Handle, clock_id uint32, offset int64) Status
+TEXT ·Sys_clock_adjust(SB),NOSPLIT,$0-20
+ MOVL handle+0(FP), DI
+ MOVL clock_id+4(FP), SI
+ MOVQ offset+8(FP), DX
+ MOVQ vdso_zx_clock_adjust(SB), AX
+ CALL AX
+ MOVL AX, ret+16(FP)
+ RET
+
+// func sys_system_get_dcache_line_size() uint32
+TEXT ·sys_system_get_dcache_line_size(SB),NOSPLIT,$0-4
+ MOVQ vdso_zx_system_get_dcache_line_size(SB), AX
+ CALL AX
+ MOVL AX, ret+0(FP)
+ RET
+
+// func Sys_system_get_num_cpus() uint32
+TEXT ·Sys_system_get_num_cpus(SB),NOSPLIT,$0-4
+ MOVQ vdso_zx_system_get_num_cpus(SB), AX
+ CALL AX
+ MOVL AX, ret+0(FP)
+ RET
+
+// func Sys_system_get_version(version *uint8, version_size uint) Status
+TEXT ·Sys_system_get_version(SB),NOSPLIT,$0-20
+ MOVQ version+0(FP), DI
+ MOVQ version_size+8(FP), SI
+ MOVQ vdso_zx_system_get_version(SB), AX
+ CALL AX
+ MOVL AX, ret+16(FP)
+ RET
+
+// func Sys_system_get_physmem() uint64
+TEXT ·Sys_system_get_physmem(SB),NOSPLIT,$0-8
+ MOVQ vdso_zx_system_get_physmem(SB), AX
+ CALL AX
+ MOVQ AX, ret+0(FP)
+ RET
+
+// func sys_system_get_features(kind uint32, out *uint32) Status
+TEXT ·sys_system_get_features(SB),NOSPLIT,$0-20
+ MOVL kind+0(FP), DI
+ MOVQ out+8(FP), SI
+ MOVQ vdso_zx_system_get_features(SB), AX
+ CALL AX
+ MOVL AX, ret+16(FP)
+ RET
+
+// func Sys_cache_flush(addr unsafe.Pointer, size uint, options uint32) Status
+TEXT ·Sys_cache_flush(SB),NOSPLIT,$0-28
+ MOVQ addr+0(FP), DI
+ MOVQ size+8(FP), SI
+ MOVL options+16(FP), DX
+ MOVQ vdso_zx_cache_flush(SB), AX
+ CALL AX
+ MOVL AX, ret+24(FP)
+ RET
+
+// func Sys_handle_close(handle Handle) Status
+TEXT ·Sys_handle_close(SB),NOSPLIT,$0-12
+ MOVL handle+0(FP), DI
+ MOVQ vdso_zx_handle_close(SB), AX
+ CALL AX
+ MOVL AX, ret+8(FP)
+ RET
+
+// func Sys_handle_close_many(handles *Handle, num_handles uint) Status
+TEXT ·Sys_handle_close_many(SB),NOSPLIT,$0-20
+ MOVQ handles+0(FP), DI
+ MOVQ num_handles+8(FP), SI
+ MOVQ vdso_zx_handle_close_many(SB), AX
+ CALL AX
+ MOVL AX, ret+16(FP)
+ RET
+
+// func sys_handle_duplicate(handle Handle, rights Rights, out *Handle) Status
+TEXT ·sys_handle_duplicate(SB),NOSPLIT,$0-20
+ MOVL handle+0(FP), DI
+ MOVL rights+4(FP), SI
+ MOVQ out+8(FP), DX
+ MOVQ vdso_zx_handle_duplicate(SB), AX
+ CALL AX
+ MOVL AX, ret+16(FP)
+ RET
+
+// func Sys_handle_replace(handle Handle, rights Rights, out *Handle) Status
+TEXT ·Sys_handle_replace(SB),NOSPLIT,$0-20
+ MOVL handle+0(FP), DI
+ MOVL rights+4(FP), SI
+ MOVQ out+8(FP), DX
+ MOVQ vdso_zx_handle_replace(SB), AX
+ CALL AX
+ MOVL AX, ret+16(FP)
+ RET
+
+// func Sys_object_wait_one(handle Handle, signals Signals, deadline Time, observed *Signals) Status
+TEXT ·Sys_object_wait_one(SB),NOSPLIT,$0-28
+ CALL runtime·entersyscall(SB)
+ MOVL handle+0(FP), DI
+ MOVL signals+4(FP), SI
+ MOVQ deadline+8(FP), DX
+ MOVQ observed+16(FP), CX
+ MOVQ vdso_zx_object_wait_one(SB), AX
+ CALL AX
+ MOVL AX, ret+24(FP)
+ CALL runtime·exitsyscall(SB)
+ RET
+
+// func sys_object_wait_many(items *WaitItem, count uint, deadline Time) Status
+TEXT ·sys_object_wait_many(SB),NOSPLIT,$0-28
+ CALL runtime·entersyscall(SB)
+ MOVQ items+0(FP), DI
+ MOVQ count+8(FP), SI
+ MOVQ deadline+16(FP), DX
+ MOVQ vdso_zx_object_wait_many(SB), AX
+ CALL AX
+ MOVL AX, ret+24(FP)
+ CALL runtime·exitsyscall(SB)
+ RET
+
+// func Sys_object_wait_async(handle Handle, port Handle, key uint64, signals Signals, options uint32) Status
+TEXT ·Sys_object_wait_async(SB),NOSPLIT,$0-28
+ MOVL handle+0(FP), DI
+ MOVL port+4(FP), SI
+ MOVQ key+8(FP), DX
+ MOVL signals+16(FP), CX
+ MOVL options+20(FP), R8
+ MOVQ vdso_zx_object_wait_async(SB), AX
+ CALL AX
+ MOVL AX, ret+24(FP)
+ RET
+
+// func Sys_object_signal(handle Handle, clear_mask uint32, set_mask uint32) Status
+TEXT ·Sys_object_signal(SB),NOSPLIT,$0-20
+ MOVL handle+0(FP), DI
+ MOVL clear_mask+4(FP), SI
+ MOVL set_mask+8(FP), DX
+ MOVQ vdso_zx_object_signal(SB), AX
+ CALL AX
+ MOVL AX, ret+16(FP)
+ RET
+
+// func Sys_object_signal_peer(handle Handle, clear_mask uint32, set_mask uint32) Status
+TEXT ·Sys_object_signal_peer(SB),NOSPLIT,$0-20
+ MOVL handle+0(FP), DI
+ MOVL clear_mask+4(FP), SI
+ MOVL set_mask+8(FP), DX
+ MOVQ vdso_zx_object_signal_peer(SB), AX
+ CALL AX
+ MOVL AX, ret+16(FP)
+ RET
+
+// func Sys_object_get_property(handle Handle, property uint32, value unsafe.Pointer, value_size uint) Status
+TEXT ·Sys_object_get_property(SB),NOSPLIT,$0-28
+ MOVL handle+0(FP), DI
+ MOVL property+4(FP), SI
+ MOVQ value+8(FP), DX
+ MOVQ value_size+16(FP), CX
+ MOVQ vdso_zx_object_get_property(SB), AX
+ CALL AX
+ MOVL AX, ret+24(FP)
+ RET
+
+// func Sys_object_set_property(handle Handle, property uint32, value unsafe.Pointer, value_size uint) Status
+TEXT ·Sys_object_set_property(SB),NOSPLIT,$0-28
+ MOVL handle+0(FP), DI
+ MOVL property+4(FP), SI
+ MOVQ value+8(FP), DX
+ MOVQ value_size+16(FP), CX
+ MOVQ vdso_zx_object_set_property(SB), AX
+ CALL AX
+ MOVL AX, ret+24(FP)
+ RET
+
+// func Sys_object_set_cookie(handle Handle, scope Handle, cookie uint64) Status
+TEXT ·Sys_object_set_cookie(SB),NOSPLIT,$0-20
+ MOVL handle+0(FP), DI
+ MOVL scope+4(FP), SI
+ MOVQ cookie+8(FP), DX
+ MOVQ vdso_zx_object_set_cookie(SB), AX
+ CALL AX
+ MOVL AX, ret+16(FP)
+ RET
+
+// func Sys_object_get_cookie(handle Handle, scope Handle, cookie *uint64) Status
+TEXT ·Sys_object_get_cookie(SB),NOSPLIT,$0-20
+ MOVL handle+0(FP), DI
+ MOVL scope+4(FP), SI
+ MOVQ cookie+8(FP), DX
+ MOVQ vdso_zx_object_get_cookie(SB), AX
+ CALL AX
+ MOVL AX, ret+16(FP)
+ RET
+
+// func Sys_object_get_info(handle Handle, topic uint32, buffer unsafe.Pointer, buffer_size uint, actual_count *uint, avail_count *uint) Status
+TEXT ·Sys_object_get_info(SB),NOSPLIT,$0-44
+ MOVL handle+0(FP), DI
+ MOVL topic+4(FP), SI
+ MOVQ buffer+8(FP), DX
+ MOVQ buffer_size+16(FP), CX
+ MOVQ actual_count+24(FP), R8
+ MOVQ avail_count+32(FP), R9
+ MOVQ vdso_zx_object_get_info(SB), AX
+ CALL AX
+ MOVL AX, ret+40(FP)
+ RET
+
+// func Sys_object_get_child(handle Handle, koid uint64, rights Rights, out *Handle) Status
+TEXT ·Sys_object_get_child(SB),NOSPLIT,$0-36
+ MOVL handle+0(FP), DI
+ MOVQ koid+8(FP), SI
+ MOVL rights+16(FP), DX
+ MOVQ out+24(FP), CX
+ MOVQ vdso_zx_object_get_child(SB), AX
+ CALL AX
+ MOVL AX, ret+32(FP)
+ RET
+
+// func sys_object_set_profile(handle Handle, profile Handle, options uint32) Status
+TEXT ·sys_object_set_profile(SB),NOSPLIT,$0-20
+ MOVL handle+0(FP), DI
+ MOVL profile+4(FP), SI
+ MOVL options+8(FP), DX
+ MOVQ vdso_zx_object_set_profile(SB), AX
+ CALL AX
+ MOVL AX, ret+16(FP)
+ RET
+
+// func sys_channel_create(options uint32, out0 *Handle, out1 *Handle) Status
+TEXT ·sys_channel_create(SB),NOSPLIT,$0-28
+ MOVL options+0(FP), DI
+ MOVQ out0+8(FP), SI
+ MOVQ out1+16(FP), DX
+ MOVQ vdso_zx_channel_create(SB), AX
+ CALL AX
+ MOVL AX, ret+24(FP)
+ RET
+
+// func sys_channel_read(handle Handle, options uint32, bytes unsafe.Pointer, handles *Handle, num_bytes uint32, num_handles uint32, actual_bytes *uint32, actual_handles *uint32) Status
+TEXT ·sys_channel_read(SB),NOSPLIT,$32-52
+ MOVL handle+0(FP), DI
+ MOVL options+4(FP), SI
+ MOVQ bytes+8(FP), DX
+ MOVQ handles+16(FP), CX
+ MOVL num_bytes+24(FP), R8
+ MOVL num_handles+28(FP), R9
+ MOVQ actual_bytes+32(FP), R12
+ MOVQ actual_handles+40(FP), R13
+ MOVQ SP, BP // BP is preserved across vsdo call by the x86-64 ABI
+ ANDQ $~15, SP // stack alignment for x86-64 ABI
+ PUSHQ R13
+ PUSHQ R12
+ MOVQ vdso_zx_channel_read(SB), AX
+ CALL AX
+ POPQ R12
+ POPQ R13
+ MOVQ BP, SP
+ MOVL AX, ret+48(FP)
+ RET
+
+// func sys_channel_read_etc(handle Handle, options uint32, bytes unsafe.Pointer, handles *int, num_bytes uint32, num_handles uint32, actual_bytes *uint32, actual_handles *uint32) Status
+TEXT ·sys_channel_read_etc(SB),NOSPLIT,$32-52
+ MOVL handle+0(FP), DI
+ MOVL options+4(FP), SI
+ MOVQ bytes+8(FP), DX
+ MOVQ handles+16(FP), CX
+ MOVL num_bytes+24(FP), R8
+ MOVL num_handles+28(FP), R9
+ MOVQ actual_bytes+32(FP), R12
+ MOVQ actual_handles+40(FP), R13
+ MOVQ SP, BP // BP is preserved across vsdo call by the x86-64 ABI
+ ANDQ $~15, SP // stack alignment for x86-64 ABI
+ PUSHQ R13
+ PUSHQ R12
+ MOVQ vdso_zx_channel_read_etc(SB), AX
+ CALL AX
+ POPQ R12
+ POPQ R13
+ MOVQ BP, SP
+ MOVL AX, ret+48(FP)
+ RET
+
+// func sys_channel_write(handle Handle, options uint32, bytes unsafe.Pointer, num_bytes uint32, handles *Handle, num_handles uint32) Status
+TEXT ·sys_channel_write(SB),NOSPLIT,$0-44
+ MOVL handle+0(FP), DI
+ MOVL options+4(FP), SI
+ MOVQ bytes+8(FP), DX
+ MOVL num_bytes+16(FP), CX
+ MOVQ handles+24(FP), R8
+ MOVL num_handles+32(FP), R9
+ MOVQ vdso_zx_channel_write(SB), AX
+ CALL AX
+ MOVL AX, ret+40(FP)
+ RET
+
+// func Sys_channel_call_noretry(handle Handle, options uint32, deadline Time, args *ChannelCallArgs, actual_bytes *uint32, actual_handles *uint32) Status
+TEXT ·Sys_channel_call_noretry(SB),NOSPLIT,$0-44
+ MOVL handle+0(FP), DI
+ MOVL options+4(FP), SI
+ MOVQ deadline+8(FP), DX
+ MOVQ args+16(FP), CX
+ MOVQ actual_bytes+24(FP), R8
+ MOVQ actual_handles+32(FP), R9
+ MOVQ vdso_zx_channel_call_noretry(SB), AX
+ CALL AX
+ MOVL AX, ret+40(FP)
+ RET
+
+// func Sys_channel_call_finish(deadline Time, args *ChannelCallArgs, actual_bytes *uint32, actual_handles *uint32) Status
+TEXT ·Sys_channel_call_finish(SB),NOSPLIT,$0-36
+ MOVQ deadline+0(FP), DI
+ MOVQ args+8(FP), SI
+ MOVQ actual_bytes+16(FP), DX
+ MOVQ actual_handles+24(FP), CX
+ MOVQ vdso_zx_channel_call_finish(SB), AX
+ CALL AX
+ MOVL AX, ret+32(FP)
+ RET
+
+// func Sys_channel_call(handle Handle, options uint32, deadline Time, args *ChannelCallArgs, actual_bytes *uint32, actual_handles *uint32) Status
+TEXT ·Sys_channel_call(SB),NOSPLIT,$0-44
+ MOVL handle+0(FP), DI
+ MOVL options+4(FP), SI
+ MOVQ deadline+8(FP), DX
+ MOVQ args+16(FP), CX
+ MOVQ actual_bytes+24(FP), R8
+ MOVQ actual_handles+32(FP), R9
+ MOVQ vdso_zx_channel_call(SB), AX
+ CALL AX
+ MOVL AX, ret+40(FP)
+ RET
+
+// func sys_socket_create(options uint32, out0 *Handle, out1 *Handle) Status
+TEXT ·sys_socket_create(SB),NOSPLIT,$0-28
+ MOVL options+0(FP), DI
+ MOVQ out0+8(FP), SI
+ MOVQ out1+16(FP), DX
+ MOVQ vdso_zx_socket_create(SB), AX
+ CALL AX
+ MOVL AX, ret+24(FP)
+ RET
+
+// func sys_socket_write(handle Handle, options uint32, buffer unsafe.Pointer, buffer_size uint, actual *uint) Status
+TEXT ·sys_socket_write(SB),NOSPLIT,$0-36
+ MOVL handle+0(FP), DI
+ MOVL options+4(FP), SI
+ MOVQ buffer+8(FP), DX
+ MOVQ buffer_size+16(FP), CX
+ MOVQ actual+24(FP), R8
+ MOVQ vdso_zx_socket_write(SB), AX
+ CALL AX
+ MOVL AX, ret+32(FP)
+ RET
+
+// func sys_socket_read(handle Handle, options uint32, buffer unsafe.Pointer, buffer_size uint, actual *uint) Status
+TEXT ·sys_socket_read(SB),NOSPLIT,$0-36
+ MOVL handle+0(FP), DI
+ MOVL options+4(FP), SI
+ MOVQ buffer+8(FP), DX
+ MOVQ buffer_size+16(FP), CX
+ MOVQ actual+24(FP), R8
+ MOVQ vdso_zx_socket_read(SB), AX
+ CALL AX
+ MOVL AX, ret+32(FP)
+ RET
+
+// func sys_socket_share(handle Handle, socket_to_share Handle) Status
+TEXT ·sys_socket_share(SB),NOSPLIT,$0-12
+ MOVL handle+0(FP), DI
+ MOVL socket_to_share+4(FP), SI
+ MOVQ vdso_zx_socket_share(SB), AX
+ CALL AX
+ MOVL AX, ret+8(FP)
+ RET
+
+// func sys_socket_accept(handle Handle, out_socket *Handle) Status
+TEXT ·sys_socket_accept(SB),NOSPLIT,$0-20
+ MOVL handle+0(FP), DI
+ MOVQ out_socket+8(FP), SI
+ MOVQ vdso_zx_socket_accept(SB), AX
+ CALL AX
+ MOVL AX, ret+16(FP)
+ RET
+
+// func Sys_thread_exit()
+TEXT ·Sys_thread_exit(SB),NOSPLIT,$0-0
+ MOVQ vdso_zx_thread_exit(SB), AX
+ CALL AX
+ RET
+
+// func Sys_thread_create(process Handle, name *uint8, name_size uint, options uint32, out *Handle) Status
+TEXT ·Sys_thread_create(SB),NOSPLIT,$0-44
+ MOVL process+0(FP), DI
+ MOVQ name+8(FP), SI
+ MOVQ name_size+16(FP), DX
+ MOVL options+24(FP), CX
+ MOVQ out+32(FP), R8
+ MOVQ vdso_zx_thread_create(SB), AX
+ CALL AX
+ MOVL AX, ret+40(FP)
+ RET
+
+// func Sys_thread_start(handle Handle, thread_entry Vaddr, stack Vaddr, arg1 uintptr, arg2 uintptr) Status
+TEXT ·Sys_thread_start(SB),NOSPLIT,$0-44
+ MOVL handle+0(FP), DI
+ MOVQ thread_entry+8(FP), SI
+ MOVQ stack+16(FP), DX
+ MOVQ arg1+24(FP), CX
+ MOVQ arg2+32(FP), R8
+ MOVQ vdso_zx_thread_start(SB), AX
+ CALL AX
+ MOVL AX, ret+40(FP)
+ RET
+
+// func Sys_thread_read_state(handle Handle, kind uint32, buffer unsafe.Pointer, buffer_size uint) Status
+TEXT ·Sys_thread_read_state(SB),NOSPLIT,$0-28
+ MOVL handle+0(FP), DI
+ MOVL kind+4(FP), SI
+ MOVQ buffer+8(FP), DX
+ MOVQ buffer_size+16(FP), CX
+ MOVQ vdso_zx_thread_read_state(SB), AX
+ CALL AX
+ MOVL AX, ret+24(FP)
+ RET
+
+// func Sys_thread_write_state(handle Handle, kind uint32, buffer unsafe.Pointer, buffer_size uint) Status
+TEXT ·Sys_thread_write_state(SB),NOSPLIT,$0-28
+ MOVL handle+0(FP), DI
+ MOVL kind+4(FP), SI
+ MOVQ buffer+8(FP), DX
+ MOVQ buffer_size+16(FP), CX
+ MOVQ vdso_zx_thread_write_state(SB), AX
+ CALL AX
+ MOVL AX, ret+24(FP)
+ RET
+
+// func Sys_thread_set_priority(prio int32) Status
+TEXT ·Sys_thread_set_priority(SB),NOSPLIT,$0-12
+ MOVL prio+0(FP), DI
+ MOVQ vdso_zx_thread_set_priority(SB), AX
+ CALL AX
+ MOVL AX, ret+8(FP)
+ RET
+
+// func Sys_process_exit(retcode int64)
+TEXT ·Sys_process_exit(SB),NOSPLIT,$0-8
+ MOVQ retcode+0(FP), DI
+ MOVQ vdso_zx_process_exit(SB), AX
+ CALL AX
+ RET
+
+// func Sys_process_create(job Handle, name *uint8, name_size uint, options uint32, proc_handle *Handle, vmar_handle *Handle) Status
+TEXT ·Sys_process_create(SB),NOSPLIT,$0-52
+ MOVL job+0(FP), DI
+ MOVQ name+8(FP), SI
+ MOVQ name_size+16(FP), DX
+ MOVL options+24(FP), CX
+ MOVQ proc_handle+32(FP), R8
+ MOVQ vmar_handle+40(FP), R9
+ MOVQ vdso_zx_process_create(SB), AX
+ CALL AX
+ MOVL AX, ret+48(FP)
+ RET
+
+// func Sys_process_start(handle Handle, thread Handle, entry Vaddr, stack Vaddr, arg1 Handle, arg2 uintptr) Status
+TEXT ·Sys_process_start(SB),NOSPLIT,$0-44
+ MOVL handle+0(FP), DI
+ MOVL thread+4(FP), SI
+ MOVQ entry+8(FP), DX
+ MOVQ stack+16(FP), CX
+ MOVL arg1+24(FP), R8
+ MOVQ arg2+32(FP), R9
+ MOVQ vdso_zx_process_start(SB), AX
+ CALL AX
+ MOVL AX, ret+40(FP)
+ RET
+
+// func Sys_process_read_memory(proc Handle, vaddr Vaddr, buffer unsafe.Pointer, buffer_size uint, actual *uint) Status
+TEXT ·Sys_process_read_memory(SB),NOSPLIT,$0-44
+ MOVL proc+0(FP), DI
+ MOVQ vaddr+8(FP), SI
+ MOVQ buffer+16(FP), DX
+ MOVQ buffer_size+24(FP), CX
+ MOVQ actual+32(FP), R8
+ MOVQ vdso_zx_process_read_memory(SB), AX
+ CALL AX
+ MOVL AX, ret+40(FP)
+ RET
+
+// func Sys_process_write_memory(proc Handle, vaddr Vaddr, buffer unsafe.Pointer, buffer_size uint, actual *uint) Status
+TEXT ·Sys_process_write_memory(SB),NOSPLIT,$0-44
+ MOVL proc+0(FP), DI
+ MOVQ vaddr+8(FP), SI
+ MOVQ buffer+16(FP), DX
+ MOVQ buffer_size+24(FP), CX
+ MOVQ actual+32(FP), R8
+ MOVQ vdso_zx_process_write_memory(SB), AX
+ CALL AX
+ MOVL AX, ret+40(FP)
+ RET
+
+// func Sys_job_create(parent_job Handle, options uint32, out *Handle) Status
+TEXT ·Sys_job_create(SB),NOSPLIT,$0-20
+ MOVL parent_job+0(FP), DI
+ MOVL options+4(FP), SI
+ MOVQ out+8(FP), DX
+ MOVQ vdso_zx_job_create(SB), AX
+ CALL AX
+ MOVL AX, ret+16(FP)
+ RET
+
+// func Sys_job_set_policy(job Handle, options uint32, topic uint32, policy unsafe.Pointer, count uint32) Status
+TEXT ·Sys_job_set_policy(SB),NOSPLIT,$0-36
+ MOVL job+0(FP), DI
+ MOVL options+4(FP), SI
+ MOVL topic+8(FP), DX
+ MOVQ policy+16(FP), CX
+ MOVL count+24(FP), R8
+ MOVQ vdso_zx_job_set_policy(SB), AX
+ CALL AX
+ MOVL AX, ret+32(FP)
+ RET
+
+// func Sys_task_bind_exception_port(handle Handle, port Handle, key uint64, options uint32) Status
+TEXT ·Sys_task_bind_exception_port(SB),NOSPLIT,$0-28
+ MOVL handle+0(FP), DI
+ MOVL port+4(FP), SI
+ MOVQ key+8(FP), DX
+ MOVL options+16(FP), CX
+ MOVQ vdso_zx_task_bind_exception_port(SB), AX
+ CALL AX
+ MOVL AX, ret+24(FP)
+ RET
+
+// func Sys_task_resume(handle Handle, options uint32) Status
+TEXT ·Sys_task_resume(SB),NOSPLIT,$0-12
+ MOVL handle+0(FP), DI
+ MOVL options+4(FP), SI
+ MOVQ vdso_zx_task_resume(SB), AX
+ CALL AX
+ MOVL AX, ret+8(FP)
+ RET
+
+// func Sys_task_suspend(handle Handle, token *Handle) Status
+TEXT ·Sys_task_suspend(SB),NOSPLIT,$0-20
+ MOVL handle+0(FP), DI
+ MOVQ token+8(FP), SI
+ MOVQ vdso_zx_task_suspend(SB), AX
+ CALL AX
+ MOVL AX, ret+16(FP)
+ RET
+
+// func Sys_task_suspend_token(handle Handle, token *Handle) Status
+TEXT ·Sys_task_suspend_token(SB),NOSPLIT,$0-20
+ MOVL handle+0(FP), DI
+ MOVQ token+8(FP), SI
+ MOVQ vdso_zx_task_suspend_token(SB), AX
+ CALL AX
+ MOVL AX, ret+16(FP)
+ RET
+
+// func Sys_task_resume_from_exception(handle Handle, port Handle, options uint32) Status
+TEXT ·Sys_task_resume_from_exception(SB),NOSPLIT,$0-20
+ MOVL handle+0(FP), DI
+ MOVL port+4(FP), SI
+ MOVL options+8(FP), DX
+ MOVQ vdso_zx_task_resume_from_exception(SB), AX
+ CALL AX
+ MOVL AX, ret+16(FP)
+ RET
+
+// func Sys_task_kill(handle Handle) Status
+TEXT ·Sys_task_kill(SB),NOSPLIT,$0-12
+ MOVL handle+0(FP), DI
+ MOVQ vdso_zx_task_kill(SB), AX
+ CALL AX
+ MOVL AX, ret+8(FP)
+ RET
+
+// func Sys_event_create(options uint32, out *Handle) Status
+TEXT ·Sys_event_create(SB),NOSPLIT,$0-20
+ MOVL options+0(FP), DI
+ MOVQ out+8(FP), SI
+ MOVQ vdso_zx_event_create(SB), AX
+ CALL AX
+ MOVL AX, ret+16(FP)
+ RET
+
+// func Sys_eventpair_create(options uint32, out0 *Handle, out1 *Handle) Status
+TEXT ·Sys_eventpair_create(SB),NOSPLIT,$0-28
+ MOVL options+0(FP), DI
+ MOVQ out0+8(FP), SI
+ MOVQ out1+16(FP), DX
+ MOVQ vdso_zx_eventpair_create(SB), AX
+ CALL AX
+ MOVL AX, ret+24(FP)
+ RET
+
+// func Sys_futex_wait(value_ptr *int, current_value int32, deadline Time) Status
+TEXT ·Sys_futex_wait(SB),NOSPLIT,$0-28
+ MOVQ value_ptr+0(FP), DI
+ MOVL current_value+8(FP), SI
+ MOVQ deadline+16(FP), DX
+ MOVQ vdso_zx_futex_wait(SB), AX
+ CALL AX
+ MOVL AX, ret+24(FP)
+ RET
+
+// func Sys_futex_wake(value_ptr *int, count uint32) Status
+TEXT ·Sys_futex_wake(SB),NOSPLIT,$0-20
+ MOVQ value_ptr+0(FP), DI
+ MOVL count+8(FP), SI
+ MOVQ vdso_zx_futex_wake(SB), AX
+ CALL AX
+ MOVL AX, ret+16(FP)
+ RET
+
+// func Sys_futex_requeue(wake_ptr *int, wake_count uint32, current_value int32, requeue_ptr *int, requeue_count uint32) Status
+TEXT ·Sys_futex_requeue(SB),NOSPLIT,$0-36
+ MOVQ wake_ptr+0(FP), DI
+ MOVL wake_count+8(FP), SI
+ MOVL current_value+12(FP), DX
+ MOVQ requeue_ptr+16(FP), CX
+ MOVL requeue_count+24(FP), R8
+ MOVQ vdso_zx_futex_requeue(SB), AX
+ CALL AX
+ MOVL AX, ret+32(FP)
+ RET
+
+// func Sys_port_create(options uint32, out *Handle) Status
+TEXT ·Sys_port_create(SB),NOSPLIT,$0-20
+ MOVL options+0(FP), DI
+ MOVQ out+8(FP), SI
+ MOVQ vdso_zx_port_create(SB), AX
+ CALL AX
+ MOVL AX, ret+16(FP)
+ RET
+
+// func Sys_port_queue(handle Handle, packet *int) Status
+TEXT ·Sys_port_queue(SB),NOSPLIT,$0-20
+ MOVL handle+0(FP), DI
+ MOVQ packet+8(FP), SI
+ MOVQ vdso_zx_port_queue(SB), AX
+ CALL AX
+ MOVL AX, ret+16(FP)
+ RET
+
+// func Sys_port_wait(handle Handle, deadline Time, packet *int) Status
+TEXT ·Sys_port_wait(SB),NOSPLIT,$0-28
+ CALL runtime·entersyscall(SB)
+ MOVL handle+0(FP), DI
+ MOVQ deadline+8(FP), SI
+ MOVQ packet+16(FP), DX
+ MOVQ vdso_zx_port_wait(SB), AX
+ CALL AX
+ MOVL AX, ret+24(FP)
+ CALL runtime·exitsyscall(SB)
+ RET
+
+// func Sys_port_cancel(handle Handle, source Handle, key uint64) Status
+TEXT ·Sys_port_cancel(SB),NOSPLIT,$0-20
+ MOVL handle+0(FP), DI
+ MOVL source+4(FP), SI
+ MOVQ key+8(FP), DX
+ MOVQ vdso_zx_port_cancel(SB), AX
+ CALL AX
+ MOVL AX, ret+16(FP)
+ RET
+
+// func Sys_timer_create(options uint32, clock_id uint32, out *Handle) Status
+TEXT ·Sys_timer_create(SB),NOSPLIT,$0-20
+ MOVL options+0(FP), DI
+ MOVL clock_id+4(FP), SI
+ MOVQ out+8(FP), DX
+ MOVQ vdso_zx_timer_create(SB), AX
+ CALL AX
+ MOVL AX, ret+16(FP)
+ RET
+
+// func Sys_timer_set(handle Handle, deadline Time, slack Duration) Status
+TEXT ·Sys_timer_set(SB),NOSPLIT,$0-28
+ MOVL handle+0(FP), DI
+ MOVQ deadline+8(FP), SI
+ MOVQ slack+16(FP), DX
+ MOVQ vdso_zx_timer_set(SB), AX
+ CALL AX
+ MOVL AX, ret+24(FP)
+ RET
+
+// func Sys_timer_cancel(handle Handle) Status
+TEXT ·Sys_timer_cancel(SB),NOSPLIT,$0-12
+ MOVL handle+0(FP), DI
+ MOVQ vdso_zx_timer_cancel(SB), AX
+ CALL AX
+ MOVL AX, ret+8(FP)
+ RET
+
+// func Sys_vmo_create(size uint64, options uint32, out *Handle) Status
+TEXT ·Sys_vmo_create(SB),NOSPLIT,$0-28
+ MOVQ size+0(FP), DI
+ MOVL options+8(FP), SI
+ MOVQ out+16(FP), DX
+ MOVQ vdso_zx_vmo_create(SB), AX
+ CALL AX
+ MOVL AX, ret+24(FP)
+ RET
+
+// func sys_vmo_read(handle Handle, buffer unsafe.Pointer, offset uint64, buffer_size uint) Status
+TEXT ·sys_vmo_read(SB),NOSPLIT,$0-36
+ MOVL handle+0(FP), DI
+ MOVQ buffer+8(FP), SI
+ MOVQ offset+16(FP), DX
+ MOVQ buffer_size+24(FP), CX
+ MOVQ vdso_zx_vmo_read(SB), AX
+ CALL AX
+ MOVL AX, ret+32(FP)
+ RET
+
+// func sys_vmo_write(handle Handle, buffer unsafe.Pointer, offset uint64, buffer_size uint) Status
+TEXT ·sys_vmo_write(SB),NOSPLIT,$0-36
+ MOVL handle+0(FP), DI
+ MOVQ buffer+8(FP), SI
+ MOVQ offset+16(FP), DX
+ MOVQ buffer_size+24(FP), CX
+ MOVQ vdso_zx_vmo_write(SB), AX
+ CALL AX
+ MOVL AX, ret+32(FP)
+ RET
+
+// func sys_vmo_get_size(handle Handle, size *uint64) Status
+TEXT ·sys_vmo_get_size(SB),NOSPLIT,$0-20
+ MOVL handle+0(FP), DI
+ MOVQ size+8(FP), SI
+ MOVQ vdso_zx_vmo_get_size(SB), AX
+ CALL AX
+ MOVL AX, ret+16(FP)
+ RET
+
+// func sys_vmo_set_size(handle Handle, size uint64) Status
+TEXT ·sys_vmo_set_size(SB),NOSPLIT,$0-20
+ MOVL handle+0(FP), DI
+ MOVQ size+8(FP), SI
+ MOVQ vdso_zx_vmo_set_size(SB), AX
+ CALL AX
+ MOVL AX, ret+16(FP)
+ RET
+
+// func sys_vmo_op_range(handle Handle, op uint32, offset uint64, size uint64, buffer unsafe.Pointer, buffer_size uint) Status
+TEXT ·sys_vmo_op_range(SB),NOSPLIT,$0-44
+ MOVL handle+0(FP), DI
+ MOVL op+4(FP), SI
+ MOVQ offset+8(FP), DX
+ MOVQ size+16(FP), CX
+ MOVQ buffer+24(FP), R8
+ MOVQ buffer_size+32(FP), R9
+ MOVQ vdso_zx_vmo_op_range(SB), AX
+ CALL AX
+ MOVL AX, ret+40(FP)
+ RET
+
+// func Sys_vmo_clone(handle Handle, options uint32, offset uint64, size uint64, out *Handle) Status
+TEXT ·Sys_vmo_clone(SB),NOSPLIT,$0-36
+ MOVL handle+0(FP), DI
+ MOVL options+4(FP), SI
+ MOVQ offset+8(FP), DX
+ MOVQ size+16(FP), CX
+ MOVQ out+24(FP), R8
+ MOVQ vdso_zx_vmo_clone(SB), AX
+ CALL AX
+ MOVL AX, ret+32(FP)
+ RET
+
+// func Sys_vmo_set_cache_policy(handle Handle, cache_policy uint32) Status
+TEXT ·Sys_vmo_set_cache_policy(SB),NOSPLIT,$0-12
+ MOVL handle+0(FP), DI
+ MOVL cache_policy+4(FP), SI
+ MOVQ vdso_zx_vmo_set_cache_policy(SB), AX
+ CALL AX
+ MOVL AX, ret+8(FP)
+ RET
+
+// func sys_vmar_allocate_old(parent_vmar Handle, offset uint64, size uint64, map_flags uint32, child_vmar *Handle, child_addr *Vaddr) Status
+TEXT ·sys_vmar_allocate_old(SB),NOSPLIT,$0-52
+ MOVL parent_vmar+0(FP), DI
+ MOVQ offset+8(FP), SI
+ MOVQ size+16(FP), DX
+ MOVL map_flags+24(FP), CX
+ MOVQ child_vmar+32(FP), R8
+ MOVQ child_addr+40(FP), R9
+ MOVQ vdso_zx_vmar_allocate_old(SB), AX
+ CALL AX
+ MOVL AX, ret+48(FP)
+ RET
+
+// func sys_vmar_map_old(handle Handle, vmar_offset uint64, vmo Handle, vmo_offset uint64, len uint64, map_flags uint32, mapped_addr *Vaddr) Status
+TEXT ·sys_vmar_map_old(SB),NOSPLIT,$24-60
+ MOVL handle+0(FP), DI
+ MOVQ vmar_offset+8(FP), SI
+ MOVL vmo+16(FP), DX
+ MOVQ vmo_offset+24(FP), CX
+ MOVQ len+32(FP), R8
+ MOVL map_flags+40(FP), R9
+ MOVQ mapped_addr+48(FP), R12
+ MOVQ SP, BP // BP is preserved across vsdo call by the x86-64 ABI
+ ANDQ $~15, SP // stack alignment for x86-64 ABI
+ PUSHQ R12
+ MOVQ vdso_zx_vmar_map_old(SB), AX
+ CALL AX
+ POPQ R12
+ MOVQ BP, SP
+ MOVL AX, ret+56(FP)
+ RET
+
+// func sys_vmar_protect_old(handle Handle, addr Vaddr, len uint64, prot_flags uint32) Status
+TEXT ·sys_vmar_protect_old(SB),NOSPLIT,$0-36
+ MOVL handle+0(FP), DI
+ MOVQ addr+8(FP), SI
+ MOVQ len+16(FP), DX
+ MOVL prot_flags+24(FP), CX
+ MOVQ vdso_zx_vmar_protect_old(SB), AX
+ CALL AX
+ MOVL AX, ret+32(FP)
+ RET
+
+// func sys_vmar_allocate(parent_vmar Handle, offset uint64, size uint64, map_flags uint32, child_vmar *Handle, child_addr *Vaddr) Status
+TEXT ·sys_vmar_allocate(SB),NOSPLIT,$0-52
+ MOVL parent_vmar+0(FP), DI
+ MOVQ offset+8(FP), SI
+ MOVQ size+16(FP), DX
+ MOVL map_flags+24(FP), CX
+ MOVQ child_vmar+32(FP), R8
+ MOVQ child_addr+40(FP), R9
+ MOVQ vdso_zx_vmar_allocate(SB), AX
+ CALL AX
+ MOVL AX, ret+48(FP)
+ RET
+
+// func sys_vmar_destroy(handle Handle) Status
+TEXT ·sys_vmar_destroy(SB),NOSPLIT,$0-12
+ MOVL handle+0(FP), DI
+ MOVQ vdso_zx_vmar_destroy(SB), AX
+ CALL AX
+ MOVL AX, ret+8(FP)
+ RET
+
+// func Sys_vmar_map(handle Handle, vmar_offset uint64, vmo Handle, vmo_offset uint64, len uint64, map_flags uint32, mapped_addr *Vaddr) Status
+TEXT ·Sys_vmar_map(SB),NOSPLIT,$24-60
+ MOVL handle+0(FP), DI
+ MOVQ vmar_offset+8(FP), SI
+ MOVL vmo+16(FP), DX
+ MOVQ vmo_offset+24(FP), CX
+ MOVQ len+32(FP), R8
+ MOVL map_flags+40(FP), R9
+ MOVQ mapped_addr+48(FP), R12
+ MOVQ SP, BP // BP is preserved across vsdo call by the x86-64 ABI
+ ANDQ $~15, SP // stack alignment for x86-64 ABI
+ PUSHQ R12
+ MOVQ vdso_zx_vmar_map(SB), AX
+ CALL AX
+ POPQ R12
+ MOVQ BP, SP
+ MOVL AX, ret+56(FP)
+ RET
+
+// func Sys_vmar_unmap(handle Handle, addr Vaddr, len uint64) Status
+TEXT ·Sys_vmar_unmap(SB),NOSPLIT,$0-28
+ MOVL handle+0(FP), DI
+ MOVQ addr+8(FP), SI
+ MOVQ len+16(FP), DX
+ MOVQ vdso_zx_vmar_unmap(SB), AX
+ CALL AX
+ MOVL AX, ret+24(FP)
+ RET
+
+// func Sys_vmar_protect(handle Handle, addr Vaddr, len uint64, prot_flags uint32) Status
+TEXT ·Sys_vmar_protect(SB),NOSPLIT,$0-36
+ MOVL handle+0(FP), DI
+ MOVQ addr+8(FP), SI
+ MOVQ len+16(FP), DX
+ MOVL prot_flags+24(FP), CX
+ MOVQ vdso_zx_vmar_protect(SB), AX
+ CALL AX
+ MOVL AX, ret+32(FP)
+ RET
+
+// func Sys_cprng_draw_once(buffer unsafe.Pointer, buffer_size uint) Status
+TEXT ·Sys_cprng_draw_once(SB),NOSPLIT,$0-20
+ MOVQ buffer+0(FP), DI
+ MOVQ buffer_size+8(FP), SI
+ MOVQ vdso_zx_cprng_draw_once(SB), AX
+ CALL AX
+ MOVL AX, ret+16(FP)
+ RET
+
+// func Sys_cprng_draw(buffer unsafe.Pointer, buffer_size uint)
+TEXT ·Sys_cprng_draw(SB),NOSPLIT,$0-16
+ MOVQ buffer+0(FP), DI
+ MOVQ buffer_size+8(FP), SI
+ MOVQ vdso_zx_cprng_draw(SB), AX
+ CALL AX
+ RET
+
+// func Sys_cprng_draw_new(buffer unsafe.Pointer, data_size uint) Status
+TEXT ·Sys_cprng_draw_new(SB),NOSPLIT,$0-20
+ MOVQ buffer+0(FP), DI
+ MOVQ data_size+8(FP), SI
+ MOVQ vdso_zx_cprng_draw_new(SB), AX
+ CALL AX
+ MOVL AX, ret+16(FP)
+ RET
+
+// func Sys_cprng_add_entropy(buffer unsafe.Pointer, len uint) Status
+TEXT ·Sys_cprng_add_entropy(SB),NOSPLIT,$0-20
+ MOVQ buffer+0(FP), DI
+ MOVQ len+8(FP), SI
+ MOVQ vdso_zx_cprng_add_entropy(SB), AX
+ CALL AX
+ MOVL AX, ret+16(FP)
+ RET
+
+// func Sys_fifo_create(elem_count uint, elem_size uint, options uint32, out0 *Handle, out1 *Handle) Status
+TEXT ·Sys_fifo_create(SB),NOSPLIT,$0-44
+ MOVQ elem_count+0(FP), DI
+ MOVQ elem_size+8(FP), SI
+ MOVL options+16(FP), DX
+ MOVQ out0+24(FP), CX
+ MOVQ out1+32(FP), R8
+ MOVQ vdso_zx_fifo_create(SB), AX
+ CALL AX
+ MOVL AX, ret+40(FP)
+ RET
+
+// func Sys_fifo_read(handle Handle, elem_size uint, data unsafe.Pointer, count uint, actual_count *uint) Status
+TEXT ·Sys_fifo_read(SB),NOSPLIT,$0-44
+ MOVL handle+0(FP), DI
+ MOVQ elem_size+8(FP), SI
+ MOVQ data+16(FP), DX
+ MOVQ count+24(FP), CX
+ MOVQ actual_count+32(FP), R8
+ MOVQ vdso_zx_fifo_read(SB), AX
+ CALL AX
+ MOVL AX, ret+40(FP)
+ RET
+
+// func Sys_fifo_write(handle Handle, elem_size uint, data unsafe.Pointer, count uint, actual_count *uint) Status
+TEXT ·Sys_fifo_write(SB),NOSPLIT,$0-44
+ MOVL handle+0(FP), DI
+ MOVQ elem_size+8(FP), SI
+ MOVQ data+16(FP), DX
+ MOVQ count+24(FP), CX
+ MOVQ actual_count+32(FP), R8
+ MOVQ vdso_zx_fifo_write(SB), AX
+ CALL AX
+ MOVL AX, ret+40(FP)
+ RET
+
+// func Sys_profile_create(resource Handle, profile *int, out *Handle) Status
+TEXT ·Sys_profile_create(SB),NOSPLIT,$0-28
+ MOVL resource+0(FP), DI
+ MOVQ profile+8(FP), SI
+ MOVQ out+16(FP), DX
+ MOVQ vdso_zx_profile_create(SB), AX
+ CALL AX
+ MOVL AX, ret+24(FP)
+ RET
+
+// func Sys_vmar_unmap_handle_close_thread_exit(vmar_handle Handle, addr Vaddr, size uint, handle Handle) Status
+TEXT ·Sys_vmar_unmap_handle_close_thread_exit(SB),NOSPLIT,$0-36
+ MOVL vmar_handle+0(FP), DI
+ MOVQ addr+8(FP), SI
+ MOVQ size+16(FP), DX
+ MOVL handle+24(FP), CX
+ MOVQ vdso_zx_vmar_unmap_handle_close_thread_exit(SB), AX
+ CALL AX
+ MOVL AX, ret+32(FP)
+ RET
+
+// func Sys_futex_wake_handle_close_thread_exit(value_ptr *int, count uint32, new_value int32, handle Handle)
+TEXT ·Sys_futex_wake_handle_close_thread_exit(SB),NOSPLIT,$0-24
+ MOVQ value_ptr+0(FP), DI
+ MOVL count+8(FP), SI
+ MOVL new_value+12(FP), DX
+ MOVL handle+16(FP), CX
+ MOVQ vdso_zx_futex_wake_handle_close_thread_exit(SB), AX
+ CALL AX
+ RET
+
+// func Sys_log_write(handle Handle, len uint32, buffer unsafe.Pointer, options uint32) Status
+TEXT ·Sys_log_write(SB),NOSPLIT,$0-28
+ MOVL handle+0(FP), DI
+ MOVL len+4(FP), SI
+ MOVQ buffer+8(FP), DX
+ MOVL options+16(FP), CX
+ MOVQ vdso_zx_log_write(SB), AX
+ CALL AX
+ MOVL AX, ret+24(FP)
+ RET
+
+// func Sys_log_read(handle Handle, len uint32, buffer unsafe.Pointer, options uint32) Status
+TEXT ·Sys_log_read(SB),NOSPLIT,$0-28
+ MOVL handle+0(FP), DI
+ MOVL len+4(FP), SI
+ MOVQ buffer+8(FP), DX
+ MOVL options+16(FP), CX
+ MOVQ vdso_zx_log_read(SB), AX
+ CALL AX
+ MOVL AX, ret+24(FP)
+ RET
+
+// func Sys_debuglog_create(resource Handle, options uint32, out *Handle) Status
+TEXT ·Sys_debuglog_create(SB),NOSPLIT,$0-20
+ MOVL resource+0(FP), DI
+ MOVL options+4(FP), SI
+ MOVQ out+8(FP), DX
+ MOVQ vdso_zx_debuglog_create(SB), AX
+ CALL AX
+ MOVL AX, ret+16(FP)
+ RET
+
+// func Sys_debuglog_write(handle Handle, options uint32, buffer unsafe.Pointer, buffer_size uint) Status
+TEXT ·Sys_debuglog_write(SB),NOSPLIT,$0-28
+ MOVL handle+0(FP), DI
+ MOVL options+4(FP), SI
+ MOVQ buffer+8(FP), DX
+ MOVQ buffer_size+16(FP), CX
+ MOVQ vdso_zx_debuglog_write(SB), AX
+ CALL AX
+ MOVL AX, ret+24(FP)
+ RET
+
+// func Sys_debuglog_read(handle Handle, options uint32, buffer unsafe.Pointer, buffer_size uint) Status
+TEXT ·Sys_debuglog_read(SB),NOSPLIT,$0-28
+ MOVL handle+0(FP), DI
+ MOVL options+4(FP), SI
+ MOVQ buffer+8(FP), DX
+ MOVQ buffer_size+16(FP), CX
+ MOVQ vdso_zx_debuglog_read(SB), AX
+ CALL AX
+ MOVL AX, ret+24(FP)
+ RET
+
+// func Sys_ktrace_read(handle Handle, data unsafe.Pointer, offset uint32, data_size uint, actual *uint) Status
+TEXT ·Sys_ktrace_read(SB),NOSPLIT,$0-44
+ MOVL handle+0(FP), DI
+ MOVQ data+8(FP), SI
+ MOVL offset+16(FP), DX
+ MOVQ data_size+24(FP), CX
+ MOVQ actual+32(FP), R8
+ MOVQ vdso_zx_ktrace_read(SB), AX
+ CALL AX
+ MOVL AX, ret+40(FP)
+ RET
+
+// func Sys_ktrace_control(handle Handle, action uint32, options uint32, ptr unsafe.Pointer) Status
+TEXT ·Sys_ktrace_control(SB),NOSPLIT,$0-28
+ MOVL handle+0(FP), DI
+ MOVL action+4(FP), SI
+ MOVL options+8(FP), DX
+ MOVQ ptr+16(FP), CX
+ MOVQ vdso_zx_ktrace_control(SB), AX
+ CALL AX
+ MOVL AX, ret+24(FP)
+ RET
+
+// func Sys_ktrace_write(handle Handle, id uint32, arg0 uint32, arg1 uint32) Status
+TEXT ·Sys_ktrace_write(SB),NOSPLIT,$0-20
+ MOVL handle+0(FP), DI
+ MOVL id+4(FP), SI
+ MOVL arg0+8(FP), DX
+ MOVL arg1+12(FP), CX
+ MOVQ vdso_zx_ktrace_write(SB), AX
+ CALL AX
+ MOVL AX, ret+16(FP)
+ RET
+
+// func Sys_mtrace_control(handle Handle, kind uint32, action uint32, options uint32, ptr unsafe.Pointer, ptr_size uint) Status
+TEXT ·Sys_mtrace_control(SB),NOSPLIT,$0-36
+ MOVL handle+0(FP), DI
+ MOVL kind+4(FP), SI
+ MOVL action+8(FP), DX
+ MOVL options+12(FP), CX
+ MOVQ ptr+16(FP), R8
+ MOVQ ptr_size+24(FP), R9
+ MOVQ vdso_zx_mtrace_control(SB), AX
+ CALL AX
+ MOVL AX, ret+32(FP)
+ RET
+
+// func Sys_debug_read(handle Handle, buffer *uint8, buffer_size *uint) Status
+TEXT ·Sys_debug_read(SB),NOSPLIT,$0-28
+ MOVL handle+0(FP), DI
+ MOVQ buffer+8(FP), SI
+ MOVQ buffer_size+16(FP), DX
+ MOVQ vdso_zx_debug_read(SB), AX
+ CALL AX
+ MOVL AX, ret+24(FP)
+ RET
+
+// func Sys_debug_write(buffer *uint8, buffer_size uint) Status
+TEXT ·Sys_debug_write(SB),NOSPLIT,$0-20
+ MOVQ buffer+0(FP), DI
+ MOVQ buffer_size+8(FP), SI
+ MOVQ vdso_zx_debug_write(SB), AX
+ CALL AX
+ MOVL AX, ret+16(FP)
+ RET
+
+// func Sys_debug_send_command(resource Handle, buffer *uint8, buffer_size uint) Status
+TEXT ·Sys_debug_send_command(SB),NOSPLIT,$0-28
+ MOVL resource+0(FP), DI
+ MOVQ buffer+8(FP), SI
+ MOVQ buffer_size+16(FP), DX
+ MOVQ vdso_zx_debug_send_command(SB), AX
+ CALL AX
+ MOVL AX, ret+24(FP)
+ RET
+
+// func Sys_interrupt_create(src_obj Handle, src_num uint32, options uint32, out *Handle) Status
+TEXT ·Sys_interrupt_create(SB),NOSPLIT,$0-28
+ MOVL src_obj+0(FP), DI
+ MOVL src_num+4(FP), SI
+ MOVL options+8(FP), DX
+ MOVQ out+16(FP), CX
+ MOVQ vdso_zx_interrupt_create(SB), AX
+ CALL AX
+ MOVL AX, ret+24(FP)
+ RET
+
+// func Sys_interrupt_bind(handle Handle, port Handle, key uint64, options uint32) Status
+TEXT ·Sys_interrupt_bind(SB),NOSPLIT,$0-28
+ MOVL handle+0(FP), DI
+ MOVL port+4(FP), SI
+ MOVQ key+8(FP), DX
+ MOVL options+16(FP), CX
+ MOVQ vdso_zx_interrupt_bind(SB), AX
+ CALL AX
+ MOVL AX, ret+24(FP)
+ RET
+
+// func Sys_interrupt_wait(handle Handle, out_timestamp *Time) Status
+TEXT ·Sys_interrupt_wait(SB),NOSPLIT,$0-20
+ MOVL handle+0(FP), DI
+ MOVQ out_timestamp+8(FP), SI
+ MOVQ vdso_zx_interrupt_wait(SB), AX
+ CALL AX
+ MOVL AX, ret+16(FP)
+ RET
+
+// func Sys_interrupt_destroy(handle Handle) Status
+TEXT ·Sys_interrupt_destroy(SB),NOSPLIT,$0-12
+ MOVL handle+0(FP), DI
+ MOVQ vdso_zx_interrupt_destroy(SB), AX
+ CALL AX
+ MOVL AX, ret+8(FP)
+ RET
+
+// func Sys_interrupt_ack(handle Handle) Status
+TEXT ·Sys_interrupt_ack(SB),NOSPLIT,$0-12
+ MOVL handle+0(FP), DI
+ MOVQ vdso_zx_interrupt_ack(SB), AX
+ CALL AX
+ MOVL AX, ret+8(FP)
+ RET
+
+// func Sys_interrupt_trigger(handle Handle, options uint32, timestamp Time) Status
+TEXT ·Sys_interrupt_trigger(SB),NOSPLIT,$0-20
+ MOVL handle+0(FP), DI
+ MOVL options+4(FP), SI
+ MOVQ timestamp+8(FP), DX
+ MOVQ vdso_zx_interrupt_trigger(SB), AX
+ CALL AX
+ MOVL AX, ret+16(FP)
+ RET
+
+// func Sys_ioports_request(resource Handle, io_addr uint16, len uint32) Status
+TEXT ·Sys_ioports_request(SB),NOSPLIT,$0-20
+ MOVL resource+0(FP), DI
+ MOVQ io_addr+4(FP), SI
+ MOVL len+8(FP), DX
+ MOVQ vdso_zx_ioports_request(SB), AX
+ CALL AX
+ MOVL AX, ret+16(FP)
+ RET
+
+// func Sys_vmo_create_contiguous(bti Handle, size uint, alignment_log2 uint32, out *Handle) Status
+TEXT ·Sys_vmo_create_contiguous(SB),NOSPLIT,$0-36
+ MOVL bti+0(FP), DI
+ MOVQ size+8(FP), SI
+ MOVL alignment_log2+16(FP), DX
+ MOVQ out+24(FP), CX
+ MOVQ vdso_zx_vmo_create_contiguous(SB), AX
+ CALL AX
+ MOVL AX, ret+32(FP)
+ RET
+
+// func Sys_vmo_create_physical(resource Handle, paddr Paddr, size uint, out *Handle) Status
+TEXT ·Sys_vmo_create_physical(SB),NOSPLIT,$0-36
+ MOVL resource+0(FP), DI
+ MOVQ paddr+8(FP), SI
+ MOVQ size+16(FP), DX
+ MOVQ out+24(FP), CX
+ MOVQ vdso_zx_vmo_create_physical(SB), AX
+ CALL AX
+ MOVL AX, ret+32(FP)
+ RET
+
+// func Sys_iommu_create(resource Handle, typ uint32, desc unsafe.Pointer, desc_size uint, out *Handle) Status
+TEXT ·Sys_iommu_create(SB),NOSPLIT,$0-36
+ MOVL resource+0(FP), DI
+ MOVL typ+4(FP), SI
+ MOVQ desc+8(FP), DX
+ MOVQ desc_size+16(FP), CX
+ MOVQ out+24(FP), R8
+ MOVQ vdso_zx_iommu_create(SB), AX
+ CALL AX
+ MOVL AX, ret+32(FP)
+ RET
+
+// func Sys_bti_create(iommu Handle, options uint32, bti_id uint64, out *Handle) Status
+TEXT ·Sys_bti_create(SB),NOSPLIT,$0-28
+ MOVL iommu+0(FP), DI
+ MOVL options+4(FP), SI
+ MOVQ bti_id+8(FP), DX
+ MOVQ out+16(FP), CX
+ MOVQ vdso_zx_bti_create(SB), AX
+ CALL AX
+ MOVL AX, ret+24(FP)
+ RET
+
+// func Sys_bti_pin(handle Handle, options uint32, vmo Handle, offset uint64, size uint64, addrs *Paddr, addrs_count uint, out *Handle) Status
+TEXT ·Sys_bti_pin(SB),NOSPLIT,$32-60
+ MOVL handle+0(FP), DI
+ MOVL options+4(FP), SI
+ MOVL vmo+8(FP), DX
+ MOVQ offset+16(FP), CX
+ MOVQ size+24(FP), R8
+ MOVQ addrs+32(FP), R9
+ MOVQ addrs_count+40(FP), R12
+ MOVQ out+48(FP), R13
+ MOVQ SP, BP // BP is preserved across vsdo call by the x86-64 ABI
+ ANDQ $~15, SP // stack alignment for x86-64 ABI
+ PUSHQ R13
+ PUSHQ R12
+ MOVQ vdso_zx_bti_pin(SB), AX
+ CALL AX
+ POPQ R12
+ POPQ R13
+ MOVQ BP, SP
+ MOVL AX, ret+56(FP)
+ RET
+
+// func Sys_bti_release_quarantine(handle Handle) Status
+TEXT ·Sys_bti_release_quarantine(SB),NOSPLIT,$0-12
+ MOVL handle+0(FP), DI
+ MOVQ vdso_zx_bti_release_quarantine(SB), AX
+ CALL AX
+ MOVL AX, ret+8(FP)
+ RET
+
+// func Sys_pmt_unpin(handle Handle) Status
+TEXT ·Sys_pmt_unpin(SB),NOSPLIT,$0-12
+ MOVL handle+0(FP), DI
+ MOVQ vdso_zx_pmt_unpin(SB), AX
+ CALL AX
+ MOVL AX, ret+8(FP)
+ RET
+
+// func Sys_framebuffer_get_info(resource Handle, format *uint32, width *uint32, height *uint32, stride *uint32) Status
+TEXT ·Sys_framebuffer_get_info(SB),NOSPLIT,$0-44
+ MOVL resource+0(FP), DI
+ MOVQ format+8(FP), SI
+ MOVQ width+16(FP), DX
+ MOVQ height+24(FP), CX
+ MOVQ stride+32(FP), R8
+ MOVQ vdso_zx_framebuffer_get_info(SB), AX
+ CALL AX
+ MOVL AX, ret+40(FP)
+ RET
+
+// func Sys_framebuffer_set_range(resource Handle, vmo Handle, len uint32, format uint32, width uint32, height uint32, stride uint32) Status
+TEXT ·Sys_framebuffer_set_range(SB),NOSPLIT,$24-36
+ MOVL resource+0(FP), DI
+ MOVL vmo+4(FP), SI
+ MOVL len+8(FP), DX
+ MOVL format+12(FP), CX
+ MOVL width+16(FP), R8
+ MOVL height+20(FP), R9
+ MOVL stride+24(FP), R12
+ MOVQ SP, BP // BP is preserved across vsdo call by the x86-64 ABI
+ ANDQ $~15, SP // stack alignment for x86-64 ABI
+ PUSHQ R12
+ MOVQ vdso_zx_framebuffer_set_range(SB), AX
+ CALL AX
+ POPQ R12
+ MOVQ BP, SP
+ MOVL AX, ret+32(FP)
+ RET
+
+// func Sys_pc_firmware_tables(handle Handle, acpi_rsdp *Paddr, smbios *Paddr) Status
+TEXT ·Sys_pc_firmware_tables(SB),NOSPLIT,$0-28
+ MOVL handle+0(FP), DI
+ MOVQ acpi_rsdp+8(FP), SI
+ MOVQ smbios+16(FP), DX
+ MOVQ vdso_zx_pc_firmware_tables(SB), AX
+ CALL AX
+ MOVL AX, ret+24(FP)
+ RET
+
+// func Sys_smc_call(handle Handle, parameters *SMCParameters, out_smc_result *SMCResult) Status
+TEXT ·Sys_smc_call(SB),NOSPLIT,$0-28
+ MOVL handle+0(FP), DI
+ MOVQ parameters+8(FP), SI
+ MOVQ out_smc_result+16(FP), DX
+ MOVQ vdso_zx_smc_call(SB), AX
+ CALL AX
+ MOVL AX, ret+24(FP)
+ RET
+
+// func Sys_resource_create(parent_rsrc Handle, options uint32, base uint64, size uint, name *uint8, name_size uint, resource_out *Handle) Status
+TEXT ·Sys_resource_create(SB),NOSPLIT,$24-52
+ MOVL parent_rsrc+0(FP), DI
+ MOVL options+4(FP), SI
+ MOVQ base+8(FP), DX
+ MOVQ size+16(FP), CX
+ MOVQ name+24(FP), R8
+ MOVQ name_size+32(FP), R9
+ MOVQ resource_out+40(FP), R12
+ MOVQ SP, BP // BP is preserved across vsdo call by the x86-64 ABI
+ ANDQ $~15, SP // stack alignment for x86-64 ABI
+ PUSHQ R12
+ MOVQ vdso_zx_resource_create(SB), AX
+ CALL AX
+ POPQ R12
+ MOVQ BP, SP
+ MOVL AX, ret+48(FP)
+ RET
+
+// func Sys_system_mexec(resource Handle, kernel Handle, bootimage Handle) Status
+TEXT ·Sys_system_mexec(SB),NOSPLIT,$0-20
+ MOVL resource+0(FP), DI
+ MOVL kernel+4(FP), SI
+ MOVL bootimage+8(FP), DX
+ MOVQ vdso_zx_system_mexec(SB), AX
+ CALL AX
+ MOVL AX, ret+16(FP)
+ RET
+
+// func Sys_system_powerctl(resource Handle, cmd uint32, arg *int) Status
+TEXT ·Sys_system_powerctl(SB),NOSPLIT,$0-20
+ MOVL resource+0(FP), DI
+ MOVL cmd+4(FP), SI
+ MOVQ arg+8(FP), DX
+ MOVQ vdso_zx_system_powerctl(SB), AX
+ CALL AX
+ MOVL AX, ret+16(FP)
+ RET
+
diff --git a/src/syscall/zx/syscalls_fuchsia_arm64.s b/src/syscall/zx/syscalls_fuchsia_arm64.s
new file mode 100644
index 0000000..13a2a13
--- /dev/null
+++ b/src/syscall/zx/syscalls_fuchsia_arm64.s
@@ -0,0 +1,1248 @@
+// Copyright 2016 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.
+
+// Zircon system calls for the Fuchsia OS.
+// Generated by mkfuchsia.go, do not edit.
+
+#include "textflag.h"
+
+// func Sys_clock_get(clock_id uint32) Time
+TEXT ·Sys_clock_get(SB),NOSPLIT,$0-16
+ MOVW clock_id+0(FP), R0
+ BL vdso_zx_clock_get(SB)
+ MOVD R0, ret+8(FP)
+ RET
+
+// func Sys_clock_get_new(clock_id uint32, out *Time) Status
+TEXT ·Sys_clock_get_new(SB),NOSPLIT,$0-20
+ MOVW clock_id+0(FP), R0
+ MOVD out+8(FP), R1
+ BL vdso_zx_clock_get_new(SB)
+ MOVW R0, ret+16(FP)
+ RET
+
+// func Sys_clock_get_monotonic() Time
+TEXT ·Sys_clock_get_monotonic(SB),NOSPLIT,$0-8
+ BL vdso_zx_clock_get_monotonic(SB)
+ MOVD R0, ret+0(FP)
+ RET
+
+// func Sys_nanosleep(deadline Time) Status
+TEXT ·Sys_nanosleep(SB),NOSPLIT,$0-12
+ MOVD deadline+0(FP), R0
+ BL vdso_zx_nanosleep(SB)
+ MOVW R0, ret+8(FP)
+ RET
+
+// func Sys_ticks_get() uint64
+TEXT ·Sys_ticks_get(SB),NOSPLIT,$0-8
+ BL vdso_zx_ticks_get(SB)
+ MOVD R0, ret+0(FP)
+ RET
+
+// func Sys_ticks_per_second() uint64
+TEXT ·Sys_ticks_per_second(SB),NOSPLIT,$0-8
+ BL vdso_zx_ticks_per_second(SB)
+ MOVD R0, ret+0(FP)
+ RET
+
+// func Sys_deadline_after(nanoseconds Duration) Time
+TEXT ·Sys_deadline_after(SB),NOSPLIT,$0-16
+ MOVD nanoseconds+0(FP), R0
+ BL vdso_zx_deadline_after(SB)
+ MOVD R0, ret+8(FP)
+ RET
+
+// func Sys_clock_adjust(handle Handle, clock_id uint32, offset int64) Status
+TEXT ·Sys_clock_adjust(SB),NOSPLIT,$0-20
+ MOVW handle+0(FP), R0
+ MOVW clock_id+4(FP), R1
+ MOVD offset+8(FP), R2
+ BL vdso_zx_clock_adjust(SB)
+ MOVW R0, ret+16(FP)
+ RET
+
+// func sys_system_get_dcache_line_size() uint32
+TEXT ·sys_system_get_dcache_line_size(SB),NOSPLIT,$0-4
+ BL vdso_zx_system_get_dcache_line_size(SB)
+ MOVW R0, ret+0(FP)
+ RET
+
+// func Sys_system_get_num_cpus() uint32
+TEXT ·Sys_system_get_num_cpus(SB),NOSPLIT,$0-4
+ BL vdso_zx_system_get_num_cpus(SB)
+ MOVW R0, ret+0(FP)
+ RET
+
+// func Sys_system_get_version(version *uint8, version_size uint) Status
+TEXT ·Sys_system_get_version(SB),NOSPLIT,$0-20
+ MOVD version+0(FP), R0
+ MOVD version_size+8(FP), R1
+ BL vdso_zx_system_get_version(SB)
+ MOVW R0, ret+16(FP)
+ RET
+
+// func Sys_system_get_physmem() uint64
+TEXT ·Sys_system_get_physmem(SB),NOSPLIT,$0-8
+ BL vdso_zx_system_get_physmem(SB)
+ MOVD R0, ret+0(FP)
+ RET
+
+// func sys_system_get_features(kind uint32, out *uint32) Status
+TEXT ·sys_system_get_features(SB),NOSPLIT,$0-20
+ MOVW kind+0(FP), R0
+ MOVD out+8(FP), R1
+ BL vdso_zx_system_get_features(SB)
+ MOVW R0, ret+16(FP)
+ RET
+
+// func Sys_cache_flush(addr unsafe.Pointer, size uint, options uint32) Status
+TEXT ·Sys_cache_flush(SB),NOSPLIT,$0-28
+ MOVD addr+0(FP), R0
+ MOVD size+8(FP), R1
+ MOVW options+16(FP), R2
+ BL vdso_zx_cache_flush(SB)
+ MOVW R0, ret+24(FP)
+ RET
+
+// func Sys_handle_close(handle Handle) Status
+TEXT ·Sys_handle_close(SB),NOSPLIT,$0-12
+ MOVW handle+0(FP), R0
+ BL vdso_zx_handle_close(SB)
+ MOVW R0, ret+8(FP)
+ RET
+
+// func Sys_handle_close_many(handles *Handle, num_handles uint) Status
+TEXT ·Sys_handle_close_many(SB),NOSPLIT,$0-20
+ MOVD handles+0(FP), R0
+ MOVD num_handles+8(FP), R1
+ BL vdso_zx_handle_close_many(SB)
+ MOVW R0, ret+16(FP)
+ RET
+
+// func sys_handle_duplicate(handle Handle, rights Rights, out *Handle) Status
+TEXT ·sys_handle_duplicate(SB),NOSPLIT,$0-20
+ MOVW handle+0(FP), R0
+ MOVW rights+4(FP), R1
+ MOVD out+8(FP), R2
+ BL vdso_zx_handle_duplicate(SB)
+ MOVW R0, ret+16(FP)
+ RET
+
+// func Sys_handle_replace(handle Handle, rights Rights, out *Handle) Status
+TEXT ·Sys_handle_replace(SB),NOSPLIT,$0-20
+ MOVW handle+0(FP), R0
+ MOVW rights+4(FP), R1
+ MOVD out+8(FP), R2
+ BL vdso_zx_handle_replace(SB)
+ MOVW R0, ret+16(FP)
+ RET
+
+// func Sys_object_wait_one(handle Handle, signals Signals, deadline Time, observed *Signals) Status
+TEXT ·Sys_object_wait_one(SB),NOSPLIT,$0-28
+ CALL runtime·entersyscall(SB)
+ MOVW handle+0(FP), R0
+ MOVW signals+4(FP), R1
+ MOVD deadline+8(FP), R2
+ MOVD observed+16(FP), R3
+ BL vdso_zx_object_wait_one(SB)
+ MOVW R0, ret+24(FP)
+ BL runtime·exitsyscall(SB)
+ RET
+
+// func sys_object_wait_many(items *WaitItem, count uint, deadline Time) Status
+TEXT ·sys_object_wait_many(SB),NOSPLIT,$0-28
+ CALL runtime·entersyscall(SB)
+ MOVD items+0(FP), R0
+ MOVD count+8(FP), R1
+ MOVD deadline+16(FP), R2
+ BL vdso_zx_object_wait_many(SB)
+ MOVW R0, ret+24(FP)
+ BL runtime·exitsyscall(SB)
+ RET
+
+// func Sys_object_wait_async(handle Handle, port Handle, key uint64, signals Signals, options uint32) Status
+TEXT ·Sys_object_wait_async(SB),NOSPLIT,$0-28
+ MOVW handle+0(FP), R0
+ MOVW port+4(FP), R1
+ MOVD key+8(FP), R2
+ MOVW signals+16(FP), R3
+ MOVW options+20(FP), R4
+ BL vdso_zx_object_wait_async(SB)
+ MOVW R0, ret+24(FP)
+ RET
+
+// func Sys_object_signal(handle Handle, clear_mask uint32, set_mask uint32) Status
+TEXT ·Sys_object_signal(SB),NOSPLIT,$0-20
+ MOVW handle+0(FP), R0
+ MOVW clear_mask+4(FP), R1
+ MOVW set_mask+8(FP), R2
+ BL vdso_zx_object_signal(SB)
+ MOVW R0, ret+16(FP)
+ RET
+
+// func Sys_object_signal_peer(handle Handle, clear_mask uint32, set_mask uint32) Status
+TEXT ·Sys_object_signal_peer(SB),NOSPLIT,$0-20
+ MOVW handle+0(FP), R0
+ MOVW clear_mask+4(FP), R1
+ MOVW set_mask+8(FP), R2
+ BL vdso_zx_object_signal_peer(SB)
+ MOVW R0, ret+16(FP)
+ RET
+
+// func Sys_object_get_property(handle Handle, property uint32, value unsafe.Pointer, value_size uint) Status
+TEXT ·Sys_object_get_property(SB),NOSPLIT,$0-28
+ MOVW handle+0(FP), R0
+ MOVW property+4(FP), R1
+ MOVD value+8(FP), R2
+ MOVD value_size+16(FP), R3
+ BL vdso_zx_object_get_property(SB)
+ MOVW R0, ret+24(FP)
+ RET
+
+// func Sys_object_set_property(handle Handle, property uint32, value unsafe.Pointer, value_size uint) Status
+TEXT ·Sys_object_set_property(SB),NOSPLIT,$0-28
+ MOVW handle+0(FP), R0
+ MOVW property+4(FP), R1
+ MOVD value+8(FP), R2
+ MOVD value_size+16(FP), R3
+ BL vdso_zx_object_set_property(SB)
+ MOVW R0, ret+24(FP)
+ RET
+
+// func Sys_object_set_cookie(handle Handle, scope Handle, cookie uint64) Status
+TEXT ·Sys_object_set_cookie(SB),NOSPLIT,$0-20
+ MOVW handle+0(FP), R0
+ MOVW scope+4(FP), R1
+ MOVD cookie+8(FP), R2
+ BL vdso_zx_object_set_cookie(SB)
+ MOVW R0, ret+16(FP)
+ RET
+
+// func Sys_object_get_cookie(handle Handle, scope Handle, cookie *uint64) Status
+TEXT ·Sys_object_get_cookie(SB),NOSPLIT,$0-20
+ MOVW handle+0(FP), R0
+ MOVW scope+4(FP), R1
+ MOVD cookie+8(FP), R2
+ BL vdso_zx_object_get_cookie(SB)
+ MOVW R0, ret+16(FP)
+ RET
+
+// func Sys_object_get_info(handle Handle, topic uint32, buffer unsafe.Pointer, buffer_size uint, actual_count *uint, avail_count *uint) Status
+TEXT ·Sys_object_get_info(SB),NOSPLIT,$0-44
+ MOVW handle+0(FP), R0
+ MOVW topic+4(FP), R1
+ MOVD buffer+8(FP), R2
+ MOVD buffer_size+16(FP), R3
+ MOVD actual_count+24(FP), R4
+ MOVD avail_count+32(FP), R5
+ BL vdso_zx_object_get_info(SB)
+ MOVW R0, ret+40(FP)
+ RET
+
+// func Sys_object_get_child(handle Handle, koid uint64, rights Rights, out *Handle) Status
+TEXT ·Sys_object_get_child(SB),NOSPLIT,$0-36
+ MOVW handle+0(FP), R0
+ MOVD koid+8(FP), R1
+ MOVW rights+16(FP), R2
+ MOVD out+24(FP), R3
+ BL vdso_zx_object_get_child(SB)
+ MOVW R0, ret+32(FP)
+ RET
+
+// func sys_object_set_profile(handle Handle, profile Handle, options uint32) Status
+TEXT ·sys_object_set_profile(SB),NOSPLIT,$0-20
+ MOVW handle+0(FP), R0
+ MOVW profile+4(FP), R1
+ MOVW options+8(FP), R2
+ BL vdso_zx_object_set_profile(SB)
+ MOVW R0, ret+16(FP)
+ RET
+
+// func sys_channel_create(options uint32, out0 *Handle, out1 *Handle) Status
+TEXT ·sys_channel_create(SB),NOSPLIT,$0-28
+ MOVW options+0(FP), R0
+ MOVD out0+8(FP), R1
+ MOVD out1+16(FP), R2
+ BL vdso_zx_channel_create(SB)
+ MOVW R0, ret+24(FP)
+ RET
+
+// func sys_channel_read(handle Handle, options uint32, bytes unsafe.Pointer, handles *Handle, num_bytes uint32, num_handles uint32, actual_bytes *uint32, actual_handles *uint32) Status
+TEXT ·sys_channel_read(SB),NOSPLIT,$0-52
+ MOVW handle+0(FP), R0
+ MOVW options+4(FP), R1
+ MOVD bytes+8(FP), R2
+ MOVD handles+16(FP), R3
+ MOVW num_bytes+24(FP), R4
+ MOVW num_handles+28(FP), R5
+ MOVD actual_bytes+32(FP), R6
+ MOVD actual_handles+40(FP), R7
+ BL vdso_zx_channel_read(SB)
+ MOVW R0, ret+48(FP)
+ RET
+
+// func sys_channel_read_etc(handle Handle, options uint32, bytes unsafe.Pointer, handles *int, num_bytes uint32, num_handles uint32, actual_bytes *uint32, actual_handles *uint32) Status
+TEXT ·sys_channel_read_etc(SB),NOSPLIT,$0-52
+ MOVW handle+0(FP), R0
+ MOVW options+4(FP), R1
+ MOVD bytes+8(FP), R2
+ MOVD handles+16(FP), R3
+ MOVW num_bytes+24(FP), R4
+ MOVW num_handles+28(FP), R5
+ MOVD actual_bytes+32(FP), R6
+ MOVD actual_handles+40(FP), R7
+ BL vdso_zx_channel_read_etc(SB)
+ MOVW R0, ret+48(FP)
+ RET
+
+// func sys_channel_write(handle Handle, options uint32, bytes unsafe.Pointer, num_bytes uint32, handles *Handle, num_handles uint32) Status
+TEXT ·sys_channel_write(SB),NOSPLIT,$0-44
+ MOVW handle+0(FP), R0
+ MOVW options+4(FP), R1
+ MOVD bytes+8(FP), R2
+ MOVW num_bytes+16(FP), R3
+ MOVD handles+24(FP), R4
+ MOVW num_handles+32(FP), R5
+ BL vdso_zx_channel_write(SB)
+ MOVW R0, ret+40(FP)
+ RET
+
+// func Sys_channel_call_noretry(handle Handle, options uint32, deadline Time, args *ChannelCallArgs, actual_bytes *uint32, actual_handles *uint32) Status
+TEXT ·Sys_channel_call_noretry(SB),NOSPLIT,$0-44
+ MOVW handle+0(FP), R0
+ MOVW options+4(FP), R1
+ MOVD deadline+8(FP), R2
+ MOVD args+16(FP), R3
+ MOVD actual_bytes+24(FP), R4
+ MOVD actual_handles+32(FP), R5
+ BL vdso_zx_channel_call_noretry(SB)
+ MOVW R0, ret+40(FP)
+ RET
+
+// func Sys_channel_call_finish(deadline Time, args *ChannelCallArgs, actual_bytes *uint32, actual_handles *uint32) Status
+TEXT ·Sys_channel_call_finish(SB),NOSPLIT,$0-36
+ MOVD deadline+0(FP), R0
+ MOVD args+8(FP), R1
+ MOVD actual_bytes+16(FP), R2
+ MOVD actual_handles+24(FP), R3
+ BL vdso_zx_channel_call_finish(SB)
+ MOVW R0, ret+32(FP)
+ RET
+
+// func Sys_channel_call(handle Handle, options uint32, deadline Time, args *ChannelCallArgs, actual_bytes *uint32, actual_handles *uint32) Status
+TEXT ·Sys_channel_call(SB),NOSPLIT,$0-44
+ MOVW handle+0(FP), R0
+ MOVW options+4(FP), R1
+ MOVD deadline+8(FP), R2
+ MOVD args+16(FP), R3
+ MOVD actual_bytes+24(FP), R4
+ MOVD actual_handles+32(FP), R5
+ BL vdso_zx_channel_call(SB)
+ MOVW R0, ret+40(FP)
+ RET
+
+// func sys_socket_create(options uint32, out0 *Handle, out1 *Handle) Status
+TEXT ·sys_socket_create(SB),NOSPLIT,$0-28
+ MOVW options+0(FP), R0
+ MOVD out0+8(FP), R1
+ MOVD out1+16(FP), R2
+ BL vdso_zx_socket_create(SB)
+ MOVW R0, ret+24(FP)
+ RET
+
+// func sys_socket_write(handle Handle, options uint32, buffer unsafe.Pointer, buffer_size uint, actual *uint) Status
+TEXT ·sys_socket_write(SB),NOSPLIT,$0-36
+ MOVW handle+0(FP), R0
+ MOVW options+4(FP), R1
+ MOVD buffer+8(FP), R2
+ MOVD buffer_size+16(FP), R3
+ MOVD actual+24(FP), R4
+ BL vdso_zx_socket_write(SB)
+ MOVW R0, ret+32(FP)
+ RET
+
+// func sys_socket_read(handle Handle, options uint32, buffer unsafe.Pointer, buffer_size uint, actual *uint) Status
+TEXT ·sys_socket_read(SB),NOSPLIT,$0-36
+ MOVW handle+0(FP), R0
+ MOVW options+4(FP), R1
+ MOVD buffer+8(FP), R2
+ MOVD buffer_size+16(FP), R3
+ MOVD actual+24(FP), R4
+ BL vdso_zx_socket_read(SB)
+ MOVW R0, ret+32(FP)
+ RET
+
+// func sys_socket_share(handle Handle, socket_to_share Handle) Status
+TEXT ·sys_socket_share(SB),NOSPLIT,$0-12
+ MOVW handle+0(FP), R0
+ MOVW socket_to_share+4(FP), R1
+ BL vdso_zx_socket_share(SB)
+ MOVW R0, ret+8(FP)
+ RET
+
+// func sys_socket_accept(handle Handle, out_socket *Handle) Status
+TEXT ·sys_socket_accept(SB),NOSPLIT,$0-20
+ MOVW handle+0(FP), R0
+ MOVD out_socket+8(FP), R1
+ BL vdso_zx_socket_accept(SB)
+ MOVW R0, ret+16(FP)
+ RET
+
+// func Sys_thread_exit()
+TEXT ·Sys_thread_exit(SB),NOSPLIT,$0-0
+ BL vdso_zx_thread_exit(SB)
+ RET
+
+// func Sys_thread_create(process Handle, name *uint8, name_size uint, options uint32, out *Handle) Status
+TEXT ·Sys_thread_create(SB),NOSPLIT,$0-44
+ MOVW process+0(FP), R0
+ MOVD name+8(FP), R1
+ MOVD name_size+16(FP), R2
+ MOVW options+24(FP), R3
+ MOVD out+32(FP), R4
+ BL vdso_zx_thread_create(SB)
+ MOVW R0, ret+40(FP)
+ RET
+
+// func Sys_thread_start(handle Handle, thread_entry Vaddr, stack Vaddr, arg1 uintptr, arg2 uintptr) Status
+TEXT ·Sys_thread_start(SB),NOSPLIT,$0-44
+ MOVW handle+0(FP), R0
+ MOVD thread_entry+8(FP), R1
+ MOVD stack+16(FP), R2
+ MOVD arg1+24(FP), R3
+ MOVD arg2+32(FP), R4
+ BL vdso_zx_thread_start(SB)
+ MOVW R0, ret+40(FP)
+ RET
+
+// func Sys_thread_read_state(handle Handle, kind uint32, buffer unsafe.Pointer, buffer_size uint) Status
+TEXT ·Sys_thread_read_state(SB),NOSPLIT,$0-28
+ MOVW handle+0(FP), R0
+ MOVW kind+4(FP), R1
+ MOVD buffer+8(FP), R2
+ MOVD buffer_size+16(FP), R3
+ BL vdso_zx_thread_read_state(SB)
+ MOVW R0, ret+24(FP)
+ RET
+
+// func Sys_thread_write_state(handle Handle, kind uint32, buffer unsafe.Pointer, buffer_size uint) Status
+TEXT ·Sys_thread_write_state(SB),NOSPLIT,$0-28
+ MOVW handle+0(FP), R0
+ MOVW kind+4(FP), R1
+ MOVD buffer+8(FP), R2
+ MOVD buffer_size+16(FP), R3
+ BL vdso_zx_thread_write_state(SB)
+ MOVW R0, ret+24(FP)
+ RET
+
+// func Sys_thread_set_priority(prio int32) Status
+TEXT ·Sys_thread_set_priority(SB),NOSPLIT,$0-12
+ MOVW prio+0(FP), R0
+ BL vdso_zx_thread_set_priority(SB)
+ MOVW R0, ret+8(FP)
+ RET
+
+// func Sys_process_exit(retcode int64)
+TEXT ·Sys_process_exit(SB),NOSPLIT,$0-8
+ MOVD retcode+0(FP), R0
+ BL vdso_zx_process_exit(SB)
+ RET
+
+// func Sys_process_create(job Handle, name *uint8, name_size uint, options uint32, proc_handle *Handle, vmar_handle *Handle) Status
+TEXT ·Sys_process_create(SB),NOSPLIT,$0-52
+ MOVW job+0(FP), R0
+ MOVD name+8(FP), R1
+ MOVD name_size+16(FP), R2
+ MOVW options+24(FP), R3
+ MOVD proc_handle+32(FP), R4
+ MOVD vmar_handle+40(FP), R5
+ BL vdso_zx_process_create(SB)
+ MOVW R0, ret+48(FP)
+ RET
+
+// func Sys_process_start(handle Handle, thread Handle, entry Vaddr, stack Vaddr, arg1 Handle, arg2 uintptr) Status
+TEXT ·Sys_process_start(SB),NOSPLIT,$0-44
+ MOVW handle+0(FP), R0
+ MOVW thread+4(FP), R1
+ MOVD entry+8(FP), R2
+ MOVD stack+16(FP), R3
+ MOVW arg1+24(FP), R4
+ MOVD arg2+32(FP), R5
+ BL vdso_zx_process_start(SB)
+ MOVW R0, ret+40(FP)
+ RET
+
+// func Sys_process_read_memory(proc Handle, vaddr Vaddr, buffer unsafe.Pointer, buffer_size uint, actual *uint) Status
+TEXT ·Sys_process_read_memory(SB),NOSPLIT,$0-44
+ MOVW proc+0(FP), R0
+ MOVD vaddr+8(FP), R1
+ MOVD buffer+16(FP), R2
+ MOVD buffer_size+24(FP), R3
+ MOVD actual+32(FP), R4
+ BL vdso_zx_process_read_memory(SB)
+ MOVW R0, ret+40(FP)
+ RET
+
+// func Sys_process_write_memory(proc Handle, vaddr Vaddr, buffer unsafe.Pointer, buffer_size uint, actual *uint) Status
+TEXT ·Sys_process_write_memory(SB),NOSPLIT,$0-44
+ MOVW proc+0(FP), R0
+ MOVD vaddr+8(FP), R1
+ MOVD buffer+16(FP), R2
+ MOVD buffer_size+24(FP), R3
+ MOVD actual+32(FP), R4
+ BL vdso_zx_process_write_memory(SB)
+ MOVW R0, ret+40(FP)
+ RET
+
+// func Sys_job_create(parent_job Handle, options uint32, out *Handle) Status
+TEXT ·Sys_job_create(SB),NOSPLIT,$0-20
+ MOVW parent_job+0(FP), R0
+ MOVW options+4(FP), R1
+ MOVD out+8(FP), R2
+ BL vdso_zx_job_create(SB)
+ MOVW R0, ret+16(FP)
+ RET
+
+// func Sys_job_set_policy(job Handle, options uint32, topic uint32, policy unsafe.Pointer, count uint32) Status
+TEXT ·Sys_job_set_policy(SB),NOSPLIT,$0-36
+ MOVW job+0(FP), R0
+ MOVW options+4(FP), R1
+ MOVW topic+8(FP), R2
+ MOVD policy+16(FP), R3
+ MOVW count+24(FP), R4
+ BL vdso_zx_job_set_policy(SB)
+ MOVW R0, ret+32(FP)
+ RET
+
+// func Sys_task_bind_exception_port(handle Handle, port Handle, key uint64, options uint32) Status
+TEXT ·Sys_task_bind_exception_port(SB),NOSPLIT,$0-28
+ MOVW handle+0(FP), R0
+ MOVW port+4(FP), R1
+ MOVD key+8(FP), R2
+ MOVW options+16(FP), R3
+ BL vdso_zx_task_bind_exception_port(SB)
+ MOVW R0, ret+24(FP)
+ RET
+
+// func Sys_task_resume(handle Handle, options uint32) Status
+TEXT ·Sys_task_resume(SB),NOSPLIT,$0-12
+ MOVW handle+0(FP), R0
+ MOVW options+4(FP), R1
+ BL vdso_zx_task_resume(SB)
+ MOVW R0, ret+8(FP)
+ RET
+
+// func Sys_task_suspend(handle Handle, token *Handle) Status
+TEXT ·Sys_task_suspend(SB),NOSPLIT,$0-20
+ MOVW handle+0(FP), R0
+ MOVD token+8(FP), R1
+ BL vdso_zx_task_suspend(SB)
+ MOVW R0, ret+16(FP)
+ RET
+
+// func Sys_task_suspend_token(handle Handle, token *Handle) Status
+TEXT ·Sys_task_suspend_token(SB),NOSPLIT,$0-20
+ MOVW handle+0(FP), R0
+ MOVD token+8(FP), R1
+ BL vdso_zx_task_suspend_token(SB)
+ MOVW R0, ret+16(FP)
+ RET
+
+// func Sys_task_resume_from_exception(handle Handle, port Handle, options uint32) Status
+TEXT ·Sys_task_resume_from_exception(SB),NOSPLIT,$0-20
+ MOVW handle+0(FP), R0
+ MOVW port+4(FP), R1
+ MOVW options+8(FP), R2
+ BL vdso_zx_task_resume_from_exception(SB)
+ MOVW R0, ret+16(FP)
+ RET
+
+// func Sys_task_kill(handle Handle) Status
+TEXT ·Sys_task_kill(SB),NOSPLIT,$0-12
+ MOVW handle+0(FP), R0
+ BL vdso_zx_task_kill(SB)
+ MOVW R0, ret+8(FP)
+ RET
+
+// func Sys_event_create(options uint32, out *Handle) Status
+TEXT ·Sys_event_create(SB),NOSPLIT,$0-20
+ MOVW options+0(FP), R0
+ MOVD out+8(FP), R1
+ BL vdso_zx_event_create(SB)
+ MOVW R0, ret+16(FP)
+ RET
+
+// func Sys_eventpair_create(options uint32, out0 *Handle, out1 *Handle) Status
+TEXT ·Sys_eventpair_create(SB),NOSPLIT,$0-28
+ MOVW options+0(FP), R0
+ MOVD out0+8(FP), R1
+ MOVD out1+16(FP), R2
+ BL vdso_zx_eventpair_create(SB)
+ MOVW R0, ret+24(FP)
+ RET
+
+// func Sys_futex_wait(value_ptr *int, current_value int32, deadline Time) Status
+TEXT ·Sys_futex_wait(SB),NOSPLIT,$0-28
+ MOVD value_ptr+0(FP), R0
+ MOVW current_value+8(FP), R1
+ MOVD deadline+16(FP), R2
+ BL vdso_zx_futex_wait(SB)
+ MOVW R0, ret+24(FP)
+ RET
+
+// func Sys_futex_wake(value_ptr *int, count uint32) Status
+TEXT ·Sys_futex_wake(SB),NOSPLIT,$0-20
+ MOVD value_ptr+0(FP), R0
+ MOVW count+8(FP), R1
+ BL vdso_zx_futex_wake(SB)
+ MOVW R0, ret+16(FP)
+ RET
+
+// func Sys_futex_requeue(wake_ptr *int, wake_count uint32, current_value int32, requeue_ptr *int, requeue_count uint32) Status
+TEXT ·Sys_futex_requeue(SB),NOSPLIT,$0-36
+ MOVD wake_ptr+0(FP), R0
+ MOVW wake_count+8(FP), R1
+ MOVW current_value+12(FP), R2
+ MOVD requeue_ptr+16(FP), R3
+ MOVW requeue_count+24(FP), R4
+ BL vdso_zx_futex_requeue(SB)
+ MOVW R0, ret+32(FP)
+ RET
+
+// func Sys_port_create(options uint32, out *Handle) Status
+TEXT ·Sys_port_create(SB),NOSPLIT,$0-20
+ MOVW options+0(FP), R0
+ MOVD out+8(FP), R1
+ BL vdso_zx_port_create(SB)
+ MOVW R0, ret+16(FP)
+ RET
+
+// func Sys_port_queue(handle Handle, packet *int) Status
+TEXT ·Sys_port_queue(SB),NOSPLIT,$0-20
+ MOVW handle+0(FP), R0
+ MOVD packet+8(FP), R1
+ BL vdso_zx_port_queue(SB)
+ MOVW R0, ret+16(FP)
+ RET
+
+// func Sys_port_wait(handle Handle, deadline Time, packet *int) Status
+TEXT ·Sys_port_wait(SB),NOSPLIT,$0-28
+ CALL runtime·entersyscall(SB)
+ MOVW handle+0(FP), R0
+ MOVD deadline+8(FP), R1
+ MOVD packet+16(FP), R2
+ BL vdso_zx_port_wait(SB)
+ MOVW R0, ret+24(FP)
+ BL runtime·exitsyscall(SB)
+ RET
+
+// func Sys_port_cancel(handle Handle, source Handle, key uint64) Status
+TEXT ·Sys_port_cancel(SB),NOSPLIT,$0-20
+ MOVW handle+0(FP), R0
+ MOVW source+4(FP), R1
+ MOVD key+8(FP), R2
+ BL vdso_zx_port_cancel(SB)
+ MOVW R0, ret+16(FP)
+ RET
+
+// func Sys_timer_create(options uint32, clock_id uint32, out *Handle) Status
+TEXT ·Sys_timer_create(SB),NOSPLIT,$0-20
+ MOVW options+0(FP), R0
+ MOVW clock_id+4(FP), R1
+ MOVD out+8(FP), R2
+ BL vdso_zx_timer_create(SB)
+ MOVW R0, ret+16(FP)
+ RET
+
+// func Sys_timer_set(handle Handle, deadline Time, slack Duration) Status
+TEXT ·Sys_timer_set(SB),NOSPLIT,$0-28
+ MOVW handle+0(FP), R0
+ MOVD deadline+8(FP), R1
+ MOVD slack+16(FP), R2
+ BL vdso_zx_timer_set(SB)
+ MOVW R0, ret+24(FP)
+ RET
+
+// func Sys_timer_cancel(handle Handle) Status
+TEXT ·Sys_timer_cancel(SB),NOSPLIT,$0-12
+ MOVW handle+0(FP), R0
+ BL vdso_zx_timer_cancel(SB)
+ MOVW R0, ret+8(FP)
+ RET
+
+// func Sys_vmo_create(size uint64, options uint32, out *Handle) Status
+TEXT ·Sys_vmo_create(SB),NOSPLIT,$0-28
+ MOVD size+0(FP), R0
+ MOVW options+8(FP), R1
+ MOVD out+16(FP), R2
+ BL vdso_zx_vmo_create(SB)
+ MOVW R0, ret+24(FP)
+ RET
+
+// func sys_vmo_read(handle Handle, buffer unsafe.Pointer, offset uint64, buffer_size uint) Status
+TEXT ·sys_vmo_read(SB),NOSPLIT,$0-36
+ MOVW handle+0(FP), R0
+ MOVD buffer+8(FP), R1
+ MOVD offset+16(FP), R2
+ MOVD buffer_size+24(FP), R3
+ BL vdso_zx_vmo_read(SB)
+ MOVW R0, ret+32(FP)
+ RET
+
+// func sys_vmo_write(handle Handle, buffer unsafe.Pointer, offset uint64, buffer_size uint) Status
+TEXT ·sys_vmo_write(SB),NOSPLIT,$0-36
+ MOVW handle+0(FP), R0
+ MOVD buffer+8(FP), R1
+ MOVD offset+16(FP), R2
+ MOVD buffer_size+24(FP), R3
+ BL vdso_zx_vmo_write(SB)
+ MOVW R0, ret+32(FP)
+ RET
+
+// func sys_vmo_get_size(handle Handle, size *uint64) Status
+TEXT ·sys_vmo_get_size(SB),NOSPLIT,$0-20
+ MOVW handle+0(FP), R0
+ MOVD size+8(FP), R1
+ BL vdso_zx_vmo_get_size(SB)
+ MOVW R0, ret+16(FP)
+ RET
+
+// func sys_vmo_set_size(handle Handle, size uint64) Status
+TEXT ·sys_vmo_set_size(SB),NOSPLIT,$0-20
+ MOVW handle+0(FP), R0
+ MOVD size+8(FP), R1
+ BL vdso_zx_vmo_set_size(SB)
+ MOVW R0, ret+16(FP)
+ RET
+
+// func sys_vmo_op_range(handle Handle, op uint32, offset uint64, size uint64, buffer unsafe.Pointer, buffer_size uint) Status
+TEXT ·sys_vmo_op_range(SB),NOSPLIT,$0-44
+ MOVW handle+0(FP), R0
+ MOVW op+4(FP), R1
+ MOVD offset+8(FP), R2
+ MOVD size+16(FP), R3
+ MOVD buffer+24(FP), R4
+ MOVD buffer_size+32(FP), R5
+ BL vdso_zx_vmo_op_range(SB)
+ MOVW R0, ret+40(FP)
+ RET
+
+// func Sys_vmo_clone(handle Handle, options uint32, offset uint64, size uint64, out *Handle) Status
+TEXT ·Sys_vmo_clone(SB),NOSPLIT,$0-36
+ MOVW handle+0(FP), R0
+ MOVW options+4(FP), R1
+ MOVD offset+8(FP), R2
+ MOVD size+16(FP), R3
+ MOVD out+24(FP), R4
+ BL vdso_zx_vmo_clone(SB)
+ MOVW R0, ret+32(FP)
+ RET
+
+// func Sys_vmo_set_cache_policy(handle Handle, cache_policy uint32) Status
+TEXT ·Sys_vmo_set_cache_policy(SB),NOSPLIT,$0-12
+ MOVW handle+0(FP), R0
+ MOVW cache_policy+4(FP), R1
+ BL vdso_zx_vmo_set_cache_policy(SB)
+ MOVW R0, ret+8(FP)
+ RET
+
+// func sys_vmar_allocate_old(parent_vmar Handle, offset uint64, size uint64, map_flags uint32, child_vmar *Handle, child_addr *Vaddr) Status
+TEXT ·sys_vmar_allocate_old(SB),NOSPLIT,$0-52
+ MOVW parent_vmar+0(FP), R0
+ MOVD offset+8(FP), R1
+ MOVD size+16(FP), R2
+ MOVW map_flags+24(FP), R3
+ MOVD child_vmar+32(FP), R4
+ MOVD child_addr+40(FP), R5
+ BL vdso_zx_vmar_allocate_old(SB)
+ MOVW R0, ret+48(FP)
+ RET
+
+// func sys_vmar_map_old(handle Handle, vmar_offset uint64, vmo Handle, vmo_offset uint64, len uint64, map_flags uint32, mapped_addr *Vaddr) Status
+TEXT ·sys_vmar_map_old(SB),NOSPLIT,$0-60
+ MOVW handle+0(FP), R0
+ MOVD vmar_offset+8(FP), R1
+ MOVW vmo+16(FP), R2
+ MOVD vmo_offset+24(FP), R3
+ MOVD len+32(FP), R4
+ MOVW map_flags+40(FP), R5
+ MOVD mapped_addr+48(FP), R6
+ BL vdso_zx_vmar_map_old(SB)
+ MOVW R0, ret+56(FP)
+ RET
+
+// func sys_vmar_protect_old(handle Handle, addr Vaddr, len uint64, prot_flags uint32) Status
+TEXT ·sys_vmar_protect_old(SB),NOSPLIT,$0-36
+ MOVW handle+0(FP), R0
+ MOVD addr+8(FP), R1
+ MOVD len+16(FP), R2
+ MOVW prot_flags+24(FP), R3
+ BL vdso_zx_vmar_protect_old(SB)
+ MOVW R0, ret+32(FP)
+ RET
+
+// func sys_vmar_allocate(parent_vmar Handle, offset uint64, size uint64, map_flags uint32, child_vmar *Handle, child_addr *Vaddr) Status
+TEXT ·sys_vmar_allocate(SB),NOSPLIT,$0-52
+ MOVW parent_vmar+0(FP), R0
+ MOVD offset+8(FP), R1
+ MOVD size+16(FP), R2
+ MOVW map_flags+24(FP), R3
+ MOVD child_vmar+32(FP), R4
+ MOVD child_addr+40(FP), R5
+ BL vdso_zx_vmar_allocate(SB)
+ MOVW R0, ret+48(FP)
+ RET
+
+// func sys_vmar_destroy(handle Handle) Status
+TEXT ·sys_vmar_destroy(SB),NOSPLIT,$0-12
+ MOVW handle+0(FP), R0
+ BL vdso_zx_vmar_destroy(SB)
+ MOVW R0, ret+8(FP)
+ RET
+
+// func Sys_vmar_map(handle Handle, vmar_offset uint64, vmo Handle, vmo_offset uint64, len uint64, map_flags uint32, mapped_addr *Vaddr) Status
+TEXT ·Sys_vmar_map(SB),NOSPLIT,$0-60
+ MOVW handle+0(FP), R0
+ MOVD vmar_offset+8(FP), R1
+ MOVW vmo+16(FP), R2
+ MOVD vmo_offset+24(FP), R3
+ MOVD len+32(FP), R4
+ MOVW map_flags+40(FP), R5
+ MOVD mapped_addr+48(FP), R6
+ BL vdso_zx_vmar_map(SB)
+ MOVW R0, ret+56(FP)
+ RET
+
+// func Sys_vmar_unmap(handle Handle, addr Vaddr, len uint64) Status
+TEXT ·Sys_vmar_unmap(SB),NOSPLIT,$0-28
+ MOVW handle+0(FP), R0
+ MOVD addr+8(FP), R1
+ MOVD len+16(FP), R2
+ BL vdso_zx_vmar_unmap(SB)
+ MOVW R0, ret+24(FP)
+ RET
+
+// func Sys_vmar_protect(handle Handle, addr Vaddr, len uint64, prot_flags uint32) Status
+TEXT ·Sys_vmar_protect(SB),NOSPLIT,$0-36
+ MOVW handle+0(FP), R0
+ MOVD addr+8(FP), R1
+ MOVD len+16(FP), R2
+ MOVW prot_flags+24(FP), R3
+ BL vdso_zx_vmar_protect(SB)
+ MOVW R0, ret+32(FP)
+ RET
+
+// func Sys_cprng_draw_once(buffer unsafe.Pointer, buffer_size uint) Status
+TEXT ·Sys_cprng_draw_once(SB),NOSPLIT,$0-20
+ MOVD buffer+0(FP), R0
+ MOVD buffer_size+8(FP), R1
+ BL vdso_zx_cprng_draw_once(SB)
+ MOVW R0, ret+16(FP)
+ RET
+
+// func Sys_cprng_draw(buffer unsafe.Pointer, buffer_size uint)
+TEXT ·Sys_cprng_draw(SB),NOSPLIT,$0-16
+ MOVD buffer+0(FP), R0
+ MOVD buffer_size+8(FP), R1
+ BL vdso_zx_cprng_draw(SB)
+ RET
+
+// func Sys_cprng_draw_new(buffer unsafe.Pointer, data_size uint) Status
+TEXT ·Sys_cprng_draw_new(SB),NOSPLIT,$0-20
+ MOVD buffer+0(FP), R0
+ MOVD data_size+8(FP), R1
+ BL vdso_zx_cprng_draw_new(SB)
+ MOVW R0, ret+16(FP)
+ RET
+
+// func Sys_cprng_add_entropy(buffer unsafe.Pointer, len uint) Status
+TEXT ·Sys_cprng_add_entropy(SB),NOSPLIT,$0-20
+ MOVD buffer+0(FP), R0
+ MOVD len+8(FP), R1
+ BL vdso_zx_cprng_add_entropy(SB)
+ MOVW R0, ret+16(FP)
+ RET
+
+// func Sys_fifo_create(elem_count uint, elem_size uint, options uint32, out0 *Handle, out1 *Handle) Status
+TEXT ·Sys_fifo_create(SB),NOSPLIT,$0-44
+ MOVD elem_count+0(FP), R0
+ MOVD elem_size+8(FP), R1
+ MOVW options+16(FP), R2
+ MOVD out0+24(FP), R3
+ MOVD out1+32(FP), R4
+ BL vdso_zx_fifo_create(SB)
+ MOVW R0, ret+40(FP)
+ RET
+
+// func Sys_fifo_read(handle Handle, elem_size uint, data unsafe.Pointer, count uint, actual_count *uint) Status
+TEXT ·Sys_fifo_read(SB),NOSPLIT,$0-44
+ MOVW handle+0(FP), R0
+ MOVD elem_size+8(FP), R1
+ MOVD data+16(FP), R2
+ MOVD count+24(FP), R3
+ MOVD actual_count+32(FP), R4
+ BL vdso_zx_fifo_read(SB)
+ MOVW R0, ret+40(FP)
+ RET
+
+// func Sys_fifo_write(handle Handle, elem_size uint, data unsafe.Pointer, count uint, actual_count *uint) Status
+TEXT ·Sys_fifo_write(SB),NOSPLIT,$0-44
+ MOVW handle+0(FP), R0
+ MOVD elem_size+8(FP), R1
+ MOVD data+16(FP), R2
+ MOVD count+24(FP), R3
+ MOVD actual_count+32(FP), R4
+ BL vdso_zx_fifo_write(SB)
+ MOVW R0, ret+40(FP)
+ RET
+
+// func Sys_profile_create(resource Handle, profile *int, out *Handle) Status
+TEXT ·Sys_profile_create(SB),NOSPLIT,$0-28
+ MOVW resource+0(FP), R0
+ MOVD profile+8(FP), R1
+ MOVD out+16(FP), R2
+ BL vdso_zx_profile_create(SB)
+ MOVW R0, ret+24(FP)
+ RET
+
+// func Sys_vmar_unmap_handle_close_thread_exit(vmar_handle Handle, addr Vaddr, size uint, handle Handle) Status
+TEXT ·Sys_vmar_unmap_handle_close_thread_exit(SB),NOSPLIT,$0-36
+ MOVW vmar_handle+0(FP), R0
+ MOVD addr+8(FP), R1
+ MOVD size+16(FP), R2
+ MOVW handle+24(FP), R3
+ BL vdso_zx_vmar_unmap_handle_close_thread_exit(SB)
+ MOVW R0, ret+32(FP)
+ RET
+
+// func Sys_futex_wake_handle_close_thread_exit(value_ptr *int, count uint32, new_value int32, handle Handle)
+TEXT ·Sys_futex_wake_handle_close_thread_exit(SB),NOSPLIT,$0-24
+ MOVD value_ptr+0(FP), R0
+ MOVW count+8(FP), R1
+ MOVW new_value+12(FP), R2
+ MOVW handle+16(FP), R3
+ BL vdso_zx_futex_wake_handle_close_thread_exit(SB)
+ RET
+
+// func Sys_log_write(handle Handle, len uint32, buffer unsafe.Pointer, options uint32) Status
+TEXT ·Sys_log_write(SB),NOSPLIT,$0-28
+ MOVW handle+0(FP), R0
+ MOVW len+4(FP), R1
+ MOVD buffer+8(FP), R2
+ MOVW options+16(FP), R3
+ BL vdso_zx_log_write(SB)
+ MOVW R0, ret+24(FP)
+ RET
+
+// func Sys_log_read(handle Handle, len uint32, buffer unsafe.Pointer, options uint32) Status
+TEXT ·Sys_log_read(SB),NOSPLIT,$0-28
+ MOVW handle+0(FP), R0
+ MOVW len+4(FP), R1
+ MOVD buffer+8(FP), R2
+ MOVW options+16(FP), R3
+ BL vdso_zx_log_read(SB)
+ MOVW R0, ret+24(FP)
+ RET
+
+// func Sys_debuglog_create(resource Handle, options uint32, out *Handle) Status
+TEXT ·Sys_debuglog_create(SB),NOSPLIT,$0-20
+ MOVW resource+0(FP), R0
+ MOVW options+4(FP), R1
+ MOVD out+8(FP), R2
+ BL vdso_zx_debuglog_create(SB)
+ MOVW R0, ret+16(FP)
+ RET
+
+// func Sys_debuglog_write(handle Handle, options uint32, buffer unsafe.Pointer, buffer_size uint) Status
+TEXT ·Sys_debuglog_write(SB),NOSPLIT,$0-28
+ MOVW handle+0(FP), R0
+ MOVW options+4(FP), R1
+ MOVD buffer+8(FP), R2
+ MOVD buffer_size+16(FP), R3
+ BL vdso_zx_debuglog_write(SB)
+ MOVW R0, ret+24(FP)
+ RET
+
+// func Sys_debuglog_read(handle Handle, options uint32, buffer unsafe.Pointer, buffer_size uint) Status
+TEXT ·Sys_debuglog_read(SB),NOSPLIT,$0-28
+ MOVW handle+0(FP), R0
+ MOVW options+4(FP), R1
+ MOVD buffer+8(FP), R2
+ MOVD buffer_size+16(FP), R3
+ BL vdso_zx_debuglog_read(SB)
+ MOVW R0, ret+24(FP)
+ RET
+
+// func Sys_ktrace_read(handle Handle, data unsafe.Pointer, offset uint32, data_size uint, actual *uint) Status
+TEXT ·Sys_ktrace_read(SB),NOSPLIT,$0-44
+ MOVW handle+0(FP), R0
+ MOVD data+8(FP), R1
+ MOVW offset+16(FP), R2
+ MOVD data_size+24(FP), R3
+ MOVD actual+32(FP), R4
+ BL vdso_zx_ktrace_read(SB)
+ MOVW R0, ret+40(FP)
+ RET
+
+// func Sys_ktrace_control(handle Handle, action uint32, options uint32, ptr unsafe.Pointer) Status
+TEXT ·Sys_ktrace_control(SB),NOSPLIT,$0-28
+ MOVW handle+0(FP), R0
+ MOVW action+4(FP), R1
+ MOVW options+8(FP), R2
+ MOVD ptr+16(FP), R3
+ BL vdso_zx_ktrace_control(SB)
+ MOVW R0, ret+24(FP)
+ RET
+
+// func Sys_ktrace_write(handle Handle, id uint32, arg0 uint32, arg1 uint32) Status
+TEXT ·Sys_ktrace_write(SB),NOSPLIT,$0-20
+ MOVW handle+0(FP), R0
+ MOVW id+4(FP), R1
+ MOVW arg0+8(FP), R2
+ MOVW arg1+12(FP), R3
+ BL vdso_zx_ktrace_write(SB)
+ MOVW R0, ret+16(FP)
+ RET
+
+// func Sys_mtrace_control(handle Handle, kind uint32, action uint32, options uint32, ptr unsafe.Pointer, ptr_size uint) Status
+TEXT ·Sys_mtrace_control(SB),NOSPLIT,$0-36
+ MOVW handle+0(FP), R0
+ MOVW kind+4(FP), R1
+ MOVW action+8(FP), R2
+ MOVW options+12(FP), R3
+ MOVD ptr+16(FP), R4
+ MOVD ptr_size+24(FP), R5
+ BL vdso_zx_mtrace_control(SB)
+ MOVW R0, ret+32(FP)
+ RET
+
+// func Sys_debug_read(handle Handle, buffer *uint8, buffer_size *uint) Status
+TEXT ·Sys_debug_read(SB),NOSPLIT,$0-28
+ MOVW handle+0(FP), R0
+ MOVD buffer+8(FP), R1
+ MOVD buffer_size+16(FP), R2
+ BL vdso_zx_debug_read(SB)
+ MOVW R0, ret+24(FP)
+ RET
+
+// func Sys_debug_write(buffer *uint8, buffer_size uint) Status
+TEXT ·Sys_debug_write(SB),NOSPLIT,$0-20
+ MOVD buffer+0(FP), R0
+ MOVD buffer_size+8(FP), R1
+ BL vdso_zx_debug_write(SB)
+ MOVW R0, ret+16(FP)
+ RET
+
+// func Sys_debug_send_command(resource Handle, buffer *uint8, buffer_size uint) Status
+TEXT ·Sys_debug_send_command(SB),NOSPLIT,$0-28
+ MOVW resource+0(FP), R0
+ MOVD buffer+8(FP), R1
+ MOVD buffer_size+16(FP), R2
+ BL vdso_zx_debug_send_command(SB)
+ MOVW R0, ret+24(FP)
+ RET
+
+// func Sys_interrupt_create(src_obj Handle, src_num uint32, options uint32, out *Handle) Status
+TEXT ·Sys_interrupt_create(SB),NOSPLIT,$0-28
+ MOVW src_obj+0(FP), R0
+ MOVW src_num+4(FP), R1
+ MOVW options+8(FP), R2
+ MOVD out+16(FP), R3
+ BL vdso_zx_interrupt_create(SB)
+ MOVW R0, ret+24(FP)
+ RET
+
+// func Sys_interrupt_bind(handle Handle, port Handle, key uint64, options uint32) Status
+TEXT ·Sys_interrupt_bind(SB),NOSPLIT,$0-28
+ MOVW handle+0(FP), R0
+ MOVW port+4(FP), R1
+ MOVD key+8(FP), R2
+ MOVW options+16(FP), R3
+ BL vdso_zx_interrupt_bind(SB)
+ MOVW R0, ret+24(FP)
+ RET
+
+// func Sys_interrupt_wait(handle Handle, out_timestamp *Time) Status
+TEXT ·Sys_interrupt_wait(SB),NOSPLIT,$0-20
+ MOVW handle+0(FP), R0
+ MOVD out_timestamp+8(FP), R1
+ BL vdso_zx_interrupt_wait(SB)
+ MOVW R0, ret+16(FP)
+ RET
+
+// func Sys_interrupt_destroy(handle Handle) Status
+TEXT ·Sys_interrupt_destroy(SB),NOSPLIT,$0-12
+ MOVW handle+0(FP), R0
+ BL vdso_zx_interrupt_destroy(SB)
+ MOVW R0, ret+8(FP)
+ RET
+
+// func Sys_interrupt_ack(handle Handle) Status
+TEXT ·Sys_interrupt_ack(SB),NOSPLIT,$0-12
+ MOVW handle+0(FP), R0
+ BL vdso_zx_interrupt_ack(SB)
+ MOVW R0, ret+8(FP)
+ RET
+
+// func Sys_interrupt_trigger(handle Handle, options uint32, timestamp Time) Status
+TEXT ·Sys_interrupt_trigger(SB),NOSPLIT,$0-20
+ MOVW handle+0(FP), R0
+ MOVW options+4(FP), R1
+ MOVD timestamp+8(FP), R2
+ BL vdso_zx_interrupt_trigger(SB)
+ MOVW R0, ret+16(FP)
+ RET
+
+// func Sys_ioports_request(resource Handle, io_addr uint16, len uint32) Status
+TEXT ·Sys_ioports_request(SB),NOSPLIT,$0-20
+ MOVW resource+0(FP), R0
+ MOVD io_addr+4(FP), R1
+ MOVW len+8(FP), R2
+ BL vdso_zx_ioports_request(SB)
+ MOVW R0, ret+16(FP)
+ RET
+
+// func Sys_vmo_create_contiguous(bti Handle, size uint, alignment_log2 uint32, out *Handle) Status
+TEXT ·Sys_vmo_create_contiguous(SB),NOSPLIT,$0-36
+ MOVW bti+0(FP), R0
+ MOVD size+8(FP), R1
+ MOVW alignment_log2+16(FP), R2
+ MOVD out+24(FP), R3
+ BL vdso_zx_vmo_create_contiguous(SB)
+ MOVW R0, ret+32(FP)
+ RET
+
+// func Sys_vmo_create_physical(resource Handle, paddr Paddr, size uint, out *Handle) Status
+TEXT ·Sys_vmo_create_physical(SB),NOSPLIT,$0-36
+ MOVW resource+0(FP), R0
+ MOVD paddr+8(FP), R1
+ MOVD size+16(FP), R2
+ MOVD out+24(FP), R3
+ BL vdso_zx_vmo_create_physical(SB)
+ MOVW R0, ret+32(FP)
+ RET
+
+// func Sys_iommu_create(resource Handle, typ uint32, desc unsafe.Pointer, desc_size uint, out *Handle) Status
+TEXT ·Sys_iommu_create(SB),NOSPLIT,$0-36
+ MOVW resource+0(FP), R0
+ MOVW typ+4(FP), R1
+ MOVD desc+8(FP), R2
+ MOVD desc_size+16(FP), R3
+ MOVD out+24(FP), R4
+ BL vdso_zx_iommu_create(SB)
+ MOVW R0, ret+32(FP)
+ RET
+
+// func Sys_bti_create(iommu Handle, options uint32, bti_id uint64, out *Handle) Status
+TEXT ·Sys_bti_create(SB),NOSPLIT,$0-28
+ MOVW iommu+0(FP), R0
+ MOVW options+4(FP), R1
+ MOVD bti_id+8(FP), R2
+ MOVD out+16(FP), R3
+ BL vdso_zx_bti_create(SB)
+ MOVW R0, ret+24(FP)
+ RET
+
+// func Sys_bti_pin(handle Handle, options uint32, vmo Handle, offset uint64, size uint64, addrs *Paddr, addrs_count uint, out *Handle) Status
+TEXT ·Sys_bti_pin(SB),NOSPLIT,$0-60
+ MOVW handle+0(FP), R0
+ MOVW options+4(FP), R1
+ MOVW vmo+8(FP), R2
+ MOVD offset+16(FP), R3
+ MOVD size+24(FP), R4
+ MOVD addrs+32(FP), R5
+ MOVD addrs_count+40(FP), R6
+ MOVD out+48(FP), R7
+ BL vdso_zx_bti_pin(SB)
+ MOVW R0, ret+56(FP)
+ RET
+
+// func Sys_bti_release_quarantine(handle Handle) Status
+TEXT ·Sys_bti_release_quarantine(SB),NOSPLIT,$0-12
+ MOVW handle+0(FP), R0
+ BL vdso_zx_bti_release_quarantine(SB)
+ MOVW R0, ret+8(FP)
+ RET
+
+// func Sys_pmt_unpin(handle Handle) Status
+TEXT ·Sys_pmt_unpin(SB),NOSPLIT,$0-12
+ MOVW handle+0(FP), R0
+ BL vdso_zx_pmt_unpin(SB)
+ MOVW R0, ret+8(FP)
+ RET
+
+// func Sys_framebuffer_get_info(resource Handle, format *uint32, width *uint32, height *uint32, stride *uint32) Status
+TEXT ·Sys_framebuffer_get_info(SB),NOSPLIT,$0-44
+ MOVW resource+0(FP), R0
+ MOVD format+8(FP), R1
+ MOVD width+16(FP), R2
+ MOVD height+24(FP), R3
+ MOVD stride+32(FP), R4
+ BL vdso_zx_framebuffer_get_info(SB)
+ MOVW R0, ret+40(FP)
+ RET
+
+// func Sys_framebuffer_set_range(resource Handle, vmo Handle, len uint32, format uint32, width uint32, height uint32, stride uint32) Status
+TEXT ·Sys_framebuffer_set_range(SB),NOSPLIT,$0-36
+ MOVW resource+0(FP), R0
+ MOVW vmo+4(FP), R1
+ MOVW len+8(FP), R2
+ MOVW format+12(FP), R3
+ MOVW width+16(FP), R4
+ MOVW height+20(FP), R5
+ MOVW stride+24(FP), R6
+ BL vdso_zx_framebuffer_set_range(SB)
+ MOVW R0, ret+32(FP)
+ RET
+
+// func Sys_pc_firmware_tables(handle Handle, acpi_rsdp *Paddr, smbios *Paddr) Status
+TEXT ·Sys_pc_firmware_tables(SB),NOSPLIT,$0-28
+ MOVW handle+0(FP), R0
+ MOVD acpi_rsdp+8(FP), R1
+ MOVD smbios+16(FP), R2
+ BL vdso_zx_pc_firmware_tables(SB)
+ MOVW R0, ret+24(FP)
+ RET
+
+// func Sys_smc_call(handle Handle, parameters *SMCParameters, out_smc_result *SMCResult) Status
+TEXT ·Sys_smc_call(SB),NOSPLIT,$0-28
+ MOVW handle+0(FP), R0
+ MOVD parameters+8(FP), R1
+ MOVD out_smc_result+16(FP), R2
+ BL vdso_zx_smc_call(SB)
+ MOVW R0, ret+24(FP)
+ RET
+
+// func Sys_resource_create(parent_rsrc Handle, options uint32, base uint64, size uint, name *uint8, name_size uint, resource_out *Handle) Status
+TEXT ·Sys_resource_create(SB),NOSPLIT,$0-52
+ MOVW parent_rsrc+0(FP), R0
+ MOVW options+4(FP), R1
+ MOVD base+8(FP), R2
+ MOVD size+16(FP), R3
+ MOVD name+24(FP), R4
+ MOVD name_size+32(FP), R5
+ MOVD resource_out+40(FP), R6
+ BL vdso_zx_resource_create(SB)
+ MOVW R0, ret+48(FP)
+ RET
+
+// func Sys_system_mexec(resource Handle, kernel Handle, bootimage Handle) Status
+TEXT ·Sys_system_mexec(SB),NOSPLIT,$0-20
+ MOVW resource+0(FP), R0
+ MOVW kernel+4(FP), R1
+ MOVW bootimage+8(FP), R2
+ BL vdso_zx_system_mexec(SB)
+ MOVW R0, ret+16(FP)
+ RET
+
+// func Sys_system_powerctl(resource Handle, cmd uint32, arg *int) Status
+TEXT ·Sys_system_powerctl(SB),NOSPLIT,$0-20
+ MOVW resource+0(FP), R0
+ MOVW cmd+4(FP), R1
+ MOVD arg+8(FP), R2
+ BL vdso_zx_system_powerctl(SB)
+ MOVW R0, ret+16(FP)
+ RET
+
diff --git a/src/syscall/zx/types.go b/src/syscall/zx/types.go
new file mode 100644
index 0000000..d6c3870
--- /dev/null
+++ b/src/syscall/zx/types.go
@@ -0,0 +1,439 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build fuchsia
+
+package zx
+
+import "unsafe"
+
+type Status int32 // zx_status_t
+type Handle uint32 // zx_handle_t
+type Clock uint32 // zx_clock_t,
+type Time int64 // zx_time_t, nanoseconds
+type Duration int64 // zx_duration_t, nanoseconds
+type Signals uint32 // zx_signals_t
+type Rights uint32 // zx_rights_t
+type Paddr uintptr // zx_paddr_t
+type Vaddr uintptr // zx_vaddr_t
+
+type WaitItem struct {
+ Handle Handle
+ WaitFor Signals
+ Pending Signals
+} // zx_wait_item_t
+
+const HandleInvalid = Handle(0)
+
+// deprecated name
+const HANDLE_INVALID = Handle(0)
+
+const HandleSize = uint64(unsafe.Sizeof(Handle(0)))
+
+const ZX_MAX_NAME_LEN = 32
+
+const (
+ ZX_RREC_DELETED = 0
+ ZX_RREC_SELF = 1
+ ZX_RREC_DATA = 2
+ ZX_RREC_IRQ = 3
+ ZX_RREC_MMIO = 4
+ ZX_RREC_IOPORT = 5
+)
+
+const (
+ ZX_RACT_ENABLE = 1
+ ZX_RACT_DISABLE = 2
+)
+
+const (
+ ZX_RREC_SELF_GENERIC = 0
+ ZX_RREC_SELF_ROOT = 1
+)
+
+type RrecSelf struct {
+ Type uint16 // ZX_RREC_SELF
+ Subtype uint16
+ Options uint32
+ Koid uint64
+ RecordCount uint32
+ ChildCount uint32
+ _ [2]uint32
+ Name [ZX_MAX_NAME_LEN]uint8
+} // zx_rrec_self_t
+
+type RrecMMIO struct {
+ Type uint16 // ZX_RREC_MMIO
+ Subtype uint16
+ Options uint32
+ PhysBase uint64
+ PhysSize uint64
+ _ [10]uint32
+} // zx_rrec_mmio_t
+
+type RrecIRQ struct {
+ Type uint16 // ZX_RREC_IRQ
+ Subtype uint16
+ Options uint32
+ IRQBase uint32
+ IRQCount uint32
+ _ [12]uint32
+} // zx_rrec_irq_t
+
+type RrecIOPort struct {
+ Type uint16 // ZX_RREC_IOPORT
+ Subtype uint16
+ Options uint32
+ PortBase uint32
+ PortCount uint32
+ _ [12]uint32
+} // zx_rrec_ioport_t
+
+type RrecData struct {
+ Type uint16
+ Subtype uint16
+ Options uint32 // low 4 bits are count
+ Data [56]uint8
+} // zx_rrec_data_t
+
+type Rrec struct {
+ typ uint16
+ _ [62]uint8
+} // zx_rrec_t
+
+func (r *Rrec) Box() RrecValue {
+ switch r.typ {
+ case ZX_RREC_DELETED:
+ return nil
+ case ZX_RREC_SELF:
+ return (*RrecSelf)(unsafe.Pointer(r))
+ case ZX_RREC_DATA:
+ return (*RrecData)(unsafe.Pointer(r))
+ case ZX_RREC_IRQ:
+ return (*RrecIRQ)(unsafe.Pointer(r))
+ case ZX_RREC_MMIO:
+ return (*RrecMMIO)(unsafe.Pointer(r))
+ case ZX_RREC_IOPORT:
+ return (*RrecIOPort)(unsafe.Pointer(r))
+ default:
+ return nil
+ }
+}
+
+type RrecValue interface {
+ rrec()
+}
+
+func (*RrecSelf) rrec() {}
+func (*RrecData) rrec() {}
+func (*RrecIRQ) rrec() {}
+func (*RrecMMIO) rrec() {}
+func (*RrecIOPort) rrec() {}
+
+type ChannelCallArgs struct {
+ WriteBytes uintptr
+ WriteHandles *Handle
+ ReadBytes uintptr
+ ReadHandles *Handle
+ WriteNumBytes uint32
+ WriteNumHandles uint32
+ ReadNumBytes uint32
+ ReadNumHandles uint32
+}
+
+type FIFOState struct {
+ head, tail uint64
+}
+
+type SMCParameters struct {
+ funcID uint32
+ arg1, arg2, arg3, arg4, arg5, arg6 uint64
+ clientId, secureOSID uint16
+}
+
+type SMCResult struct {
+ arg0, arg1, arg2, arg3 uint64
+}
+
+// Status codes. See zircon/system/public/zircon/errors.h
+const (
+ ErrOk Status = -iota
+ ErrInternal
+ ErrNotSupported
+ ErrNoResources
+ ErrNoMemory
+ ErrCallFailed
+ ErrInterruptedRetry
+ _ // -7
+ _ // -8
+ _ // -9
+ ErrInvalidArgs
+ ErrBadHandle
+ ErrWrongType
+ ErrBadSyscall
+ ErrOutOfRange
+ ErrBufferTooSmall
+ _ // -16
+ _ // -17
+ _ // -18
+ _ // -19
+ ErrBadState
+ ErrTimedOut
+ ErrShouldWait
+ ErrCanceled
+ ErrPeerClosed
+ ErrNotFound
+ ErrAlreadyExists
+ ErrAlreadyBound
+ ErrUnavailable
+ _ // -29
+ ErrAccessDenied
+ _ // -31
+ _ // -32
+ _ // -33
+ _ // -34
+ _ // -35
+ _ // -36
+ _ // -37
+ _ // -38
+ _ // -39
+ ErrIO
+ ErrIORefused
+ ErrIODataIntegrity
+ ErrIODataLoss
+ _ // -44
+ _ // -45
+ _ // -46
+ _ // -47
+ _ // -48
+ _ // -49
+ ErrBadPath
+ ErrNotDir
+ ErrNotFile
+ ErrFileBig
+ ErrNoSpace
+ ErrNotEmpty
+ _ // -56
+ _ // -57
+ _ // -58
+ _ // -59
+ ErrStop
+ ErrNext
+ _ // -62
+ _ // -63
+ _ // -64
+ _ // -65
+ _ // -66
+ _ // -67
+ _ // -68
+ _ // -69
+ ErrProtocolNotSupported
+ ErrAddressUnreachable
+ ErrAddressInUse
+ ErrNotConnected
+ ErrConnectionRefused
+ ErrConnectionReset
+ ErrConnectionAborted
+
+ // deprecated
+ ErrHandleClosed = ErrCanceled
+ ErrRemoteClosed = ErrPeerClosed
+)
+
+const (
+ SignalObject0 = (1 << iota)
+ SignalObject1
+ SignalObject2
+ SignalObject3
+ SignalObject4
+ SignalObject5
+ SignalObject6
+ SignalObject7
+ SignalObject8
+ SignalObject9
+ SignalObject10
+ SignalObject11
+ SignalObject12
+ SignalObject13
+ SignalObject14
+ SignalObject15
+ SignalObject16
+ SignalObject17
+ SignalObject18
+ SignalObject19
+ SignalObject20
+ SignalObject21
+ SignalObject22
+ SignalObject23
+
+ SignalUser0
+ SignalUser1
+ SignalUser2
+ SignalUser3
+ SignalUser4
+ SignalUser5
+ SignalUser6
+ SignalUser7
+
+ // Aliases
+ SignalHandleClosed = SignalObject23
+
+ // Event
+ SignalEventSignaled = SignalObject3
+ SignalEventMask = SignalUserAll | SignalEventSignaled
+
+ // EventPair
+ SignalEpairSignaled = SignalObject3
+ SignalEpairPeerClosed = SignalObject2
+
+ // Channel
+ SignalChannelReadable = SignalObject0
+ SignalChannelWritable = SignalObject1
+ SignalChannelPeerClosed = SignalObject2
+
+ // Socket
+ SignalSocketReadable = SignalObject0
+ SignalSocketWritable = SignalObject1
+ SignalSocketPeerClosed = SignalObject2
+ SignalSocketReadDisabled = SignalObject4
+ SignalSocketWriteDisabled = SignalObject5
+ SignalSocketControlReadable = SignalObject6
+ SignalSocketControlWriteable = SignalObject7
+ SignalSocketAccept = SignalObject8
+ SignalSocketShare = SignalObject9
+
+ // Port
+ SignalPortReadable = SignalObject0
+ SignalPortPeerClosed = SignalObject2
+ SignalPortSignaled = SignalObject3
+
+ // Resource
+ SignalResourceReadable = SignalObject0
+ SignalResourceWritable = SignalObject1
+ SignalResourceChildAdded = SignalObject2
+
+ // Fifo
+ SignalFIFOReadable = SignalObject0
+ SignalFIFOWritable = SignalObject1
+ SignalFIFOPeerClosed = SignalObject2
+ SignalFIFOSignalMask = SignalFIFOReadable | SignalFIFOWritable | SignalFIFOPeerClosed
+
+ // Task signals (process, thread, job)
+ SignalTaskTerminated = SignalObject3
+ SignalTaskSignalMask = SignalObject3
+
+ // Job
+ SignalJobSignaled = SignalObject3
+
+ // Process
+ SignalProccessSignaled = SignalObject3
+
+ // Thread
+ SignalThreadSignaled = SignalObject3
+
+ SignalObjectAll = (0xfffff)
+ SignalUserAll = Signals(15 << 4)
+ SignalNone = Signals(0)
+)
+
+const (
+ RightDuplicate = Rights(1 << iota)
+ RightTransfer
+ RightRead
+ RightWrite
+ RightExecute
+ RightDebug
+ RightSameRights = Rights(1 << 31)
+ RightNone = Rights(0)
+)
+
+// Topics for object_get_info
+const (
+ _ = iota
+ ObjectInfoHandleValid
+ ObjectInfoHandleBasic
+ ObjectInfoProcess
+ ObjectInfoProcessThreads
+ ObjectInfoResourceChildren
+ ObjectInfoResourceRecords
+ ObjectInfoVMAR
+)
+
+// Options for socket_create
+const (
+ SocketStream = iota // 0
+ SocketDatagram = 1 << (iota - 1) // 1
+ SocketHasControl // 2
+ SocketHasAccept // 4
+)
+
+// Options for socket_write
+const (
+ _ = iota // 0
+ SocketShutdownWrite // 1
+ SocketShutdownRead // 2
+)
+
+// Options for socket_write and socket_read
+const (
+ SocketControl = 1 << 2
+)
+
+const (
+ _ = iota // 0
+ _ // 1
+ PropNumStateKinds // ZX_PROP_NUM_STATE_KINDS
+ PropName // ZX_PROP_NAME
+ PropRegisterFS // ZX_PROP_REGISTER_FS
+ PropProcessDebugAddr // ZX_PROP_PROCESS_DEBUG_ADDR
+ PropProcessVDSOBaseAddress // ZX_PROP_PROCESS_VDSO_BASE_ADDRESS
+ PropJobMaxHeight // ZX_PROP_JOB_MAX_HEIGHT
+)
+
+const (
+ TimensecInfinite = Time(0x7FFFFFFFFFFFFFFF)
+)
+
+// EOF is used like io.EOF.
+//
+// When package io is linked in, at initialization this value is
+// rewritten to be equivalent to io.EOF, so that the io.Readers
+// and io.Writers in this package meet their specs.
+var EOF error = eof{}
+
+type eof struct{}
+
+func (eof) Error() string { return "zx.EOF" }
+
+// EPIPE is used like syscall.EPIPE
+
+// When package syscall is linked in, at initialization this value is
+// rewritten to be equivalent to syscall.EPIPE.
+
+var EPIPE error = epipe{}
+
+type epipe struct{}
+
+func (epipe) Error() string { return "errno(32)" }
+
+type VMOOption int
+
+const (
+ VMOOptionNonResizable VMOOption = 1 << 0 // ZX_VMO_NON_RESIZABLE
+)
+
+type VMFlag int
+
+const (
+ VMFlagPermRead VMFlag = 1 << 0 // ZX_VM_FLAG_PERM_READ
+ VMFlagPermWrite VMFlag = 1 << 1 // ZX_VM_FLAG_PERM_WRITE
+ VMFlagPermExecute VMFlag = 1 << 2 // ZX_VM_FLAG_PERM_EXECUTE
+ VMFlagCompact VMFlag = 1 << 3 // ZX_VM_FLAG_COMPACT
+ VMFlagSpecific VMFlag = 1 << 4 // ZX_VM_FLAG_SPECIFIC
+ VMFlagSpecificOverwrite VMFlag = 1 << 5 // ZX_VM_FLAG_SPECIFIC_OVERWRITE
+ VMFlagCanMapSpecific VMFlag = 1 << 6 // ZX_VM_FLAG_CAN_MAP_SPECIFIC
+ VMFlagCanMapRead VMFlag = 1 << 7 // ZX_VM_FLAG_CAN_MAP_READ
+ VMFlagCanMapWrite VMFlag = 1 << 8 // ZX_VM_FLAG_CAN_MAP_WRITE
+ VMFlagCanMapExecute VMFlag = 1 << 9 // ZX_VM_FLAG_CAN_MAP_EXECUTE
+)
diff --git a/src/syscall/zx/types_string.go b/src/syscall/zx/types_string.go
new file mode 100644
index 0000000..aac9809
--- /dev/null
+++ b/src/syscall/zx/types_string.go
@@ -0,0 +1,68 @@
+// generated by stringer -type=Status; DO NOT EDIT
+
+// +build fuchsia
+
+package zx
+
+const (
+ _Status_name_0 = "ErrNoSpaceErrFileBigErrNotFileErrNotDirErrBadPath"
+ _Status_name_1 = "ErrIODataLossErrIODataIntegrityErrIORefusedErrIO"
+ _Status_name_2 = "ErrAccessDenied"
+ _Status_name_3 = "ErrUnavailableErrAlreadyBoundErrAlreadyExistsErrNotFoundErrPeerClosedErrCanceledErrShouldWaitErrTimedOutErrBadState"
+ _Status_name_4 = "ErrBufferTooSmallErrOutOfRangeErrBadSyscallErrWrongTypeErrBadHandleErrInvalidArgs"
+ _Status_name_5 = "ErrInterruptedRetryErrCallFailedErrNoMemoryErrNoResourcesErrNotSupportedErrInternalErrOk"
+)
+
+var (
+ _Status_index_0 = [...]uint8{0, 10, 20, 30, 39, 49}
+ _Status_index_1 = [...]uint8{0, 13, 31, 43, 48}
+ _Status_index_2 = [...]uint8{0, 15}
+ _Status_index_3 = [...]uint8{0, 14, 29, 45, 56, 69, 80, 93, 104, 115}
+ _Status_index_4 = [...]uint8{0, 17, 30, 43, 55, 67, 81}
+ _Status_index_5 = [...]uint8{0, 19, 32, 43, 57, 72, 83, 88}
+)
+
+func (i Status) String() string {
+ switch {
+ case -54 <= i && i <= -50:
+ i -= -54
+ return _Status_name_0[_Status_index_0[i]:_Status_index_0[i+1]]
+ case -43 <= i && i <= -40:
+ i -= -43
+ return _Status_name_1[_Status_index_1[i]:_Status_index_1[i+1]]
+ case i == -30:
+ return _Status_name_2
+ case -28 <= i && i <= -20:
+ i -= -28
+ return _Status_name_3[_Status_index_3[i]:_Status_index_3[i+1]]
+ case -15 <= i && i <= -10:
+ i -= -15
+ return _Status_name_4[_Status_index_4[i]:_Status_index_4[i+1]]
+ case -6 <= i && i <= 0:
+ i -= -6
+ return _Status_name_5[_Status_index_5[i]:_Status_index_5[i+1]]
+ default:
+ var buf [20]byte
+ return "zx.Status(" + string(itoa(buf[:], int(i))) + ")"
+ }
+}
+
+func itoa(buf []byte, val int) []byte {
+ i := len(buf) - 1
+ neg := false
+ if val < 0 {
+ neg = true
+ val = 0 - val
+ }
+ for val >= 10 {
+ buf[i] = byte(val%10 + '0')
+ i--
+ val /= 10
+ }
+ buf[i] = byte(val + '0')
+ if neg {
+ i--
+ buf[i] = '-'
+ }
+ return buf[i:]
+}
diff --git a/src/syscall/zx/zxsocket/client.go b/src/syscall/zx/zxsocket/client.go
new file mode 100644
index 0000000..03b1135
--- /dev/null
+++ b/src/syscall/zx/zxsocket/client.go
@@ -0,0 +1,178 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build fuchsia
+
+package zxsocket
+
+import (
+ "errors"
+ "syscall/zx"
+ "syscall/zx/mxnet"
+ "unsafe"
+)
+
+// Bind is BSD Sockets bind on a *Socket.
+func (s *Socket) Bind(addr mxnet.Addr, port uint16) error {
+ b := make([]byte, mxnet.SockaddrLen)
+ addrlen, err := mxnet.EncodeSockaddr(b, addr, port)
+ if err != nil {
+ return err
+ }
+ b = b[:addrlen]
+ _, err = s.Misc(OpBind, 0, b, nil, nil)
+ return err
+}
+
+// Connect is BSD Sockets connect on a *Socket.
+func (s *Socket) Connect(addr mxnet.Addr, port uint16) error {
+ b := make([]byte, mxnet.SockaddrLen)
+ addrlen, err := mxnet.EncodeSockaddr(b, addr, port)
+ if err != nil {
+ return err
+ }
+ b = b[:addrlen]
+
+ _, err = s.Misc(OpConnect, 0, b, nil, nil)
+ if err != nil && status(err) == zx.ErrShouldWait {
+ obs, err := s.Wait(mxnet.MXSIO_SIGNAL_OUTGOING, zx.TimensecInfinite)
+ switch status(err) {
+ case zx.ErrOk:
+ switch {
+ case obs&mxnet.MXSIO_SIGNAL_CONNECTED != 0:
+ return nil
+ default:
+ // TODO: Use opSetSockOpt to get the reason of the error.
+ return errors.New("zxsocket.Connect: OpConnect was not successful")
+ }
+ default:
+ return err
+ }
+ }
+ return err
+}
+
+// txn completes the client-side part of the RIO transaction.
+func (s *Socket) txn(msg *Msg) (uint32, error) {
+ if !msg.IsValid() {
+ return 0, zx.Error{Status: zx.ErrInvalidArgs, Text: "zxsocket.txn"}
+ }
+
+ msgBytes := (*[MessageSizeMax]byte)(unsafe.Pointer(msg))
+ numBytes, err := WriteControl(s.socket, msgBytes[:MessageHeaderSize+msg.Datalen])
+ if err != nil {
+ return 0, err
+ }
+ numBytes, err = ReadControl(s.socket, msgBytes[:])
+ if err != nil {
+ return 0, err
+ }
+
+ if !msg.IsValidIncoming(uint32(numBytes)) {
+ return 0, zx.Error{Status: zx.ErrIO, Text: "zxsocket.txn"}
+ }
+
+ // Check for remote error
+ status := zx.Status(msg.Arg)
+ if status < 0 {
+ return 0, zx.Error{Status: status, Text: "zxsocket.txn"}
+ }
+ return uint32(status), nil
+}
+
+func (s *Socket) ListenStream(backlog int) error {
+ b := make([]byte, 4)
+ b[0] = byte(backlog)
+ b[1] = byte(backlog >> 8)
+ b[2] = byte(backlog >> 16)
+ b[3] = byte(backlog >> 24)
+ _, err := s.Misc(OpListen, 0, b, nil, nil)
+ return err
+}
+
+func (s *Socket) Accept() (*Socket, error) {
+ if s.flags&SocketFlagsDidListen == 0 {
+ return nil, errors.New("zxsocket.Accept: listen was not called")
+ }
+
+ var h zx.Handle
+ for {
+ err := s.socket.Accept(&h)
+ if err == nil {
+ break
+ }
+ if status(err) != zx.ErrShouldWait {
+ return nil, err
+ }
+ s.socket.Handle().SignalPeer(0, zx.SignalUser7)
+ // TODO: non-blocking support, pass this to the poller
+ const ZX_SOCKET_ACCEPT = zx.SignalSocketAccept
+ const ZX_SOCKET_PEER_CLOSED = zx.SignalSocketPeerClosed
+ pending, err := s.Wait(ZX_SOCKET_ACCEPT|ZX_SOCKET_PEER_CLOSED, zx.TimensecInfinite)
+ if err != nil {
+ return nil, err
+ }
+ if pending&ZX_SOCKET_ACCEPT != 0 {
+ continue
+ }
+ if pending&ZX_SOCKET_PEER_CLOSED != 0 {
+ return nil, zx.Error{Status: zx.ErrPeerClosed, Text: "zxsocket"}
+ }
+ }
+ return NewSocket(zx.Socket(h)), nil
+}
+
+func (s *Socket) getName(op uint32, debug string) (addr mxnet.Addr, port uint16, err error) {
+ out := make([]byte, mxnet.SockaddrReplyLen)
+ _, err = s.Misc(OpGetSockname, 0, nil, out, nil)
+ if err != nil {
+ return "", 0, err
+ }
+ addr, port, err = mxnet.DecodeSockaddr(out)
+ if err != nil {
+ return "", 0, err
+ }
+
+ return addr, port, nil
+}
+
+func (s *Socket) SockName() (addr mxnet.Addr, port uint16, err error) {
+ return s.getName(OpGetSockname, "GetSockName")
+}
+
+func (s *Socket) PeerName() (addr mxnet.Addr, port uint16, err error) {
+ return s.getName(OpGetPeerName, "GetPeerName")
+}
+
+func (s *Socket) Misc(op uint32, off int64, in, out []byte, handles []zx.Handle) (n int, err error) {
+ if len(in) > MessageChunkSize || len(out) > MessageChunkSize {
+ return 0, zx.Error{Status: zx.ErrInvalidArgs, Text: "zxsocket.Misc"}
+ }
+
+ var msg Msg
+ msg.SetOp(op)
+ msg.Arg = int32(len(out))
+ msg.Datalen = uint32(len(in))
+ msg.SetOff(off)
+ copy(msg.Data[:], in)
+
+ if len(handles) > 0 {
+ copy(msg.Handle[:], handles)
+ msg.Hcount = uint32(len(handles))
+ }
+ if _, err = s.txn(&msg); err != nil {
+ return 0, err
+ }
+
+ if int(msg.Datalen) > len(out) {
+ return 0, zx.Error{Status: zx.ErrIO, Text: "zxsocket.Misc"}
+ }
+ n = copy(out, msg.Data[:msg.Datalen])
+
+ if op == OpListen {
+ s.flags |= SocketFlagsDidListen
+ }
+
+ return n, nil
+}
diff --git a/src/syscall/zx/zxsocket/message.go b/src/syscall/zx/zxsocket/message.go
new file mode 100644
index 0000000..b3a89a9
--- /dev/null
+++ b/src/syscall/zx/zxsocket/message.go
@@ -0,0 +1,227 @@
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build fuchsia
+
+package zxsocket
+
+import (
+ "unsafe"
+
+ "syscall/zx"
+)
+
+const (
+ // MessageChunkSize is the largest size of 'data' in an zxsocket message
+ MessageChunkSize = 900
+
+ // MessageSizeMax is the largest size of a zxsocket message
+ MessageSizeMax = uint32(unsafe.Sizeof(Msg{}))
+
+ // MessageHeaderSize is the size of zxsocket message without 'data'
+ MessageHeaderSize = uint32(unsafe.Sizeof(MsgHeader{}))
+
+ // MessageMaxHandles is the maximum number of handles a message may carry.
+ // In reality, zx.Sockets can't hold handles, but this is used to support
+ // the deprecated RemoteIO protocol over a socket.
+ MessageMaxHandles = 3
+)
+
+// Custom errors for zxsocket RemoteIO.
+var (
+ // If returned from dispatcher callback, indicates that the dispatcher should immediately
+ // disconnect with no additional callbacks.
+ ErrDisconnectNoCallback = zx.Error{Status: 1, Text: "fdio.Dispatcher"}
+ // If returned from dispatcher callback, indicates that there are no more messages to read.
+ ErrNoWork = zx.Error{Status: -9999, Text: "fdio.Dispatcher.NoWork"}
+ // If returned from dispatcher callback, indicates that the message was handed to another
+ // server.
+ ErrIndirect = zx.Error{Status: -9998, Text: "fdio.Dispatcher.Indirect"}
+)
+
+const (
+ OpFlagOneHandle = uint32(0x100 + iota)
+)
+
+// Values for op. Each one will signify a request for a different operation.
+// This is a copy of the list in fdio/message.go, with the non-socket-related
+// options removed. Note that these are deprecated. We will be migrating to
+// FIDL2 ordinals soon.
+const (
+ _ = uint32(iota)
+ OpClose
+ OpClone = uint32(iota) | OpFlagOneHandle
+ OpOpen = uint32(iota) | OpFlagOneHandle
+ _ = uint32(iota) // OpMisc
+ OpRead
+ OpWrite
+ _ // OpSeek
+ _ // OpStat
+ _ // OpReaddir
+ OpIoctl
+ _ // OpUnlink
+ _ // OpReadAt
+ _ // OpWriteAt
+ _ // OpTruncate
+ _ = uint32(iota) | OpFlagOneHandle // OpRename
+ OpConnect = uint32(iota)
+ OpBind
+ OpListen
+ OpGetSockname
+ OpGetPeerName
+ OpGetSockOpt
+ OpSetSockOpt
+ OpGetAddrInfo
+ _ // OpSetAttr
+ _ // OpSync
+ _ = uint32(iota) | OpFlagOneHandle // OpLink
+ _ = uint32(iota) // OpMmap
+ OpFcntl
+ OpNumOps = uint32(iota) // The total number of operations
+)
+
+type Protocol uint32
+
+// All available FDIO protocols
+const (
+ // The SERVICE protocol allows access to a generic interface.
+ ProtocolService = Protocol(iota)
+ // The FILE protocol allows access to a regular file.
+ ProtocolFile
+ // The DIRECTORY protocol allows access to a directory, which may
+ // contain additional nodes.
+ ProtocolDirectory
+ // The PIPE protocol uses message ports as simple, no-flow-control io pipes.
+ ProtocolPipe
+ // The VMOFILE protocol accesses a file as a VMO.
+ ProtocolVMOFile
+ // The DEVICE protocol allows access to a generic device.
+ ProtocolDevice
+ // The SOCKET protocol provides socket access.
+ ProtocolSocket
+ ProtocolSocketConnected
+)
+
+const (
+ OpenFlagDescribe = 0x00800000
+)
+
+// FIDL2 message header
+type FIDLHeader struct {
+ Txid uint32
+ reserved0 uint32
+ flags uint32
+ op uint32
+}
+
+type MsgHeader struct {
+ FIDLHeader
+ Datalen uint32
+ Arg int32
+ arg2 int64
+ reserved1 int32
+ Hcount uint32
+ Handle [4]zx.Handle // 3 handles + reply pipe, unused here though.
+}
+
+func (m *MsgHeader) Op() uint32 {
+ return m.op & 0x3FFF
+}
+func (m *MsgHeader) SetOp(v uint32) {
+ m.op = (v & 0x3FFF)
+}
+func (m *MsgHeader) OpHandleCount() uint32 {
+ return (m.op >> 8) & 3
+}
+func (m *MsgHeader) Off() int64 {
+ return m.arg2
+}
+func (m *MsgHeader) SetOff(v int64) {
+ m.arg2 = v
+}
+func (m *MsgHeader) Mode() uint32 {
+ return uint32(m.arg2)
+}
+func (m *MsgHeader) SetMode(v uint32) {
+ m.arg2 = int64(v)
+}
+func (m *MsgHeader) Protocol() Protocol {
+ return Protocol(m.arg2)
+}
+func (m *MsgHeader) SetProtocol(p Protocol) {
+ m.arg2 = int64(p)
+}
+func (m *MsgHeader) IoctlOp() uint32 {
+ return uint32(m.arg2)
+}
+func (m *MsgHeader) SetIoctlOp(v uint32) {
+ m.arg2 = int64(v)
+}
+func (m *MsgHeader) FcntlFlags() uint32 {
+ return uint32(m.arg2)
+}
+func (m *MsgHeader) SetFcntlFlags(v uint32) {
+ m.arg2 = int64(v)
+}
+
+// Msg is the message sent in the zxsocket protocol.
+type Msg struct {
+ MsgHeader
+ Data [MessageChunkSize]uint8
+}
+
+func (m *Msg) CallMsg(c *zx.Channel) (numBytes, numHandles uint32, err error) {
+ wData := (*[MessageSizeMax]byte)(unsafe.Pointer(m))[:MessageHeaderSize+m.Datalen]
+ var wHandles []zx.Handle
+ if m.Hcount > 0 {
+ wHandles = m.Handle[:m.Hcount]
+ }
+ rData := (*[MessageSizeMax]byte)(unsafe.Pointer(m))[:]
+ rHandles := m.Handle[:]
+ numBytes, numHandles, err = c.Call(0, zx.TimensecInfinite, wData, wHandles, rData, rHandles)
+ m.Hcount = numHandles
+ return
+}
+
+// ReadMsg reads a message from a socket.
+func (m *Msg) ReadMsg(s zx.Socket) (numBytes int, numHandles uint32, err error) {
+ msgBytes := (*[MessageSizeMax]byte)(unsafe.Pointer(m))
+ // TODO: why is numBytes int?
+ numBytes, err = s.Read(msgBytes[:], zx.SocketControl)
+ numHandles = 0
+ m.Hcount = numHandles
+ return
+}
+
+// WriteMsg writes a message to a socket.
+func (m *Msg) WriteMsg(s zx.Socket) (int, error) {
+ msgBytes := (*[MessageSizeMax]byte)(unsafe.Pointer(m))
+ data := msgBytes[:MessageHeaderSize+m.Datalen]
+ return s.Write(data, zx.SocketControl)
+}
+
+// WriteMsg writes a message to a channel.
+func (m *Msg) WriteChannelMsg(c *zx.Channel) error {
+ msgBytes := (*[MessageSizeMax]byte)(unsafe.Pointer(m))
+ data := msgBytes[:MessageHeaderSize+m.Datalen]
+ var handles []zx.Handle
+ if m.Hcount > 0 {
+ handles = m.Handle[:m.Hcount]
+ }
+ return c.Write(data, handles, 0)
+}
+
+func (m *Msg) IsValid() bool {
+ if m.Datalen > MessageChunkSize || m.Hcount != 0 {
+ return false
+ }
+ return true
+}
+
+func (m *Msg) IsValidIncoming(size uint32) bool {
+ if (size < MessageHeaderSize) || m.Datalen != (size-MessageHeaderSize) {
+ return false
+ }
+ return m.IsValid()
+}
diff --git a/src/syscall/zx/zxsocket/server.go b/src/syscall/zx/zxsocket/server.go
new file mode 100644
index 0000000..211babf
--- /dev/null
+++ b/src/syscall/zx/zxsocket/server.go
@@ -0,0 +1,69 @@
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build fuchsia
+
+package zxsocket
+
+import (
+ "syscall/zx"
+)
+
+// ServerHandler is the type of the callback which contains the remoteio "server". It is called from
+// the server handler function.
+// - msg.Datalen represents the size of the incoming/outgoing message in msg.Data.
+// - Return values are placed in msg.Arg. Negative is error.
+type ServerHandler func(msg *Msg, rh zx.Socket, cookie int64) zx.Status
+
+// Handler reads a single RIO message from the handle h. If the message is valid, the callback
+// cb is invoked. If the callback is successful, a response may be sent back on handle h.
+func Handler(h zx.Socket, cb interface{}, cookie int64) error {
+ var msg Msg
+
+ serverCb := cb.(ServerHandler)
+ if h == 0 {
+ // The remote side has been closed. Send our final callback and leave.
+ msg.SetOp(OpClose)
+ msg.Arg = 0
+ msg.Datalen = 0
+ msg.Hcount = 0
+ serverCb(&msg, 0, cookie)
+ return nil
+ }
+ msg.Hcount = MessageMaxHandles
+ numBytesInt, _, err := msg.ReadMsg(h)
+ numBytes := uint32(numBytesInt)
+ if err != nil {
+ if mxerr, hasStatus := err.(zx.Error); hasStatus && mxerr.Status == zx.ErrBadState {
+ return ErrNoWork
+ }
+ return err
+ }
+ if !msg.IsValidIncoming(numBytes) {
+ return zx.Error{Status: zx.ErrInvalidArgs, Text: "zxsocket.Handler"}
+ }
+
+ isClose := (msg.Op() == OpClose)
+ status := serverCb(&msg, h, cookie)
+ msg.Arg = int32(status)
+ if zx.Status(msg.Arg) == ErrIndirect.Status {
+ // The callback is handling the reply itself
+ return nil
+ } else if status < 0 || !msg.IsValid() {
+ // zx.Error case
+ msg.Datalen = 0
+ if msg.Arg >= 0 {
+ // TODO(smklein): This error code may change. It currently is set to "ERR_FAULT" in
+ // Zircon, but is scheduled to change.
+ msg.Arg = int32(zx.ErrIO)
+ }
+ }
+
+ _, err = msg.WriteMsg(h)
+ if isClose {
+ // Signals that a close callback is not necessary -- the op has already completed
+ return ErrDisconnectNoCallback
+ }
+ return err
+}
diff --git a/src/syscall/zx/zxsocket/socket.go b/src/syscall/zx/zxsocket/socket.go
new file mode 100644
index 0000000..d38b9f5
--- /dev/null
+++ b/src/syscall/zx/zxsocket/socket.go
@@ -0,0 +1,380 @@
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build fuchsia
+
+package zxsocket
+
+import (
+ "io"
+ "syscall/zx"
+ "syscall/zx/fdio"
+ fidlIo "syscall/zx/io"
+ "syscall/zx/mxnet"
+ "syscall/zx/zxwait"
+)
+
+// Status extracts an zx.Status from an error. This is duplicated from syscall/zx/merror,
+// but we can't import that directly because it causes an import loop.
+func status(err error) zx.Status {
+ if err == nil {
+ return zx.ErrOk
+ }
+ if s, hasStatus := err.(zx.Error); hasStatus {
+ return s.Status
+ }
+ return zx.ErrInternal
+}
+
+// Socket is an fdio.FDIO socket.
+type Socket struct {
+ socket zx.Socket
+
+ dgram bool
+ flags uint32
+}
+
+// Socket flags
+const (
+ SocketFlagsDidListen = 1 << iota // zxsocket._DID_LISTEN
+)
+
+func NewSocket(s zx.Socket) *Socket {
+ return &Socket{socket: s}
+}
+
+func (s *Socket) Wait(signals zx.Signals, timeout zx.Time) (observed zx.Signals, err error) {
+ return zxwait.Wait(zx.Handle(s.socket), signals, timeout)
+}
+
+// Handles returns the underlying handles for this Socket.
+func (s *Socket) Handles() []zx.Handle {
+ return []zx.Handle{zx.Handle(s.socket)}
+}
+
+// Clone makes a clone of the object.
+func (s *Socket) Clone() (fdio.FDIO, error) {
+ return nil, zx.Error{Status: zx.ErrNotSupported, Text: "zxsocket.Socket.Clone"}
+}
+
+// Close closes the object.
+func (s *Socket) Close() error {
+ if s.socket == 0 {
+ return nil
+ }
+ var msg Msg
+ msg.SetOp(OpClose)
+
+ _, err := s.txn(&msg)
+
+ s.socket.Close()
+ s.socket = 0
+
+ if err != nil {
+ return err
+ }
+ return nil
+}
+
+// Sync implements fdio.FDIO for Socket.
+func (s *Socket) Sync() error {
+ return zx.Error{Status: zx.ErrNotSupported, Text: "zxsocket.Socket"}
+}
+
+// GetAttr implements fdio.FDIO for Socket.
+func (s *Socket) GetAttr() (fidlIo.NodeAttributes, error) {
+ return fidlIo.NodeAttributes{}, zx.Error{Status: zx.ErrNotSupported, Text: "zxsocket.Socket"}
+}
+
+// SetAttr implements fdio.FDIO for Socket.
+func (s *Socket) SetAttr(flags uint32, attr fidlIo.NodeAttributes) error {
+ return zx.Error{Status: zx.ErrNotSupported, Text: "zxsocket.Socket"}
+}
+
+// Ioctl implements fdio.FDIO for Socket.
+func (s *Socket) Ioctl(op uint32, max uint64, in []byte, _ []zx.Handle) ([]byte, []zx.Handle, error) {
+ var msg Msg
+ if len(in) > fdio.IoctlMaxInput {
+ return nil, nil, zx.Error{Status: zx.ErrInvalidArgs, Text: "zxsocket.Ioctl"}
+ }
+
+ if fdio.IoctlKind(op) != fdio.IoctlKindDefault {
+ return nil, nil, zx.Error{Status: zx.ErrNotSupported, Text: "zxsocket.Ioctl"}
+ }
+
+ out := make([]byte, MessageSizeMax)
+ msg.SetOp(OpIoctl)
+ msg.Datalen = uint32(len(in))
+ msg.Arg = int32(len(out))
+ msg.SetIoctlOp(op)
+ copy(msg.Data[:], in)
+
+ _, err := s.txn(&msg)
+ if err != nil {
+ return nil, nil, err
+ }
+
+ copy(out, msg.Data[:msg.Datalen])
+ return out[:msg.Datalen], nil, nil
+}
+
+// Read implements fdio.FDIO for Socket.
+func (s *Socket) Read(data []byte) (n int, err error) {
+ if s.dgram {
+ b, _, _, _, err := s.RecvMsg(len(data))
+ n = copy(data, b)
+ return n, err
+ }
+ // c.f. mxsio_read_stream in zircon/system/ulib/fdio/remoteio.c
+ for {
+ n, err = s.socket.Read(data, 0)
+ switch status(err) {
+ case zx.ErrOk:
+ return n, nil
+ case zx.ErrPeerClosed:
+ return 0, io.EOF
+ case zx.ErrShouldWait:
+ obs, err := s.Wait(zx.SignalSocketReadable|zx.SignalSocketPeerClosed, zx.TimensecInfinite)
+ switch status(err) {
+ case zx.ErrOk:
+ switch {
+ case obs&zx.SignalSocketReadable != 0:
+ continue
+ case obs&zx.SignalSocketPeerClosed != 0:
+ return 0, io.EOF
+ }
+ case zx.ErrBadHandle, zx.ErrCanceled:
+ return 0, io.EOF
+ default:
+ return 0, err
+ }
+ default:
+ return 0, err
+ }
+ }
+}
+
+// ReadAt implements fdio.FDIO for Socket.
+func (s *Socket) ReadAt(data []byte, off int64) (int, error) {
+ return 0, zx.Error{Status: zx.ErrNotSupported, Text: "zxsocket.Socket"}
+}
+
+// Write implements fdio.FDIO for Socket.
+func (s *Socket) Write(data []byte) (int, error) {
+ if s.dgram {
+ n, err := s.SendMsg(data, "", 0)
+ return n, err
+ }
+
+ // c.f. zxsio_write_stream
+ var total int
+ for {
+ n, err := s.socket.Write(data, 0)
+ total += n
+
+ switch status(err) {
+ case zx.ErrOk:
+ return total, nil
+ case zx.ErrShouldWait:
+ obs, err := s.Wait(zx.SignalSocketWritable|zx.SignalSocketPeerClosed|zx.SignalSocketWriteDisabled, zx.TimensecInfinite)
+ if err != nil {
+ return total, err
+ }
+ if obs&zx.SignalSocketPeerClosed != 0 || obs&zx.SignalSocketWriteDisabled != 0 {
+ return total, zx.Error{Status: zx.ErrPeerClosed, Text: "zxsocket.Socket.Write"}
+ }
+ if obs&zx.SignalSocketWritable != 0 {
+ data = data[n:]
+ continue
+ }
+ // This case should be impossible:
+ return total, zx.Error{Status: zx.ErrInternal, Text: "zxsocket.Socket.Write(impossible state)"}
+ default:
+ return total, err
+ }
+ }
+}
+
+// WriteAt implements fdio.FDIO for Socket.
+func (s *Socket) WriteAt(data []byte, off int64) (int, error) {
+ return 0, zx.Error{Status: zx.ErrNotSupported, Text: "zxsocket.Socket"}
+}
+
+// Seek implements fdio.FDIO for Socket.
+func (s *Socket) Seek(offset int64, whence int) (int64, error) {
+ return 0, zx.Error{Status: zx.ErrNotSupported, Text: "zxsocket.Socket"}
+}
+
+// Truncate implements fdio.FDIO for Socket.
+func (s *Socket) Truncate(length uint64) error {
+ return zx.Error{Status: zx.ErrNotSupported, Text: "zxsocket.Socket"}
+}
+
+// Open implements fdio.FDIO for Socket.
+func (s *Socket) Open(path string, flags uint32, mode uint32) (fdio.FDIO, error) {
+ return nil, zx.Error{Status: zx.ErrNotSupported, Text: "zxsocket.Socket"}
+}
+
+// Link implements fdio.FDIO for Socket.
+func (s *Socket) Link(oldpath, newpath string) error {
+ return zx.Error{Status: zx.ErrNotSupported, Text: "zxsocket.Socket"}
+}
+
+// Rename implements fdio.FDIO for Socket.
+func (s *Socket) Rename(oldpath, newpath string) error {
+ return zx.Error{Status: zx.ErrNotSupported, Text: "zxsocket.Socket"}
+}
+
+// Unlink implements fdio.FDIO for Socket.
+func (s *Socket) Unlink(path string) error {
+ return zx.Error{Status: zx.ErrNotSupported, Text: "zxsocket.Socket"}
+}
+
+// ReadDirents implements fdio.FDIO for Socket.
+func (s *Socket) ReadDirents(max uint64) ([]byte, error) {
+ return nil, zx.Error{Status: zx.ErrNotSupported, Text: "zxsocket.Socket"}
+}
+
+// Rewind implements fdio.FDIO for Socket.
+func (s *Socket) Rewind() error {
+ return zx.Error{Status: zx.ErrNotSupported, Text: "zxsocket.Socket"}
+}
+
+func (s *Socket) RecvMsg(maxLen int) (b []byte, flags int, addr string, port uint16, err error) {
+ mlen := maxLen + mxnet.SockmsgHdrLen
+ msgdata := make([]byte, mlen)
+ n, err := s.recvMsg(msgdata)
+ if err != nil {
+ return nil, 0, "", 0, err
+ }
+ msgdata = msgdata[:n]
+ addrstr, port, flags, err := mxnet.DecodeSockmsgHdr(msgdata)
+ if err != nil {
+ return nil, 0, "", 0, err
+ }
+ return msgdata[mxnet.SockmsgHdrLen:], flags, string(addrstr), port, nil
+}
+
+func (s *Socket) recvMsg(data []byte) (int, error) {
+ for {
+ n, err := s.socket.Read(data, 0)
+ switch status(err) {
+ case zx.ErrOk:
+ return n, err
+ case zx.ErrShouldWait:
+ if n != 0 {
+ return n, zx.Error{Status: zx.ErrInternal, Text: "zsocket.Socket.recvMsg(datagram short-read)"}
+ }
+
+ obs, err := s.Wait(zx.SignalSocketReadable|zx.SignalSocketPeerClosed|zx.SignalSocketReadDisabled, zx.TimensecInfinite)
+ if err != nil {
+ return n, err
+ }
+ if obs&zx.SignalSocketReadable != 0 {
+ continue
+ }
+ if obs&zx.SignalSocketPeerClosed != 0 || obs&zx.SignalSocketReadDisabled != 0 {
+ return n, zx.Error{Status: zx.ErrPeerClosed, Text: "zxsocket.Socket.recvMsg"}
+ }
+ return n, zx.Error{Status: zx.ErrInternal, Text: "zxsocket.Socket.recvMsg"}
+ default:
+ return n, err
+ }
+ }
+}
+
+func (s *Socket) SendMsg(b []byte, addr string, port uint16) (int, error) {
+ data := make([]byte, len(b)+mxnet.SockmsgHdrLen)
+ err := mxnet.EncodeSockmsgHdr(data, mxnet.Addr(addr), port, 0)
+ if err != nil {
+ return 0, err
+ }
+ copy(data[mxnet.SockmsgHdrLen:], b)
+
+ for {
+ n, err := s.socket.Write(data, 0)
+ switch status(err) {
+ case zx.ErrOk:
+ return len(b), nil
+ case zx.ErrShouldWait:
+ if n != 0 {
+ return n, zx.Error{Status: zx.ErrInternal, Text: "zxsocket.Socket.SendMsg(datagram short-write)"}
+ }
+
+ obs, err := s.Wait(zx.SignalSocketWritable|zx.SignalSocketPeerClosed|zx.SignalSocketWriteDisabled, zx.TimensecInfinite)
+ if err != nil {
+ return 0, err
+ }
+ if obs&zx.SignalSocketWritable != 0 {
+ continue
+ }
+ if obs&zx.SignalSocketPeerClosed != 0 || obs&zx.SignalSocketWriteDisabled != 0 {
+ return 0, zx.Error{Status: zx.ErrPeerClosed, Text: "zxsocket.Socket.SendMsg"}
+ }
+ return 0, zx.Error{Status: zx.ErrInternal, Text: "zxsocket.Socket.SendMsg(impossible state)"}
+ default:
+ if n != 0 {
+ return n, zx.Error{Status: zx.ErrInternal, Text: "zxsocket.Socket.SendMsg(datagram short-write)"}
+ }
+ return 0, err
+ }
+ }
+}
+
+// SetDgram marks a *Socket as a datagram (UDP) socket.
+// A different protocol is used internally.
+func (s *Socket) SetDgram() {
+ s.dgram = true
+}
+
+func ReadControl(s zx.Socket, data []byte) (n int, err error) {
+ // c.f. zxsocket._read_control in zircon/system/ulib/fdio/remoteio.c
+ for {
+ n, err = s.Read(data, zx.SocketControl)
+ switch status(err) {
+ case zx.ErrOk:
+ return n, nil
+ case zx.ErrPeerClosed:
+ return 0, io.EOF
+ case zx.ErrShouldWait:
+ obs, err := zxwait.Wait(
+ zx.Handle(s),
+ zx.SignalSocketControlReadable|zx.SignalSocketPeerClosed,
+ zx.TimensecInfinite,
+ )
+ switch status(err) {
+ case zx.ErrOk:
+ switch {
+ case obs&zx.SignalSocketControlReadable != 0:
+ continue
+ case obs&zx.SignalSocketPeerClosed != 0:
+ return 0, io.EOF
+ }
+ case zx.ErrBadHandle, zx.ErrCanceled:
+ return 0, io.EOF
+ default:
+ return 0, err
+ }
+ default:
+ return 0, err
+ }
+ }
+}
+
+func WriteControl(s zx.Socket, data []byte) (int, error) {
+ // c.f. zxsocket._write_control
+ for {
+ n, err := s.Write(data, zx.SocketControl)
+ switch status(err) {
+ case zx.ErrOk:
+ return n, nil
+ case zx.ErrShouldWait:
+ _, err := zxwait.Wait(zx.Handle(s), zx.SignalSocketControlWriteable, zx.TimensecInfinite)
+ if err != nil {
+ return n, err
+ }
+ continue
+ }
+ }
+}
diff --git a/src/syscall/zx/zxwait/zxwait.go b/src/syscall/zx/zxwait/zxwait.go
new file mode 100644
index 0000000..f96b941
--- /dev/null
+++ b/src/syscall/zx/zxwait/zxwait.go
@@ -0,0 +1,178 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build fuchsia
+
+// Package zxwait implements a Zircon port waiter compatible with goroutines.
+//
+// The function Wait can be used to wait on a handle without consuming
+// an OS thread or resorting to event-driven programming.
+package zxwait
+
+import (
+ "sync"
+ "sync/atomic"
+ "syscall/zx"
+
+ _ "unsafe" // for go:linkname
+)
+
+// Wait waits for signals on handle.
+//
+// The goroutine that calls Wait is parked until a signal is observed or the
+// handle is closed. No OS thread is tied up while Wait is blocked.
+//
+// Semantically it is equivalent to calling the WaitOne method on a zx.Handle.
+// However it is not implemented with zx_object_wait_one, instead it uses
+// zx_object_wait_async and a port to wait for signals.
+func Wait(handle zx.Handle, signals zx.Signals, timeout zx.Time) (observed zx.Signals, err error) {
+ // TODO: support finite timeouts.
+ if timeout != zx.TimensecInfinite {
+ if status := zx.Sys_object_wait_one(handle, signals, timeout, &observed); status != zx.ErrOk {
+ return observed, zx.Error{Status: status, Text: "zxwait.Wait"}
+ }
+ return observed, nil
+ }
+ sysWaiterOnce.Do(sysWaiterInit)
+ return sysWaiter.Wait(handle, signals)
+}
+
+//go:linkname gopark runtime.gopark
+func gopark(unlockf func(g uintptr, waiting *waitingG) bool, waitng *waitingG, reason string, traceEv byte, traceskip int)
+
+//go:linkname goready runtime.goready
+func goready(g uintptr, traceskip int)
+
+// waitingG is used to track a parked g waiting on a singal.
+//
+// A waitingG is represented by a unique key, which is also
+// its positional index in the waiter's all slice. This key
+// is not a GCed pointer, so it can be safely passed to the
+// kernel and returned at a later time.
+type waitingG struct {
+ key uint64 // index into all, stable identifier passed to kernel
+ g uintptr
+ obs uint32 // zx.Signals
+ ready uintptr // set when g is set by unlockf or obs set by dequeue
+}
+
+// A waiter is a zircon port that parks goroutines waiting on signals.
+//
+// Currently there is only one instance of waiter per process, stored
+// in sysWaiter. It is however a self-contained object and multiple
+// of them can safely exist concurrently.
+type waiter struct {
+ port zx.Port
+
+ mu sync.Mutex
+ free []*waitingG
+ all []*waitingG
+}
+
+func newWaiter() *waiter {
+ port, err := zx.NewPort(0)
+ if err != nil {
+ panic(err) // misuse of system call, no useful recovery
+ }
+ w := &waiter{
+ port: port,
+ }
+ go w.dequeue()
+ return w
+}
+
+var sysWaiterOnce sync.Once
+var sysWaiter *waiter
+
+func sysWaiterInit() {
+ sysWaiter = newWaiter()
+}
+
+// dequeue is a dedicated goroutine to waiting on the waiter's port.
+func (w *waiter) dequeue() {
+ var pkt zx.Packet
+ for {
+ err := w.port.Wait(&pkt, zx.TimensecInfinite)
+ if err != nil {
+ panic(err)
+ }
+
+ w.mu.Lock()
+ waiting := w.all[pkt.Hdr.Key]
+ w.mu.Unlock()
+
+ obs := pkt.Signal().Observed
+
+ atomic.StoreUint32(&waiting.obs, uint32(obs))
+ if atomic.CompareAndSwapUintptr(&waiting.ready, 0, 1) {
+ // We beat unlockf, goroutine never parked.
+ continue
+ }
+ // We were beaten by unlockf, so waiting.g has a real value.
+ g := atomic.LoadUintptr(&waiting.g)
+ goready(g, 0)
+ }
+}
+
+// Wait waits for signals on handle.
+//
+// See the package function Wait for more commentary.
+func (w *waiter) Wait(handle zx.Handle, signals zx.Signals) (observed zx.Signals, err error) {
+ var waiting *waitingG
+
+ w.mu.Lock()
+ if len(w.free) == 0 {
+ waiting = &waitingG{
+ key: uint64(len(w.all)),
+ }
+ w.all = append(w.all, waiting)
+ } else {
+ waiting = w.free[len(w.free)-1]
+ w.free = w.free[:len(w.free)-1]
+ }
+ w.mu.Unlock()
+
+ var pkt zx.Packet
+ pkt.Hdr.Key = waiting.key
+ pkt.Signal().Trigger = signals
+
+ const ZX_WAIT_ASYNC_ONCE = 0
+ if err = w.port.WaitAsync(handle, pkt.Hdr.Key, signals, ZX_WAIT_ASYNC_ONCE); err != nil {
+ return 0, err
+ }
+
+ const traceEv = 24
+ gopark(w.unlockf, waiting, "zxwait", traceEv, 0)
+
+ obs := atomic.LoadUint32(&waiting.obs)
+
+ *waiting = waitingG{key: waiting.key} // clear waitingG for reuse
+
+ w.mu.Lock()
+ w.free = append(w.free, waiting)
+ w.mu.Unlock()
+
+ return zx.Signals(obs), nil
+}
+
+// unlockf is passed as a callback to gopark.
+//
+// Reporting true will park the goroutine until goready is called.
+//
+// Reporting false will immediately start running the goroutine
+// again, and nothing else should call goready.
+//
+// This method is called without a 'g', so it can do very little.
+// Avoid the stack. Don't use anything with 'g'-based runtime
+// support (like sync.Mutex). Do as little as possible.
+func (w *waiter) unlockf(g uintptr, waiting *waitingG) bool {
+ atomic.StoreUintptr(&waiting.g, g)
+
+ // If we can set ready, then this executed before dequeue
+ // and the goroutine will be parked.
+ //
+ // If we cannot set it, then dequeue has already run and
+ // waiting.obs is set, so do not park the goroutine.
+ return atomic.CompareAndSwapUintptr(&waiting.ready, 0, 1)
+}
diff --git a/src/syscall/zx/zxwait/zxwait.s b/src/syscall/zx/zxwait/zxwait.s
new file mode 100644
index 0000000..a35105e
--- /dev/null
+++ b/src/syscall/zx/zxwait/zxwait.s
@@ -0,0 +1,5 @@
+// Copyright 2018 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.
+
+// Empty assembly file so empty func definitions work.
diff --git a/src/syscall/zx/zxwait/zxwait_test.go b/src/syscall/zx/zxwait/zxwait_test.go
new file mode 100644
index 0000000..b649344
--- /dev/null
+++ b/src/syscall/zx/zxwait/zxwait_test.go
@@ -0,0 +1,84 @@
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build fuchsia
+
+package zxwait_test
+
+import (
+ "runtime"
+ "sync"
+ "syscall/zx"
+ "syscall/zx/zxwait"
+ "testing"
+)
+
+func TestWaitPreexisting(t *testing.T) {
+ c0, c1, err := zx.NewChannel(0)
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer c0.Close()
+ defer c1.Close()
+
+ obs, err := zxwait.Wait(*c0.Handle(), zx.SignalChannelWritable, zx.TimensecInfinite)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if obs&zx.SignalChannelWritable == 0 {
+ t.Errorf("want zx.SignalChannelWritable, got obs=%x", obs)
+ }
+
+ obs, err = zxwait.Wait(*c1.Handle(), zx.SignalChannelWritable, zx.TimensecInfinite)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if obs&zx.SignalChannelWritable == 0 {
+ t.Errorf("want zx.SignalChannelWritable, got obs=%x", obs)
+ }
+}
+
+func TestWait(t *testing.T) {
+ t.Logf("GOMAXPROCS=%v", runtime.GOMAXPROCS(0))
+ c0s := make([]zx.Channel, 100)
+ c1s := make([]zx.Channel, len(c0s))
+ allObs := make([]zx.Signals, len(c0s))
+
+ var wg sync.WaitGroup
+ for i := range c0s {
+ var err error
+ c0s[i], c1s[i], err = zx.NewChannel(0)
+ if err != nil {
+ t.Fatal(err)
+ }
+ wg.Add(1)
+ go func(i int) {
+ obs, err := zxwait.Wait(*c0s[i].Handle(), zx.SignalChannelReadable, zx.TimensecInfinite)
+ if err != nil {
+ t.Fatal(err)
+ }
+ allObs[i] = obs
+ //t.Logf("signal for channel %d received", i)
+ //fmt.Printf("TEST: signal for channel %d received\n", i)
+ wg.Done()
+ }(i)
+ }
+
+ b := []byte("hello")
+ for i, c1 := range c1s {
+ //t.Logf("writing on channel %d", i)
+ //fmt.Printf("TEST: writing on channel %d\n", i)
+ if err := c1.Write(b, nil, 0); err != nil {
+ t.Errorf("failed to write on channel %d: %v", i, err)
+ }
+ }
+
+ wg.Wait()
+
+ for i, obs := range allObs {
+ if obs&zx.SignalChannelWritable == 0 {
+ t.Errorf("channel %d: obs=%x want zx.SignalChannelReadable", i, obs)
+ }
+ }
+}
diff --git a/src/time/sys_fuchsia.go b/src/time/sys_fuchsia.go
new file mode 100644
index 0000000..6fdb086
--- /dev/null
+++ b/src/time/sys_fuchsia.go
@@ -0,0 +1,29 @@
+// Copyright 2016 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 time
+
+func initLocal() {
+ localLoc.name = "UTC"
+}
+
+func read(fd uintptr, buf []byte) (int, error) {
+ panic("TODO")
+}
+
+func open(name string) (uintptr, error) {
+ panic("TODO")
+}
+
+func closefd(fd uintptr) {
+ panic("TODO")
+}
+
+func preadn(fd uintptr, buf []byte, off int) error {
+ panic("TODO")
+}
+
+func isNotExist(err error) bool {
+ panic("TODO")
+}
diff --git a/src/time/zoneinfo_fuchsia.go b/src/time/zoneinfo_fuchsia.go
new file mode 100644
index 0000000..09a6696
--- /dev/null
+++ b/src/time/zoneinfo_fuchsia.go
@@ -0,0 +1,7 @@
+// 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 time
+
+var zoneSources = []string{}
