libpod: switch to golang native error wrapping

We now use the golang error wrapping format specifier `%w` instead of
the deprecated github.com/pkg/errors package.

[NO NEW TESTS NEEDED]

Signed-off-by: Sascha Grunert <sgrunert@redhat.com>

4 files changed, 45 insertions, 44 deletions

diff --git a/libpod/lock/file/file_lock.go b/libpod/lock/file/file_lock.go
index 145aa6e26..1379e690a 100644
--- a/libpod/lock/file/file_lock.go
+++ b/libpod/lock/file/file_lock.go
@@ -1,6 +1,7 @@
 package file
 
 import (
+	"fmt"
 	"io/ioutil"
 	"os"
 	"path/filepath"
@@ -8,7 +9,6 @@ import (
 	"syscall"
 
 	"github.com/containers/storage"
-	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 )
 
@@ -23,7 +23,7 @@ type FileLocks struct { //nolint:revive // struct name stutters
 func CreateFileLock(path string) (*FileLocks, error) {
 	_, err := os.Stat(path)
 	if err == nil {
-		return nil, errors.Wrapf(syscall.EEXIST, "directory %s exists", path)
+		return nil, fmt.Errorf("directory %s exists: %w", path, syscall.EEXIST)
 	}
 	if err := os.MkdirAll(path, 0711); err != nil {
 		return nil, err
@@ -57,11 +57,11 @@ func OpenFileLock(path string) (*FileLocks, error) {
 // Close() is only intended to be used while testing the locks.
 func (locks *FileLocks) Close() error {
 	if !locks.valid {
-		return errors.Wrapf(syscall.EINVAL, "locks have already been closed")
+		return fmt.Errorf("locks have already been closed: %w", syscall.EINVAL)
 	}
 	err := os.RemoveAll(locks.lockPath)
 	if err != nil {
-		return errors.Wrapf(err, "deleting directory %s", locks.lockPath)
+		return fmt.Errorf("deleting directory %s: %w", locks.lockPath, err)
 	}
 	return nil
 }
@@ -73,7 +73,7 @@ func (locks *FileLocks) getLockPath(lck uint32) string {
 // AllocateLock allocates a lock and returns the index of the lock that was allocated.
 func (locks *FileLocks) AllocateLock() (uint32, error) {
 	if !locks.valid {
-		return 0, errors.Wrapf(syscall.EINVAL, "locks have already been closed")
+		return 0, fmt.Errorf("locks have already been closed: %w", syscall.EINVAL)
 	}
 
 	id := uint32(0)
@@ -84,7 +84,7 @@ func (locks *FileLocks) AllocateLock() (uint32, error) {
 			if os.IsExist(err) {
 				continue
 			}
-			return 0, errors.Wrap(err, "creating lock file")
+			return 0, fmt.Errorf("creating lock file: %w", err)
 		}
 		f.Close()
 		break
@@ -98,12 +98,12 @@ func (locks *FileLocks) AllocateLock() (uint32, error) {
 // returned.
 func (locks *FileLocks) AllocateGivenLock(lck uint32) error {
 	if !locks.valid {
-		return errors.Wrapf(syscall.EINVAL, "locks have already been closed")
+		return fmt.Errorf("locks have already been closed: %w", syscall.EINVAL)
 	}
 
 	f, err := os.OpenFile(locks.getLockPath(lck), os.O_RDWR|os.O_CREATE|os.O_EXCL, 0666)
 	if err != nil {
-		return errors.Wrapf(err, "error creating lock %d", lck)
+		return fmt.Errorf("error creating lock %d: %w", lck, err)
 	}
 	f.Close()
 
@@ -115,10 +115,10 @@ func (locks *FileLocks) AllocateGivenLock(lck uint32) error {
 // The given lock must be already allocated, or an error will be returned.
 func (locks *FileLocks) DeallocateLock(lck uint32) error {
 	if !locks.valid {
-		return errors.Wrapf(syscall.EINVAL, "locks have already been closed")
+		return fmt.Errorf("locks have already been closed: %w", syscall.EINVAL)
 	}
 	if err := os.Remove(locks.getLockPath(lck)); err != nil {
-		return errors.Wrapf(err, "deallocating lock %d", lck)
+		return fmt.Errorf("deallocating lock %d: %w", lck, err)
 	}
 	return nil
 }
@@ -127,11 +127,11 @@ func (locks *FileLocks) DeallocateLock(lck uint32) error {
 // other containers and pods.
 func (locks *FileLocks) DeallocateAllLocks() error {
 	if !locks.valid {
-		return errors.Wrapf(syscall.EINVAL, "locks have already been closed")
+		return fmt.Errorf("locks have already been closed: %w", syscall.EINVAL)
 	}
 	files, err := ioutil.ReadDir(locks.lockPath)
 	if err != nil {
-		return errors.Wrapf(err, "error reading directory %s", locks.lockPath)
+		return fmt.Errorf("error reading directory %s: %w", locks.lockPath, err)
 	}
 	var lastErr error
 	for _, f := range files {
@@ -148,12 +148,12 @@ func (locks *FileLocks) DeallocateAllLocks() error {
 // LockFileLock locks the given lock.
 func (locks *FileLocks) LockFileLock(lck uint32) error {
 	if !locks.valid {
-		return errors.Wrapf(syscall.EINVAL, "locks have already been closed")
+		return fmt.Errorf("locks have already been closed: %w", syscall.EINVAL)
 	}
 
 	l, err := storage.GetLockfile(locks.getLockPath(lck))
 	if err != nil {
-		return errors.Wrapf(err, "error acquiring lock")
+		return fmt.Errorf("error acquiring lock: %w", err)
 	}
 
 	l.Lock()
@@ -163,11 +163,11 @@ func (locks *FileLocks) LockFileLock(lck uint32) error {
 // UnlockFileLock unlocks the given lock.
 func (locks *FileLocks) UnlockFileLock(lck uint32) error {
 	if !locks.valid {
-		return errors.Wrapf(syscall.EINVAL, "locks have already been closed")
+		return fmt.Errorf("locks have already been closed: %w", syscall.EINVAL)
 	}
 	l, err := storage.GetLockfile(locks.getLockPath(lck))
 	if err != nil {
-		return errors.Wrapf(err, "error acquiring lock")
+		return fmt.Errorf("error acquiring lock: %w", err)
 	}
 
 	l.Unlock()
diff --git a/libpod/lock/in_memory_locks.go b/libpod/lock/in_memory_locks.go
index f7f47760c..f00f01032 100644
--- a/libpod/lock/in_memory_locks.go
+++ b/libpod/lock/in_memory_locks.go
@@ -1,9 +1,9 @@
 package lock
 
 import (
+	"errors"
+	"fmt"
 	"sync"
-
-	"github.com/pkg/errors"
 )
 
 // Mutex holds a single mutex and whether it has been allocated.
@@ -49,7 +49,7 @@ type InMemoryManager struct {
 // of locks.
 func NewInMemoryManager(numLocks uint32) (Manager, error) {
 	if numLocks == 0 {
-		return nil, errors.Errorf("must provide a non-zero number of locks")
+		return nil, errors.New("must provide a non-zero number of locks")
 	}
 
 	manager := new(InMemoryManager)
@@ -78,13 +78,13 @@ func (m *InMemoryManager) AllocateLock() (Locker, error) {
 		}
 	}
 
-	return nil, errors.Errorf("all locks have been allocated")
+	return nil, errors.New("all locks have been allocated")
 }
 
 // RetrieveLock retrieves a lock from the manager.
 func (m *InMemoryManager) RetrieveLock(id uint32) (Locker, error) {
 	if id >= m.numLocks {
-		return nil, errors.Errorf("given lock ID %d is too large - this manager only supports lock indexes up to %d", id, m.numLocks-1)
+		return nil, fmt.Errorf("given lock ID %d is too large - this manager only supports lock indexes up to %d", id, m.numLocks-1)
 	}
 
 	return m.locks[id], nil
@@ -94,11 +94,11 @@ func (m *InMemoryManager) RetrieveLock(id uint32) (Locker, error) {
 // use) and returns it.
 func (m *InMemoryManager) AllocateAndRetrieveLock(id uint32) (Locker, error) {
 	if id >= m.numLocks {
-		return nil, errors.Errorf("given lock ID %d is too large - this manager only supports lock indexes up to %d", id, m.numLocks)
+		return nil, fmt.Errorf("given lock ID %d is too large - this manager only supports lock indexes up to %d", id, m.numLocks)
 	}
 
 	if m.locks[id].allocated {
-		return nil, errors.Errorf("given lock ID %d is already in use, cannot reallocate", id)
+		return nil, fmt.Errorf("given lock ID %d is already in use, cannot reallocate", id)
 	}
 
 	m.locks[id].allocated = true
diff --git a/libpod/lock/shm/shm_lock.go b/libpod/lock/shm/shm_lock.go
index 6eaf37e48..3334a4018 100644
--- a/libpod/lock/shm/shm_lock.go
+++ b/libpod/lock/shm/shm_lock.go
@@ -11,11 +11,12 @@ package shm
 import "C"
 
 import (
+	"errors"
+	"fmt"
 	"runtime"
 	"syscall"
 	"unsafe"
 
-	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 )
 
@@ -40,7 +41,7 @@ type SHMLocks struct {
 // size used by the underlying implementation.
 func CreateSHMLock(path string, numLocks uint32) (*SHMLocks, error) {
 	if numLocks == 0 {
-		return nil, errors.Wrapf(syscall.EINVAL, "number of locks must be greater than 0")
+		return nil, fmt.Errorf("number of locks must be greater than 0: %w", syscall.EINVAL)
 	}
 
 	locks := new(SHMLocks)
@@ -52,7 +53,7 @@ func CreateSHMLock(path string, numLocks uint32) (*SHMLocks, error) {
 	lockStruct := C.setup_lock_shm(cPath, C.uint32_t(numLocks), &errCode)
 	if lockStruct == nil {
 		// We got a null pointer, so something errored
-		return nil, errors.Wrapf(syscall.Errno(-1*errCode), "failed to create %d locks in %s", numLocks, path)
+		return nil, fmt.Errorf("failed to create %d locks in %s: %w", numLocks, path, syscall.Errno(-1*errCode))
 	}
 
 	locks.lockStruct = lockStruct
@@ -69,7 +70,7 @@ func CreateSHMLock(path string, numLocks uint32) (*SHMLocks, error) {
 // segment was created with.
 func OpenSHMLock(path string, numLocks uint32) (*SHMLocks, error) {
 	if numLocks == 0 {
-		return nil, errors.Wrapf(syscall.EINVAL, "number of locks must be greater than 0")
+		return nil, fmt.Errorf("number of locks must be greater than 0: %w", syscall.EINVAL)
 	}
 
 	locks := new(SHMLocks)
@@ -81,7 +82,7 @@ func OpenSHMLock(path string, numLocks uint32) (*SHMLocks, error) {
 	lockStruct := C.open_lock_shm(cPath, C.uint32_t(numLocks), &errCode)
 	if lockStruct == nil {
 		// We got a null pointer, so something errored
-		return nil, errors.Wrapf(syscall.Errno(-1*errCode), "failed to open %d locks in %s", numLocks, path)
+		return nil, fmt.Errorf("failed to open %d locks in %s: %w", numLocks, path, syscall.Errno(-1*errCode))
 	}
 
 	locks.lockStruct = lockStruct
@@ -103,7 +104,7 @@ func (locks *SHMLocks) GetMaxLocks() uint32 {
 // Close() is only intended to be used while testing the locks.
 func (locks *SHMLocks) Close() error {
 	if !locks.valid {
-		return errors.Wrapf(syscall.EINVAL, "locks have already been closed")
+		return fmt.Errorf("locks have already been closed: %w", syscall.EINVAL)
 	}
 
 	locks.valid = false
@@ -124,7 +125,7 @@ func (locks *SHMLocks) Close() error {
 // created will result in an error, and no semaphore will be allocated.
 func (locks *SHMLocks) AllocateSemaphore() (uint32, error) {
 	if !locks.valid {
-		return 0, errors.Wrapf(syscall.EINVAL, "locks have already been closed")
+		return 0, fmt.Errorf("locks have already been closed: %w", syscall.EINVAL)
 	}
 
 	// This returns a U64, so we have the full u32 range available for
@@ -138,7 +139,7 @@ func (locks *SHMLocks) AllocateSemaphore() (uint32, error) {
 			// that there's no room in the SHM inn for this lock, this tends to send normal people
 			// down the path of checking disk-space which is not actually their problem.
 			// Give a clue that it's actually due to num_locks filling up.
-			var errFull = errors.Errorf("allocation failed; exceeded num_locks (%d)", locks.maxLocks)
+			var errFull = fmt.Errorf("allocation failed; exceeded num_locks (%d)", locks.maxLocks)
 			return uint32(retCode), errFull
 		}
 		return uint32(retCode), syscall.Errno(-1 * retCode)
@@ -153,7 +154,7 @@ func (locks *SHMLocks) AllocateSemaphore() (uint32, error) {
 // returned.
 func (locks *SHMLocks) AllocateGivenSemaphore(sem uint32) error {
 	if !locks.valid {
-		return errors.Wrapf(syscall.EINVAL, "locks have already been closed")
+		return fmt.Errorf("locks have already been closed: %w", syscall.EINVAL)
 	}
 
 	retCode := C.allocate_given_semaphore(locks.lockStruct, C.uint32_t(sem))
@@ -169,11 +170,11 @@ func (locks *SHMLocks) AllocateGivenSemaphore(sem uint32) error {
 // The given semaphore must be already allocated, or an error will be returned.
 func (locks *SHMLocks) DeallocateSemaphore(sem uint32) error {
 	if !locks.valid {
-		return errors.Wrapf(syscall.EINVAL, "locks have already been closed")
+		return fmt.Errorf("locks have already been closed: %w", syscall.EINVAL)
 	}
 
 	if sem > locks.maxLocks {
-		return errors.Wrapf(syscall.EINVAL, "given semaphore %d is higher than maximum locks count %d", sem, locks.maxLocks)
+		return fmt.Errorf("given semaphore %d is higher than maximum locks count %d: %w", sem, locks.maxLocks, syscall.EINVAL)
 	}
 
 	retCode := C.deallocate_semaphore(locks.lockStruct, C.uint32_t(sem))
@@ -189,7 +190,7 @@ func (locks *SHMLocks) DeallocateSemaphore(sem uint32) error {
 // other containers and pods.
 func (locks *SHMLocks) DeallocateAllSemaphores() error {
 	if !locks.valid {
-		return errors.Wrapf(syscall.EINVAL, "locks have already been closed")
+		return fmt.Errorf("locks have already been closed: %w", syscall.EINVAL)
 	}
 
 	retCode := C.deallocate_all_semaphores(locks.lockStruct)
@@ -210,11 +211,11 @@ func (locks *SHMLocks) DeallocateAllSemaphores() error {
 // succeed.
 func (locks *SHMLocks) LockSemaphore(sem uint32) error {
 	if !locks.valid {
-		return errors.Wrapf(syscall.EINVAL, "locks have already been closed")
+		return fmt.Errorf("locks have already been closed: %w", syscall.EINVAL)
 	}
 
 	if sem > locks.maxLocks {
-		return errors.Wrapf(syscall.EINVAL, "given semaphore %d is higher than maximum locks count %d", sem, locks.maxLocks)
+		return fmt.Errorf("given semaphore %d is higher than maximum locks count %d: %w", sem, locks.maxLocks, syscall.EINVAL)
 	}
 
 	// For pthread mutexes, we have to guarantee lock and unlock happen in
@@ -238,11 +239,11 @@ func (locks *SHMLocks) LockSemaphore(sem uint32) error {
 // succeed.
 func (locks *SHMLocks) UnlockSemaphore(sem uint32) error {
 	if !locks.valid {
-		return errors.Wrapf(syscall.EINVAL, "locks have already been closed")
+		return fmt.Errorf("locks have already been closed: %w", syscall.EINVAL)
 	}
 
 	if sem > locks.maxLocks {
-		return errors.Wrapf(syscall.EINVAL, "given semaphore %d is higher than maximum locks count %d", sem, locks.maxLocks)
+		return fmt.Errorf("given semaphore %d is higher than maximum locks count %d: %w", sem, locks.maxLocks, syscall.EINVAL)
 	}
 
 	retCode := C.unlock_semaphore(locks.lockStruct, C.uint32_t(sem))
diff --git a/libpod/lock/shm_lock_manager_linux.go b/libpod/lock/shm_lock_manager_linux.go
index 3076cd864..fa20bc353 100644
--- a/libpod/lock/shm_lock_manager_linux.go
+++ b/libpod/lock/shm_lock_manager_linux.go
@@ -4,10 +4,10 @@
 package lock
 
 import (
+	"fmt"
 	"syscall"
 
 	"github.com/containers/podman/v4/libpod/lock/shm"
-	"github.com/pkg/errors"
 )
 
 // SHMLockManager manages shared memory locks.
@@ -66,8 +66,8 @@ func (m *SHMLockManager) AllocateAndRetrieveLock(id uint32) (Locker, error) {
 	lock.manager = m
 
 	if id >= m.locks.GetMaxLocks() {
-		return nil, errors.Wrapf(syscall.EINVAL, "lock ID %d is too large - max lock size is %d",
-			id, m.locks.GetMaxLocks()-1)
+		return nil, fmt.Errorf("lock ID %d is too large - max lock size is %d: %w",
+			id, m.locks.GetMaxLocks()-1, syscall.EINVAL)
 	}
 
 	if err := m.locks.AllocateGivenSemaphore(id); err != nil {
@@ -84,8 +84,8 @@ func (m *SHMLockManager) RetrieveLock(id uint32) (Locker, error) {
 	lock.manager = m
 
 	if id >= m.locks.GetMaxLocks() {
-		return nil, errors.Wrapf(syscall.EINVAL, "lock ID %d is too large - max lock size is %d",
-			id, m.locks.GetMaxLocks()-1)
+		return nil, fmt.Errorf("lock ID %d is too large - max lock size is %d: %w",
+			id, m.locks.GetMaxLocks()-1, syscall.EINVAL)
 	}
 
 	return lock, nil