feat: Add namespace isolation support for proxy processes

cmd/remoteproc-runtime/create.go

@@ -20,7 +20,7 @@ var createCmd = &cobra.Command{
 		if bundlePath == "" {
 			bundlePath = "."
 		}
-		return runtime.Create(containerID, bundlePath, pidFile)
+		return runtime.Create(logger, containerID, bundlePath, pidFile)
 	},
 }
 

docs/DEVELOPMENT.md

@@ -76,8 +76,6 @@ Useful for development without access to hardware with Remoteproc support.
 
 #### Testing with Docker
 
-⚠️ Docker network must be set to 'Host' (`--network=host`), as the proxy runs in the host's network namespace.
-
 1. **Build and install the shim and runtime with custom root**
 
    ```bash
@@ -114,7 +112,6 @@ Useful for development without access to hardware with Remoteproc support.
    docker run \
        --runtime io.containerd.remoteproc.v1 \
        --annotation remoteproc.name="test-processor" \
-       --network=host \
        test-remoteproc-image
    ```
 

e2e/limavm/limavm.go

@@ -21,7 +21,9 @@
 }
 
 var BinBuildEnv = map[string]string{
-	"GOOS": "linux",
+	"GOOS":   "linux",
+	"GOARCH": "amd64",
+	"CGO_ENABLED": "0",
 }
 
 func NewWithDocker(mountDir string, buildContext string, bins repo.Bins) (LimaVM, error) {
@@ -32,6 +34,10 @@
 	return New("podman", mountDir, buildContext, string(runtimeBin))
 }
 
+func NewAlpine(mountDir string, runtimeBin repo.RuntimeBin) (LimaVM, error) {
+	return New("alpine", mountDir, "", string(runtimeBin))
+}
+
 func New(template string, mountDir string, buildContext string, binsToInstall ...string) (LimaVM, error) {
 	cmd := exec.Command(
 		prepareLimaVMScript,

e2e/limavm/prepare-lima-vm.sh

@@ -11,17 +11,19 @@ BINARIES=()
 
 usage() {
     echo "Usage: $0 <template> <mount-dir> <build-context> <binary1> [binary2] ..." >&2
-    echo "  template:         Lima template to use (docker or podman)" >&2
+    echo "  template:         Lima template to use (docker, podman, or alpine)" >&2
     echo "  mount-dir:        Directory attached in the vm" >&2
     echo "  build-context:    Build context directory for test-image build" >&2
     echo "  binary1...N:      Path to binaries to install in /usr/local/bin" >&2
     exit 1
 }
 
 validate_inputs() {
-    if [ ! -d "$BUILD_CONTEXT" ]; then
-        echo "Error: Build context directory not found: $BUILD_CONTEXT" >&2
-        exit 1
+    if [ "$TEMPLATE" = "docker" ] || [ "$TEMPLATE" = "podman" ]; then
+        if [ ! -d "$BUILD_CONTEXT" ]; then
+            echo "Error: Build context directory not found: $BUILD_CONTEXT" >&2
+            exit 1
+        fi
     fi
 
     for binary in "${BINARIES[@]}"; do
@@ -58,7 +60,13 @@ start_vm() {
 install_binary() {
     local source_path="$1"
     local binary_name="$2"
-    local dest_path="/usr/local/bin/$binary_name"
+    local dest_dir="/usr/local/bin"
+
+    if [ "$TEMPLATE" = "alpine" ]; then
+        dest_dir="/usr/bin"
+    fi
+
+    local dest_path="$dest_dir/$binary_name"
 
     echo "Installing $binary_name..." >&2
 
@@ -115,6 +123,12 @@ build_image() {
                 exit 1
             fi
             ;;
+        ""|none)
+            echo "Skipping image build (no build context provided)" >&2
+            ;;
+        alpine)
+            echo "Skipping image build for alpine template" >&2
+            ;;
         *)
             echo "Error: Unsupported template '$TEMPLATE'. Only 'docker' and 'podman' are supported." >&2
             cleanup_on_failure
@@ -149,7 +163,9 @@ main() {
         install_binary "$binary_path" "$binary_name"
     done
 
-    build_image
+    if [ -n "$BUILD_CONTEXT" ] || [ "$TEMPLATE" = "docker" ] || [ "$TEMPLATE" = "podman" ]; then
+        build_image
+    fi
 
     echo "VM setup completed successfully" >&2
 

e2e/runtime_test.go

@@ -7,9 +7,11 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
+	"strings"
 	"syscall"
 	"testing"
 
+	"github.com/arm/remoteproc-runtime/e2e/limavm"
 	"github.com/arm/remoteproc-runtime/e2e/remoteproc"
 	"github.com/arm/remoteproc-runtime/e2e/repo"
 	"github.com/opencontainers/runtime-spec/specs-go"
@@ -128,13 +130,143 @@ func TestRuntimeWriteProcessPid(t *testing.T) {
 	assertFileContent(t, pidFilePath, fmt.Sprintf("%d", pid))
 }
 
+func TestRuntimeProxyKeepsHostNamespaceWhenNotRoot(t *testing.T) {
+	rootDir := t.TempDir()
+	remoteprocName := "a-lovely-blue-device"
+
+	runtimeBin, err := repo.BuildRuntimeBin(t.TempDir(), rootDir, limavm.BinBuildEnv)
+	require.NoError(t, err)
+
+	vm, err := limavm.NewAlpine(rootDir, runtimeBin)
+	require.NoError(t, err)
+	t.Cleanup(vm.Cleanup)
+
+	sim := remoteproc.NewSimulator(rootDir).WithName(remoteprocName)
+	if err := sim.Start(); err != nil {
+		t.Fatalf("failed to run simulator: %s", err)
+	}
+	t.Cleanup(func() { _ = sim.Stop() })
+
+	const containerName = "not-root-namespace-container"
+	bundlePath := filepath.Join(rootDir, "not-root-namespace-bundle")
+	require.NoError(t, generateBundle(
+		bundlePath,
+		remoteprocName,
+		specs.LinuxNamespace{Type: specs.MountNamespace},
+	))
+
+	_, stderr, err := vm.RunCommand(
+		"remoteproc-runtime",
+		"create", "--bundle", bundlePath,
+		containerName,
+	)
+	require.NoError(t, err, "stderr: %s", stderr)
+	t.Cleanup(func() {
+		_, _, _ = vm.RunCommand("remoteproc-runtime", "delete", containerName)
+	})
+
+	pid, err := checkContainerRunning(func() (specs.State, error) {
+		stdout, stderr, err := vm.RunCommand("remoteproc-runtime", "state", containerName)
+		if err != nil {
+			return specs.State{}, fmt.Errorf("stderr: %s: %w", stderr, err)
+		}
+		var state specs.State
+		if err := json.Unmarshal([]byte(stdout), &state); err != nil {
+			return specs.State{}, err
+		}
+		return state, nil
+	})
+	require.NoError(t, err)
+
+	hostMountNS, stderr, err := vm.RunCommand("readlink", "/proc/self/ns/mnt")
+	require.NoError(t, err, "stderr: %s", stderr)
+
+	proxyMountNS, stderr, err := vm.RunCommand("readlink", fmt.Sprintf("/proc/%d/ns/mnt", pid))
+	require.NoError(t, err, "stderr: %s", stderr)
+
+	assert.Equal(t, strings.TrimSpace(hostMountNS), strings.TrimSpace(proxyMountNS))
+}
+
+func TestRuntimeProxyKeepsHostNamespaceWhenRootInLimaVM(t *testing.T) {
+	rootDir := t.TempDir()
+	remoteprocName := "a-lovely-blue-device"
+
+	runtimeBin, err := repo.BuildRuntimeBin(t.TempDir(), rootDir, limavm.BinBuildEnv)
+	require.NoError(t, err)
+
+	vm, err := limavm.NewAlpine(rootDir, runtimeBin)
+	require.NoError(t, err)
+	t.Cleanup(vm.Cleanup)
+
+	sim := remoteproc.NewSimulator(rootDir).WithName(remoteprocName)
+	if err := sim.Start(); err != nil {
+		t.Fatalf("failed to run simulator: %s", err)
+	}
+	t.Cleanup(func() { _ = sim.Stop() })
+
+	const containerName = "root-namespace-container"
+	bundlePath := filepath.Join(rootDir, "root-namespace-bundle")
+	require.NoError(t, generateBundle(
+		bundlePath,
+		remoteprocName,
+		specs.LinuxNamespace{Type: specs.MountNamespace},
+	))
+
+	_, stderr, err := vm.RunCommand(
+		"sudo", "remoteproc-runtime",
+		"create", "--bundle", bundlePath,
+		containerName,
+	)
+	require.NoError(t, err, "stderr: %s", stderr)
+	t.Cleanup(func() {
+		_, _, _ = vm.RunCommand("sudo", "remoteproc-runtime", "delete", containerName)
+	})
+
+	pid, err := checkContainerRunning(func() (specs.State, error) {
+		stdout, stderr, err := vm.RunCommand("sudo", "remoteproc-runtime", "state", containerName)
+		if err != nil {
+			return specs.State{}, fmt.Errorf("stderr: %s: %w", stderr, err)
+		}
+		var state specs.State
+		if err := json.Unmarshal([]byte(stdout), &state); err != nil {
+			return specs.State{}, err
+		}
+		return state, nil
+	})
+	require.NoError(t, err)
+
+	hostMountNS, stderr, err := vm.RunCommand("readlink", "/proc/self/ns/mnt")
+	require.NoError(t, err, "stderr: %s", stderr)
+
+	proxyMountNS, stderr, err := vm.RunCommand("sudo", "readlink", fmt.Sprintf("/proc/%d/ns/mnt", pid))
+	require.NoError(t, err, "stderr: %s", stderr)
+	assert.NotEqual(t, strings.TrimSpace(hostMountNS), strings.TrimSpace(proxyMountNS))
+
+	remoteproc.AssertState(t, sim.DeviceDir(), "offline")
+
+	_, stderr, err = vm.RunCommand("sudo", "remoteproc-runtime", "start", containerName)
+	require.NoError(t, err, "stderr: %s", stderr)
+	remoteproc.AssertState(t, sim.DeviceDir(), "running")
+}
+
 func assertContainerStatus(t testing.TB, bin repo.RuntimeBin, containerName string, wantStatus specs.ContainerState) {
 	t.Helper()
 	state, err := getContainerState(bin, containerName)
 	require.NoError(t, err)
 	assert.Equal(t, wantStatus, state.Status)
 }
 
+func checkContainerRunning(fetch func() (specs.State, error)) (int, error) {
+	state, err := fetch()
+	if err != nil {
+		return 0, err
+	}
+	if state.Pid <= 0 {
+		return 0, fmt.Errorf("container is not running - pid is %d", state.Pid)
+	}
+	return state.Pid, nil
+}
+
 func getContainerPid(bin repo.RuntimeBin, containerName string) (int, error) {
 	state, err := getContainerState(bin, containerName)
 	if err != nil {
@@ -156,7 +288,7 @@ func getContainerState(bin repo.RuntimeBin, containerName string) (specs.State,
 	return state, nil
 }
 
-func generateBundle(targetDir string, remoteprocName string) error {
+func generateBundle(targetDir string, remoteprocName string, namespaces ...specs.LinuxNamespace) error {
 	const bundleRoot = "rootfs"
 	const firmwareName = "hello_world.elf"
 
@@ -179,6 +311,7 @@ func generateBundle(targetDir string, remoteprocName string) error {
 		Annotations: map[string]string{
 			"remoteproc.name": remoteprocName,
 		},
+		Linux: &specs.Linux{Namespaces: namespaces},
 	}
 
 	specPath := filepath.Join(targetDir, "config.json")

internal/proxy/namespaces.go

@@ -0,0 +1,54 @@
+package proxy
+
+import (
+	"fmt"
+	"log/slog"
+
+	"github.com/opencontainers/runtime-spec/specs-go"
+	"golang.org/x/sys/unix"
+)
+
+var specNamespacesToUnixCloneFlags = map[specs.LinuxNamespaceType]uintptr{
+	specs.CgroupNamespace:  unix.CLONE_NEWCGROUP,
+	specs.IPCNamespace:     unix.CLONE_NEWIPC,
+	specs.MountNamespace:   unix.CLONE_NEWNS,
+	specs.NetworkNamespace: unix.CLONE_NEWNET,
+	specs.PIDNamespace:     unix.CLONE_NEWPID,
+	specs.TimeNamespace:    unix.CLONE_NEWTIME,
+	specs.UserNamespace:    unix.CLONE_NEWUSER,
+	specs.UTSNamespace:     unix.CLONE_NEWUTS,
+}
+
+func ParseNamespaceFlags(namespaces []specs.LinuxNamespace) (uintptr, error) {
+	if namespaces == nil {
+		return 0, nil
+	}
+
+	var flags uintptr
+	for _, ns := range namespaces {
+		if ns.Path != "" {
+			continue
+		}
+		flag, ok := specNamespacesToUnixCloneFlags[ns.Type]
+		if !ok {
+			err := fmt.Errorf("unknown namespace type %q", ns.Type)
+			return 0, err
+		}
+		flags |= flag
+	}
+	return flags, nil
+}
+
+func LinuxCloneFlags(logger *slog.Logger, isRoot bool, namespaces []specs.LinuxNamespace) (uintptr, error) {
+	flags, err := ParseNamespaceFlags(namespaces)
+	if err != nil {
+		return 0, err
+	}
+
+	if !isRoot && flags != 0 {
+		logger.Warn("running non-root; namespace isolation disabled")
+		return 0, nil
+	}
+
+	return flags, nil
+}

internal/proxy/namespaces_test.go

@@ -0,0 +1,58 @@
+package proxy_test
+
+import (
+	"io"
+	"log/slog"
+	"testing"
+
+	proxy "github.com/arm/remoteproc-runtime/internal/proxy"
+	"github.com/opencontainers/runtime-spec/specs-go"
+	"github.com/stretchr/testify/require"
+	"golang.org/x/sys/unix"
+)
+
+func TestLinuxCloneFlags(t *testing.T) {
+	t.Run("converts known linux namespace flags to unix", func(t *testing.T) {
+		isRoot := true
+		namespaces := []specs.LinuxNamespace{
+			{Type: specs.CgroupNamespace},
+			{Type: specs.UserNamespace},
+		}
+
+		logger := slog.New(slog.NewTextHandler(io.Discard, nil))
+
+		got, err := proxy.LinuxCloneFlags(logger, isRoot, namespaces)
+
+		require.NoError(t, err)
+		want := uintptr(unix.CLONE_NEWCGROUP | unix.CLONE_NEWUSER)
+		require.Equal(t, want, got)
+	})
+
+	t.Run("non-root disables cloning", func(t *testing.T) {
+		isRoot := false
+		namespaces := []specs.LinuxNamespace{
+			{Type: specs.CgroupNamespace},
+			{Type: specs.UserNamespace},
+		}
+
+		logger := slog.New(slog.NewTextHandler(io.Discard, nil))
+
+		got, err := proxy.LinuxCloneFlags(logger, isRoot, namespaces)
+
+		require.NoError(t, err)
+		require.Equal(t, uintptr(0), got)
+	})
+
+	t.Run("errors given unknown namespace", func(t *testing.T) {
+		isRoot := true
+		namespaces := []specs.LinuxNamespace{
+			{Type: specs.LinuxNamespaceType("weird-name")},
+		}
+
+		logger := slog.New(slog.NewTextHandler(io.Discard, nil))
+
+		_, err := proxy.LinuxCloneFlags(logger, isRoot, namespaces)
+
+		require.Error(t, err)
+	})
+}