vendor: update buildkit to 2f99651

Signed-off-by: CrazyMax <crazy-max@users.noreply.github.com>

vendor/github.com/containerd/containerd/content/helpers.go

@@ -18,6 +18,8 @@ package content
 
 import (
 	"context"
+	"errors"
+	"fmt"
 	"io"
 	"math/rand"
 	"sync"
@@ -26,7 +28,6 @@ import (
 	"github.com/containerd/containerd/errdefs"
 	"github.com/opencontainers/go-digest"
 	ocispec "github.com/opencontainers/image-spec/specs-go/v1"
-	"github.com/pkg/errors"
 )
 
 var bufPool = sync.Pool{
@@ -76,7 +77,7 @@ func WriteBlob(ctx context.Context, cs Ingester, ref string, r io.Reader, desc o
 	cw, err := OpenWriter(ctx, cs, WithRef(ref), WithDescriptor(desc))
 	if err != nil {
 		if !errdefs.IsAlreadyExists(err) {
-			return errors.Wrap(err, "failed to open writer")
+			return fmt.Errorf("failed to open writer: %w", err)
 		}
 
 		return nil // all ready present
@@ -133,28 +134,28 @@ func OpenWriter(ctx context.Context, cs Ingester, opts ...WriterOpt) (Writer, er
 func Copy(ctx context.Context, cw Writer, r io.Reader, size int64, expected digest.Digest, opts ...Opt) error {
 	ws, err := cw.Status()
 	if err != nil {
-		return errors.Wrap(err, "failed to get status")
+		return fmt.Errorf("failed to get status: %w", err)
 	}
 
 	if ws.Offset > 0 {
 		r, err = seekReader(r, ws.Offset, size)
 		if err != nil {
-			return errors.Wrapf(err, "unable to resume write to %v", ws.Ref)
+			return fmt.Errorf("unable to resume write to %v: %w", ws.Ref, err)
 		}
 	}
 
 	copied, err := copyWithBuffer(cw, r)
 	if err != nil {
-		return errors.Wrap(err, "failed to copy")
+		return fmt.Errorf("failed to copy: %w", err)
 	}
 	if size != 0 && copied < size-ws.Offset {
 		// Short writes would return its own error, this indicates a read failure
-		return errors.Wrapf(io.ErrUnexpectedEOF, "failed to read expected number of bytes")
+		return fmt.Errorf("failed to read expected number of bytes: %w", io.ErrUnexpectedEOF)
 	}
 
 	if err := cw.Commit(ctx, size, expected, opts...); err != nil {
 		if !errdefs.IsAlreadyExists(err) {
-			return errors.Wrapf(err, "failed commit on ref %q", ws.Ref)
+			return fmt.Errorf("failed commit on ref %q: %w", ws.Ref, err)
 		}
 	}
 
@@ -171,11 +172,11 @@ func CopyReaderAt(cw Writer, ra ReaderAt, n int64) error {
 
 	copied, err := copyWithBuffer(cw, io.NewSectionReader(ra, ws.Offset, n))
 	if err != nil {
-		return errors.Wrap(err, "failed to copy")
+		return fmt.Errorf("failed to copy: %w", err)
 	}
 	if copied < n {
 		// Short writes would return its own error, this indicates a read failure
-		return errors.Wrap(io.ErrUnexpectedEOF, "failed to read expected number of bytes")
+		return fmt.Errorf("failed to read expected number of bytes: %w", io.ErrUnexpectedEOF)
 	}
 	return nil
 }
@@ -189,13 +190,13 @@ func CopyReaderAt(cw Writer, ra ReaderAt, n int64) error {
 func CopyReader(cw Writer, r io.Reader) (int64, error) {
 	ws, err := cw.Status()
 	if err != nil {
-		return 0, errors.Wrap(err, "failed to get status")
+		return 0, fmt.Errorf("failed to get status: %w", err)
 	}
 
 	if ws.Offset > 0 {
 		r, err = seekReader(r, ws.Offset, 0)
 		if err != nil {
-			return 0, errors.Wrapf(err, "unable to resume write to %v", ws.Ref)
+			return 0, fmt.Errorf("unable to resume write to %v: %w", ws.Ref, err)
 		}
 	}
 
@@ -211,7 +212,10 @@ func seekReader(r io.Reader, offset, size int64) (io.Reader, error) {
 	if ok {
 		nn, err := seeker.Seek(offset, io.SeekStart)
 		if nn != offset {
-			return nil, errors.Wrapf(err, "failed to seek to offset %v", offset)
+			if err == nil {
+				err = fmt.Errorf("unexpected seek location without seek error")
+			}
+			return nil, fmt.Errorf("failed to seek to offset %v: %w", offset, err)
 		}
 
 		if err != nil {
@@ -231,10 +235,10 @@ func seekReader(r io.Reader, offset, size int64) (io.Reader, error) {
 	// well then, let's just discard up to the offset
 	n, err := copyWithBuffer(io.Discard, io.LimitReader(r, offset))
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to discard to offset")
+		return nil, fmt.Errorf("failed to discard to offset: %w", err)
 	}
 	if n != offset {
-		return nil, errors.Errorf("unable to discard to offset")
+		return nil, errors.New("unable to discard to offset")
 	}
 
 	return r, nil

vendor/github.com/containerd/containerd/content/local/locks.go

@@ -17,11 +17,11 @@
 package local
 
 import (
+	"fmt"
 	"sync"
 	"time"
 
 	"github.com/containerd/containerd/errdefs"
-	"github.com/pkg/errors"
 )
 
 // Handles locking references
@@ -44,9 +44,9 @@ func tryLock(ref string) error {
 		// Returning the duration may help developers distinguish dead locks (long duration) from
 		// lock contentions (short duration).
 		now := time.Now()
-		return errors.Wrapf(
+		return fmt.Errorf(
+			"ref %s locked for %s (since %s): %w", ref, now.Sub(v.since), v.since,
 			errdefs.ErrUnavailable,
-			"ref %s locked for %s (since %s)", ref, now.Sub(v.since), v.since,
 		)
 	}
 

vendor/github.com/containerd/containerd/content/local/readerat.go

@@ -17,10 +17,9 @@
 package local
 
 import (
+	"fmt"
 	"os"
 
-	"github.com/pkg/errors"
-
 	"github.com/containerd/containerd/content"
 	"github.com/containerd/containerd/errdefs"
 )
@@ -40,7 +39,7 @@ func OpenReader(p string) (content.ReaderAt, error) {
 			return nil, err
 		}
 
-		return nil, errors.Wrap(errdefs.ErrNotFound, "blob not found")
+		return nil, fmt.Errorf("blob not found: %w", errdefs.ErrNotFound)
 	}
 
 	fp, err := os.Open(p)
@@ -49,7 +48,7 @@ func OpenReader(p string) (content.ReaderAt, error) {
 			return nil, err
 		}
 
-		return nil, errors.Wrap(errdefs.ErrNotFound, "blob not found")
+		return nil, fmt.Errorf("blob not found: %w", errdefs.ErrNotFound)
 	}
 
 	return sizeReaderAt{size: fi.Size(), fp: fp}, nil

vendor/github.com/containerd/containerd/content/local/store.go

@@ -36,7 +36,6 @@ import (
 
 	digest "github.com/opencontainers/go-digest"
 	ocispec "github.com/opencontainers/image-spec/specs-go/v1"
-	"github.com/pkg/errors"
 )
 
 var bufPool = sync.Pool{
@@ -93,13 +92,13 @@ func NewLabeledStore(root string, ls LabelStore) (content.Store, error) {
 func (s *store) Info(ctx context.Context, dgst digest.Digest) (content.Info, error) {
 	p, err := s.blobPath(dgst)
 	if err != nil {
-		return content.Info{}, errors.Wrapf(err, "calculating blob info path")
+		return content.Info{}, fmt.Errorf("calculating blob info path: %w", err)
 	}
 
 	fi, err := os.Stat(p)
 	if err != nil {
 		if os.IsNotExist(err) {
-			err = errors.Wrapf(errdefs.ErrNotFound, "content %v", dgst)
+			err = fmt.Errorf("content %v: %w", dgst, errdefs.ErrNotFound)
 		}
 
 		return content.Info{}, err
@@ -128,12 +127,12 @@ func (s *store) info(dgst digest.Digest, fi os.FileInfo, labels map[string]strin
 func (s *store) ReaderAt(ctx context.Context, desc ocispec.Descriptor) (content.ReaderAt, error) {
 	p, err := s.blobPath(desc.Digest)
 	if err != nil {
-		return nil, errors.Wrapf(err, "calculating blob path for ReaderAt")
+		return nil, fmt.Errorf("calculating blob path for ReaderAt: %w", err)
 	}
 
 	reader, err := OpenReader(p)
 	if err != nil {
-		return nil, errors.Wrapf(err, "blob %s expected at %s", desc.Digest, p)
+		return nil, fmt.Errorf("blob %s expected at %s: %w", desc.Digest, p, err)
 	}
 
 	return reader, nil
@@ -146,7 +145,7 @@ func (s *store) ReaderAt(ctx context.Context, desc ocispec.Descriptor) (content.
 func (s *store) Delete(ctx context.Context, dgst digest.Digest) error {
 	bp, err := s.blobPath(dgst)
 	if err != nil {
-		return errors.Wrapf(err, "calculating blob path for delete")
+		return fmt.Errorf("calculating blob path for delete: %w", err)
 	}
 
 	if err := os.RemoveAll(bp); err != nil {
@@ -154,7 +153,7 @@ func (s *store) Delete(ctx context.Context, dgst digest.Digest) error {
 			return err
 		}
 
-		return errors.Wrapf(errdefs.ErrNotFound, "content %v", dgst)
+		return fmt.Errorf("content %v: %w", dgst, errdefs.ErrNotFound)
 	}
 
 	return nil
@@ -162,18 +161,18 @@ func (s *store) Delete(ctx context.Context, dgst digest.Digest) error {
 
 func (s *store) Update(ctx context.Context, info content.Info, fieldpaths ...string) (content.Info, error) {
 	if s.ls == nil {
-		return content.Info{}, errors.Wrapf(errdefs.ErrFailedPrecondition, "update not supported on immutable content store")
+		return content.Info{}, fmt.Errorf("update not supported on immutable content store: %w", errdefs.ErrFailedPrecondition)
 	}
 
 	p, err := s.blobPath(info.Digest)
 	if err != nil {
-		return content.Info{}, errors.Wrapf(err, "calculating blob path for update")
+		return content.Info{}, fmt.Errorf("calculating blob path for update: %w", err)
 	}
 
 	fi, err := os.Stat(p)
 	if err != nil {
 		if os.IsNotExist(err) {
-			err = errors.Wrapf(errdefs.ErrNotFound, "content %v", info.Digest)
+			err = fmt.Errorf("content %v: %w", info.Digest, errdefs.ErrNotFound)
 		}
 
 		return content.Info{}, err
@@ -200,7 +199,7 @@ func (s *store) Update(ctx context.Context, info content.Info, fieldpaths ...str
 				all = true
 				labels = info.Labels
 			default:
-				return content.Info{}, errors.Wrapf(errdefs.ErrInvalidArgument, "cannot update %q field on content info %q", path, info.Digest)
+				return content.Info{}, fmt.Errorf("cannot update %q field on content info %q: %w", path, info.Digest, errdefs.ErrInvalidArgument)
 			}
 		}
 	} else {
@@ -377,7 +376,7 @@ func (s *store) status(ingestPath string) (content.Status, error) {
 	fi, err := os.Stat(dp)
 	if err != nil {
 		if os.IsNotExist(err) {
-			err = errors.Wrap(errdefs.ErrNotFound, err.Error())
+			err = fmt.Errorf("%s: %w", err.Error(), errdefs.ErrNotFound)
 		}
 		return content.Status{}, err
 	}
@@ -385,19 +384,19 @@ func (s *store) status(ingestPath string) (content.Status, error) {
 	ref, err := readFileString(filepath.Join(ingestPath, "ref"))
 	if err != nil {
 		if os.IsNotExist(err) {
-			err = errors.Wrap(errdefs.ErrNotFound, err.Error())
+			err = fmt.Errorf("%s: %w", err.Error(), errdefs.ErrNotFound)
 		}
 		return content.Status{}, err
 	}
 
 	startedAt, err := readFileTimestamp(filepath.Join(ingestPath, "startedat"))
 	if err != nil {
-		return content.Status{}, errors.Wrapf(err, "could not read startedat")
+		return content.Status{}, fmt.Errorf("could not read startedat: %w", err)
 	}
 
 	updatedAt, err := readFileTimestamp(filepath.Join(ingestPath, "updatedat"))
 	if err != nil {
-		return content.Status{}, errors.Wrapf(err, "could not read updatedat")
+		return content.Status{}, fmt.Errorf("could not read updatedat: %w", err)
 	}
 
 	// because we don't write updatedat on every write, the mod time may
@@ -460,7 +459,7 @@ func (s *store) Writer(ctx context.Context, opts ...content.WriterOpt) (content.
 	// TODO(AkihiroSuda): we could create a random string or one calculated based on the context
 	// https://github.com/containerd/containerd/issues/2129#issuecomment-380255019
 	if wOpts.Ref == "" {
-		return nil, errors.Wrap(errdefs.ErrInvalidArgument, "ref must not be empty")
+		return nil, fmt.Errorf("ref must not be empty: %w", errdefs.ErrInvalidArgument)
 	}
 	var lockErr error
 	for count := uint64(0); count < 10; count++ {
@@ -494,16 +493,16 @@ func (s *store) resumeStatus(ref string, total int64, digester digest.Digester)
 	path, _, data := s.ingestPaths(ref)
 	status, err := s.status(path)
 	if err != nil {
-		return status, errors.Wrap(err, "failed reading status of resume write")
+		return status, fmt.Errorf("failed reading status of resume write: %w", err)
 	}
 	if ref != status.Ref {
 		// NOTE(stevvooe): This is fairly catastrophic. Either we have some
 		// layout corruption or a hash collision for the ref key.
-		return status, errors.Errorf("ref key does not match: %v != %v", ref, status.Ref)
+		return status, fmt.Errorf("ref key does not match: %v != %v", ref, status.Ref)
 	}
 
 	if total > 0 && status.Total > 0 && total != status.Total {
-		return status, errors.Errorf("provided total differs from status: %v != %v", total, status.Total)
+		return status, fmt.Errorf("provided total differs from status: %v != %v", total, status.Total)
 	}
 
 	// TODO(stevvooe): slow slow slow!!, send to goroutine or use resumable hashes
@@ -527,10 +526,10 @@ func (s *store) writer(ctx context.Context, ref string, total int64, expected di
 	if expected != "" {
 		p, err := s.blobPath(expected)
 		if err != nil {
-			return nil, errors.Wrap(err, "calculating expected blob path for writer")
+			return nil, fmt.Errorf("calculating expected blob path for writer: %w", err)
 		}
 		if _, err := os.Stat(p); err == nil {
-			return nil, errors.Wrapf(errdefs.ErrAlreadyExists, "content %v", expected)
+			return nil, fmt.Errorf("content %v: %w", expected, errdefs.ErrAlreadyExists)
 		}
 	}
 
@@ -588,11 +587,12 @@ func (s *store) writer(ctx context.Context, ref string, total int64, expected di
 
 	fp, err := os.OpenFile(data, os.O_WRONLY|os.O_CREATE, 0666)
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to open data file")
+		return nil, fmt.Errorf("failed to open data file: %w", err)
 	}
 
 	if _, err := fp.Seek(offset, io.SeekStart); err != nil {
-		return nil, errors.Wrap(err, "could not seek to current write offset")
+		fp.Close()
+		return nil, fmt.Errorf("could not seek to current write offset: %w", err)
 	}
 
 	return &writer{
@@ -614,7 +614,7 @@ func (s *store) Abort(ctx context.Context, ref string) error {
 	root := s.ingestRoot(ref)
 	if err := os.RemoveAll(root); err != nil {
 		if os.IsNotExist(err) {
-			return errors.Wrapf(errdefs.ErrNotFound, "ingest ref %q", ref)
+			return fmt.Errorf("ingest ref %q: %w", ref, errdefs.ErrNotFound)
 		}
 
 		return err
@@ -625,7 +625,7 @@ func (s *store) Abort(ctx context.Context, ref string) error {
 
 func (s *store) blobPath(dgst digest.Digest) (string, error) {
 	if err := dgst.Validate(); err != nil {
-		return "", errors.Wrapf(errdefs.ErrInvalidArgument, "cannot calculate blob path from invalid digest: %v", err)
+		return "", fmt.Errorf("cannot calculate blob path from invalid digest: %v: %w", err, errdefs.ErrInvalidArgument)
 	}
 
 	return filepath.Join(s.root, "blobs", dgst.Algorithm().String(), dgst.Hex()), nil
@@ -664,14 +664,14 @@ func readFileTimestamp(p string) (time.Time, error) {
 	b, err := os.ReadFile(p)
 	if err != nil {
 		if os.IsNotExist(err) {
-			err = errors.Wrap(errdefs.ErrNotFound, err.Error())
+			err = fmt.Errorf("%s: %w", err.Error(), errdefs.ErrNotFound)
 		}
 		return time.Time{}, err
 	}
 
 	var t time.Time
 	if err := t.UnmarshalText(b); err != nil {
-		return time.Time{}, errors.Wrapf(err, "could not parse timestamp file %v", p)
+		return time.Time{}, fmt.Errorf("could not parse timestamp file %v: %w", p, err)
 	}
 
 	return t, nil
@@ -689,16 +689,16 @@ func writeToCompletion(path string, data []byte, mode os.FileMode) error {
 	tmp := fmt.Sprintf("%s.tmp", path)
 	f, err := os.OpenFile(tmp, os.O_RDWR|os.O_CREATE|os.O_TRUNC|os.O_SYNC, mode)
 	if err != nil {
-		return errors.Wrap(err, "create tmp file")
+		return fmt.Errorf("create tmp file: %w", err)
 	}
 	_, err = f.Write(data)
 	f.Close()
 	if err != nil {
-		return errors.Wrap(err, "write tmp file")
+		return fmt.Errorf("write tmp file: %w", err)
 	}
 	err = os.Rename(tmp, path)
 	if err != nil {
-		return errors.Wrap(err, "rename tmp file")
+		return fmt.Errorf("rename tmp file: %w", err)
 	}
 	return nil
 }

vendor/github.com/containerd/containerd/content/local/store_bsd.go

@@ -27,7 +27,7 @@ import (
 
 func getATime(fi os.FileInfo) time.Time {
 	if st, ok := fi.Sys().(*syscall.Stat_t); ok {
-		return time.Unix(int64(st.Atimespec.Sec), int64(st.Atimespec.Nsec)) //nolint: unconvert // int64 conversions ensure the line compiles for 32-bit systems as well.
+		return time.Unix(st.Atimespec.Unix())
 	}
 
 	return fi.ModTime()

vendor/github.com/containerd/containerd/content/local/store_openbsd.go

@@ -27,7 +27,7 @@ import (
 
 func getATime(fi os.FileInfo) time.Time {
 	if st, ok := fi.Sys().(*syscall.Stat_t); ok {
-		return time.Unix(int64(st.Atim.Sec), int64(st.Atim.Nsec)) //nolint: unconvert // int64 conversions ensure the line compiles for 32-bit systems as well.
+		return time.Unix(st.Atim.Unix())
 	}
 
 	return fi.ModTime()

vendor/github.com/containerd/containerd/content/local/store_unix.go

@@ -27,7 +27,7 @@ import (
 
 func getATime(fi os.FileInfo) time.Time {
 	if st, ok := fi.Sys().(*syscall.Stat_t); ok {
-		return time.Unix(int64(st.Atim.Sec), int64(st.Atim.Nsec)) //nolint: unconvert // int64 conversions ensure the line compiles for 32-bit systems as well.
+		return time.Unix(st.Atim.Unix())
 	}
 
 	return fi.ModTime()

vendor/github.com/containerd/containerd/content/local/writer.go

@@ -18,6 +18,8 @@ package local
 
 import (
 	"context"
+	"errors"
+	"fmt"
 	"io"
 	"os"
 	"path/filepath"
@@ -28,7 +30,6 @@ import (
 	"github.com/containerd/containerd/errdefs"
 	"github.com/containerd/containerd/log"
 	"github.com/opencontainers/go-digest"
-	"github.com/pkg/errors"
 )
 
 // writer represents a write transaction against the blob store.
@@ -88,30 +89,30 @@ func (w *writer) Commit(ctx context.Context, size int64, expected digest.Digest,
 	w.fp = nil
 
 	if fp == nil {
-		return errors.Wrap(errdefs.ErrFailedPrecondition, "cannot commit on closed writer")
+		return fmt.Errorf("cannot commit on closed writer: %w", errdefs.ErrFailedPrecondition)
 	}
 
 	if err := fp.Sync(); err != nil {
 		fp.Close()
-		return errors.Wrap(err, "sync failed")
+		return fmt.Errorf("sync failed: %w", err)
 	}
 
 	fi, err := fp.Stat()
 	closeErr := fp.Close()
 	if err != nil {
-		return errors.Wrap(err, "stat on ingest file failed")
+		return fmt.Errorf("stat on ingest file failed: %w", err)
 	}
 	if closeErr != nil {
-		return errors.Wrap(err, "failed to close ingest file")
+		return fmt.Errorf("failed to close ingest file: %w", closeErr)
 	}
 
 	if size > 0 && size != fi.Size() {
-		return errors.Wrapf(errdefs.ErrFailedPrecondition, "unexpected commit size %d, expected %d", fi.Size(), size)
+		return fmt.Errorf("unexpected commit size %d, expected %d: %w", fi.Size(), size, errdefs.ErrFailedPrecondition)
 	}
 
 	dgst := w.digester.Digest()
 	if expected != "" && expected != dgst {
-		return errors.Wrapf(errdefs.ErrFailedPrecondition, "unexpected commit digest %s, expected %s", dgst, expected)
+		return fmt.Errorf("unexpected commit digest %s, expected %s: %w", dgst, expected, errdefs.ErrFailedPrecondition)
 	}
 
 	var (
@@ -127,9 +128,9 @@ func (w *writer) Commit(ctx context.Context, size int64, expected digest.Digest,
 	if _, err := os.Stat(target); err == nil {
 		// collision with the target file!
 		if err := os.RemoveAll(w.path); err != nil {
-			log.G(ctx).WithField("ref", w.ref).WithField("path", w.path).Errorf("failed to remove ingest directory")
+			log.G(ctx).WithField("ref", w.ref).WithField("path", w.path).Error("failed to remove ingest directory")
 		}
-		return errors.Wrapf(errdefs.ErrAlreadyExists, "content %v", dgst)
+		return fmt.Errorf("content %v: %w", dgst, errdefs.ErrAlreadyExists)
 	}
 
 	if err := os.Rename(ingest, target); err != nil {
@@ -142,17 +143,17 @@ func (w *writer) Commit(ctx context.Context, size int64, expected digest.Digest,
 
 	commitTime := time.Now()
 	if err := os.Chtimes(target, commitTime, commitTime); err != nil {
-		log.G(ctx).WithField("digest", dgst).Errorf("failed to change file time to commit time")
+		log.G(ctx).WithField("digest", dgst).Error("failed to change file time to commit time")
 	}
 
 	// clean up!!
 	if err := os.RemoveAll(w.path); err != nil {
-		log.G(ctx).WithField("ref", w.ref).WithField("path", w.path).Errorf("failed to remove ingest directory")
+		log.G(ctx).WithField("ref", w.ref).WithField("path", w.path).Error("failed to remove ingest directory")
 	}
 
 	if w.s.ls != nil && base.Labels != nil {
 		if err := w.s.ls.Set(dgst, base.Labels); err != nil {
-			log.G(ctx).WithField("digest", dgst).Errorf("failed to set labels")
+			log.G(ctx).WithField("digest", dgst).Error("failed to set labels")
 		}
 	}
 
@@ -165,7 +166,7 @@ func (w *writer) Commit(ctx context.Context, size int64, expected digest.Digest,
 	// NOTE: Windows does not support this operation
 	if runtime.GOOS != "windows" {
 		if err := os.Chmod(target, (fi.Mode()&os.ModePerm)&^0333); err != nil {
-			log.G(ctx).WithField("ref", w.ref).Errorf("failed to make readonly")
+			log.G(ctx).WithField("ref", w.ref).Error("failed to make readonly")
 		}
 	}
 

vendor/github.com/containerd/containerd/content/proxy/content_writer.go

@@ -18,13 +18,13 @@ package proxy
 
 import (
 	"context"
+	"fmt"
 	"io"
 
 	contentapi "github.com/containerd/containerd/api/services/content/v1"
 	"github.com/containerd/containerd/content"
 	"github.com/containerd/containerd/errdefs"
 	digest "github.com/opencontainers/go-digest"
-	"github.com/pkg/errors"
 )
 
 type remoteWriter struct {
@@ -57,7 +57,7 @@ func (rw *remoteWriter) Status() (content.Status, error) {
 		Action: contentapi.WriteActionStat,
 	})
 	if err != nil {
-		return content.Status{}, errors.Wrap(errdefs.FromGRPC(err), "error getting writer status")
+		return content.Status{}, fmt.Errorf("error getting writer status: %w", errdefs.FromGRPC(err))
 	}
 
 	return content.Status{
@@ -82,7 +82,7 @@ func (rw *remoteWriter) Write(p []byte) (n int, err error) {
 		Data:   p,
 	})
 	if err != nil {
-		return 0, errors.Wrap(errdefs.FromGRPC(err), "failed to send write")
+		return 0, fmt.Errorf("failed to send write: %w", errdefs.FromGRPC(err))
 	}
 
 	n = int(resp.Offset - offset)
@@ -119,15 +119,15 @@ func (rw *remoteWriter) Commit(ctx context.Context, size int64, expected digest.
 		Labels:   base.Labels,
 	})
 	if err != nil {
-		return errors.Wrap(errdefs.FromGRPC(err), "commit failed")
+		return fmt.Errorf("commit failed: %w", errdefs.FromGRPC(err))
 	}
 
 	if size != 0 && resp.Offset != size {
-		return errors.Errorf("unexpected size: %v != %v", resp.Offset, size)
+		return fmt.Errorf("unexpected size: %v != %v", resp.Offset, size)
 	}
 
 	if expected != "" && resp.Digest != expected {
-		return errors.Errorf("unexpected digest: %v != %v", resp.Digest, expected)
+		return fmt.Errorf("unexpected digest: %v != %v", resp.Digest, expected)
 	}
 
 	rw.digest = resp.Digest