containerd
diff --git a/‎go.mod
Copy file name to clipboard
-2Lines changed: 0 additions & 2 deletions b/‎go.mod
Copy file name to clipboard
-2Lines changed: 0 additions & 2 deletions
diff --git a/‎pkg/process/io.go
Copy file name to clipboard
+18-22Lines changed: 18 additions & 22 deletions b/‎pkg/process/io.go
Copy file name to clipboard
+18-22Lines changed: 18 additions & 22 deletions
diff --git a/‎runtime/v2/shim.go
Copy file name to clipboard
+5-6Lines changed: 5 additions & 6 deletions b/‎runtime/v2/shim.go
Copy file name to clipboard
+5-6Lines changed: 5 additions & 6 deletions
diff --git a/‎snapshots/devmapper/config.go
Copy file name to clipboard
+8-8Lines changed: 8 additions & 8 deletions b/‎snapshots/devmapper/config.go
Copy file name to clipboard
+8-8Lines changed: 8 additions & 8 deletions
diff --git a/‎snapshots/devmapper/config_test.go
Copy file name to clipboard
+6-7Lines changed: 6 additions & 7 deletions b/‎snapshots/devmapper/config_test.go
Copy file name to clipboard
+6-7Lines changed: 6 additions & 7 deletions
diff --git a/‎snapshots/devmapper/pool_device.go
Copy file name to clipboard
+22-25Lines changed: 22 additions & 25 deletions b/‎snapshots/devmapper/pool_device.go
Copy file name to clipboard
+22-25Lines changed: 22 additions & 25 deletions
@@ -37,7 +37,6 @@ require (
 	github.com/google/uuid v1.3.1
 	github.com/grpc-ecosystem/go-grpc-middleware v1.3.0
 	github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0
-	github.com/hashicorp/go-multierror v1.1.1
 	github.com/intel/goresctrl v0.2.0
 	github.com/klauspost/compress v1.15.9
 	github.com/moby/locker v1.0.1
@@ -97,7 +96,6 @@ require (
 	github.com/golang/protobuf v1.5.4 // indirect
 	github.com/google/gofuzz v1.2.0 // indirect
 	github.com/grpc-ecosystem/grpc-gateway v1.16.0 // indirect
-	github.com/hashicorp/errwrap v1.1.0 // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
 	github.com/matttproud/golang_protobuf_extensions v1.0.4 // indirect
 	github.com/miekg/pkcs11 v1.1.1 // indirect
 
@@ -21,6 +21,7 @@ package process
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"io"
 	"net/url"
@@ -36,7 +37,6 @@ import (
 	"github.com/containerd/fifo"
 	runc "github.com/containerd/go-runc"
 	"github.com/containerd/log"
-	"github.com/hashicorp/go-multierror"
 	exec "golang.org/x/sys/execabs"
 )
 
@@ -256,11 +256,11 @@ func NewBinaryIO(ctx context.Context, id string, uri *url.URL) (_ runc.IO, err e
 		if err == nil {
 			return
 		}
-		result := multierror.Append(err)
+		result := []error{err}
 		for _, fn := range closers {
-			result = multierror.Append(result, fn())
+			result = append(result, fn())
 		}
-		err = multierror.Flatten(result)
+		err = errors.Join(result...)
 	}()
 
 	out, err := newPipe()
@@ -314,39 +314,35 @@ type binaryIO struct {
 }
 
 func (b *binaryIO) CloseAfterStart() error {
-	var (
-		result *multierror.Error
-	)
+	var result []error
 
 	for _, v := range []*pipe{b.out, b.err} {
 		if v != nil {
 			if err := v.r.Close(); err != nil {
-				result = multierror.Append(result, err)
+				result = append(result, err)
 			}
 		}
 	}
 
-	return result.ErrorOrNil()
+	return errors.Join(result...)
 }
 
 func (b *binaryIO) Close() error {
-	var (
-		result *multierror.Error
-	)
+	var result []error
 
 	for _, v := range []*pipe{b.out, b.err} {
 		if v != nil {
 			if err := v.Close(); err != nil {
-				result = multierror.Append(result, err)
+				result = append(result, err)
 			}
 		}
 	}
 
 	if err := b.cancel(); err != nil {
-		result = multierror.Append(result, err)
+		result = append(result, err)
 	}
 
-	return result.ErrorOrNil()
+	return errors.Join(result...)
 }
 
 func (b *binaryIO) cancel() error {
@@ -356,15 +352,15 @@ func (b *binaryIO) cancel() error {
 
 	// Send SIGTERM first, so logger process has a chance to flush and exit properly
 	if err := b.cmd.Process.Signal(syscall.SIGTERM); err != nil {
-		result := multierror.Append(fmt.Errorf("failed to send SIGTERM: %w", err))
+		result := []error{fmt.Errorf("failed to send SIGTERM: %w", err)}
 
 		log.L.WithError(err).Warn("failed to send SIGTERM signal, killing logging shim")
 
 		if err := b.cmd.Process.Kill(); err != nil {
-			result = multierror.Append(result, fmt.Errorf("failed to kill process after faulty SIGTERM: %w", err))
+			result = append(result, fmt.Errorf("failed to kill process after faulty SIGTERM: %w", err))
 		}
 
-		return result.ErrorOrNil()
+		return errors.Join(result...)
 	}
 
 	done := make(chan error, 1)
@@ -425,15 +421,15 @@ type pipe struct {
 }
 
 func (p *pipe) Close() error {
-	var result *multierror.Error
+	var result []error
 
 	if err := p.w.Close(); err != nil {
-		result = multierror.Append(result, fmt.Errorf("failed to close write pipe: %w", err))
+		result = append(result, fmt.Errorf("pipe: failed to close write pipe: %w", err))
 	}
 
 	if err := p.r.Close(); err != nil {
-		result = multierror.Append(result, fmt.Errorf("failed to close read pipe: %w", err))
+		result = append(result, fmt.Errorf("pipe: failed to close read pipe: %w", err))
 	}
 
-	return multierror.Prefix(result.ErrorOrNil(), "pipe:")
+	return errors.Join(result...)
 }
@@ -39,7 +39,6 @@ import (
 	"github.com/containerd/log"
 	"github.com/containerd/ttrpc"
 	ptypes "github.com/gogo/protobuf/types"
-	"github.com/hashicorp/go-multierror"
 	"github.com/sirupsen/logrus"
 )
 
@@ -216,23 +215,23 @@ func (s *shim) Close() error {
 
 func (s *shim) delete(ctx context.Context) error {
 	var (
-		result *multierror.Error
+		result []error
 	)
 
 	if err := s.Close(); err != nil {
-		result = multierror.Append(result, fmt.Errorf("failed to close ttrpc client: %w", err))
+		result = append(result, fmt.Errorf("failed to close ttrpc client: %w", err))
 	}
 
 	if err := s.client.UserOnCloseWait(ctx); err != nil {
-		result = multierror.Append(result, fmt.Errorf("close wait error: %w", err))
+		result = append(result, fmt.Errorf("close wait error: %w", err))
 	}
 
 	if err := s.bundle.Delete(); err != nil {
 		log.G(ctx).WithField("id", s.ID()).WithError(err).Error("failed to delete bundle")
-		result = multierror.Append(result, fmt.Errorf("failed to delete bundle: %w", err))
+		result = append(result, fmt.Errorf("failed to delete bundle: %w", err))
 	}
 
-	return result.ErrorOrNil()
+	return errors.Join(result...)
 }
 
 var _ runtime.Task = &shimTask{}
 
@@ -20,11 +20,11 @@
 package devmapper
 
 import (
+	"errors"
 	"fmt"
 	"os"
 
 	"github.com/docker/go-units"
-	"github.com/hashicorp/go-multierror"
 	"github.com/pelletier/go-toml"
 )
 
@@ -101,29 +101,29 @@ func (c *Config) parse() error {
 
 // Validate makes sure configuration fields are valid
 func (c *Config) Validate() error {
-	var result *multierror.Error
+	var result []error
 
 	if c.PoolName == "" {
-		result = multierror.Append(result, fmt.Errorf("pool_name is required"))
+		result = append(result, fmt.Errorf("pool_name is required"))
 	}
 
 	if c.RootPath == "" {
-		result = multierror.Append(result, fmt.Errorf("root_path is required"))
+		result = append(result, fmt.Errorf("root_path is required"))
 	}
 
 	if c.BaseImageSize == "" {
-		result = multierror.Append(result, fmt.Errorf("base_image_size is required"))
+		result = append(result, fmt.Errorf("base_image_size is required"))
 	}
 
 	if c.FileSystemType != "" {
 		switch c.FileSystemType {
 		case fsTypeExt4, fsTypeXFS:
 		default:
-			result = multierror.Append(result, fmt.Errorf("unsupported Filesystem Type: %q", c.FileSystemType))
+			result = append(result, fmt.Errorf("unsupported Filesystem Type: %q", c.FileSystemType))
 		}
 	} else {
-		result = multierror.Append(result, fmt.Errorf("filesystem type cannot be empty"))
+		result = append(result, fmt.Errorf("filesystem type cannot be empty"))
 	}
 
-	return result.ErrorOrNil()
+	return errors.Join(result...)
 }
@@ -23,7 +23,6 @@ import (
 	"os"
 	"testing"
 
-	"github.com/hashicorp/go-multierror"
 	"github.com/pelletier/go-toml"
 	"github.com/stretchr/testify/assert"
 )
@@ -81,13 +80,13 @@ func TestFieldValidation(t *testing.T) {
 	err := config.Validate()
 	assert.NotNil(t, err)
 
-	multErr := (err).(*multierror.Error)
-	assert.Len(t, multErr.Errors, 4)
+	multErr := err.(interface{ Unwrap() []error }).Unwrap()
+	assert.Len(t, multErr, 4)
 
-	assert.NotNil(t, multErr.Errors[0], "pool_name is empty")
-	assert.NotNil(t, multErr.Errors[1], "root_path is empty")
-	assert.NotNil(t, multErr.Errors[2], "base_image_size is empty")
-	assert.NotNil(t, multErr.Errors[3], "filesystem type cannot be empty")
+	assert.NotNil(t, multErr[0], "pool_name is empty")
+	assert.NotNil(t, multErr[1], "root_path is empty")
+	assert.NotNil(t, multErr[2], "base_image_size is empty")
+	assert.NotNil(t, multErr[3], "filesystem type cannot be empty")
 }
 
 func TestExistingPoolFieldValidation(t *testing.T) {
 
@@ -27,7 +27,6 @@ import (
 	"strconv"
 	"time"
 
-	"github.com/hashicorp/go-multierror"
 	"golang.org/x/sys/unix"
 
 	blkdiscard "github.com/containerd/containerd/snapshots/devmapper/blkdiscard"
@@ -146,15 +145,15 @@ func (p *PoolDevice) ensureDeviceStates(ctx context.Context) error {
 		return fmt.Errorf("failed to query devices from metastore: %w", err)
 	}
 
-	var result *multierror.Error
+	var result []error
 	for _, dev := range activatedDevices {
 		if p.IsActivated(dev.Name) {
 			continue
 		}
 
 		log.G(ctx).Warnf("devmapper device %q marked as %q but not active, activating it", dev.Name, dev.State)
 		if err := p.activateDevice(ctx, dev); err != nil {
-			result = multierror.Append(result, err)
+			result = append(result, fmt.Errorf("devmapper: %w", err))
 		}
 	}
 
@@ -166,11 +165,11 @@ func (p *PoolDevice) ensureDeviceStates(ctx context.Context) error {
 			Warnf("devmapper device %q has invalid state %q, marking as faulty", dev.Name, dev.State)
 
 		if err := p.metadata.MarkFaulty(ctx, dev.Name); err != nil {
-			result = multierror.Append(result, err)
+			result = append(result, fmt.Errorf("devmapper: %w", err))
 		}
 	}
 
-	return multierror.Prefix(result.ErrorOrNil(), "devmapper:")
+	return errors.Join(result...)
 }
 
 // transition invokes 'updateStateFn' callback to perform devmapper operation and reflects device state changes/errors in meta store.
@@ -187,13 +186,13 @@ func (p *PoolDevice) transition(ctx context.Context, deviceName string, tryingSt
 		return fmt.Errorf("failed to set device %q state to %q: %w", deviceName, tryingState, uerr)
 	}
 
-	var result *multierror.Error
+	var result []error
 
 	// Invoke devmapper operation
 	err := updateStateFn()
 
 	if err != nil {
-		result = multierror.Append(result, err)
+		result = append(result, err)
 	}
 
 	// If operation succeeded transition to success state, otherwise save error details
@@ -208,25 +207,23 @@ func (p *PoolDevice) transition(ctx context.Context, deviceName string, tryingSt
 	})
 
 	if uerr != nil {
-		result = multierror.Append(result, uerr)
+		result = append(result, uerr)
 	}
 
-	return unwrapError(result)
+	return unwrapError(errors.Join(result...))
 }
 
-// unwrapError converts multierror.Error to the original error when it is possible.
-// multierror 1.1.0 has the similar function named Unwrap, but it requires Go 1.14.
-func unwrapError(e *multierror.Error) error {
+func unwrapError(e error) error {
 	if e == nil {
 		return nil
 	}
 
-	// If the error can be expressed without multierror, return the original error.
-	if len(e.Errors) == 1 {
-		return e.Errors[0]
+	if joinErr, ok := e.(interface{ Unwrap() []error }); ok {
+		if errs := joinErr.Unwrap(); len(errs) == 1 {
+			return errs[0]
+		}
 	}
-
-	return e.ErrorOrNil()
+	return e
 }
 
 // CreateThinDevice creates new devmapper thin-device with given name and size.
@@ -254,7 +251,7 @@ func (p *PoolDevice) CreateThinDevice(ctx context.Context, deviceName string, vi
 
 		// We're unable to create the devmapper device, most likely something wrong with the deviceID
 		if devErr != nil {
-			retErr = multierror.Append(retErr, p.metadata.MarkFaulty(ctx, info.Name))
+			retErr = errors.Join(retErr, p.metadata.MarkFaulty(ctx, info.Name))
 			return
 		}
 	}()
@@ -286,12 +283,12 @@ func (p *PoolDevice) rollbackActivate(ctx context.Context, info *DeviceInfo, act
 	if delErr != nil {
 		// Failed to rollback, mark the device as faulty and keep metadata in order to
 		// preserve the faulty device ID
-		return multierror.Append(activateErr, delErr, p.metadata.MarkFaulty(ctx, info.Name))
+		return errors.Join(activateErr, delErr, p.metadata.MarkFaulty(ctx, info.Name))
 	}
 
 	// The devmapper device has been successfully deleted, deallocate device ID
 	if err := p.RemoveDevice(ctx, info.Name); err != nil {
-		return multierror.Append(activateErr, err)
+		return errors.Join(activateErr, err)
 	}
 
 	return activateErr
@@ -348,7 +345,7 @@ func (p *PoolDevice) CreateSnapshotDevice(ctx context.Context, deviceName string
 
 		// We're unable to create the devmapper device, most likely something wrong with the deviceID
 		if devErr != nil {
-			retErr = multierror.Append(retErr, p.metadata.MarkFaulty(ctx, snapInfo.Name))
+			retErr = errors.Join(retErr, p.metadata.MarkFaulty(ctx, snapInfo.Name))
 			return
 		}
 	}()
@@ -562,20 +559,20 @@ func (p *PoolDevice) RemovePool(ctx context.Context) error {
 		return fmt.Errorf("can't query device names: %w", err)
 	}
 
-	var result *multierror.Error
+	var result []error
 
 	// Deactivate devices if any
 	for _, name := range deviceNames {
 		if err := p.DeactivateDevice(ctx, name, true, true); err != nil {
-			result = multierror.Append(result, fmt.Errorf("failed to remove %q: %w", name, err))
+			result = append(result, fmt.Errorf("failed to remove %q: %w", name, err))
 		}
 	}
 
 	if err := dmsetup.RemoveDevice(p.poolName, dmsetup.RemoveWithForce, dmsetup.RemoveWithRetries, dmsetup.RemoveDeferred); err != nil {
-		result = multierror.Append(result, fmt.Errorf("failed to remove pool %q: %w", p.poolName, err))
+		result = append(result, fmt.Errorf("failed to remove pool %q: %w", p.poolName, err))
 	}
 
-	return result.ErrorOrNil()
+	return errors.Join(result...)
 }
 
 // MarkDeviceState changes the device's state in metastore
Original file line number	Diff line number	Diff line change
`@@ -21,6 +21,7 @@ package process`
`21`	`21`
`22`	`22`	`import (`
`23`	`23`	`"context"`
	`24`	`+ "errors"`
`24`	`25`	`"fmt"`
`25`	`26`	`"io"`
`26`	`27`	`"net/url"`
`@@ -36,7 +37,6 @@ import (`
`36`	`37`	`"github.com/containerd/fifo"`
`37`	`38`	`runc "github.com/containerd/go-runc"`
`38`	`39`	`"github.com/containerd/log"`
`39`		`- "github.com/hashicorp/go-multierror"`
`40`	`40`	`exec "golang.org/x/sys/execabs"`
`41`	`41`	`)`
`42`	`42`
`@@ -256,11 +256,11 @@ func NewBinaryIO(ctx context.Context, id string, uri *url.URL) (_ runc.IO, err e`
`256`	`256`	`if err == nil {`
`257`	`257`	`return`
`258`	`258`	`}`
`259`		`- result := multierror.Append(err)`
	`259`	`+ result := []error{err}`
`260`	`260`	`for _, fn := range closers {`
`261`		`- result = multierror.Append(result, fn())`
	`261`	`+ result = append(result, fn())`
`262`	`262`	`}`
`263`		`- err = multierror.Flatten(result)`
	`263`	`+ err = errors.Join(result...)`
`264`	`264`	`}()`
`265`	`265`
`266`	`266`	`out, err := newPipe()`
`@@ -314,39 +314,35 @@ type binaryIO struct {`
`314`	`314`	`}`
`315`	`315`
`316`	`316`	`func (b *binaryIO) CloseAfterStart() error {`
`317`		`- var (`
`318`		`- result *multierror.Error`
`319`		`- )`
	`317`	`+ var result []error`
`320`	`318`
`321`	`319`	`for _, v := range []*pipe{b.out, b.err} {`
`322`	`320`	`if v != nil {`
`323`	`321`	`if err := v.r.Close(); err != nil {`
`324`		`- result = multierror.Append(result, err)`
	`322`	`+ result = append(result, err)`
`325`	`323`	`}`
`326`	`324`	`}`
`327`	`325`	`}`
`328`	`326`
`329`		`- return result.ErrorOrNil()`
	`327`	`+ return errors.Join(result...)`
`330`	`328`	`}`
`331`	`329`
`332`	`330`	`func (b *binaryIO) Close() error {`
`333`		`- var (`
`334`		`- result *multierror.Error`
`335`		`- )`
	`331`	`+ var result []error`
`336`	`332`
`337`	`333`	`for _, v := range []*pipe{b.out, b.err} {`
`338`	`334`	`if v != nil {`
`339`	`335`	`if err := v.Close(); err != nil {`
`340`		`- result = multierror.Append(result, err)`
	`336`	`+ result = append(result, err)`
`341`	`337`	`}`
`342`	`338`	`}`
`343`	`339`	`}`
`344`	`340`
`345`	`341`	`if err := b.cancel(); err != nil {`
`346`		`- result = multierror.Append(result, err)`
	`342`	`+ result = append(result, err)`
`347`	`343`	`}`
`348`	`344`
`349`		`- return result.ErrorOrNil()`
	`345`	`+ return errors.Join(result...)`
`350`	`346`	`}`
`351`	`347`
`352`	`348`	`func (b *binaryIO) cancel() error {`
`@@ -356,15 +352,15 @@ func (b *binaryIO) cancel() error {`
`356`	`352`
`357`	`353`	`// Send SIGTERM first, so logger process has a chance to flush and exit properly`
`358`	`354`	`if err := b.cmd.Process.Signal(syscall.SIGTERM); err != nil {`
`359`		`- result := multierror.Append(fmt.Errorf("failed to send SIGTERM: %w", err))`
	`355`	`+ result := []error{fmt.Errorf("failed to send SIGTERM: %w", err)}`
`360`	`356`
`361`	`357`	`log.L.WithError(err).Warn("failed to send SIGTERM signal, killing logging shim")`
`362`	`358`
`363`	`359`	`if err := b.cmd.Process.Kill(); err != nil {`
`364`		`- result = multierror.Append(result, fmt.Errorf("failed to kill process after faulty SIGTERM: %w", err))`
	`360`	`+ result = append(result, fmt.Errorf("failed to kill process after faulty SIGTERM: %w", err))`
`365`	`361`	`}`
`366`	`362`
`367`		`- return result.ErrorOrNil()`
	`363`	`+ return errors.Join(result...)`
`368`	`364`	`}`
`369`	`365`
`370`	`366`	`done := make(chan error, 1)`
`@@ -425,15 +421,15 @@ type pipe struct {`
`425`	`421`	`}`
`426`	`422`
`427`	`423`	`func (p *pipe) Close() error {`
`428`		`- var result *multierror.Error`
	`424`	`+ var result []error`
`429`	`425`
`430`	`426`	`if err := p.w.Close(); err != nil {`
`431`		`- result = multierror.Append(result, fmt.Errorf("failed to close write pipe: %w", err))`
	`427`	`+ result = append(result, fmt.Errorf("pipe: failed to close write pipe: %w", err))`
`432`	`428`	`}`
`433`	`429`
`434`	`430`	`if err := p.r.Close(); err != nil {`
`435`		`- result = multierror.Append(result, fmt.Errorf("failed to close read pipe: %w", err))`
	`431`	`+ result = append(result, fmt.Errorf("pipe: failed to close read pipe: %w", err))`
`436`	`432`	`}`
`437`	`433`
`438`		`- return multierror.Prefix(result.ErrorOrNil(), "pipe:")`
	`434`	`+ return errors.Join(result...)`
`439`	`435`	`}`
Original file line number	Diff line number	Diff line change
`@@ -39,7 +39,6 @@ import (`
`39`	`39`	`"github.com/containerd/log"`
`40`	`40`	`"github.com/containerd/ttrpc"`
`41`	`41`	`ptypes "github.com/gogo/protobuf/types"`
`42`		`- "github.com/hashicorp/go-multierror"`
`43`	`42`	`"github.com/sirupsen/logrus"`
`44`	`43`	`)`
`45`	`44`
`@@ -216,23 +215,23 @@ func (s *shim) Close() error {`
`216`	`215`
`217`	`216`	`func (s *shim) delete(ctx context.Context) error {`
`218`	`217`	`var (`
`219`		`- result *multierror.Error`
	`218`	`+ result []error`
`220`	`219`	`)`
`221`	`220`
`222`	`221`	`if err := s.Close(); err != nil {`
`223`		`- result = multierror.Append(result, fmt.Errorf("failed to close ttrpc client: %w", err))`
	`222`	`+ result = append(result, fmt.Errorf("failed to close ttrpc client: %w", err))`
`224`	`223`	`}`
`225`	`224`
`226`	`225`	`if err := s.client.UserOnCloseWait(ctx); err != nil {`
`227`		`- result = multierror.Append(result, fmt.Errorf("close wait error: %w", err))`
	`226`	`+ result = append(result, fmt.Errorf("close wait error: %w", err))`
`228`	`227`	`}`
`229`	`228`
`230`	`229`	`if err := s.bundle.Delete(); err != nil {`
`231`	`230`	`log.G(ctx).WithField("id", s.ID()).WithError(err).Error("failed to delete bundle")`
`232`		`- result = multierror.Append(result, fmt.Errorf("failed to delete bundle: %w", err))`
	`231`	`+ result = append(result, fmt.Errorf("failed to delete bundle: %w", err))`
`233`	`232`	`}`
`234`	`233`
`235`		`- return result.ErrorOrNil()`
	`234`	`+ return errors.Join(result...)`
`236`	`235`	`}`
`237`	`236`
`238`	`237`	`var _ runtime.Task = &shimTask{}`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,6 @@ import (`
`27`	`27`	`"strconv"`
`28`	`28`	`"time"`
`29`	`29`
`30`		`- "github.com/hashicorp/go-multierror"`
`31`	`30`	`"golang.org/x/sys/unix"`
`32`	`31`
`33`	`32`	`blkdiscard "github.com/containerd/containerd/snapshots/devmapper/blkdiscard"`
`@@ -146,15 +145,15 @@ func (p *PoolDevice) ensureDeviceStates(ctx context.Context) error {`
`146`	`145`	`return fmt.Errorf("failed to query devices from metastore: %w", err)`
`147`	`146`	`}`
`148`	`147`
`149`		`- var result *multierror.Error`
	`148`	`+ var result []error`
`150`	`149`	`for _, dev := range activatedDevices {`
`151`	`150`	`if p.IsActivated(dev.Name) {`
`152`	`151`	`continue`
`153`	`152`	`}`
`154`	`153`
`155`	`154`	`log.G(ctx).Warnf("devmapper device %q marked as %q but not active, activating it", dev.Name, dev.State)`
`156`	`155`	`if err := p.activateDevice(ctx, dev); err != nil {`
`157`		`- result = multierror.Append(result, err)`
	`156`	`+ result = append(result, fmt.Errorf("devmapper: %w", err))`
`158`	`157`	`}`
`159`	`158`	`}`
`160`	`159`
`@@ -166,11 +165,11 @@ func (p *PoolDevice) ensureDeviceStates(ctx context.Context) error {`
`166`	`165`	`Warnf("devmapper device %q has invalid state %q, marking as faulty", dev.Name, dev.State)`
`167`	`166`
`168`	`167`	`if err := p.metadata.MarkFaulty(ctx, dev.Name); err != nil {`
`169`		`- result = multierror.Append(result, err)`
	`168`	`+ result = append(result, fmt.Errorf("devmapper: %w", err))`
`170`	`169`	`}`
`171`	`170`	`}`
`172`	`171`
`173`		`- return multierror.Prefix(result.ErrorOrNil(), "devmapper:")`
	`172`	`+ return errors.Join(result...)`
`174`	`173`	`}`
`175`	`174`
`176`	`175`	`// transition invokes 'updateStateFn' callback to perform devmapper operation and reflects device state changes/errors in meta store.`
`@@ -187,13 +186,13 @@ func (p *PoolDevice) transition(ctx context.Context, deviceName string, tryingSt`
`187`	`186`	`return fmt.Errorf("failed to set device %q state to %q: %w", deviceName, tryingState, uerr)`
`188`	`187`	`}`
`189`	`188`
`190`		`- var result *multierror.Error`
	`189`	`+ var result []error`
`191`	`190`
`192`	`191`	`// Invoke devmapper operation`
`193`	`192`	`err := updateStateFn()`
`194`	`193`
`195`	`194`	`if err != nil {`
`196`		`- result = multierror.Append(result, err)`
	`195`	`+ result = append(result, err)`
`197`	`196`	`}`
`198`	`197`
`199`	`198`	`// If operation succeeded transition to success state, otherwise save error details`
`@@ -208,25 +207,23 @@ func (p *PoolDevice) transition(ctx context.Context, deviceName string, tryingSt`
`208`	`207`	`})`
`209`	`208`
`210`	`209`	`if uerr != nil {`
`211`		`- result = multierror.Append(result, uerr)`
	`210`	`+ result = append(result, uerr)`
`212`	`211`	`}`
`213`	`212`
`214`		`- return unwrapError(result)`
	`213`	`+ return unwrapError(errors.Join(result...))`
`215`	`214`	`}`
`216`	`215`
`217`		`-// unwrapError converts multierror.Error to the original error when it is possible.`
`218`		`-// multierror 1.1.0 has the similar function named Unwrap, but it requires Go 1.14.`
`219`		`-func unwrapError(e *multierror.Error) error {`
	`216`	`+func unwrapError(e error) error {`
`220`	`217`	`if e == nil {`
`221`	`218`	`return nil`
`222`	`219`	`}`
`223`	`220`
`224`		`- // If the error can be expressed without multierror, return the original error.`
`225`		`- if len(e.Errors) == 1 {`
`226`		`- return e.Errors[0]`
	`221`	`+ if joinErr, ok := e.(interface{ Unwrap() []error }); ok {`
	`222`	`+ if errs := joinErr.Unwrap(); len(errs) == 1 {`
	`223`	`+ return errs[0]`
	`224`	`+ }`
`227`	`225`	`}`
`228`		`-`
`229`		`- return e.ErrorOrNil()`
	`226`	`+ return e`
`230`	`227`	`}`
`231`	`228`
`232`	`229`	`// CreateThinDevice creates new devmapper thin-device with given name and size.`
`@@ -254,7 +251,7 @@ func (p *PoolDevice) CreateThinDevice(ctx context.Context, deviceName string, vi`
`254`	`251`
`255`	`252`	`// We're unable to create the devmapper device, most likely something wrong with the deviceID`
`256`	`253`	`if devErr != nil {`
`257`		`- retErr = multierror.Append(retErr, p.metadata.MarkFaulty(ctx, info.Name))`
	`254`	`+ retErr = errors.Join(retErr, p.metadata.MarkFaulty(ctx, info.Name))`
`258`	`255`	`return`
`259`	`256`	`}`
`260`	`257`	`}()`
`@@ -286,12 +283,12 @@ func (p PoolDevice) rollbackActivate(ctx context.Context, info DeviceInfo, act`
`286`	`283`	`if delErr != nil {`
`287`	`284`	`// Failed to rollback, mark the device as faulty and keep metadata in order to`
`288`	`285`	`// preserve the faulty device ID`
`289`		`- return multierror.Append(activateErr, delErr, p.metadata.MarkFaulty(ctx, info.Name))`
	`286`	`+ return errors.Join(activateErr, delErr, p.metadata.MarkFaulty(ctx, info.Name))`
`290`	`287`	`}`
`291`	`288`
`292`	`289`	`// The devmapper device has been successfully deleted, deallocate device ID`
`293`	`290`	`if err := p.RemoveDevice(ctx, info.Name); err != nil {`
`294`		`- return multierror.Append(activateErr, err)`
	`291`	`+ return errors.Join(activateErr, err)`
`295`	`292`	`}`
`296`	`293`
`297`	`294`	`return activateErr`
`@@ -348,7 +345,7 @@ func (p *PoolDevice) CreateSnapshotDevice(ctx context.Context, deviceName string`
`348`	`345`
`349`	`346`	`// We're unable to create the devmapper device, most likely something wrong with the deviceID`
`350`	`347`	`if devErr != nil {`
`351`		`- retErr = multierror.Append(retErr, p.metadata.MarkFaulty(ctx, snapInfo.Name))`
	`348`	`+ retErr = errors.Join(retErr, p.metadata.MarkFaulty(ctx, snapInfo.Name))`
`352`	`349`	`return`
`353`	`350`	`}`
`354`	`351`	`}()`
`@@ -562,20 +559,20 @@ func (p *PoolDevice) RemovePool(ctx context.Context) error {`
`562`	`559`	`return fmt.Errorf("can't query device names: %w", err)`
`563`	`560`	`}`
`564`	`561`
`565`		`- var result *multierror.Error`
	`562`	`+ var result []error`
`566`	`563`
`567`	`564`	`// Deactivate devices if any`
`568`	`565`	`for _, name := range deviceNames {`
`569`	`566`	`if err := p.DeactivateDevice(ctx, name, true, true); err != nil {`
`570`		`- result = multierror.Append(result, fmt.Errorf("failed to remove %q: %w", name, err))`
	`567`	`+ result = append(result, fmt.Errorf("failed to remove %q: %w", name, err))`
`571`	`568`	`}`
`572`	`569`	`}`
`573`	`570`
`574`	`571`	`if err := dmsetup.RemoveDevice(p.poolName, dmsetup.RemoveWithForce, dmsetup.RemoveWithRetries, dmsetup.RemoveDeferred); err != nil {`
`575`		`- result = multierror.Append(result, fmt.Errorf("failed to remove pool %q: %w", p.poolName, err))`
	`572`	`+ result = append(result, fmt.Errorf("failed to remove pool %q: %w", p.poolName, err))`
`576`	`573`	`}`
`577`	`574`
`578`		`- return result.ErrorOrNil()`
	`575`	`+ return errors.Join(result...)`
`579`	`576`	`}`
`580`	`577`
`581`	`578`	`// MarkDeviceState changes the device's state in metastore`