linux support for net.Dial by stubbing out runtime polling

Signed-off-by: leongross <leon.gross@9elements.com>
tinygo-org · leongross · Sep 2, 2024 · Sep 10, 2024 · Sep 11, 2024 · Sep 18, 2024
commit 329fef6b4a6394ebe7e5ec49e5cacfa15f61b006
diff --git a/.gitmodules b/.gitmodules
@@ -32,10 +32,6 @@
 [submodule "lib/macos-minimal-sdk"]
 	path = lib/macos-minimal-sdk
 	url = https://github.com/aykevl/macos-minimal-sdk.git
-[submodule "src/net"]
-	path = src/net
-	url = https://github.com/tinygo-org/net.git
-	branch = dev
 [submodule "lib/wasi-cli"]
 	path = lib/wasi-cli
 	url = https://github.com/WebAssembly/wasi-cli
diff --git a/loader/goroot.go b/loader/goroot.go
@@ -270,6 +270,12 @@ func pathsToOverride(goMinor int, needsSyscallPackage bool) map[string]bool {
 	if needsSyscallPackage {
 		paths["syscall/"] = true // include syscall/js
 	}
+
+	// to enable network support for linux systems, reuse the Go version of the net package
+	// and the according runtime functions
+	// if runtime.GOOS == "linux" {
+	// 	paths["runtime/netpoll/"] = true
+	// }
 	return paths
 }
 

diff --git a/src/crypto/tls/common.go b/src/crypto/tls/common.go
diff --git a/src/crypto/tls/ticket.go b/src/crypto/tls/ticket.go
diff --git a/src/crypto/tls/tls.go b/src/crypto/tls/tls.go
diff --git a/src/net b/src/net
diff --git a/src/runtime/netpoll.go b/src/runtime/netpoll.go
@@ -0,0 +1,45 @@
+// Copyright 2024 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
+
+// For debugging purposes this is used for all target architectures, but this is only valid for linux systems.
+// TODO: add linux specific build tags
+type pollDesc struct {
+	runtimeCtx uintptr
+}
+
+func (pd *pollDesc) wait(mode int, isFile bool) error {
+	return nil
+}
+
+const (
+	pollNoError        = 0 // no error
+	pollErrClosing     = 1 // descriptor is closed
+	pollErrTimeout     = 2 // I/O timeout
+	pollErrNotPollable = 3 // general error polling descriptor
+)
+
+//go:linkname poll_runtime_pollReset internal/poll.runtime_pollReset
+func poll_runtime_pollReset(pd *pollDesc, mode int) int {
+	println("poll_runtime_pollReset not implemented", pd, mode)
+	return pollNoError
+}
+
+//go:linkname poll_runtime_pollWait internal/poll.runtime_pollWait
+func poll_runtime_pollWait(pd *pollDesc, mode int) int {
+	println("poll_runtime_pollWait not implemented", pd, mode)
+	return pollNoError
+}
+
+//go:linkname poll_runtime_pollSetDeadline internal/poll.runtime_pollSetDeadline
+func poll_runtime_pollSetDeadline(pd *pollDesc, d int64, mode int) {
+	println("poll_runtime_pollSetDeadline not implemented", pd, d, mode)
+}
+
+//go:linkname poll_runtime_pollOpen internal/poll.runtime_pollOpen
+func poll_runtime_pollOpen(fd uintptr) (*pollDesc, int) {
+	println("poll_runtime_pollOpen not implemented", fd)
+	return &pollDesc{runtimeCtx: 0x13371337}, pollNoError
+}
diff --git a/src/runtime/netpoll_generic.go b/src/runtime/netpoll_generic.go
@@ -0,0 +1,31 @@
+// Copyright 2024 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build (js && wasm) || wasip1 || windows
+
+package runtime
+
+// Network poller descriptor.
+//
+// No heap pointers.
+// For linux to call create Fds with a pollDesc, it needs a ctxRuntime pointer, so use the original pollDesc struct.
+// On linux we have a heap.
+type pollDesc struct{}
+
+//go:linkname poll_runtime_pollReset internal/poll.runtime_pollReset
+func poll_runtime_pollReset(pd *pollDesc, mode int) int {
+	println("poll_runtime_pollReset not implemented", pd, mode)
+	return 1
+}
+
+//go:linkname poll_runtime_pollWait internal/poll.runtime_pollWait
+func poll_runtime_pollWait(pd *pollDesc, mode int) int {
+	println("poll_runtime_pollWait not implemented", pd, mode)
+	return 1
+}
+
+//go:linkname poll_runtime_pollSetDeadline internal/poll.runtime_pollSetDeadline
+func poll_runtime_pollSetDeadline(pd *pollDesc, d int64, mode int) {
+	println("poll_runtime_pollSetDeadline not implemented", pd, d, mode)
+}
diff --git a/src/runtime/poll.go b/src/runtime/poll.go
@@ -4,20 +4,21 @@ package runtime
 
 //go:linkname poll_runtime_pollServerInit internal/poll.runtime_pollServerInit
 func poll_runtime_pollServerInit() {
-	panic("todo: runtime_pollServerInit")
+	// fmt.Printf("poll_runtime_pollServerInit not implemented, skipping panic\n")
 }
 
-//go:linkname poll_runtime_pollOpen internal/poll.runtime_pollOpen
-func poll_runtime_pollOpen(fd uintptr) (uintptr, int) {
-	panic("todo: runtime_pollOpen")
-}
+// //go:linkname poll_runtime_pollOpen internal/poll.runtime_pollOpen
+// func poll_runtime_pollOpen(fd uintptr) (uintptr, int) {
+// 	// fmt.Printf("poll_runtime_pollOpen not implemented, skipping panic\n")
+// 	return 0, 0
+// }
 
 //go:linkname poll_runtime_pollClose internal/poll.runtime_pollClose
 func poll_runtime_pollClose(ctx uintptr) {
+	// fmt.Printf("poll_runtime_pollClose not implemented, skipping panic\n")
 }
 
 //go:linkname poll_runtime_pollUnblock internal/poll.runtime_pollUnblock
 func poll_runtime_pollUnblock(ctx uintptr) {
-	panic("todo: runtime_pollUnblock")
+	// fmt.Printf("poll_runtime_pollUnblock not implemented, skipping panic\n")
 }
diff --git a/src/runtime/sync.go b/src/runtime/sync.go
@@ -4,10 +4,14 @@ package runtime
 
 //go:linkname semacquire internal/poll.runtime_Semacquire
 func semacquire(sema *uint32) {
-	panic("todo: semacquire")
+	// TODO the "net" pkg calls this, so panic() isn't an option.  Right
+	// now, just ignore the call.
+	// panic("todo: semacquire")
 }
 
 //go:linkname semrelease internal/poll.runtime_Semrelease
 func semrelease(sema *uint32) {
-	panic("todo: semrelease")
+	// TODO the "net" pkg calls this, so panic() isn't an option.  Right
+	// now, just ignore the call.
+	// panic("todo: semrelease")
 }
diff --git a/src/syscall/forklock_tinygo.go b/src/syscall/forklock_tinygo.go
@@ -0,0 +1,38 @@
+//go:build tinygo
+
+package syscall
+
+// This is the original ForkLock:
+//
+// var ForkLock sync.RWMutex
+//
+// This requires importing sync, but importing sync causes an import loop:
+//
+// package tinygo.org/x/drivers/examples/net/tcpclient
+//        imports bytes
+//        imports io
+//        imports sync
+//        imports internal/task
+//        imports runtime/interrupt
+//        imports device/arm
+//        imports syscall
+//        imports sync: import cycle not allowed
+//
+// So for now, make our own stubbed-out ForkLock that doesn't use sync..
+
+type forklock struct{}
+
+func (f forklock) RLock()   {}
+func (f forklock) RUnlock() {}
+
+var ForkLock forklock
+
+func CloseOnExec(fd int) {
+	system.CloseOnExec(fd)
+}
+
+func SetNonblock(fd int, nonblocking bool) (err error) {
+	return system.SetNonblock(fd, nonblocking)
+}
+
+type SysProcAttr struct{}