9p: initial version

Author: redbeam

cmd/crc/cmd/daemon.go

@@ -24,6 +24,7 @@ import (
 	"github.com/crc-org/crc/v2/pkg/crc/constants"
 	"github.com/crc-org/crc/v2/pkg/crc/daemonclient"
 	"github.com/crc-org/crc/v2/pkg/crc/logging"
+	"github.com/crc-org/crc/v2/pkg/fileserver/fs9p"
 	"github.com/crc-org/machine/libmachine/drivers"
 	"github.com/docker/go-units"
 	"github.com/gorilla/handlers"
@@ -248,6 +249,15 @@ func run(configuration *types.Configuration) error {
 		}
 	}()
 
+	// 9p home directory sharing
+	listener9p, err := vn.Listen("tcp", net.JoinHostPort(configuration.GatewayIP, fmt.Sprintf("%d", constants.Plan9Port)))
+	if err != nil {
+		return err
+	}
+	if err := fs9p.StartShares([]fs9p.Mount9p{{Listener: listener9p, Path: constants.GetHomeDir()}}); err != nil {
+		return err
+	}
+
 	startupDone()
 
 	if logging.IsDebug() {

pkg/crc/constants/constants.go

@@ -55,6 +55,9 @@ const (
 	OpenShiftIngressHTTPSPort = 443
 
 	BackgroundLauncherExecutable = "crc-background-launcher.exe"
+
+	Plan9Port  = 564
+	Plan9Msize = 1024 * 1024
 )
 
 var adminHelperExecutableForOs = map[string]string{

pkg/crc/machine/start.go

@@ -248,6 +248,7 @@ func configureSharedDirs(vm *virtualMachine, sshRunner *crcssh.Runner) error {
 			if _, _, err := sshRunner.RunPrivileged(fmt.Sprintf("Mounting %s", mount.Target), "mount", "-o", "context=\"system_u:object_r:container_file_t:s0\"", "-t", mount.Type, mount.Tag, mount.Target); err != nil {
 				return err
 			}
+
 		case "cifs":
 			smbUncPath := fmt.Sprintf("//%s/%s", hostVirtualIP, mount.Tag)
 			if _, _, err := sshRunner.RunPrivate("sudo", "mount", "-o", fmt.Sprintf("rw,uid=core,gid=core,username='%s',password='%s'", mount.Username, mount.Password), "-t", mount.Type, smbUncPath, mount.Target); err != nil {
@@ -257,6 +258,16 @@ func configureSharedDirs(vm *virtualMachine, sshRunner *crcssh.Runner) error {
 				}
 				return fmt.Errorf("Failed to mount CIFS/SMB share '%s' please make sure configured password is correct: %w", mount.Tag, err)
 			}
+
+		case "9p":
+			// change owner to core user to allow mounting to it as a non-root user
+			if _, _, err := sshRunner.RunPrivileged("Changing owner of mount directory", "chown core:core", mount.Target); err != nil {
+				return err
+			}
+			if _, _, err := sshRunner.Run("9pfs 192.168.127.1", mount.Target); err != nil {
+				return err
+			}
+
 		default:
 			return fmt.Errorf("Unknown Shared dir type requested: %s", mount.Type)
 		}

pkg/fileserver/fs9p/server.go

@@ -0,0 +1,80 @@
+package fs9p
+
+import (
+	"fmt"
+	"net"
+	"os"
+	"path/filepath"
+
+	"github.com/DeedleFake/p9"
+	"github.com/DeedleFake/p9/proto"
+	"github.com/crc-org/crc/v2/pkg/crc/constants"
+	"github.com/sirupsen/logrus"
+)
+
+type Server struct {
+	// Listener this server is bound to
+	Listener net.Listener
+	// Directory this server exposes
+	ExposedDir string
+	// Errors from the server being started will come out here
+	ErrChan chan error
+}
+
+// New9pServer exposes a single directory (and all children) via the given net.Listener.
+// Directory given must be an absolute path and must exist.
+func New9pServer(listener net.Listener, exposeDir string) (*Server, error) {
+	// Verify that exposeDir makes sense.
+	if !filepath.IsAbs(exposeDir) {
+		return nil, fmt.Errorf("path to expose to machine must be absolute: %s", exposeDir)
+	}
+	stat, err := os.Stat(exposeDir)
+	if err != nil {
+		return nil, fmt.Errorf("cannot stat path to expose to machine: %w", err)
+	}
+	if !stat.IsDir() {
+		return nil, fmt.Errorf("path to expose to machine must be a directory: %s", exposeDir)
+	}
+
+	errChan := make(chan error)
+
+	fs := p9.FileSystem(p9.Dir(exposeDir))
+
+	go func() {
+		errChan <- proto.Serve(listener, p9.Proto(), p9.FSConnHandler(fs, constants.Plan9Msize))
+		close(errChan)
+	}()
+
+	toReturn := new(Server)
+	toReturn.Listener = listener
+	toReturn.ExposedDir = exposeDir
+	toReturn.ErrChan = errChan
+
+	// Just before returning, check to see if we got an error off server startup.
+	select {
+	case err := <-errChan:
+		return nil, fmt.Errorf("starting 9p server: %w", err)
+	default:
+		logrus.Infof("Successfully started 9p server on %s for directory %s", listener.Addr().String(), exposeDir)
+	}
+
+	return toReturn, nil
+}
+
+// Stop a running server.
+// Please note that this does *BAD THINGS* to clients if they are still running
+// when the server stops. Processes get stuck in I/O deep sleep and zombify, and
+// nothing I do other than restarting the VM can remove the zombies.
+func (s *Server) Stop() error {
+	if err := s.Listener.Close(); err != nil {
+		return err
+	}
+	logrus.Infof("Successfully stopped 9p server for directory %s", s.ExposedDir)
+	return nil
+}
+
+// WaitForError from a running server.
+func (s *Server) WaitForError() error {
+	err := <-s.ErrChan
+	return err
+}

pkg/fileserver/fs9p/shares.go

@@ -0,0 +1,42 @@
+package fs9p
+
+import (
+	"fmt"
+	"net"
+
+	"github.com/sirupsen/logrus"
+)
+
+type Mount struct {
+	Listener net.Listener
+	Path     string
+}
+
+func StartShares(plan9Mounts []Mount) (defErr error) {
+	for _, m := range plan9Mounts {
+		server, err := New9pServer(m.Listener, m.Path)
+		if err != nil {
+			return fmt.Errorf("serving directory %s on %s: %w", m.Path, m.Listener.Addr().String(), err)
+		}
+		defer func() {
+			if defErr != nil {
+				if err := server.Stop(); err != nil {
+					logrus.Errorf("Error stopping 9p server: %v", err)
+				}
+			}
+		}()
+
+		serverDir := m.Path
+
+		go func() {
+			if err := server.WaitForError(); err != nil {
+				logrus.Errorf("Error from 9p server on %s for %s: %v", m.Listener.Addr().String(), serverDir, err)
+			} else {
+				// We do not expect server exits - this should run until the program exits.
+				logrus.Warnf("9p server on %s for %s exited without error", m.Listener.Addr().String(), serverDir)
+			}
+		}()
+	}
+
+	return nil
+}

pkg/fileserver/fs9p/shares_unsupported.go

@@ -0,0 +1,15 @@
+//go:build !windows
+
+package fs9p
+
+import (
+	"fmt"
+)
+
+func StartHvsockShares(mounts map[string]string) error {
+	if len(mounts) == 0 {
+		return nil
+	}
+
+	return fmt.Errorf("this platform does not support sharing directories")
+}

pkg/fileserver/fs9p/shares_windows.go

@@ -0,0 +1,36 @@
+package fs9p
+
+import (
+	"fmt"
+
+	"github.com/linuxkit/virtsock/pkg/hvsock"
+	"github.com/sirupsen/logrus"
+)
+
+// Start serving the given shares on Windows HVSocks for use by a Hyper-V VM.
+// Mounts is formatted as a map of directory to be shared to vsock GUID.
+// The vsocks used must already be defined before StartShares is called; it's
+// expected that the vsocks will be created and torn down by the program calling
+// gvproxy.
+// TODO: The map here probably doesn't make sense.
+func StartHvsockShares(mounts map[string]string) (defErr error) {
+	plan9Mounts := []Mount{}
+	for path, guid := range mounts {
+		service, err := hvsock.GUIDFromString(guid)
+		if err != nil {
+			return fmt.Errorf("parsing vsock guid %s: %w", guid, err)
+		}
+
+		listener, err := hvsock.Listen(hvsock.Addr{
+			VMID:      hvsock.GUIDWildcard,
+			ServiceID: service,
+		})
+		if err != nil {
+			return fmt.Errorf("retrieving listener for vsock %s: %w", guid, err)
+		}
+
+		logrus.Debugf("Going to serve directory %s on vsock %s", path, guid)
+		plan9Mounts = append(plan9Mounts, Mount{Listener: listener, Path: path})
+	}
+	return StartShares(plan9Mounts)
+}