Looking for the magic name /dev/fuse doesn't seem like a good approach. What if someone does ln -s /dev/fuse myfuse and then tries to open myfuse? Presumably that will fail in the same way.

Is there some way to check for a type as we already do for a FIFO?

CC @golang/freebsd

We could probably implement a function similar to devname(3), which is used by mount_fusefs(8) to check the device name. Hardcoding "kern.devname" MIB (which is [1, 2147483224] on 13.1-RELEASE) doesn't sound right so this approach would need runtime translation of the sysctl name to MIB. sysctlnametomib() is present in runtime but unexported. I'm not sure what would be the best course of action here.

For example, it would be fine to add sysctlnametomib to internal/syscall/unix and to call it from the os package.

Change https://go.dev/cl/420235 mentions this issue: os: Disable polling for fuse devices on FreeBSD

I've ended looking at this as well. I ran the bazil/fuse/examples/hellofs example, under truss, getting the same result:

# truss -SdHf -o /tmp/truss ./hellofs -fuse.debug /tmp/tst1
2022/07/30 14:30:17 resource temporarily unavailable

The relevant part is this:

 3678 100150: 0.032046504 open("/dev/fuse",O_RDWR|O_CLOEXEC,00) = 3 (0x3)

 3678 100150: 0.032667484 fstat(3,{ mode=crw-rw-rw- ,inode=102,size=0,blksize=4096 }) = 0 (0x0)
 3678 100150: 0.032856138 kqueue()               = 4 (0x4)
 3678 100150: 0.033037163 fcntl(4,F_SETFD,FD_CLOEXEC) = 0 (0x0)


 3678 100150: 0.033541314 compat11.kevent(4,{ 3,EVFILT_READ,EV_ADD|EV_CLEAR,0,0,0x827253f68 3,EVFILT_WRITE,EV_ADD|EV_CLEAR,0,0,0x827253f68 },2,0x0,0,0x0) = 0 (0x0)
 3678 100150: 0.033721862 fcntl(3,F_GETFL,)      = 2 (0x2)
 3678 100150: 0.033866169 fcntl(3,F_SETFL,O_RDWR|O_NONBLOCK) ERR#19 'Operation not supported by device'

Note how the file is registered under the netpoller, but fails to set the file into non-blocking mode. Corresponding to the following code:

While this is addressed (or maybe wait for a kernel fix?), this is a simple workaround to bazil/fuse#280

diff --git a/mount_freebsd.go b/mount_freebsd.go
index 9106a18..52a1af0 100644
--- a/mount_freebsd.go
+++ b/mount_freebsd.go
@@ -56,10 +56,11 @@ func mount(dir string, conf *mountConfig) (*os.File, error) {
                }
        }

-       f, err := os.OpenFile("/dev/fuse", os.O_RDWR, 0o000)
+       fd, err := syscall.Open("/dev/fuse", os.O_RDWR|syscall.O_CLOEXEC, 0o000)
        if err != nil {
                return nil, err
        }
+       f := os.NewFile(uintptr(fd), "/dev/fuse")

        cmd := exec.Command(
                "/sbin/mount_fusefs",

By using os.NewFile() on a blocking file-descriptor, we end up with the "old" behavior.

Change https://go.dev/cl/420334 mentions this issue: os: don't attempt to call syscall.SetNonblock() when kind == kindNonBlock

I've sent https://go.dev/cl/420334, with it the bazil/fuse module can be made to work properly with /dev/fuse and the netpoller by going through os.NewFile + O_NONBLOCK which makes fdi go through the kindNonBlock flow.

When the kernel fuse device ends up supporting SETFL, then we can return back to regular os.OpenFile use.

diff --git a/mount_freebsd.go b/mount_freebsd.go
index 9106a18..28d4ef1 100644
--- a/mount_freebsd.go
+++ b/mount_freebsd.go
@@ -8,6 +8,8 @@ import (
        "strings"
        "sync"
        "syscall"
+
+       "golang.org/x/sys/unix"
 )

 func handleMountFusefsStderr(errCh chan<- error) func(line string) (ignore bool) {
@@ -56,10 +58,11 @@ func mount(dir string, conf *mountConfig) (*os.File, error) {
                }
        }

-       f, err := os.OpenFile("/dev/fuse", os.O_RDWR, 0o000)
+       fd, err := unix.Open("/dev/fuse", unix.O_RDWR|unix.O_NONBLOCK|unix.O_CLOEXEC, 0o000)
        if err != nil {
                return nil, err
        }
+       f := os.NewFile(uintptr(fd), "/dev/fuse")

        cmd := exec.Command(
                "/sbin/mount_fusefs",

Update: I believe there's a kernel issue here with the fuse device. bazil/fuse is always using blocking IO:
https://github.com/bazil/fuse/blob/fb710f7dfd05053a3bc9516dd5a7a8f84ead8aab/fuse.go#L557-L560
https://github.com/bazil/fuse/blob/fb710f7dfd05053a3bc9516dd5a7a8f84ead8aab/fuse.go#L577-L579
(Direct use of syscall.Read/Write on an os.File.Fd())

However the mere initial attempt to set the file descriptor into non-blocking mode, which reports an error:
fcntl(3,F_SETFL,O_RDWR|O_NONBLOCK) ERR#19 'Operation not supported by device'
Does switch the device into non-blocking mode, which enables it to return EAGAIN (resource temporarily unavailable) on Reads. These errors are unexpected by bazil/fuse causing the mount to fail.

If we skip this initial attempt, for example by explicitly starting from a blocking file descriptor #54100 (comment). Then the device doesn't enter non-blocking mode, and never returns EAGAIN.

Remaining FreeBSD fuse(4) fcntl issue is tracked here: https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=265736

That FreeBSD bug, which actually turned out not to be in fusefs, is now fixed. The fix will be included in the next builds of 14.0-CURRENT.

@asomers
# restic -r restic-repo mount /mnt OK
read, copy files from /mnt OK

Thank you!