Repository: firecracker-microvm/firecracker-containerd
Pull request #659 (2022-06-01 00:43:36)

update kernel configs, make kernel in integ test
Signed-off-by: Gavin Inglis <giinglis@amazon.com>

*Issue #, if available:*

#658 

*Description of changes:*

in upgrading to firecracker v1.1, we noticed some configuration options
prompted for using when `make kernel`. These options are specific to
kernel 4.14. Additionally, this upgrade changed the build output from
firecracker's devtool to exclude the full kernel version, and installing would fail as it expects the path to include the patch number.

Some relevant links from the linux kernel driver db:

* https://cateee.net/lkddb/web-lkddb/KMEMCHECK.html
* https://cateee.net/lkddb/web-lkddb/CRYPTO_SALSA20_X86_64.html
* https://cateee.net/lkddb/web-lkddb/FRAME_POINTER_UNWINDER.html
* https://cateee.net/lkddb/web-lkddb/ORC_UNWINDER.html
* https://cateee.net/lkddb/web-lkddb/R3964.html

This PR also updates the integ test Docker image to use a freshly built
kernel such that FUSE is enabled.


By submitting this pull request, I confirm that my contribution is made under the terms of the Apache 2.0 license.



Patch:
diff --git a/Makefile b/Makefile
index 334dfb1..0e2d3ef 100644
--- a/Makefile
+++ b/Makefile
@@ -57,9 +57,9 @@ $(error "Kernel version $(KERNEL_VERSION) is not supported. Supported versions a
 endif
 
 KERNEL_CONFIG=tools/kernel-configs/microvm-kernel-$(host_arch)-$(KERNEL_VERSION).config
-# Copied from https://github.com/firecracker-microvm/firecracker/blob/v1.0.0/tools/devtool#L2015
+# Copied from https://github.com/firecracker-microvm/firecracker/blob/v1.1.0/tools/devtool#L2082
 # This allows us to specify a kernel without the patch version, but still get the correct build path to reference the kernel binary
-KERNEL_FULL_VERSION=$(shell cat "$(KERNEL_CONFIG)" | grep -Po "^\# Linux\/$(kernel_config_pattern) (([0-9]+.){2}[0-9]+)" | cut -d ' ' -f 3)
+KERNEL_FULL_VERSION=$(shell cat "$(KERNEL_CONFIG)" | grep -Po "^\# Linux\/$(kernel_config_pattern) (([0-9]+.)[0-9]+)" | cut -d ' ' -f 3)
 KERNEL_BIN=$(FIRECRACKER_DIR)/build/kernel/linux-$(KERNEL_FULL_VERSION)/vmlinux-$(KERNEL_FULL_VERSION)-$(host_arch).bin
 
 RUNC_DIR=$(SUBMODULES)/runc
@@ -190,7 +190,7 @@ test-images: test-images-stamp
 test-images-stamp: | image firecracker-containerd-test-image
 	touch $@
 
-firecracker-containerd-test-image: all-in-docker firecracker runc test-cni-bins cni-bins default-vmlinux
+firecracker-containerd-test-image: all-in-docker firecracker runc test-cni-bins cni-bins default-vmlinux kernel
 	DOCKER_BUILDKIT=1 docker build \
 		--progress=plain \
 		--file tools/docker/Dockerfile.integ-test \
diff --git a/snapshotter/demux/cache/cache.go b/snapshotter/demux/cache/cache.go
index 9d1c3cb..1250144 100644
--- a/snapshotter/demux/cache/cache.go
+++ b/snapshotter/demux/cache/cache.go
@@ -16,7 +16,6 @@ package cache
 import (
 	"context"
 
-	"github.com/containerd/containerd/snapshots"
 	"github.com/firecracker-microvm/firecracker-containerd/snapshotter/demux/proxy"
 )
 
@@ -29,9 +28,6 @@ type Cache interface {
 	// fetch function if the snapshotter is not currently cached.
 	Get(ctx context.Context, key string, fetch SnapshotterProvider) (*proxy.RemoteSnapshotter, error)
 
-	// WalkAll applies the provided function across all cached snapshotters.
-	WalkAll(ctx context.Context, fn snapshots.WalkFunc, filters ...string) error
-
 	// Closes the snapshotter and removes it from the cache.
 	Evict(key string) error
 
diff --git a/snapshotter/demux/cache/snapshotter_cache.go b/snapshotter/demux/cache/snapshotter_cache.go
index 7915a92..761cbf8 100644
--- a/snapshotter/demux/cache/snapshotter_cache.go
+++ b/snapshotter/demux/cache/snapshotter_cache.go
@@ -18,7 +18,6 @@ import (
 	"fmt"
 	"sync"
 
-	"github.com/containerd/containerd/snapshots"
 	"github.com/firecracker-microvm/firecracker-containerd/snapshotter/demux/proxy"
 	"github.com/hashicorp/go-multierror"
 )
@@ -57,21 +56,6 @@ func (cache *SnapshotterCache) Get(ctx context.Context, key string, fetch Snapsh
 	return snapshotter, nil
 }
 
-// WalkAll applies the provided function to all cached snapshotters.
-func (cache *SnapshotterCache) WalkAll(ctx context.Context, fn snapshots.WalkFunc, filters ...string) error {
-	cache.mutex.RLock()
-	defer cache.mutex.RUnlock()
-
-	var allErr error
-
-	for namespace, snapshotter := range cache.snapshotters {
-		if err := snapshotter.Walk(ctx, fn, filters...); err != nil {
-			allErr = multierror.Append(allErr, fmt.Errorf("failed to walk function on snapshotter[%s]: %w", namespace, err))
-		}
-	}
-	return allErr
-}
-
 // Evict removes a cached snapshotter for a given key.
 func (cache *SnapshotterCache) Evict(key string) error {
 	cache.mutex.RLock()
diff --git a/snapshotter/demux/internal/failing_snapshotter.go b/snapshotter/demux/internal/failing_snapshotter.go
index 1896b37..b0aec49 100644
--- a/snapshotter/demux/internal/failing_snapshotter.go
+++ b/snapshotter/demux/internal/failing_snapshotter.go
@@ -74,8 +74,3 @@ func (s *FailingSnapshotter) Walk(ctx context.Context, fn snapshots.WalkFunc, fi
 func (s *FailingSnapshotter) Close() error {
 	return errors.New("mock Close error from remote snapshotter")
 }
-
-// Cleanup mocks a failing remote call with a non-nil error.
-func (s *FailingSnapshotter) Cleanup(ctx context.Context) error {
-	return errors.New("mock Cleanup error from remote snapshotter")
-}
diff --git a/snapshotter/demux/internal/successful_snapshotter.go b/snapshotter/demux/internal/successful_snapshotter.go
index 4ed3e93..bd30020 100644
--- a/snapshotter/demux/internal/successful_snapshotter.go
+++ b/snapshotter/demux/internal/successful_snapshotter.go
@@ -73,8 +73,3 @@ func (s *SuccessfulSnapshotter) Walk(ctx context.Context, fn snapshots.WalkFunc,
 func (s *SuccessfulSnapshotter) Close() error {
 	return nil
 }
-
-// Cleanup mocks a successful remote call with a nil error.
-func (s *SuccessfulSnapshotter) Cleanup(ctx context.Context) error {
-	return nil
-}
diff --git a/snapshotter/demux/proxy/snapshotter.go b/snapshotter/demux/proxy/snapshotter.go
index 202cb8d..2f24c73 100644
--- a/snapshotter/demux/proxy/snapshotter.go
+++ b/snapshotter/demux/proxy/snapshotter.go
@@ -73,14 +73,6 @@ func NewRemoteSnapshotter(ctx context.Context, address string,
 	return &RemoteSnapshotter{proxy.NewSnapshotter(snapshotsapi.NewSnapshotsClient(gRPCConn), address), metricsProxy}, nil
 }
 
-// Cleanup implements the Cleaner interface for snapshotters.
-// This enables asynchronous resource cleanup by remote snapshotters.
-//
-// See https://github.com/containerd/containerd/blob/v1.6.4/snapshots/snapshotter.go
-func (rs *RemoteSnapshotter) Cleanup(ctx context.Context) error {
-	return rs.Snapshotter.(snapshots.Cleaner).Cleanup(ctx)
-}
-
 // MetricsProxyPort returns the metrics proxy port for a remote snapshotter.
 func (rs *RemoteSnapshotter) MetricsProxyPort() int {
 	return rs.metricsProxy.Port
diff --git a/snapshotter/demux/snapshotter.go b/snapshotter/demux/snapshotter.go
index 086a882..345f6fc 100644
--- a/snapshotter/demux/snapshotter.go
+++ b/snapshotter/demux/snapshotter.go
@@ -27,6 +27,8 @@ import (
 	mountutil "github.com/firecracker-microvm/firecracker-containerd/snapshotter/internal/mount"
 )
 
+const proxiedFunctionCallErrorString = "Proxied function call failed"
+
 // Snapshotter routes snapshotter requests to their destined
 // remote snapshotter via their snapshotter namespace.
 //
@@ -44,59 +46,95 @@ func NewSnapshotter(cache cache.Cache, fetchSnapshotter cache.SnapshotterProvide
 
 // Stat proxies remote snapshotter stat request.
 //
-// See https://github.com/containerd/containerd/blob/v1.6.4/snapshots/snapshotter.go
+// See https://github.com/containerd/containerd/blob/main/snapshots/snapshotter.go
 func (s *Snapshotter) Stat(ctx context.Context, key string) (snapshots.Info, error) {
 	contextLogger := log.G(ctx).WithField("function", "Stat")
+	namespace, err := getNamespaceFromContext(ctx, contextLogger)
+	if err != nil {
+		return snapshots.Info{}, err
+	}
+	logger := contextLogger.WithField("namespace", namespace)
 
-	snapshotter, err := s.getSnapshotterFromCache(ctx, contextLogger)
+	snapshotter, err := s.getSnapshotterFromCache(ctx, namespace, logger)
 	if err != nil {
 		return snapshots.Info{}, err
 	}
 
-	return snapshotter.Stat(ctx, key)
+	info, err := snapshotter.Stat(ctx, key)
+	if err != nil {
+		contextLogger.WithError(err).Error(proxiedFunctionCallErrorString)
+		return snapshots.Info{}, err
+	}
+	return info, nil
 }
 
 // Update proxies remote snapshotter update request.
 //
-// See https://github.com/containerd/containerd/blob/v1.6.4/snapshots/snapshotter.go
+// See https://github.com/containerd/containerd/blob/main/snapshots/snapshotter.go
 func (s *Snapshotter) Update(ctx context.Context, info snapshots.Info, fieldpaths ...string) (snapshots.Info, error) {
 	contextLogger := log.G(ctx).WithField("function", "Update")
+	namespace, err := getNamespaceFromContext(ctx, contextLogger)
+	if err != nil {
+		return snapshots.Info{}, err
+	}
+	logger := contextLogger.WithField("namespace", namespace)
 
-	snapshotter, err := s.getSnapshotterFromCache(ctx, contextLogger)
+	snapshotter, err := s.getSnapshotterFromCache(ctx, namespace, logger)
 	if err != nil {
 		return snapshots.Info{}, err
 	}
 
-	return snapshotter.Update(ctx, info, fieldpaths...)
+	updatedInfo, err := snapshotter.Update(ctx, info, fieldpaths...)
+	if err != nil {
+		contextLogger.WithError(err).Error(proxiedFunctionCallErrorString)
+		return snapshots.Info{}, err
+	}
+	return updatedInfo, nil
 }
 
 // Usage proxies remote snapshotter usage request.
 //
-// See https://github.com/containerd/containerd/blob/v1.6.4/snapshots/snapshotter.go
+// See https://github.com/containerd/containerd/blob/main/snapshots/snapshotter.go
 func (s *Snapshotter) Usage(ctx context.Context, key string) (snapshots.Usage, error) {
 	contextLogger := log.G(ctx).WithField("function", "Usage")
+	namespace, err := getNamespaceFromContext(ctx, contextLogger)
+	if err != nil {
+		return snapshots.Usage{}, err
+	}
+	logger := contextLogger.WithField("namespace", namespace)
 
-	snapshotter, err := s.getSnapshotterFromCache(ctx, contextLogger)
+	snapshotter, err := s.getSnapshotterFromCache(ctx, namespace, logger)
 	if err != nil {
 		return snapshots.Usage{}, err
 	}
 
-	return snapshotter.Usage(ctx, key)
+	usage, err := snapshotter.Usage(ctx, key)
+	if err != nil {
+		contextLogger.WithError(err).Error(proxiedFunctionCallErrorString)
+		return snapshots.Usage{}, err
+	}
+	return usage, nil
 }
 
 // Mounts proxies remote snapshotter mounts request.
 //
-// See https://github.com/containerd/containerd/blob/v1.6.4/snapshots/snapshotter.go
+// See https://github.com/containerd/containerd/blob/main/snapshots/snapshotter.go
 func (s *Snapshotter) Mounts(ctx context.Context, key string) ([]mount.Mount, error) {
 	contextLogger := log.G(ctx).WithField("function", "Mounts")
+	namespace, err := getNamespaceFromContext(ctx, contextLogger)
+	if err != nil {
+		return []mount.Mount{}, err
+	}
+	logger := contextLogger.WithField("namespace", namespace)
 
-	snapshotter, err := s.getSnapshotterFromCache(ctx, contextLogger)
+	snapshotter, err := s.getSnapshotterFromCache(ctx, namespace, logger)
 	if err != nil {
 		return []mount.Mount{}, err
 	}
 
 	mounts, err := snapshotter.Mounts(ctx, key)
 	if err != nil {
+		contextLogger.WithError(err).Error(proxiedFunctionCallErrorString)
 		return []mount.Mount{}, err
 	}
 	return mountutil.Map(mounts, vm.AddLocalMountIdentifier), nil
@@ -104,17 +142,23 @@ func (s *Snapshotter) Mounts(ctx context.Context, key string) ([]mount.Mount, er
 
 // Prepare proxies remote snapshotter prepare request.
 //
-// See https://github.com/containerd/containerd/blob/v1.6.4/snapshots/snapshotter.go
+// See https://github.com/containerd/containerd/blob/main/snapshots/snapshotter.go
 func (s *Snapshotter) Prepare(ctx context.Context, key string, parent string, opts ...snapshots.Opt) ([]mount.Mount, error) {
 	contextLogger := log.G(ctx).WithField("function", "Prepare")
+	namespace, err := getNamespaceFromContext(ctx, contextLogger)
+	if err != nil {
+		return []mount.Mount{}, err
+	}
+	logger := contextLogger.WithField("namespace", namespace)
 
-	snapshotter, err := s.getSnapshotterFromCache(ctx, contextLogger)
+	snapshotter, err := s.getSnapshotterFromCache(ctx, namespace, logger)
 	if err != nil {
 		return []mount.Mount{}, err
 	}
 
 	mounts, err := snapshotter.Prepare(ctx, key, parent, opts...)
 	if err != nil {
+		contextLogger.WithError(err).Error(proxiedFunctionCallErrorString)
 		return []mount.Mount{}, err
 	}
 	return mountutil.Map(mounts, vm.AddLocalMountIdentifier), nil
@@ -122,17 +166,23 @@ func (s *Snapshotter) Prepare(ctx context.Context, key string, parent string, op
 
 // View proxies remote snapshotter view request.
 //
-// See https://github.com/containerd/containerd/blob/v1.6.4/snapshots/snapshotter.go
+// See https://github.com/containerd/containerd/blob/main/snapshots/snapshotter.go
 func (s *Snapshotter) View(ctx context.Context, key string, parent string, opts ...snapshots.Opt) ([]mount.Mount, error) {
 	contextLogger := log.G(ctx).WithField("function", "View")
+	namespace, err := getNamespaceFromContext(ctx, contextLogger)
+	if err != nil {
+		return []mount.Mount{}, err
+	}
+	logger := contextLogger.WithField("namespace", namespace)
 
-	snapshotter, err := s.getSnapshotterFromCache(ctx, contextLogger)
+	snapshotter, err := s.getSnapshotterFromCache(ctx, namespace, logger)
 	if err != nil {
 		return []mount.Mount{}, err
 	}
 
 	mounts, err := snapshotter.View(ctx, key, parent, opts...)
 	if err != nil {
+		contextLogger.WithError(err).Error(proxiedFunctionCallErrorString)
 		return []mount.Mount{}, err
 	}
 	return mountutil.Map(mounts, vm.AddLocalMountIdentifier), nil
@@ -140,83 +190,89 @@ func (s *Snapshotter) View(ctx context.Context, key string, parent string, opts
 
 // Commit proxies remote snapshotter commit request.
 //
-// See https://github.com/containerd/containerd/blob/v1.6.4/snapshots/snapshotter.go
+// See https://github.com/containerd/containerd/blob/main/snapshots/snapshotter.go
 func (s *Snapshotter) Commit(ctx context.Context, name string, key string, opts ...snapshots.Opt) error {
 	contextLogger := log.G(ctx).WithField("function", "Commit")
+	namespace, err := getNamespaceFromContext(ctx, contextLogger)
+	if err != nil {
+		return err
+	}
+	logger := contextLogger.WithField("namespace", namespace)
 
-	snapshotter, err := s.getSnapshotterFromCache(ctx, contextLogger)
+	snapshotter, err := s.getSnapshotterFromCache(ctx, namespace, logger)
 	if err != nil {
 		return err
 	}
 
-	return snapshotter.Commit(ctx, name, key, opts...)
+	err = snapshotter.Commit(ctx, name, key, opts...)
+	if err != nil {
+		contextLogger.WithError(err).Error(proxiedFunctionCallErrorString)
+		return err
+	}
+	return nil
 }
 
 // Remove proxies remote snapshotter remove request.
 //
-// See https://github.com/containerd/containerd/blob/v1.6.4/snapshots/snapshotter.go
+// See https://github.com/containerd/containerd/blob/main/snapshots/snapshotter.go
 func (s *Snapshotter) Remove(ctx context.Context, key string) error {
 	contextLogger := log.G(ctx).WithField("function", "Remove")
+	namespace, err := getNamespaceFromContext(ctx, contextLogger)
+	if err != nil {
+		return err
+	}
+	logger := contextLogger.WithField("namespace", namespace)
 
-	snapshotter, err := s.getSnapshotterFromCache(ctx, contextLogger)
+	snapshotter, err := s.getSnapshotterFromCache(ctx, namespace, logger)
 	if err != nil {
 		return err
 	}
 
-	return snapshotter.Remove(ctx, key)
+	err = snapshotter.Remove(ctx, key)
+	if err != nil {
+		contextLogger.WithError(err).Error(proxiedFunctionCallErrorString)
+		return err
+	}
+	return nil
 }
 
 // Walk proxies remote snapshotter walk request.
 //
-// See https://github.com/containerd/containerd/blob/v1.6.4/snapshots/snapshotter.go
+// See https://github.com/containerd/containerd/blob/main/snapshots/snapshotter.go
 func (s *Snapshotter) Walk(ctx context.Context, fn snapshots.WalkFunc, filters ...string) error {
 	contextLogger := log.G(ctx).WithField("function", "Walk")
-
-	_, err := getNamespaceFromContext(ctx, contextLogger)
+	namespace, err := getNamespaceFromContext(ctx, contextLogger)
 	if err != nil {
-		contextLogger.Debug("no namespace found, proxying walk function to all cached snapshotters")
-		return s.cache.WalkAll(ctx, fn, filters...)
+		return err
 	}
+	logger := contextLogger.WithField("namespace", namespace)
 
-	snapshotter, err := s.getSnapshotterFromCache(ctx, contextLogger)
+	snapshotter, err := s.getSnapshotterFromCache(ctx, namespace, logger)
 	if err != nil {
 		return err
 	}
 
-	return snapshotter.Walk(ctx, fn, filters...)
+	err = snapshotter.Walk(ctx, fn, filters...)
+	if err != nil {
+		contextLogger.WithError(err).Error(proxiedFunctionCallErrorString)
+		return err
+	}
+	return nil
 }
 
 // Close calls close on all cached remote snapshotters.
 //
-// See https://github.com/containerd/containerd/blob/v1.6.4/snapshots/snapshotter.go
+// See https://github.com/containerd/containerd/blob/main/snapshots/snapshotter.go
 func (s *Snapshotter) Close() error {
 	return s.cache.Close()
 }
 
-// Cleanup proxies remote snapshotter cleanup request.
-//
-// See https://github.com/containerd/containerd/blob/v1.6.4/snapshots/snapshotter.go
-func (s *Snapshotter) Cleanup(ctx context.Context) error {
-	contextLogger := log.G(ctx).WithField("function", "Cleanup")
-
-	snapshotter, err := s.getSnapshotterFromCache(ctx, contextLogger)
-	if err != nil {
-		return err
-	}
-
-	return snapshotter.(snapshots.Cleaner).Cleanup(ctx)
-}
-
 const snapshotterNotFoundErrorString = "Snapshotter not found in cache"
 
-func (s *Snapshotter) getSnapshotterFromCache(ctx context.Context, log *logrus.Entry) (snapshots.Snapshotter, error) {
-	namespace, err := getNamespaceFromContext(ctx, log)
-	if err != nil {
-		return nil, err
-	}
+func (s *Snapshotter) getSnapshotterFromCache(ctx context.Context, namespace string, log *logrus.Entry) (snapshots.Snapshotter, error) {
 	snapshotter, err := s.cache.Get(ctx, namespace, s.fetchSnapshotter)
 	if err != nil {
-		log.WithField("namespace", namespace).WithError(err).Error(snapshotterNotFoundErrorString)
+		log.WithError(err).Error(snapshotterNotFoundErrorString)
 		return nil, err
 	}
 	return snapshotter, nil
diff --git a/tools/kernel-configs/microvm-kernel-aarch64-4.14.config b/tools/kernel-configs/microvm-kernel-aarch64-4.14.config
index 6b8a7e3..3ee49ac 100644
--- a/tools/kernel-configs/microvm-kernel-aarch64-4.14.config
+++ b/tools/kernel-configs/microvm-kernel-aarch64-4.14.config
@@ -1123,6 +1123,7 @@ CONFIG_VIRTIO_BLK=y
 # CONFIG_ENCLOSURE_SERVICES is not set
 # CONFIG_SRAM is not set
 # CONFIG_C2PORT is not set
+# CONFIG_R3964 is not set
 
 #
 # EEPROM support
diff --git a/tools/kernel-configs/microvm-kernel-x86_64-4.14.config b/tools/kernel-configs/microvm-kernel-x86_64-4.14.config
index 24fdd95..86838cc 100644
--- a/tools/kernel-configs/microvm-kernel-x86_64-4.14.config
+++ b/tools/kernel-configs/microvm-kernel-x86_64-4.14.config
@@ -1208,6 +1208,7 @@ CONFIG_VIRTIO_BLK=y
 # CONFIG_ENCLOSURE_SERVICES is not set
 # CONFIG_SRAM is not set
 # CONFIG_C2PORT is not set
+# CONFIG_R3964 is not set
 
 #
 # EEPROM support
@@ -2077,6 +2078,7 @@ CONFIG_DEBUG_KERNEL=y
 # CONFIG_SLUB_STATS is not set
 CONFIG_HAVE_DEBUG_KMEMLEAK=y
 # CONFIG_DEBUG_KMEMLEAK is not set
+# CONFIG_KMEMCHECK is not set
 # CONFIG_DEBUG_STACK_USAGE is not set
 # CONFIG_DEBUG_VM is not set
 CONFIG_ARCH_HAS_DEBUG_VIRTUAL=y
@@ -2225,8 +2227,8 @@ CONFIG_OPTIMIZE_INLINING=y
 # CONFIG_DEBUG_ENTRY is not set
 # CONFIG_DEBUG_NMI_SELFTEST is not set
 # CONFIG_X86_DEBUG_FPU is not set
-# CONFIG_UNWINDER_ORC is not set
-CONFIG_UNWINDER_FRAME_POINTER=y
+# CONFIG_ORC_UNWINDER is not set
+CONFIG_FRAME_POINTER_UNWINDER=y
 
 #
 # Security options
@@ -2394,6 +2396,7 @@ CONFIG_CRYPTO_AES_TI=y
 # CONFIG_CRYPTO_FCRYPT is not set
 # CONFIG_CRYPTO_KHAZAD is not set
 # CONFIG_CRYPTO_SALSA20 is not set
+# CONFIG_CRYPTO_SALSA20_X86_64 is not set
 # CONFIG_CRYPTO_CHACHA20 is not set
 # CONFIG_CRYPTO_CHACHA20_X86_64 is not set
 # CONFIG_CRYPTO_SEED is not set
diff --git a/volume/image.go b/volume/image.go
deleted file mode 100644
index 9a6f8b1..0000000
--- a/volume/image.go
+++ /dev/null
@@ -1,188 +0,0 @@
-// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"). You may
-// not use this file except in compliance with the License. A copy of the
-// License is located at
-//
-//	http://aws.amazon.com/apache2.0/
-//
-// or in the "license" file accompanying this file. This file is distributed
-// on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
-// express or implied. See the License for the specific language governing
-// permissions and limitations under the License.
-
-package volume
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"os"
-	"time"
-
-	"github.com/containerd/containerd"
-	"github.com/containerd/containerd/content"
-	"github.com/containerd/containerd/images"
-	"github.com/containerd/containerd/mount"
-	"github.com/containerd/containerd/snapshots"
-	"github.com/containerd/continuity/fs"
-	"github.com/hashicorp/go-multierror"
-	"github.com/opencontainers/image-spec/identity"
-	v1 "github.com/opencontainers/image-spec/specs-go/v1"
-)
-
-type imageVolumeProvider struct {
-	client      *containerd.Client
-	image       string
-	target      string
-	snapshotter string
-	snapshot    string
-}
-
-// ImageOpt allows setting optional properties of the provider.
-type ImageOpt func(*imageVolumeProvider)
-
-// WithSnapshotter sets the snapshotter to pull images.
-func WithSnapshotter(ss string) ImageOpt {
-	return func(p *imageVolumeProvider) {
-		p.snapshotter = ss
-	}
-}
-
-func getV1ImageConfig(ctx context.Context, image containerd.Image) (*v1.Image, error) {
-	var result v1.Image
-
-	ic, err := image.Config(ctx)
-	if err != nil {
-		return nil, err
-	}
-
-	switch ic.MediaType {
-	case v1.MediaTypeImageConfig, images.MediaTypeDockerSchema2Config:
-		p, err := content.ReadBlob(ctx, image.ContentStore(), ic)
-		if err != nil {
-			return nil, err
-		}
-		if err := json.Unmarshal(p, &result); err != nil {
-			return nil, err
-		}
-	default:
-		return nil, fmt.Errorf("unknown type: %s", ic.MediaType)
-	}
-	return &result, nil
-}
-
-// FromImage returns a new provider to that expose the volumes on the given image.
-func FromImage(client *containerd.Client, image, snapshot string, opts ...ImageOpt) Provider {
-	p := imageVolumeProvider{
-		snapshotter: containerd.DefaultSnapshotter,
-		client:      client,
-		image:       image,
-		snapshot:    snapshot,
-	}
-
-	for _, opt := range opts {
-		opt(&p)
-	}
-
-	return &p
-}
-
-func (p *imageVolumeProvider) Name() string {
-	return p.image
-}
-
-func (p *imageVolumeProvider) Delete(ctx context.Context) error {
-	var retErr error
-
-	if p.target != "" {
-		retErr = mount.UnmountAll(p.target, 0)
-	}
-
-	ss := p.client.SnapshotService(p.snapshotter)
-	err := ss.Remove(ctx, p.snapshot)
-	if err != nil {
-		retErr = multierror.Append(retErr, err)
-	}
-	defer ss.Close()
-
-	return retErr
-}
-
-func (p *imageVolumeProvider) CreateVolumesUnder(ctx context.Context, tempDir string) ([]*Volume, error) {
-	image, err := p.client.GetImage(ctx, p.image)
-	if err != nil {
-		return nil, err
-	}
-
-	unpacked, err := image.IsUnpacked(ctx, p.snapshotter)
-	if err != nil {
-		return nil, err
-	}
-
-	if !unpacked {
-		err := image.Unpack(ctx, p.snapshotter)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	config, err := getV1ImageConfig(ctx, image)
-	if err != nil {
-		return nil, err
-	}
-
-	if len(config.Config.Volumes) == 0 {
-		return nil, nil
-	}
-
-	root, err := p.mountImage(ctx, tempDir)
-	if err != nil {
-		return nil, err
-	}
-	p.target = root
-
-	result := make([]*Volume, 0, len(config.Config.Volumes))
-	for path := range config.Config.Volumes {
-		hostPath, err := fs.RootPath(root, path)
-		if err != nil {
-			return nil, err
-		}
-		result = append(result, &Volume{hostPath: hostPath, containerPath: path})
-	}
-	return result, nil
-}
-
-func (p *imageVolumeProvider) mountImage(ctx context.Context, tempDir string) (string, error) {
-	image, err := p.client.GetImage(ctx, p.image)
-	if err != nil {
-		return "", err
-	}
-
-	ids, err := image.RootFS(ctx)
-	if err != nil {
-		return "", err
-	}
-
-	parent := identity.ChainID(ids).String()
-
-	ss := p.client.SnapshotService(p.snapshotter)
-	mounts, err := ss.View(ctx, p.snapshot, parent, snapshots.WithLabels(map[string]string{
-		"containerd.io/gc.root": time.Now().UTC().Format(time.RFC3339),
-	}))
-	if err != nil {
-		return "", err
-	}
-	defer ss.Close()
-
-	target, err := os.MkdirTemp(tempDir, "mount")
-	if err != nil {
-		return "", err
-	}
-	err = mount.All(mounts, target)
-	if err != nil {
-		return "", err
-	}
-
-	return target, nil
-}
diff --git a/volume/set.go b/volume/set.go
index 369df0c..a7c7e38 100644
--- a/volume/set.go
+++ b/volume/set.go
@@ -21,7 +21,6 @@ import (
 	"path/filepath"
 
 	"github.com/containerd/containerd/containers"
-	"github.com/containerd/containerd/errdefs"
 	"github.com/containerd/containerd/mount"
 	"github.com/containerd/containerd/oci"
 	"github.com/containerd/continuity/fs"
@@ -38,24 +37,11 @@ const (
 // Set is a set of volumes.
 type Set struct {
 	volumes   map[string]*Volume
-	providers map[string][]Mount
 	tempDir   string
 	runtime   string
 	volumeDir string
 }
 
-// Provider provides volumes from different sources.
-type Provider interface {
-	// Name of the provider.
-	Name() string
-
-	// CreateVolumesUnder creates volumes under the given directory.
-	CreateVolumesUnder(ctx context.Context, tempDir string) ([]*Volume, error)
-
-	// Delete all resources made by the provider.
-	Delete(ctx context.Context) error
-}
-
 // NewSet returns a new volume set.
 func NewSet(runtime string) *Set {
 	return NewSetWithTempDir(runtime, os.TempDir())
@@ -63,45 +49,12 @@ func NewSet(runtime string) *Set {
 
 // NewSetWithTempDir returns a new volume set and creates all temporary files under the tempDir.
 func NewSetWithTempDir(runtime, tempDir string) *Set {
-	return &Set{
-		runtime:   runtime,
-		providers: make(map[string][]Mount),
-		volumes:   make(map[string]*Volume),
-		tempDir:   tempDir,
-	}
+	return &Set{runtime: runtime, volumes: make(map[string]*Volume), tempDir: tempDir}
 }
 
 // Add a volume to the set.
 func (vs *Set) Add(v *Volume) {
-	vs.volumes[fmt.Sprintf("named_%s", v.name)] = v
-}
-
-// AddFrom adds volumes from the given provider.
-func (vs *Set) AddFrom(ctx context.Context, vp Provider) error {
-	if _, exists := vs.providers[vp.Name()]; exists {
-		return fmt.Errorf("failed to add %q: %w", vp.Name(), errdefs.ErrAlreadyExists)
-	}
-	dir, err := os.MkdirTemp(vs.tempDir, "AddFrom")
-	if err != nil {
-		return err
-	}
-	volumes, err := vp.CreateVolumesUnder(ctx, dir)
-	if err != nil {
-		return err
-	}
-
-	mounts := make([]Mount, 0, len(volumes))
-	for _, v := range volumes {
-		if v.name == "" {
-			index := len(vs.volumes)
-			v.name = fmt.Sprintf("anon_%d", index)
-		}
-		vs.volumes[v.name] = v
-
-		mounts = append(mounts, Mount{key: v.name, Destination: v.containerPath, ReadOnly: false})
-	}
-	vs.providers[vp.Name()] = mounts
-	return nil
+	vs.volumes[v.name] = v
 }
 
 func (vs *Set) createDiskImage(ctx context.Context, size int64) (path string, retErr error) {
@@ -162,14 +115,11 @@ func (vs *Set) PrepareDirectory(ctx context.Context) (retErr error) {
 	}()
 
 	for _, v := range vs.volumes {
-		path, err := fs.RootPath(dir, v.name)
-		if err != nil {
-			return err
-		}
+		path := filepath.Join(dir, v.name)
 		if v.hostPath == "" {
 			continue
 		}
-		err = fs.CopyDir(path, v.hostPath)
+		err := fs.CopyDir(path, v.hostPath)
 		if err != nil {
 			retErr = fmt.Errorf("failed to copy volume %q: %w", v.name, err)
 			return
@@ -222,15 +172,11 @@ func (vs *Set) PrepareDriveMount(ctx context.Context, size int64) (dm *proto.Fir
 	}()
 
 	for _, v := range vs.volumes {
-		path, err := fs.RootPath(dir, v.name)
-		if err != nil {
-			retErr = err
-			return
-		}
+		path := filepath.Join(dir, v.name)
 		if v.hostPath == "" {
 			continue
 		}
-		err = fs.CopyDir(path, v.hostPath)
+		err := fs.CopyDir(path, v.hostPath)
 		if err != nil {
 			retErr = fmt.Errorf("failed to copy volume %q: %w", v.name, err)
 			return
@@ -255,8 +201,6 @@ type Mount struct {
 	Destination string
 	// ReadOnly is true if the volume is mounted as read-only.
 	ReadOnly bool
-
-	key string
 }
 
 // WithMounts expose given volumes to the container.
@@ -264,11 +208,7 @@ func (vs *Set) WithMounts(mountpoints []Mount) (oci.SpecOpts, error) {
 	mounts := []specs.Mount{}
 
 	for _, mp := range mountpoints {
-		key := mp.key
-		if key == "" {
-			key = fmt.Sprintf("named_%s", mp.Source)
-		}
-		v, ok := vs.volumes[key]
+		v, ok := vs.volumes[mp.Source]
 		if !ok {
 			return nil, fmt.Errorf("failed to find volume %q", mp.Source)
 		}
@@ -293,8 +233,3 @@ func (vs *Set) WithMounts(mountpoints []Mount) (oci.SpecOpts, error) {
 		return nil
 	}, nil
 }
-
-// WithMountsFromProvider exposes volumes from the provider.
-func (vs *Set) WithMountsFromProvider(name string) (oci.SpecOpts, error) {
-	return vs.WithMounts(vs.providers[name])
-}
diff --git a/volume/volume.go b/volume/volume.go
index 67d9ff2..a8a0fb1 100644
--- a/volume/volume.go
+++ b/volume/volume.go
@@ -19,9 +19,8 @@ package volume
 
 // Volume is a special directory that could be shared between containers.
 type Volume struct {
-	name          string
-	hostPath      string
-	containerPath string
+	name     string
+	hostPath string
 }
 
 // New returns an empty volume.


Test patch:
diff --git a/runtime/volume_integ_test.go b/runtime/volume_integ_test.go
index 5df030f..c4af9d3 100644
--- a/runtime/volume_integ_test.go
+++ b/runtime/volume_integ_test.go
@@ -174,111 +174,3 @@ func testVolumes(t *testing.T, runtime string) {
 	assert.Equal(t, "hello from host\nhello from c1\nhello from c2\n", stdout.String())
 	assert.Equal(t, "", stderr.String())
 }
-
-func TestVolumeFrom_Isolated(t *testing.T) {
-	integtest.Prepare(t)
-
-	runtimes := []string{firecrackerRuntime, "io.containerd.runc.v2"}
-
-	for _, rt := range runtimes {
-		t.Run(rt, func(t *testing.T) {
-			testVolumeFrom(t, rt)
-		})
-	}
-}
-
-func testVolumeFrom(t *testing.T, runtime string) {
-	const vmID = 0
-
-	ctx := namespaces.WithNamespace(context.Background(), "default")
-
-	client, err := containerd.New(integtest.ContainerdSockPath, containerd.WithDefaultRuntime(runtime))
-	require.NoError(t, err, "unable to create client to containerd service at %s, is containerd running?", integtest.ContainerdSockPath)
-	defer client.Close()
-
-	image, err := alpineImage(ctx, client, defaultSnapshotterName)
-	require.NoError(t, err, "failed to get alpine image")
-
-	fcClient, err := integtest.NewFCControlClient(integtest.ContainerdSockPath)
-	require.NoError(t, err, "failed to create fccontrol client")
-
-	// TODO: Create and host own images with non-empty volumes.
-	ref := "docker.io/library/postgres:14.3"
-	vs := volume.NewSet(runtime)
-	provider := volume.FromImage(client, ref, "vfc-snapshot", volume.WithSnapshotter(defaultSnapshotterName))
-	defer func() {
-		err := provider.Delete(ctx)
-		require.NoError(t, err)
-	}()
-	err = vs.AddFrom(ctx, provider)
-	require.NoError(t, err)
-
-	containers := []string{"c1", "c2"}
-
-	if runtime == firecrackerRuntime {
-		mount, err := vs.PrepareDriveMount(ctx, 10*mib)
-		require.NoError(t, err)
-
-		_, err = fcClient.CreateVM(ctx, &proto.CreateVMRequest{
-			VMID:           strconv.Itoa(vmID),
-			ContainerCount: int32(len(containers)),
-			DriveMounts:    []*proto.FirecrackerDriveMount{mount},
-		})
-		require.NoError(t, err, "failed to create VM")
-	} else {
-		err := vs.PrepareDirectory(ctx)
-		require.NoError(t, err)
-	}
-
-	// Make volmes from a container.
-	volumesFromContainerImage, err := vs.WithMountsFromProvider(ref)
-	require.NoError(t, err)
-
-	dir := "/var/lib/postgresql/data"
-
-	for _, name := range containers {
-		snapshotName := fmt.Sprintf("%s-snapshot", name)
-
-		sh := fmt.Sprintf("echo hello from %s >> %s/hello.txt", name, dir)
-		container, err := client.NewContainer(ctx,
-			name,
-			containerd.WithSnapshotter(defaultSnapshotterName),
-			containerd.WithNewSnapshot(snapshotName, image),
-			containerd.WithNewSpec(
-				firecrackeroci.WithVMID(strconv.Itoa(vmID)),
-				oci.WithProcessArgs("sh", "-c", sh),
-				oci.WithDefaultPathEnv,
-				volumesFromContainerImage,
-			),
-		)
-		require.NoError(t, err, "failed to create container %s", name)
-		defer container.Delete(ctx, containerd.WithSnapshotCleanup)
-
-		result, err := integtest.RunTask(ctx, container)
-		require.NoError(t, err)
-		assert.Equalf(t, uint32(0), result.ExitCode, "stdout=%q stderr=%q", result.Stdout, result.Stderr)
-	}
-
-	name := "cat"
-	snapshotName := fmt.Sprintf("%s-snapshot", name)
-	container, err := client.NewContainer(ctx,
-		name,
-		containerd.WithSnapshotter(defaultSnapshotterName),
-		containerd.WithNewSnapshot(snapshotName, image),
-		containerd.WithNewSpec(
-			firecrackeroci.WithVMID(strconv.Itoa(vmID)),
-			oci.WithProcessArgs("cat", fmt.Sprintf("%s/hello.txt", dir)),
-			oci.WithDefaultPathEnv,
-			volumesFromContainerImage,
-		),
-	)
-	require.NoError(t, err, "failed to create container %s", name)
-	defer container.Delete(ctx, containerd.WithSnapshotCleanup)
-
-	result, err := integtest.RunTask(ctx, container)
-	require.NoError(t, err)
-
-	assert.Equal(t, uint32(0), result.ExitCode)
-	assert.Equal(t, "hello from c1\nhello from c2\n", result.Stdout)
-	assert.Equal(t, "", result.Stderr)
-}
diff --git a/snapshotter/demux/cache/snapshotter_cache_test.go b/snapshotter/demux/cache/snapshotter_cache_test.go
index bb84f45..46405eb 100644
--- a/snapshotter/demux/cache/snapshotter_cache_test.go
+++ b/snapshotter/demux/cache/snapshotter_cache_test.go
@@ -17,7 +17,6 @@ import (
 	"context"
 	"testing"
 
-	"github.com/containerd/containerd/snapshots"
 	"github.com/hashicorp/go-multierror"
 	"github.com/pkg/errors"
 
@@ -56,53 +55,13 @@ func getCachedSnapshotter(uut *SnapshotterCache) error {
 	return nil
 }
 
-func getSnapshotterPropagatesErrors(uut *SnapshotterCache) error {
+func getSnapshotterPropogatesErrors(uut *SnapshotterCache) error {
 	if _, err := uut.Get(context.Background(), "SnapshotterKey", getSnapshotterErrorFunction); err == nil {
 		return errors.New("Get function did not propagate errors from snapshotter generator function")
 	}
 	return nil
 }
 
-func successfulWalk(ctx context.Context, info snapshots.Info) error {
-	return nil
-}
-
-func applyWalkFunctionOnEmptyCache(uut *SnapshotterCache) error {
-	if err := uut.WalkAll(context.Background(), successfulWalk); err != nil {
-		return errors.New("WalkAll on empty cache incorrectly resulted in error")
-	}
-	return nil
-}
-
-func applyWalkFunctionToAllCachedSnapshotters(uut *SnapshotterCache) error {
-	if _, err := uut.Get(context.Background(), "Snapshotter-A", getSnapshotterOkFunction); err != nil {
-		return errors.Wrap(err, "Adding snapshotter A to empty cache incorrectly resulted in error")
-	}
-	if _, err := uut.Get(context.Background(), "Snapshotter-B", getSnapshotterOkFunction); err != nil {
-		return errors.Wrap(err, "Adding snapshotter B to empty cache incorrectly resulted in error")
-	}
-	if err := uut.WalkAll(context.Background(), successfulWalk); err != nil {
-		return errors.New("WalkAll on populated cache incorrectly resulted in error")
-	}
-	return nil
-}
-
-func applyWalkFunctionPropagatesErrors(uut *SnapshotterCache) error {
-	if _, err := uut.Get(context.Background(), "Snapshotter-A", getFailingSnapshotterOkFunction); err != nil {
-		return errors.Wrap(err, "Adding snapshotter A to empty cache incorrectly resulted in error")
-	}
-	// The failing snapshotter mock will fail all Walk calls before applying
-	// the snapshots.WalkFunc, but for the purposes of this test that is fine.
-	// In which case, any function will do.
-	walkFunc := func(ctx context.Context, info snapshots.Info) error {
-		return nil
-	}
-	if err := uut.WalkAll(context.Background(), walkFunc); err == nil {
-		return errors.New("WalkAll did not propagate errors from walk function")
-	}
-	return nil
-}
-
 func evictSnapshotterFromEmptyCache(uut *SnapshotterCache) error {
 	if err := uut.Evict("SnapshotterKey"); err == nil {
 		return errors.New("Evict function did not return error on call on empty cache")
@@ -121,7 +80,7 @@ func evictSnapshotterFromCache(uut *SnapshotterCache) error {
 	return nil
 }
 
-func evictSnapshotterFromCachePropagatesCloseError(uut *SnapshotterCache) error {
+func evictSnapshotterFromCachePropogatesCloseError(uut *SnapshotterCache) error {
 	if _, err := uut.Get(context.Background(), "SnapshotterKey", getFailingSnapshotterOkFunction); err != nil {
 		return errors.Wrap(err, "Adding snapshotter to empty cache incorrectly resulted in error")
 	}
@@ -197,36 +156,14 @@ func TestGetSnapshotterFromCache(t *testing.T) {
 	}{
 		{"AddSnapshotterToCache", getSnapshotterFromEmptyCache},
 		{"GetCachedSnapshotter", getCachedSnapshotter},
-		{"PropogateFetchSnapshotterErrors", getSnapshotterPropagatesErrors},
-	}
-
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			uut := NewSnapshotterCache()
-			if err := test.run(uut); err != nil {
-				t.Fatalf("%s: %s", test.name, err.Error())
-			}
-		})
-	}
-}
-
-func TestWalkAllFunctionOnCache(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name string
-		run  func(*SnapshotterCache) error
-	}{
-		{"ApplyWalkFunctionOnEmptyCache", applyWalkFunctionOnEmptyCache},
-		{"ApplyWalkFunctionToAllCachedSnapshotters", applyWalkFunctionToAllCachedSnapshotters},
-		{"ApplyWalkFunctionPropogatesErrors", applyWalkFunctionPropagatesErrors},
+		{"PropogateFetchSnapshotterErrors", getSnapshotterPropogatesErrors},
 	}
 
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
 			uut := NewSnapshotterCache()
 			if err := test.run(uut); err != nil {
-				t.Fatalf("%s: %s", test.name, err.Error())
+				t.Fatal(test.name + ": " + err.Error())
 			}
 		})
 	}
@@ -241,14 +178,14 @@ func TestEvictSnapshotterFromCache(t *testing.T) {
 	}{
 		{"EvictSnapshotterFromEmptyCache", evictSnapshotterFromEmptyCache},
 		{"EvictSnapshotterFromCache", evictSnapshotterFromCache},
-		{"PropogateEvictSnapshotterCloseErrors", evictSnapshotterFromCachePropagatesCloseError},
+		{"PropogateEvictSnapshotterCloseErrors", evictSnapshotterFromCachePropogatesCloseError},
 	}
 
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
 			uut := NewSnapshotterCache()
 			if err := test.run(uut); err != nil {
-				t.Fatalf("%s: %s", test.name, err.Error())
+				t.Fatal(test.name + ": " + err.Error())
 			}
 		})
 	}
@@ -270,7 +207,7 @@ func TestCloseCache(t *testing.T) {
 		t.Run(test.name, func(t *testing.T) {
 			uut := NewSnapshotterCache()
 			if err := test.run(uut); err != nil {
-				t.Fatalf("%s: %s", test.name, err.Error())
+				t.Fatal(test.name + ": " + err.Error())
 			}
 		})
 	}
@@ -291,7 +228,7 @@ func TestListSnapshotters(t *testing.T) {
 		t.Run(test.name, func(t *testing.T) {
 			uut := NewSnapshotterCache()
 			if err := test.run(uut); err != nil {
-				t.Fatalf("%s: %s", test.name, err.Error())
+				t.Fatal(test.name + ": " + err.Error())
 			}
 		})
 	}
diff --git a/snapshotter/demux/snapshotter_test.go b/snapshotter/demux/snapshotter_test.go
index 01d23b8..70d20bd 100644
--- a/snapshotter/demux/snapshotter_test.go
+++ b/snapshotter/demux/snapshotter_test.go
@@ -73,28 +73,6 @@ func TestReturnErrorWhenCalledWithoutNamespacedContext(t *testing.T) {
 		{"View", func() error { _, err := uut.View(ctx, "layerKey", ""); return err }},
 		{"Commit", func() error { return uut.Commit(ctx, "layer1", "layerKey") }},
 		{"Remove", func() error { return uut.Remove(ctx, "layerKey") }},
-		{"Cleanup", func() error { return uut.(snapshots.Cleaner).Cleanup(ctx) }},
-	}
-
-	for _, test := range tests {
-		if err := test.run(); err == nil {
-			t.Fatalf("%s call did not return error", test.name)
-		}
-	}
-}
-
-func TestNoErrorWhenCalledWithoutNamespacedContext(t *testing.T) {
-	t.Parallel()
-
-	cache := cache.NewSnapshotterCache()
-	ctx := logtest.WithT(context.Background(), t)
-
-	uut := NewSnapshotter(cache, fetchOkSnapshotter)
-
-	tests := []struct {
-		name string
-		run  func() error
-	}{
 		{"Walk", func() error {
 			var callback = func(c context.Context, i snapshots.Info) error { return nil }
 			return uut.Walk(ctx, callback)
@@ -102,8 +80,8 @@ func TestNoErrorWhenCalledWithoutNamespacedContext(t *testing.T) {
 	}
 
 	for _, test := range tests {
-		if err := test.run(); err != nil {
-			t.Fatalf("%s call returned error on no namespace execution", test.name)
+		if err := test.run(); err == nil {
+			t.Fatal(test.name + " call did not return error")
 		}
 	}
 }
@@ -134,12 +112,11 @@ func TestReturnErrorWhenSnapshotterNotFound(t *testing.T) {
 			var callback = func(c context.Context, i snapshots.Info) error { return nil }
 			return uut.Walk(ctx, callback)
 		}},
-		{"Cleanup", func() error { return uut.(snapshots.Cleaner).Cleanup(ctx) }},
 	}
 
 	for _, test := range tests {
 		if err := test.run(); err == nil {
-			t.Fatalf("%s call did not return error", test.name)
+			t.Fatal(test.name + " call did not return error")
 		}
 	}
 }
@@ -171,13 +148,12 @@ func TestReturnErrorAfterProxyFunctionFailure(t *testing.T) {
 			return uut.Walk(ctx, callback)
 		}},
 		{"Close", func() error { return uut.Close() }},
-		{"Cleanup", func() error { return uut.(snapshots.Cleaner).Cleanup(ctx) }},
 	}
 
 	for _, test := range tests {
 		t.Run(test.name+"ProxyFailure", func(t *testing.T) {
 			if err := test.run(); err == nil {
-				t.Fatalf("%s call did not return error", test.name)
+				t.Fatal(test.name + " call did not return error")
 			}
 		})
 	}
@@ -210,13 +186,12 @@ func TestNoErrorIsReturnedOnSuccessfulProxyExecution(t *testing.T) {
 			return uut.Walk(ctx, callback)
 		}},
 		{"Close", func() error { return uut.Close() }},
-		{"Cleanup", func() error { return uut.(snapshots.Cleaner).Cleanup(ctx) }},
 	}
 
 	for _, test := range tests {
 		t.Run(test.name+"SuccessfulProxyCall", func(t *testing.T) {
 			if err := test.run(); err != nil {
-				t.Fatalf("%s call incorrectly returned an error", test.name)
+				t.Fatal(test.name + " call incorrectly returned an error")
 			}
 		})
 	}
diff --git a/tools/docker/Dockerfile.integ-test b/tools/docker/Dockerfile.integ-test
index 728b237..c9a7a96 100644
--- a/tools/docker/Dockerfile.integ-test
+++ b/tools/docker/Dockerfile.integ-test
@@ -46,8 +46,7 @@ RUN --mount=type=bind,target=/src \
   ln -sv /usr/local/bin/firecracker-ctr /usr/local/bin/ctr
 RUN containerd 2>/dev/null & \
   ctr --address /run/firecracker-containerd/containerd.sock content fetch docker.io/library/alpine:3.10.1 >/dev/null && \
-  ctr --address /run/firecracker-containerd/containerd.sock content fetch docker.io/mlabbe/iperf3:3.6-r0 >/dev/null && \
-  ctr --address /run/firecracker-containerd/containerd.sock content fetch docker.io/library/postgres:14.3 >/dev/null
+  ctr --address /run/firecracker-containerd/containerd.sock content fetch docker.io/mlabbe/iperf3:3.6-r0 >/dev/null
 
 # Install critest
 ENV VERSION="v1.23.0"
@@ -62,7 +61,7 @@ RUN --mount=type=bind,target=/src make -C /src \
   install \
   install-firecracker \
   install-runc \
-  install-default-vmlinux \
+  install-kernel \
   install-default-rootfs \
   install-default-runc-jailer-config \
   install-test-cni-bins \
diff --git a/volume/set_test.go b/volume/set_test.go
deleted file mode 100644
index 14a5d6a..0000000
--- a/volume/set_test.go
+++ /dev/null
@@ -1,44 +0,0 @@
-// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"). You may
-// not use this file except in compliance with the License. A copy of the
-// License is located at
-//
-//	http://aws.amazon.com/apache2.0/
-//
-// or in the "license" file accompanying this file. This file is distributed
-// on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
-// express or implied. See the License for the specific language governing
-// permissions and limitations under the License.
-
-package volume
-
-import (
-	"context"
-	"testing"
-
-	"github.com/stretchr/testify/require"
-)
-
-type testProvider struct {
-	name string
-}
-
-func (p *testProvider) CreateVolumesUnder(ctx context.Context, path string) ([]*Volume, error) {
-	return nil, nil
-}
-func (p *testProvider) Delete(ctx context.Context) error {
-	return nil
-}
-func (p *testProvider) Name() string {
-	return p.name
-}
-
-func TestNewSet(t *testing.T) {
-	provider := &testProvider{name: "foobar"}
-
-	ctx := context.Background()
-	vs := NewSet("")
-	err := vs.AddFrom(ctx, provider)
-	require.NoError(t, err)
-}