111 lines
2.7 KiB
Go
111 lines
2.7 KiB
Go
// Copyright 2016 the Go-FUSE 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 fuse
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"os"
|
|
"os/exec"
|
|
"strings"
|
|
"syscall"
|
|
)
|
|
|
|
func unixgramSocketpair() (l, r *os.File, err error) {
|
|
fd, err := syscall.Socketpair(syscall.AF_UNIX, syscall.SOCK_STREAM, 0)
|
|
if err != nil {
|
|
return nil, nil, os.NewSyscallError("socketpair",
|
|
err.(syscall.Errno))
|
|
}
|
|
l = os.NewFile(uintptr(fd[0]), "socketpair-half1")
|
|
r = os.NewFile(uintptr(fd[1]), "socketpair-half2")
|
|
return
|
|
}
|
|
|
|
// Create a FUSE FS on the specified mount point. The returned
|
|
// mount point is always absolute.
|
|
func mount(mountPoint string, opts *MountOptions, ready chan<- error) (fd int, err error) {
|
|
local, remote, err := unixgramSocketpair()
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
defer local.Close()
|
|
defer remote.Close()
|
|
|
|
bin, err := fusermountBinary()
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
cmd := exec.Command(bin,
|
|
"-o", strings.Join(opts.optionsStrings(), ","),
|
|
"-o", fmt.Sprintf("iosize=%d", opts.MaxWrite),
|
|
mountPoint)
|
|
cmd.ExtraFiles = []*os.File{remote} // fd would be (index + 3)
|
|
cmd.Env = append(os.Environ(),
|
|
"_FUSE_CALL_BY_LIB=",
|
|
"_FUSE_DAEMON_PATH="+os.Args[0],
|
|
"_FUSE_COMMFD=3",
|
|
"_FUSE_COMMVERS=2",
|
|
"MOUNT_OSXFUSE_CALL_BY_LIB=",
|
|
"MOUNT_OSXFUSE_DAEMON_PATH="+os.Args[0])
|
|
|
|
var out, errOut bytes.Buffer
|
|
cmd.Stdout = &out
|
|
cmd.Stderr = &errOut
|
|
|
|
if err = cmd.Start(); err != nil {
|
|
return
|
|
}
|
|
|
|
fd, err = getConnection(local)
|
|
if err != nil {
|
|
return -1, err
|
|
}
|
|
|
|
go func() {
|
|
// On macos, mount_osxfuse is not just a suid
|
|
// wrapper. It interacts with the FS setup, and will
|
|
// not exit until the filesystem has successfully
|
|
// responded to INIT and STATFS. This means we can
|
|
// only wait on the mount_osxfuse process after the
|
|
// server has fully started
|
|
if err := cmd.Wait(); err != nil {
|
|
err = fmt.Errorf("mount_osxfusefs failed: %v. Stderr: %s, Stdout: %s",
|
|
err, errOut.String(), out.String())
|
|
}
|
|
|
|
ready <- err
|
|
close(ready)
|
|
}()
|
|
|
|
// golang sets CLOEXEC on file descriptors when they are
|
|
// acquired through normal operations (e.g. open).
|
|
// Buf for fd, we have to set CLOEXEC manually
|
|
syscall.CloseOnExec(fd)
|
|
|
|
return fd, err
|
|
}
|
|
|
|
func unmount(dir string, opts *MountOptions) error {
|
|
return syscall.Unmount(dir, 0)
|
|
}
|
|
|
|
func fusermountBinary() (string, error) {
|
|
binPaths := []string{
|
|
"/Library/Filesystems/macfuse.fs/Contents/Resources/mount_macfuse",
|
|
"/Library/Filesystems/osxfuse.fs/Contents/Resources/mount_osxfuse",
|
|
}
|
|
|
|
for _, path := range binPaths {
|
|
if _, err := os.Stat(path); err == nil {
|
|
return path, nil
|
|
}
|
|
}
|
|
|
|
return "", fmt.Errorf("no FUSE mount utility found")
|
|
}
|