virtcontainers: tests: Ensure Linux specific tests are just run on Linux

Fixes: kata-containers#5993

Several tests utilize linux'isms like Mounts, bindmounts, vsock etc.

Let's ensure that these are still tested on Linux, but that we also skip
these tests when on other operating systems (Darwin). This commit just
moves tests; there shouldn't be any functional test changes. While the
tests still won't be runnable on Darwin/other hosts yet, this is a necessary
step forward.

Signed-off-by: Eric Ernst <[email protected]>
Signed-off-by: Danny Canter <[email protected]>

src/runtime/virtcontainers/acrn_arch_base_test.go

@@ -3,6 +3,9 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
+//go:build linux
+// +build linux
+
 package virtcontainers
 
 import (

src/runtime/virtcontainers/container_linux_test.go

@@ -0,0 +1,302 @@
+// Copyright (c) 2017 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+package virtcontainers
+
+import (
+	"context"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"syscall"
+	"testing"
+
+	"github.com/kata-containers/kata-containers/src/runtime/pkg/device/config"
+	"github.com/kata-containers/kata-containers/src/runtime/pkg/device/manager"
+	ktu "github.com/kata-containers/kata-containers/src/runtime/pkg/katatestutils"
+	"github.com/kata-containers/kata-containers/src/runtime/virtcontainers/persist"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestUnmountHostMountsRemoveBindHostPath(t *testing.T) {
+	if tc.NotValid(ktu.NeedRoot()) {
+		t.Skip(testDisabledAsNonRoot)
+	}
+
+	createFakeMountDir := func(t *testing.T, dir, prefix string) string {
+		name, err := os.MkdirTemp(dir, "test-mnt-"+prefix+"-")
+		if err != nil {
+			t.Fatal(err)
+		}
+		return name
+	}
+
+	createFakeMountFile := func(t *testing.T, dir, prefix string) string {
+		f, err := os.CreateTemp(dir, "test-mnt-"+prefix+"-")
+		if err != nil {
+			t.Fatal(err)
+		}
+		f.Close()
+		return f.Name()
+	}
+
+	doUnmountCheck := func(s *Sandbox, src, dest, hostPath, nonEmptyHostpath, devPath string) {
+		mounts := []Mount{
+			{
+				Source:      src,
+				Destination: dest,
+				HostPath:    hostPath,
+				Type:        "bind",
+			},
+			{
+				Source:      src,
+				Destination: dest,
+				HostPath:    nonEmptyHostpath,
+				Type:        "bind",
+			},
+			{
+				Source:      src,
+				Destination: dest,
+				HostPath:    devPath,
+				Type:        "dev",
+			},
+		}
+
+		c := Container{
+			mounts:  mounts,
+			ctx:     context.Background(),
+			id:      "fooabr",
+			sandbox: s,
+		}
+
+		if err := bindMount(c.ctx, src, hostPath, false, "private"); err != nil {
+			t.Fatal(err)
+		}
+		defer syscall.Unmount(hostPath, 0)
+		if err := bindMount(c.ctx, src, nonEmptyHostpath, false, "private"); err != nil {
+			t.Fatal(err)
+		}
+		defer syscall.Unmount(nonEmptyHostpath, 0)
+		if err := bindMount(c.ctx, src, devPath, false, "private"); err != nil {
+			t.Fatal(err)
+		}
+		defer syscall.Unmount(devPath, 0)
+
+		err := c.unmountHostMounts(c.ctx)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		for _, path := range [3]string{src, dest, devPath} {
+			if _, err := os.Stat(path); err != nil {
+				if os.IsNotExist(err) {
+					t.Fatalf("path %s should not be removed", path)
+				} else {
+					t.Fatal(err)
+				}
+			}
+		}
+
+		if _, err := os.Stat(hostPath); err == nil {
+			t.Fatal("empty host-path should be removed")
+		} else if !os.IsNotExist(err) {
+			t.Fatal(err)
+		}
+
+		if _, err := os.Stat(nonEmptyHostpath); err != nil {
+			if os.IsNotExist(err) {
+				t.Fatal("non-empty host-path should not be removed")
+			} else {
+				t.Fatal(err)
+			}
+		}
+	}
+
+	src := createFakeMountDir(t, testDir, "src")
+	dest := createFakeMountDir(t, testDir, "dest")
+	hostPath := createFakeMountDir(t, testDir, "host-path")
+	nonEmptyHostpath := createFakeMountDir(t, testDir, "non-empty-host-path")
+	devPath := createFakeMountDir(t, testDir, "dev-hostpath")
+	// create sandbox for mounting into
+	sandbox := &Sandbox{
+		ctx:    context.Background(),
+		id:     "foobar",
+		config: &SandboxConfig{},
+	}
+
+	fsShare, err := NewFilesystemShare(sandbox)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sandbox.fsShare = fsShare
+
+	createFakeMountDir(t, nonEmptyHostpath, "nop")
+	doUnmountCheck(sandbox, src, dest, hostPath, nonEmptyHostpath, devPath)
+
+	src = createFakeMountFile(t, testDir, "src")
+	dest = createFakeMountFile(t, testDir, "dest")
+	hostPath = createFakeMountFile(t, testDir, "host-path")
+	nonEmptyHostpath = createFakeMountFile(t, testDir, "non-empty-host-path")
+	devPath = createFakeMountFile(t, testDir, "dev-host-path")
+	f, err := os.OpenFile(nonEmptyHostpath, os.O_WRONLY, os.FileMode(0640))
+	if err != nil {
+		t.Fatal(err)
+	}
+	f.WriteString("nop\n")
+	f.Close()
+	doUnmountCheck(sandbox, src, dest, hostPath, nonEmptyHostpath, devPath)
+}
+
+func testSetupFakeRootfs(t *testing.T) (testRawFile, loopDev, mntDir string, err error) {
+	assert := assert.New(t)
+	if tc.NotValid(ktu.NeedRoot()) {
+		t.Skip(testDisabledAsNonRoot)
+	}
+
+	tmpDir := t.TempDir()
+
+	testRawFile = filepath.Join(tmpDir, "raw.img")
+	_, err = os.Stat(testRawFile)
+	assert.True(os.IsNotExist(err))
+
+	output, err := exec.Command("losetup", "-f").CombinedOutput()
+	assert.NoError(err)
+	loopDev = strings.TrimSpace(string(output[:]))
+
+	_, err = exec.Command("fallocate", "-l", "256K", testRawFile).CombinedOutput()
+	assert.NoError(err)
+
+	_, err = exec.Command("mkfs.ext4", "-F", testRawFile).CombinedOutput()
+	assert.NoError(err)
+
+	_, err = exec.Command("losetup", loopDev, testRawFile).CombinedOutput()
+	assert.NoError(err)
+
+	mntDir = filepath.Join(tmpDir, "rootfs")
+	err = os.Mkdir(mntDir, DirMode)
+	assert.NoError(err)
+
+	err = syscall.Mount(loopDev, mntDir, "ext4", uintptr(0), "")
+	assert.NoError(err)
+	return
+}
+
+func cleanupFakeRootfsSetup(testRawFile, loopDev, mntDir string) {
+	// unmount loop device
+	if mntDir != "" {
+		syscall.Unmount(mntDir, 0)
+	}
+
+	// detach loop device
+	if loopDev != "" {
+		exec.Command("losetup", "-d", loopDev).CombinedOutput()
+	}
+
+	if _, err := os.Stat(testRawFile); err == nil {
+		tmpDir := filepath.Dir(testRawFile)
+		os.RemoveAll(tmpDir)
+	}
+}
+
+func TestContainerAddDriveDir(t *testing.T) {
+	assert := assert.New(t)
+	if tc.NotValid(ktu.NeedRoot()) {
+		t.Skip(testDisabledAsNonRoot)
+	}
+
+	testRawFile, loopDev, fakeRootfs, err := testSetupFakeRootfs(t)
+
+	defer cleanupFakeRootfsSetup(testRawFile, loopDev, fakeRootfs)
+
+	assert.NoError(err)
+
+	sandbox := &Sandbox{
+		ctx:        context.Background(),
+		id:         testSandboxID,
+		devManager: manager.NewDeviceManager(config.VirtioSCSI, false, "", nil),
+		hypervisor: &mockHypervisor{},
+		agent:      &mockAgent{},
+		config: &SandboxConfig{
+			HypervisorConfig: HypervisorConfig{
+				DisableBlockDeviceUse: false,
+			},
+		},
+	}
+
+	sandbox.store, err = persist.GetDriver()
+	assert.NoError(err)
+	assert.NotNil(sandbox.store)
+
+	defer sandbox.store.Destroy(sandbox.id)
+
+	contID := "100"
+	container := Container{
+		sandbox: sandbox,
+		id:      contID,
+		rootFs:  RootFs{Target: fakeRootfs, Mounted: true},
+	}
+
+	// Make the checkStorageDriver func variable point to a fake Check function
+	savedFunc := checkStorageDriver
+	checkStorageDriver = func(major, minor int) (bool, error) {
+		return true, nil
+	}
+
+	defer func() {
+		checkStorageDriver = savedFunc
+	}()
+
+	container.state.Fstype = ""
+
+	err = container.hotplugDrive(sandbox.ctx)
+	assert.NoError(err)
+
+	assert.NotEmpty(container.state.Fstype)
+}
+
+func TestContainerRootfsPath(t *testing.T) {
+
+	testRawFile, loopDev, fakeRootfs, err := testSetupFakeRootfs(t)
+	defer cleanupFakeRootfsSetup(testRawFile, loopDev, fakeRootfs)
+	assert.Nil(t, err)
+
+	truecheckstoragedriver := checkStorageDriver
+	checkStorageDriver = func(major, minor int) (bool, error) {
+		return true, nil
+	}
+	defer func() {
+		checkStorageDriver = truecheckstoragedriver
+	}()
+
+	sandbox := &Sandbox{
+		ctx:        context.Background(),
+		id:         "rootfstestsandbox",
+		agent:      &mockAgent{},
+		hypervisor: &mockHypervisor{},
+		config: &SandboxConfig{
+			HypervisorConfig: HypervisorConfig{
+				DisableBlockDeviceUse: false,
+			},
+		},
+	}
+
+	container := Container{
+		id:           "rootfstestcontainerid",
+		sandbox:      sandbox,
+		rootFs:       RootFs{Target: fakeRootfs, Mounted: true},
+		rootfsSuffix: "rootfs",
+	}
+
+	container.hotplugDrive(sandbox.ctx)
+	assert.Empty(t, container.rootfsSuffix)
+
+	// Reset the value to test the other case
+	container.rootFs = RootFs{Target: fakeRootfs + "/rootfs", Mounted: true}
+	container.rootfsSuffix = "rootfs"
+
+	container.hotplugDrive(sandbox.ctx)
+	assert.Equal(t, container.rootfsSuffix, "rootfs")
+}