fs-gen: proot is working!

This creates a mounted loopback ps, and then executes a binary there
with proot. We have a custom open function that prints the path
and next we would want to cache that somehow.

Signed-off-by: vsoch <[email protected]>

Author: vsoch

README.md

@@ -38,14 +38,19 @@ This was the experiment to generate something akin to spindle. I think it still
 2. Generate a fuse overlay where everything will be found in one spot (no searching needed)
 3. Then execute the binary.
 
-We would want to see that the exercise of not needing to do the search speeds up that loading time. If it does, it would make sense to pre-package this metadata with the binary for some registry to use.
-This isn't currently working because I can't execute the binary in the proot, so that's the unsolved problem. Here is to test running with a binary. 
+We would want to see that the exercise of not needing to do the search speeds up that loading time. If it does, it would make sense to pre-package this metadata with the binary for some registry to use. Here is how to run it with a binary:
 
 ```bash
 ./bin/fs-gen /home/vanessa/Desktop/Code/spack/opt/spack/linux-ubuntu24.04-zen4/gcc-13.2.0/xz-5.4.6-klise22d77jjaoejkucrczlkvnm6f4au/bin/xz --help
 ```
 
-I tried removing read only (ro) and then it freezes, so that's probably not it.
+This one has a few more paths:
+
+```bash
+./bin/fs-gen /home/vanessa/Desktop/Code/spack/opt/spack/linux-ubuntu24.04-zen4/gcc-13.2.0/hwloc-2.11.1-zuv2etx7sgd5yn6khpblfw6qjh54lpsp/bin/hwloc-ls
+```
+
+Next we would want to add some kind of cache to store file descriptors (or paths) and return something else.
 
 ### 2. Compatibility Wrapper
 

cmd/fs/fs.go

@@ -7,14 +7,15 @@ import (
 	"os"
 	"os/signal"
 	"path/filepath"
+	"strings"
 	"syscall"
 
 	"github.com/compspec/compat-lib/pkg/fs"
 	"github.com/compspec/compat-lib/pkg/generate"
 )
 
 func main() {
-	fmt.Println("⭐️ Compatibility Filesystem (clib-fs)")
+	fmt.Println("⭐️ Compatibility Filesystem (fs-gen)")
 	mountPoint := flag.String("mount-path", "", "Mount path (for control from calling process)")
 
 	flag.Parse()
@@ -34,13 +35,10 @@ func main() {
 
 	// This is where we should look them up in some cache
 	fmt.Printf("Preparing to find shared libraries needed for %s\n", args)
-	paths, err := generate.FindSharedLibs(path)
+	_, err = generate.FindSharedLibs(path)
 	if err != nil {
 		log.Panicf("Error finding shared libraries for %s: %x", path, err)
 	}
-	for _, lib := range paths {
-		fmt.Println(lib)
-	}
 
 	// Generate the fusefs server
 	compatFS, err := fs.NewCompatFS(mountPath)
@@ -60,15 +58,14 @@ func main() {
 	}()
 
 	// Execute the command with proot
-	// Disabled for now - operation not permitted. Removing ro seems to freeze
-	// proot := []string{"proot", "-r", compatFS.MountPoint}
-	//args = append(proot, args...)
-	//call := strings.Join(args, " ")
-	//fmt.Println(call)
-	//err = compatFS.RunCommand(call)
-	//if err != nil {
-	//		log.Panicf("Error running command: %s", err)
-	//}
+	proot := []string{"proot", "-S", compatFS.MountPoint, "-0"}
+	args = append(proot, args...)
+	call := strings.Join(args, " ")
+	fmt.Println(call)
+	err = compatFS.RunCommand(call)
+	if err != nil {
+		log.Panicf("Error running command: %s", err)
+	}
 	defer compatFS.Server.Unmount()
 	compatFS.Server.Wait()
 }

go.mod

@@ -3,6 +3,7 @@ module github.com/compspec/compat-lib
 go 1.22
 
 require (
+	github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510
 	github.com/hanwen/go-fuse/v2 v2.6.1
 	github.com/opencontainers/image-spec v1.1.0
 	github.com/pkg/errors v0.9.1

go.sum

@@ -1,6 +1,8 @@
 github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
 github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
 github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 h1:El6M4kTTCOh6aBiKaUGG7oYTSPP8MxqL4YI3kZKwcP4=
+github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510/go.mod h1:pupxD2MaaD3pAXIBCelhxNneeOaAeabZDe5s4K6zSpQ=
 github.com/hanwen/go-fuse/v2 v2.6.1 h1:F3RUMbAuRhVTi3fvgf8HjMPvOm9xEv5wjuy/AXJtEwI=
 github.com/hanwen/go-fuse/v2 v2.6.1/go.mod h1:ugNaD/iv5JYyS1Rcvi57Wz7/vrLQJo10mmketmoef48=
 github.com/kylelemons/godebug v0.0.0-20170820004349-d65d576e9348 h1:MtvEpTB6LX3vkb4ax0b5D2DHbNAUsen0Gx5wZoq3lV4=

pkg/fs/fs.go

@@ -4,8 +4,8 @@ import (
 	"fmt"
 	"os"
 	"os/exec"
-	"syscall"
 
+	"github.com/google/shlex"
 	"github.com/hanwen/go-fuse/v2/fuse"
 )
 
@@ -83,43 +83,30 @@ func NewCompatFS(mountPath string) (*CompatFS, error) {
 // separately.
 func (c *CompatFS) RunCommand(command string) error {
 
-	// Get current working directory to return to
-	cwd, err := os.Getwd()
+	// returns list of strings
+	call, err := shlex.Split(command)
 	if err != nil {
 		return err
 	}
 
-	// Get the file descriptor to return to later
-	fd, err := os.Open(cwd)
+	command, args := call[0], call[1:]
+
+	// Get current working directory to return to
+	cwd, err := os.Getwd()
 	if err != nil {
 		return err
 	}
-	defer fd.Close()
 
 	// Setup command, using standard outputs
-	cmd := exec.Command(command)
+	cmd := exec.Command(command, args...)
 	cmd.Stdin = os.Stdin
 	cmd.Stdout = os.Stdout
 	cmd.Stderr = os.Stderr
+	cmd.Dir = cwd
 
-	// Change directory to the new "root" (mountpoint) and call chroot
-	err = syscall.Chdir(c.MountPoint)
-	if err != nil {
-		return err
-	}
-	err = syscall.Chroot(c.MountPoint)
-	if err != nil {
-		return err
-	}
 	err = cmd.Run()
 	if err != nil {
 		return err
 	}
-
-	// Return to previous location
-	err = syscall.Fchdir(int(fd.Fd()))
-	if err != nil {
-		return err
-	}
-	return syscall.Chroot(".")
+	return err
 }

pkg/fs/loopback.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"log"
 	"os"
+	"path/filepath"
 	"syscall"
 	"time"
 
@@ -19,14 +20,33 @@ type CompatLoopbackNode struct {
 	fs.LoopbackNode
 }
 
+func (n *CompatLoopbackNode) path() string {
+	path := n.Path(n.root())
+	return filepath.Join(n.RootData.Path, path)
+}
+
+// path returns the full path to the file in the underlying file system.
+func (n *CompatLoopbackNode) root() *fs.Inode {
+	var rootNode *fs.Inode
+	if n.RootData.RootNode != nil {
+		rootNode = n.RootData.RootNode.EmbeddedInode()
+	} else {
+		rootNode = n.Root()
+	}
+
+	return rootNode
+}
+
 func (n *CompatLoopbackNode) Open(ctx context.Context, flags uint32) (fs.FileHandle, uint32, syscall.Errno) {
-	fmt.Println("CUSTOM OPEN FOR %s with flags %s\n", ctx, flags)
+	flags = flags &^ syscall.O_APPEND
+	p := n.path()
+	fmt.Printf("CUSTOM OPEN FOR %s with flags %d\n", p, flags)
 	fh, flags, errno := n.LoopbackNode.Open(ctx, flags)
 	return fh, flags, errno
 }
 
 func (n *CompatLoopbackNode) Create(ctx context.Context, name string, flags uint32, mode uint32, out *fuse.EntryOut) (*fs.Inode, fs.FileHandle, uint32, syscall.Errno) {
-	fmt.Println("CUSTOM CREATE FOR %s with flags %s\n", name, flags)
+	fmt.Printf("CUSTOM CREATE FOR %s with flags %d\n", name, flags)
 	inode, fh, flags, errno := n.LoopbackNode.Create(ctx, name, flags, mode, out)
 	return inode, fh, flags, errno
 }