Merge pull request #3419 from baude/removelibpodfrommainphase1

remove libpod from main

44 files changed, 655 insertions, 606 deletions

diff --git a/libpod/boltdb_state.go b/libpod/boltdb_state.go
index 12c364993..b047c9fa0 100644
--- a/libpod/boltdb_state.go
+++ b/libpod/boltdb_state.go
@@ -5,6 +5,7 @@ import (
 	"strings"
 	"sync"
 
+	"github.com/containers/libpod/libpod/define"
 	bolt "github.com/etcd-io/bbolt"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
@@ -133,7 +134,7 @@ func (s *BoltState) Close() error {
 // Refresh clears container and pod states after a reboot
 func (s *BoltState) Refresh() error {
 	if !s.valid {
-		return ErrDBClosed
+		return define.ErrDBClosed
 	}
 
 	db, err := s.getDBCon()
@@ -171,13 +172,13 @@ func (s *BoltState) Refresh() error {
 				if podBkt == nil {
 					// This is neither a pod nor a container
 					// Error out on the dangling ID
-					return errors.Wrapf(ErrInternal, "id %s is not a pod or a container", string(id))
+					return errors.Wrapf(define.ErrInternal, "id %s is not a pod or a container", string(id))
 				}
 
 				// Get the state
 				stateBytes := podBkt.Get(stateKey)
 				if stateBytes == nil {
-					return errors.Wrapf(ErrInternal, "pod %s missing state key", string(id))
+					return errors.Wrapf(define.ErrInternal, "pod %s missing state key", string(id))
 				}
 
 				state := new(podState)
@@ -210,7 +211,7 @@ func (s *BoltState) Refresh() error {
 			stateBytes := ctrBkt.Get(stateKey)
 			if stateBytes == nil {
 				// Badly formatted container bucket
-				return errors.Wrapf(ErrInternal, "container %s missing state in DB", string(id))
+				return errors.Wrapf(define.ErrInternal, "container %s missing state in DB", string(id))
 			}
 
 			state := new(ContainerState)
@@ -243,7 +244,7 @@ func (s *BoltState) Refresh() error {
 // the database was first initialized
 func (s *BoltState) GetDBConfig() (*DBConfig, error) {
 	if !s.valid {
-		return nil, ErrDBClosed
+		return nil, define.ErrDBClosed
 	}
 
 	cfg := new(DBConfig)
@@ -290,7 +291,7 @@ func (s *BoltState) GetDBConfig() (*DBConfig, error) {
 // ValidateDBConfig validates paths in the given runtime against the database
 func (s *BoltState) ValidateDBConfig(runtime *Runtime) error {
 	if !s.valid {
-		return ErrDBClosed
+		return define.ErrDBClosed
 	}
 
 	db, err := s.getDBCon()
@@ -324,11 +325,11 @@ func (s *BoltState) SetNamespace(ns string) error {
 // Container retrieves a single container from the state by its full ID
 func (s *BoltState) Container(id string) (*Container, error) {
 	if id == "" {
-		return nil, ErrEmptyID
+		return nil, define.ErrEmptyID
 	}
 
 	if !s.valid {
-		return nil, ErrDBClosed
+		return nil, define.ErrDBClosed
 	}
 
 	ctrID := []byte(id)
@@ -362,11 +363,11 @@ func (s *BoltState) Container(id string) (*Container, error) {
 // partial ID or name
 func (s *BoltState) LookupContainer(idOrName string) (*Container, error) {
 	if idOrName == "" {
-		return nil, ErrEmptyID
+		return nil, define.ErrEmptyID
 	}
 
 	if !s.valid {
-		return nil, ErrDBClosed
+		return nil, define.ErrDBClosed
 	}
 
 	ctr := new(Container)
@@ -446,7 +447,7 @@ func (s *BoltState) LookupContainer(idOrName string) (*Container, error) {
 			}
 			if strings.HasPrefix(string(checkID), idOrName) {
 				if exists {
-					return errors.Wrapf(ErrCtrExists, "more than one result for container ID %s", idOrName)
+					return errors.Wrapf(define.ErrCtrExists, "more than one result for container ID %s", idOrName)
 				}
 				id = checkID
 				exists = true
@@ -458,9 +459,9 @@ func (s *BoltState) LookupContainer(idOrName string) (*Container, error) {
 			return err
 		} else if !exists {
 			if isPod {
-				return errors.Wrapf(ErrNoSuchCtr, "%s is a pod, not a container", idOrName)
+				return errors.Wrapf(define.ErrNoSuchCtr, "%s is a pod, not a container", idOrName)
 			}
-			return errors.Wrapf(ErrNoSuchCtr, "no container with name or ID %s found", idOrName)
+			return errors.Wrapf(define.ErrNoSuchCtr, "no container with name or ID %s found", idOrName)
 		}
 
 		return s.getContainerFromDB(id, ctr, ctrBucket)
@@ -475,11 +476,11 @@ func (s *BoltState) LookupContainer(idOrName string) (*Container, error) {
 // HasContainer checks if a container is present in the state
 func (s *BoltState) HasContainer(id string) (bool, error) {
 	if id == "" {
-		return false, ErrEmptyID
+		return false, define.ErrEmptyID
 	}
 
 	if !s.valid {
-		return false, ErrDBClosed
+		return false, define.ErrDBClosed
 	}
 
 	ctrID := []byte(id)
@@ -523,15 +524,15 @@ func (s *BoltState) HasContainer(id string) (bool, error) {
 // The container being added cannot belong to a pod
 func (s *BoltState) AddContainer(ctr *Container) error {
 	if !s.valid {
-		return ErrDBClosed
+		return define.ErrDBClosed
 	}
 
 	if !ctr.valid {
-		return ErrCtrRemoved
+		return define.ErrCtrRemoved
 	}
 
 	if ctr.config.Pod != "" {
-		return errors.Wrapf(ErrInvalidArg, "cannot add a container that belongs to a pod with AddContainer - use AddContainerToPod")
+		return errors.Wrapf(define.ErrInvalidArg, "cannot add a container that belongs to a pod with AddContainer - use AddContainerToPod")
 	}
 
 	return s.addContainer(ctr, nil)
@@ -542,11 +543,11 @@ func (s *BoltState) AddContainer(ctr *Container) error {
 // pod, use RemoveContainerFromPod
 func (s *BoltState) RemoveContainer(ctr *Container) error {
 	if !s.valid {
-		return ErrDBClosed
+		return define.ErrDBClosed
 	}
 
 	if ctr.config.Pod != "" {
-		return errors.Wrapf(ErrPodExists, "container %s is part of a pod, use RemoveContainerFromPod instead", ctr.ID())
+		return errors.Wrapf(define.ErrPodExists, "container %s is part of a pod, use RemoveContainerFromPod instead", ctr.ID())
 	}
 
 	db, err := s.getDBCon()
@@ -564,15 +565,15 @@ func (s *BoltState) RemoveContainer(ctr *Container) error {
 // UpdateContainer updates a container's state from the database
 func (s *BoltState) UpdateContainer(ctr *Container) error {
 	if !s.valid {
-		return ErrDBClosed
+		return define.ErrDBClosed
 	}
 
 	if !ctr.valid {
-		return ErrCtrRemoved
+		return define.ErrCtrRemoved
 	}
 
 	if s.namespace != "" && s.namespace != ctr.config.Namespace {
-		return errors.Wrapf(ErrNSMismatch, "container %s is in namespace %q, does not match our namespace %q", ctr.ID(), ctr.config.Namespace, s.namespace)
+		return errors.Wrapf(define.ErrNSMismatch, "container %s is in namespace %q, does not match our namespace %q", ctr.ID(), ctr.config.Namespace, s.namespace)
 	}
 
 	newState := new(ContainerState)
@@ -595,12 +596,12 @@ func (s *BoltState) UpdateContainer(ctr *Container) error {
 		ctrToUpdate := ctrBucket.Bucket(ctrID)
 		if ctrToUpdate == nil {
 			ctr.valid = false
-			return errors.Wrapf(ErrNoSuchCtr, "container %s does not exist in database", ctr.ID())
+			return errors.Wrapf(define.ErrNoSuchCtr, "container %s does not exist in database", ctr.ID())
 		}
 
 		newStateBytes := ctrToUpdate.Get(stateKey)
 		if newStateBytes == nil {
-			return errors.Wrapf(ErrInternal, "container %s does not have a state key in DB", ctr.ID())
+			return errors.Wrapf(define.ErrInternal, "container %s does not have a state key in DB", ctr.ID())
 		}
 
 		if err := json.Unmarshal(newStateBytes, newState); err != nil {
@@ -632,15 +633,15 @@ func (s *BoltState) UpdateContainer(ctr *Container) error {
 // SaveContainer saves a container's current state in the database
 func (s *BoltState) SaveContainer(ctr *Container) error {
 	if !s.valid {
-		return ErrDBClosed
+		return define.ErrDBClosed
 	}
 
 	if !ctr.valid {
-		return ErrCtrRemoved
+		return define.ErrCtrRemoved
 	}
 
 	if s.namespace != "" && s.namespace != ctr.config.Namespace {
-		return errors.Wrapf(ErrNSMismatch, "container %s is in namespace %q, does not match our namespace %q", ctr.ID(), ctr.config.Namespace, s.namespace)
+		return errors.Wrapf(define.ErrNSMismatch, "container %s is in namespace %q, does not match our namespace %q", ctr.ID(), ctr.config.Namespace, s.namespace)
 	}
 
 	stateJSON, err := json.Marshal(ctr.state)
@@ -666,7 +667,7 @@ func (s *BoltState) SaveContainer(ctr *Container) error {
 		ctrToSave := ctrBucket.Bucket(ctrID)
 		if ctrToSave == nil {
 			ctr.valid = false
-			return errors.Wrapf(ErrNoSuchCtr, "container %s does not exist in DB", ctr.ID())
+			return errors.Wrapf(define.ErrNoSuchCtr, "container %s does not exist in DB", ctr.ID())
 		}
 
 		// Update the state
@@ -695,15 +696,15 @@ func (s *BoltState) SaveContainer(ctr *Container) error {
 // container. If the slice is empty, no containers depend on the given container
 func (s *BoltState) ContainerInUse(ctr *Container) ([]string, error) {
 	if !s.valid {
-		return nil, ErrDBClosed
+		return nil, define.ErrDBClosed
 	}
 
 	if !ctr.valid {
-		return nil, ErrCtrRemoved
+		return nil, define.ErrCtrRemoved
 	}
 
 	if s.namespace != "" && s.namespace != ctr.config.Namespace {
-		return nil, errors.Wrapf(ErrNSMismatch, "container %s is in namespace %q, does not match our namespace %q", ctr.ID(), ctr.config.Namespace, s.namespace)
+		return nil, errors.Wrapf(define.ErrNSMismatch, "container %s is in namespace %q, does not match our namespace %q", ctr.ID(), ctr.config.Namespace, s.namespace)
 	}
 
 	depCtrs := []string{}
@@ -723,12 +724,12 @@ func (s *BoltState) ContainerInUse(ctr *Container) ([]string, error) {
 		ctrDB := ctrBucket.Bucket([]byte(ctr.ID()))
 		if ctrDB == nil {
 			ctr.valid = false
-			return errors.Wrapf(ErrNoSuchCtr, "no container with ID %s found in DB", ctr.ID())
+			return errors.Wrapf(define.ErrNoSuchCtr, "no container with ID %s found in DB", ctr.ID())
 		}
 
 		dependsBkt := ctrDB.Bucket(dependenciesBkt)
 		if dependsBkt == nil {
-			return errors.Wrapf(ErrInternal, "container %s has no dependencies bucket", ctr.ID())
+			return errors.Wrapf(define.ErrInternal, "container %s has no dependencies bucket", ctr.ID())
 		}
 
 		// Iterate through and add dependencies
@@ -754,7 +755,7 @@ func (s *BoltState) ContainerInUse(ctr *Container) ([]string, error) {
 // AllContainers retrieves all the containers in the database
 func (s *BoltState) AllContainers() ([]*Container, error) {
 	if !s.valid {
-		return nil, ErrDBClosed
+		return nil, define.ErrDBClosed
 	}
 
 	ctrs := []*Container{}
@@ -782,7 +783,7 @@ func (s *BoltState) AllContainers() ([]*Container, error) {
 			// be much less helpful.
 			ctrExists := ctrBucket.Bucket(id)
 			if ctrExists == nil {
-				return errors.Wrapf(ErrInternal, "state is inconsistent - container ID %s in all containers, but container not found", string(id))
+				return errors.Wrapf(define.ErrInternal, "state is inconsistent - container ID %s in all containers, but container not found", string(id))
 			}
 
 			ctr := new(Container)
@@ -794,7 +795,7 @@ func (s *BoltState) AllContainers() ([]*Container, error) {
 				// ignore it safely.
 				// We just won't include the container in the
 				// results.
-				if errors.Cause(err) != ErrNSMismatch {
+				if errors.Cause(err) != define.ErrNSMismatch {
 					// Even if it's not an NS mismatch, it's
 					// not worth erroring over.
 					// If we do, a single bad container JSON
@@ -821,11 +822,11 @@ func (s *BoltState) AllContainers() ([]*Container, error) {
 // comment on this function in state.go.
 func (s *BoltState) RewriteContainerConfig(ctr *Container, newCfg *ContainerConfig) error {
 	if !s.valid {
-		return ErrDBClosed
+		return define.ErrDBClosed
 	}
 
 	if !ctr.valid {
-		return ErrCtrRemoved
+		return define.ErrCtrRemoved
 	}
 
 	newCfgJSON, err := json.Marshal(newCfg)
@@ -848,7 +849,7 @@ func (s *BoltState) RewriteContainerConfig(ctr *Container, newCfg *ContainerConf
 		ctrDB := ctrBkt.Bucket([]byte(ctr.ID()))
 		if ctrDB == nil {
 			ctr.valid = false
-			return errors.Wrapf(ErrNoSuchCtr, "no container with ID %s found in DB", ctr.ID())
+			return errors.Wrapf(define.ErrNoSuchCtr, "no container with ID %s found in DB", ctr.ID())
 		}
 
 		if err := ctrDB.Put(configKey, newCfgJSON); err != nil {
@@ -865,11 +866,11 @@ func (s *BoltState) RewriteContainerConfig(ctr *Container, newCfg *ContainerConf
 // comment on this function in state.go.
 func (s *BoltState) RewritePodConfig(pod *Pod, newCfg *PodConfig) error {
 	if !s.valid {
-		return ErrDBClosed
+		return define.ErrDBClosed
 	}
 
 	if !pod.valid {
-		return ErrPodRemoved
+		return define.ErrPodRemoved
 	}
 
 	newCfgJSON, err := json.Marshal(newCfg)
@@ -892,7 +893,7 @@ func (s *BoltState) RewritePodConfig(pod *Pod, newCfg *PodConfig) error {
 		podDB := podBkt.Bucket([]byte(pod.ID()))
 		if podDB == nil {
 			pod.valid = false
-			return errors.Wrapf(ErrNoSuchPod, "no pod with ID %s found in DB", pod.ID())
+			return errors.Wrapf(define.ErrNoSuchPod, "no pod with ID %s found in DB", pod.ID())
 		}
 
 		if err := podDB.Put(configKey, newCfgJSON); err != nil {
@@ -907,11 +908,11 @@ func (s *BoltState) RewritePodConfig(pod *Pod, newCfg *PodConfig) error {
 // Pod retrieves a pod given its full ID
 func (s *BoltState) Pod(id string) (*Pod, error) {
 	if id == "" {
-		return nil, ErrEmptyID
+		return nil, define.ErrEmptyID
 	}
 
 	if !s.valid {
-		return nil, ErrDBClosed
+		return nil, define.ErrDBClosed
 	}
 
 	podID := []byte(id)
@@ -944,11 +945,11 @@ func (s *BoltState) Pod(id string) (*Pod, error) {
 // LookupPod retrieves a pod from full or unique partial ID or name
 func (s *BoltState) LookupPod(idOrName string) (*Pod, error) {
 	if idOrName == "" {
-		return nil, ErrEmptyID
+		return nil, define.ErrEmptyID
 	}
 
 	if !s.valid {
-		return nil, ErrDBClosed
+		return nil, define.ErrDBClosed
 	}
 
 	pod := new(Pod)
@@ -1025,7 +1026,7 @@ func (s *BoltState) LookupPod(idOrName string) (*Pod, error) {
 			}
 			if strings.HasPrefix(string(checkID), idOrName) {
 				if exists {
-					return errors.Wrapf(ErrPodExists, "more than one result for ID or name %s", idOrName)
+					return errors.Wrapf(define.ErrPodExists, "more than one result for ID or name %s", idOrName)
 				}
 				id = checkID
 				exists = true
@@ -1037,9 +1038,9 @@ func (s *BoltState) LookupPod(idOrName string) (*Pod, error) {
 			return err
 		} else if !exists {
 			if isCtr {
-				return errors.Wrapf(ErrNoSuchPod, "%s is a container, not a pod", idOrName)
+				return errors.Wrapf(define.ErrNoSuchPod, "%s is a container, not a pod", idOrName)
 			}
-			return errors.Wrapf(ErrNoSuchPod, "no pod with name or ID %s found", idOrName)
+			return errors.Wrapf(define.ErrNoSuchPod, "no pod with name or ID %s found", idOrName)
 		}
 
 		// We might have found a container ID, but it's OK
@@ -1056,11 +1057,11 @@ func (s *BoltState) LookupPod(idOrName string) (*Pod, error) {
 // HasPod checks if a pod with the given ID exists in the state
 func (s *BoltState) HasPod(id string) (bool, error) {
 	if id == "" {
-		return false, ErrEmptyID
+		return false, define.ErrEmptyID
 	}
 
 	if !s.valid {
-		return false, ErrDBClosed
+		return false, define.ErrDBClosed
 	}
 
 	podID := []byte(id)
@@ -1103,19 +1104,19 @@ func (s *BoltState) HasPod(id string) (bool, error) {
 // PodHasContainer checks if the given pod has a container with the given ID
 func (s *BoltState) PodHasContainer(pod *Pod, id string) (bool, error) {
 	if id == "" {
-		return false, ErrEmptyID
+		return false, define.ErrEmptyID
 	}
 
 	if !s.valid {
-		return false, ErrDBClosed
+		return false, define.ErrDBClosed
 	}
 
 	if !pod.valid {
-		return false, ErrPodRemoved
+		return false, define.ErrPodRemoved
 	}
 
 	if s.namespace != "" && s.namespace != pod.config.Namespace {
-		return false, errors.Wrapf(ErrNSMismatch, "pod %s is in namespace %q but we are in namespace %q", pod.ID(), pod.config.Namespace, s.namespace)
+		return false, errors.Wrapf(define.ErrNSMismatch, "pod %s is in namespace %q but we are in namespace %q", pod.ID(), pod.config.Namespace, s.namespace)
 	}
 
 	ctrID := []byte(id)
@@ -1139,13 +1140,13 @@ func (s *BoltState) PodHasContainer(pod *Pod, id string) (bool, error) {
 		podDB := podBkt.Bucket(podID)
 		if podDB == nil {
 			pod.valid = false
-			return errors.Wrapf(ErrNoSuchPod, "pod %s not found in database", pod.ID())
+			return errors.Wrapf(define.ErrNoSuchPod, "pod %s not found in database", pod.ID())
 		}
 
 		// Get pod containers bucket
 		podCtrs := podDB.Bucket(containersBkt)
 		if podCtrs == nil {
-			return errors.Wrapf(ErrInternal, "pod %s missing containers bucket in DB", pod.ID())
+			return errors.Wrapf(define.ErrInternal, "pod %s missing containers bucket in DB", pod.ID())
 		}
 
 		// Don't bother with a namespace check on the container -
@@ -1170,15 +1171,15 @@ func (s *BoltState) PodHasContainer(pod *Pod, id string) (bool, error) {
 // PodContainersByID returns the IDs of all containers present in the given pod
 func (s *BoltState) PodContainersByID(pod *Pod) ([]string, error) {
 	if !s.valid {
-		return nil, ErrDBClosed
+		return nil, define.ErrDBClosed
 	}
 
 	if !pod.valid {
-		return nil, ErrPodRemoved
+		return nil, define.ErrPodRemoved
 	}
 
 	if s.namespace != "" && s.namespace != pod.config.Namespace {
-		return nil, errors.Wrapf(ErrNSMismatch, "pod %s is in namespace %q but we are in namespace %q", pod.ID(), pod.config.Namespace, s.namespace)
+		return nil, errors.Wrapf(define.ErrNSMismatch, "pod %s is in namespace %q but we are in namespace %q", pod.ID(), pod.config.Namespace, s.namespace)
 	}
 
 	podID := []byte(pod.ID())
@@ -1201,13 +1202,13 @@ func (s *BoltState) PodContainersByID(pod *Pod) ([]string, error) {
 		podDB := podBkt.Bucket(podID)
 		if podDB == nil {
 			pod.valid = false
-			return errors.Wrapf(ErrNoSuchPod, "pod %s not found in database", pod.ID())
+			return errors.Wrapf(define.ErrNoSuchPod, "pod %s not found in database", pod.ID())
 		}
 
 		// Get pod containers bucket
 		podCtrs := podDB.Bucket(containersBkt)
 		if podCtrs == nil {
-			return errors.Wrapf(ErrInternal, "pod %s missing containers bucket in DB", pod.ID())
+			return errors.Wrapf(define.ErrInternal, "pod %s missing containers bucket in DB", pod.ID())
 		}
 
 		// Iterate through all containers in the pod
@@ -1232,15 +1233,15 @@ func (s *BoltState) PodContainersByID(pod *Pod) ([]string, error) {
 // PodContainers returns all the containers present in the given pod
 func (s *BoltState) PodContainers(pod *Pod) ([]*Container, error) {
 	if !s.valid {
-		return nil, ErrDBClosed
+		return nil, define.ErrDBClosed
 	}
 
 	if !pod.valid {
-		return nil, ErrPodRemoved
+		return nil, define.ErrPodRemoved
 	}
 
 	if s.namespace != "" && s.namespace != pod.config.Namespace {
-		return nil, errors.Wrapf(ErrNSMismatch, "pod %s is in namespace %q but we are in namespace %q", pod.ID(), pod.config.Namespace, s.namespace)
+		return nil, errors.Wrapf(define.ErrNSMismatch, "pod %s is in namespace %q but we are in namespace %q", pod.ID(), pod.config.Namespace, s.namespace)
 	}
 
 	podID := []byte(pod.ID())
@@ -1268,13 +1269,13 @@ func (s *BoltState) PodContainers(pod *Pod) ([]*Container, error) {
 		podDB := podBkt.Bucket(podID)
 		if podDB == nil {
 			pod.valid = false
-			return errors.Wrapf(ErrNoSuchPod, "pod %s not found in database", pod.ID())
+			return errors.Wrapf(define.ErrNoSuchPod, "pod %s not found in database", pod.ID())
 		}
 
 		// Get pod containers bucket
 		podCtrs := podDB.Bucket(containersBkt)
 		if podCtrs == nil {
-			return errors.Wrapf(ErrInternal, "pod %s missing containers bucket in DB", pod.ID())
+			return errors.Wrapf(define.ErrInternal, "pod %s missing containers bucket in DB", pod.ID())
 		}
 
 		// Iterate through all containers in the pod
@@ -1303,11 +1304,11 @@ func (s *BoltState) PodContainers(pod *Pod) ([]*Container, error) {
 // the sub bucket holding the container dependencies that this volume has
 func (s *BoltState) AddVolume(volume *Volume) error {
 	if !s.valid {
-		return ErrDBClosed
+		return define.ErrDBClosed
 	}
 
 	if !volume.valid {
-		return ErrVolumeRemoved
+		return define.ErrVolumeRemoved
 	}
 
 	volName := []byte(volume.Name())
@@ -1337,7 +1338,7 @@ func (s *BoltState) AddVolume(volume *Volume) error {
 		// Check if we already have a volume with the given name
 		volExists := allVolsBkt.Get(volName)
 		if volExists != nil {
-			return errors.Wrapf(ErrVolumeExists, "name %s is in use", volume.Name())
+			return errors.Wrapf(define.ErrVolumeExists, "name %s is in use", volume.Name())
 		}
 
 		// We are good to add the volume
@@ -1369,7 +1370,7 @@ func (s *BoltState) AddVolume(volume *Volume) error {
 // RemoveVolume removes the given volume from the state
 func (s *BoltState) RemoveVolume(volume *Volume) error {
 	if !s.valid {
-		return ErrDBClosed
+		return define.ErrDBClosed
 	}
 
 	volName := []byte(volume.Name())
@@ -1400,7 +1401,7 @@ func (s *BoltState) RemoveVolume(volume *Volume) error {
 		volDB := volBkt.Bucket(volName)
 		if volDB == nil {
 			volume.valid = false
-			return errors.Wrapf(ErrNoSuchVolume, "volume %s does not exist in DB", volume.Name())
+			return errors.Wrapf(define.ErrNoSuchVolume, "volume %s does not exist in DB", volume.Name())
 		}
 
 		// Check if volume is not being used by any container
@@ -1430,7 +1431,7 @@ func (s *BoltState) RemoveVolume(volume *Volume) error {
 				return errors.Wrapf(err, "error getting list of dependencies from dependencies bucket for volumes %q", volume.Name())
 			}
 			if len(deps) > 0 {
-				return errors.Wrapf(ErrVolumeBeingUsed, "volume %s is being used by container(s) %s", volume.Name(), strings.Join(deps, ","))
+				return errors.Wrapf(define.ErrVolumeBeingUsed, "volume %s is being used by container(s) %s", volume.Name(), strings.Join(deps, ","))
 			}
 		}
 
@@ -1451,7 +1452,7 @@ func (s *BoltState) RemoveVolume(volume *Volume) error {
 // AllVolumes returns all volumes present in the state
 func (s *BoltState) AllVolumes() ([]*Volume, error) {
 	if !s.valid {
-		return nil, ErrDBClosed
+		return nil, define.ErrDBClosed
 	}
 
 	volumes := []*Volume{}
@@ -1477,14 +1478,14 @@ func (s *BoltState) AllVolumes() ([]*Volume, error) {
 			// This check can be removed if performance becomes an
 			// issue, but much less helpful errors will be produced
 			if volExists == nil {
-				return errors.Wrapf(ErrInternal, "inconsistency in state - volume %s is in all volumes bucket but volume not found", string(id))
+				return errors.Wrapf(define.ErrInternal, "inconsistency in state - volume %s is in all volumes bucket but volume not found", string(id))
 			}
 
 			volume := new(Volume)
 			volume.config = new(VolumeConfig)
 
 			if err := s.getVolumeFromDB(id, volume, volBucket); err != nil {
-				if errors.Cause(err) != ErrNSMismatch {
+				if errors.Cause(err) != define.ErrNSMismatch {
 					logrus.Errorf("Error retrieving volume %s from the database: %v", string(id), err)
 				}
 			} else {
@@ -1505,11 +1506,11 @@ func (s *BoltState) AllVolumes() ([]*Volume, error) {
 // Volume retrieves a volume from full name
 func (s *BoltState) Volume(name string) (*Volume, error) {
 	if name == "" {
-		return nil, ErrEmptyID
+		return nil, define.ErrEmptyID
 	}
 
 	if !s.valid {
-		return nil, ErrDBClosed
+		return nil, define.ErrDBClosed
 	}
 
 	volName := []byte(name)
@@ -1541,11 +1542,11 @@ func (s *BoltState) Volume(name string) (*Volume, error) {
 // HasVolume returns true if the given volume exists in the state, otherwise it returns false
 func (s *BoltState) HasVolume(name string) (bool, error) {
 	if name == "" {
-		return false, ErrEmptyID
+		return false, define.ErrEmptyID
 	}
 
 	if !s.valid {
-		return false, ErrDBClosed
+		return false, define.ErrDBClosed
 	}
 
 	volName := []byte(name)
@@ -1583,11 +1584,11 @@ func (s *BoltState) HasVolume(name string) (bool, error) {
 // volume. If the slice is empty, no containers use the given volume
 func (s *BoltState) VolumeInUse(volume *Volume) ([]string, error) {
 	if !s.valid {
-		return nil, ErrDBClosed
+		return nil, define.ErrDBClosed
 	}
 
 	if !volume.valid {
-		return nil, ErrVolumeRemoved
+		return nil, define.ErrVolumeRemoved
 	}
 
 	depCtrs := []string{}
@@ -1612,12 +1613,12 @@ func (s *BoltState) VolumeInUse(volume *Volume) ([]string, error) {
 		volDB := volBucket.Bucket([]byte(volume.Name()))
 		if volDB == nil {
 			volume.valid = false
-			return errors.Wrapf(ErrNoSuchVolume, "no volume with name %s found in DB", volume.Name())
+			return errors.Wrapf(define.ErrNoSuchVolume, "no volume with name %s found in DB", volume.Name())
 		}
 
 		dependsBkt := volDB.Bucket(volDependenciesBkt)
 		if dependsBkt == nil {
-			return errors.Wrapf(ErrInternal, "volume %s has no dependencies bucket", volume.Name())
+			return errors.Wrapf(define.ErrInternal, "volume %s has no dependencies bucket", volume.Name())
 		}
 
 		// Iterate through and add dependencies
@@ -1649,15 +1650,15 @@ func (s *BoltState) VolumeInUse(volume *Volume) ([]string, error) {
 // AddPod adds the given pod to the state.
 func (s *BoltState) AddPod(pod *Pod) error {
 	if !s.valid {
-		return ErrDBClosed
+		return define.ErrDBClosed
 	}
 
 	if !pod.valid {
-		return ErrPodRemoved
+		return define.ErrPodRemoved
 	}
 
 	if s.namespace != "" && s.namespace != pod.config.Namespace {
-		return errors.Wrapf(ErrNSMismatch, "pod %s is in namespace %q but we are in namespace %q", pod.ID(), pod.config.Namespace, s.namespace)
+		return errors.Wrapf(define.ErrNSMismatch, "pod %s is in namespace %q but we are in namespace %q", pod.ID(), pod.config.Namespace, s.namespace)
 	}
 
 	podID := []byte(pod.ID())
@@ -1713,11 +1714,11 @@ func (s *BoltState) AddPod(pod *Pod) error {
 		// Check if we already have something with the given ID and name
 		idExist := idsBkt.Get(podID)
 		if idExist != nil {
-			return errors.Wrapf(ErrPodExists, "ID %s is in use", pod.ID())
+			return errors.Wrapf(define.ErrPodExists, "ID %s is in use", pod.ID())
 		}
 		nameExist := namesBkt.Get(podName)
 		if nameExist != nil {
-			return errors.Wrapf(ErrPodExists, "name %s is in use", pod.Name())
+			return errors.Wrapf(define.ErrPodExists, "name %s is in use", pod.Name())
 		}
 
 		// We are good to add the pod
@@ -1773,15 +1774,15 @@ func (s *BoltState) AddPod(pod *Pod) error {
 // Only empty pods can be removed
 func (s *BoltState) RemovePod(pod *Pod) error {
 	if !s.valid {
-		return ErrDBClosed
+		return define.ErrDBClosed
 	}
 
 	if !pod.valid {
-		return ErrPodRemoved
+		return define.ErrPodRemoved
 	}
 
 	if s.namespace != "" && s.namespace != pod.config.Namespace {
-		return errors.Wrapf(ErrNSMismatch, "pod %s is in namespace %q but we are in namespace %q", pod.ID(), pod.config.Namespace, s.namespace)
+		return errors.Wrapf(define.ErrNSMismatch, "pod %s is in namespace %q but we are in namespace %q", pod.ID(), pod.config.Namespace, s.namespace)
 	}
 
 	podID := []byte(pod.ID())
@@ -1823,7 +1824,7 @@ func (s *BoltState) RemovePod(pod *Pod) error {
 		podDB := podBkt.Bucket(podID)
 		if podDB == nil {
 			pod.valid = false
-			return errors.Wrapf(ErrNoSuchPod, "pod %s does not exist in DB", pod.ID())
+			return errors.Wrapf(define.ErrNoSuchPod, "pod %s does not exist in DB", pod.ID())
 		}
 
 		// Check if pod is empty
@@ -1835,7 +1836,7 @@ func (s *BoltState) RemovePod(pod *Pod) error {
 		if podCtrsBkt != nil {
 			cursor := podCtrsBkt.Cursor()
 			if id, _ := cursor.First(); id != nil {
-				return errors.Wrapf(ErrCtrExists, "pod %s is not empty", pod.ID())
+				return errors.Wrapf(define.ErrCtrExists, "pod %s is not empty", pod.ID())
 			}
 		}
 
@@ -1869,15 +1870,15 @@ func (s *BoltState) RemovePod(pod *Pod) error {
 // RemovePodContainers removes all containers in a pod
 func (s *BoltState) RemovePodContainers(pod *Pod) error {
 	if !s.valid {
-		return ErrDBClosed
+		return define.ErrDBClosed
 	}
 
 	if !pod.valid {
-		return ErrPodRemoved
+		return define.ErrPodRemoved
 	}
 
 	if s.namespace != "" && s.namespace != pod.config.Namespace {
-		return errors.Wrapf(ErrNSMismatch, "pod %s is in namespace %q but we are in namespace %q", pod.ID(), pod.config.Namespace, s.namespace)
+		return errors.Wrapf(define.ErrNSMismatch, "pod %s is in namespace %q but we are in namespace %q", pod.ID(), pod.config.Namespace, s.namespace)
 	}
 
 	podID := []byte(pod.ID())
@@ -1918,12 +1919,12 @@ func (s *BoltState) RemovePodContainers(pod *Pod) error {
 		podDB := podBkt.Bucket(podID)
 		if podDB == nil {
 			pod.valid = false
-			return errors.Wrapf(ErrNoSuchPod, "pod %s does not exist in DB", pod.ID())
+			return errors.Wrapf(define.ErrNoSuchPod, "pod %s does not exist in DB", pod.ID())
 		}
 
 		podCtrsBkt := podDB.Bucket(containersBkt)
 		if podCtrsBkt == nil {
-			return errors.Wrapf(ErrInternal, "pod %s does not have a containers bucket", pod.ID())
+			return errors.Wrapf(define.ErrInternal, "pod %s does not have a containers bucket", pod.ID())
 		}
 
 		// Traverse all containers in the pod with a cursor
@@ -1934,7 +1935,7 @@ func (s *BoltState) RemovePodContainers(pod *Pod) error {
 			if ctr == nil {
 				// This should never happen
 				// State is inconsistent
-				return errors.Wrapf(ErrNoSuchCtr, "pod %s referenced nonexistant container %s", pod.ID(), string(id))
+				return errors.Wrapf(define.ErrNoSuchCtr, "pod %s referenced nonexistant container %s", pod.ID(), string(id))
 			}
 			ctrDeps := ctr.Bucket(dependenciesBkt)
 			// This should never be nil, but if it is, we're
@@ -1943,7 +1944,7 @@ func (s *BoltState) RemovePodContainers(pod *Pod) error {
 				err = ctrDeps.ForEach(func(depID, name []byte) error {
 					exists := podCtrsBkt.Get(depID)
 					if exists == nil {
-						return errors.Wrapf(ErrCtrExists, "container %s has dependency %s outside of pod %s", string(id), string(depID), pod.ID())
+						return errors.Wrapf(define.ErrCtrExists, "container %s has dependency %s outside of pod %s", string(id), string(depID), pod.ID())
 					}
 					return nil
 				})
@@ -1955,7 +1956,7 @@ func (s *BoltState) RemovePodContainers(pod *Pod) error {
 			// Dependencies are set, we're clear to remove
 
 			if err := ctrBkt.DeleteBucket(id); err != nil {
-				return errors.Wrapf(ErrInternal, "error deleting container %s from DB", string(id))
+				return errors.Wrapf(define.ErrInternal, "error deleting container %s from DB", string(id))
 			}
 
 			if err := idsBkt.Delete(id); err != nil {
@@ -1997,19 +1998,19 @@ func (s *BoltState) RemovePodContainers(pod *Pod) error {
 // The container will be added to the state and the pod
 func (s *BoltState) AddContainerToPod(pod *Pod, ctr *Container) error {
 	if !s.valid {
-		return ErrDBClosed
+		return define.ErrDBClosed
 	}
 
 	if !pod.valid {
-		return ErrPodRemoved
+		return define.ErrPodRemoved
 	}
 
 	if !ctr.valid {
-		return ErrCtrRemoved
+		return define.ErrCtrRemoved
 	}
 
 	if ctr.config.Pod != pod.ID() {
-		return errors.Wrapf(ErrNoSuchCtr, "container %s is not part of pod %s", ctr.ID(), pod.ID())
+		return errors.Wrapf(define.ErrNoSuchCtr, "container %s is not part of pod %s", ctr.ID(), pod.ID())
 	}
 
 	return s.addContainer(ctr, pod)
@@ -2019,28 +2020,28 @@ func (s *BoltState) AddContainerToPod(pod *Pod, ctr *Container) error {
 // The container will also be removed from the state
 func (s *BoltState) RemoveContainerFromPod(pod *Pod, ctr *Container) error {
 	if !s.valid {
-		return ErrDBClosed
+		return define.ErrDBClosed
 	}
 
 	if !pod.valid {
-		return ErrPodRemoved
+		return define.ErrPodRemoved
 	}
 
 	if s.namespace != "" {
 		if s.namespace != pod.config.Namespace {
-			return errors.Wrapf(ErrNSMismatch, "pod %s is in namespace %q but we are in namespace %q", pod.ID(), pod.config.Namespace, s.namespace)
+			return errors.Wrapf(define.ErrNSMismatch, "pod %s is in namespace %q but we are in namespace %q", pod.ID(), pod.config.Namespace, s.namespace)
 		}
 		if s.namespace != ctr.config.Namespace {
-			return errors.Wrapf(ErrNSMismatch, "container %s in in namespace %q but we are in namespace %q", ctr.ID(), ctr.config.Namespace, s.namespace)
+			return errors.Wrapf(define.ErrNSMismatch, "container %s in in namespace %q but we are in namespace %q", ctr.ID(), ctr.config.Namespace, s.namespace)
 		}
 	}
 
 	if ctr.config.Pod == "" {
-		return errors.Wrapf(ErrNoSuchPod, "container %s is not part of a pod, use RemoveContainer instead", ctr.ID())
+		return errors.Wrapf(define.ErrNoSuchPod, "container %s is not part of a pod, use RemoveContainer instead", ctr.ID())
 	}
 
 	if ctr.config.Pod != pod.ID() {
-		return errors.Wrapf(ErrInvalidArg, "container %s is not part of pod %s", ctr.ID(), pod.ID())
+		return errors.Wrapf(define.ErrInvalidArg, "container %s is not part of pod %s", ctr.ID(), pod.ID())
 	}
 
 	db, err := s.getDBCon()
@@ -2058,15 +2059,15 @@ func (s *BoltState) RemoveContainerFromPod(pod *Pod, ctr *Container) error {
 // UpdatePod updates a pod's state from the database
 func (s *BoltState) UpdatePod(pod *Pod) error {
 	if !s.valid {
-		return ErrDBClosed
+		return define.ErrDBClosed
 	}
 
 	if !pod.valid {
-		return ErrPodRemoved
+		return define.ErrPodRemoved
 	}
 
 	if s.namespace != "" && s.namespace != pod.config.Namespace {
-		return errors.Wrapf(ErrNSMismatch, "pod %s is in namespace %q but we are in namespace %q", pod.ID(), pod.config.Namespace, s.namespace)
+		return errors.Wrapf(define.ErrNSMismatch, "pod %s is in namespace %q but we are in namespace %q", pod.ID(), pod.config.Namespace, s.namespace)
 	}
 
 	newState := new(podState)
@@ -2088,13 +2089,13 @@ func (s *BoltState) UpdatePod(pod *Pod) error {
 		podDB := podBkt.Bucket(podID)
 		if podDB == nil {
 			pod.valid = false
-			return errors.Wrapf(ErrNoSuchPod, "no pod with ID %s found in database", pod.ID())
+			return errors.Wrapf(define.ErrNoSuchPod, "no pod with ID %s found in database", pod.ID())
 		}
 
 		// Get the pod state JSON
 		podStateBytes := podDB.Get(stateKey)
 		if podStateBytes == nil {
-			return errors.Wrapf(ErrInternal, "pod %s is missing state key in DB", pod.ID())
+			return errors.Wrapf(define.ErrInternal, "pod %s is missing state key in DB", pod.ID())
 		}
 
 		if err := json.Unmarshal(podStateBytes, newState); err != nil {
@@ -2115,15 +2116,15 @@ func (s *BoltState) UpdatePod(pod *Pod) error {
 // SavePod saves a pod's state to the database
 func (s *BoltState) SavePod(pod *Pod) error {
 	if !s.valid {
-		return ErrDBClosed
+		return define.ErrDBClosed
 	}
 
 	if !pod.valid {
-		return ErrPodRemoved
+		return define.ErrPodRemoved
 	}
 
 	if s.namespace != "" && s.namespace != pod.config.Namespace {
-		return errors.Wrapf(ErrNSMismatch, "pod %s is in namespace %q but we are in namespace %q", pod.ID(), pod.config.Namespace, s.namespace)
+		return errors.Wrapf(define.ErrNSMismatch, "pod %s is in namespace %q but we are in namespace %q", pod.ID(), pod.config.Namespace, s.namespace)
 	}
 
 	stateJSON, err := json.Marshal(pod.state)
@@ -2148,7 +2149,7 @@ func (s *BoltState) SavePod(pod *Pod) error {
 		podDB := podBkt.Bucket(podID)
 		if podDB == nil {
 			pod.valid = false
-			return errors.Wrapf(ErrNoSuchPod, "no pod with ID %s found in database", pod.ID())
+			return errors.Wrapf(define.ErrNoSuchPod, "no pod with ID %s found in database", pod.ID())
 		}
 
 		// Set the pod state JSON
@@ -2168,7 +2169,7 @@ func (s *BoltState) SavePod(pod *Pod) error {
 // AllPods returns all pods present in the state
 func (s *BoltState) AllPods() ([]*Pod, error) {
 	if !s.valid {
-		return nil, ErrDBClosed
+		return nil, define.ErrDBClosed
 	}
 
 	pods := []*Pod{}
@@ -2195,7 +2196,7 @@ func (s *BoltState) AllPods() ([]*Pod, error) {
 			// This check can be removed if performance becomes an
 			// issue, but much less helpful errors will be produced
 			if podExists == nil {
-				return errors.Wrapf(ErrInternal, "inconsistency in state - pod %s is in all pods bucket but pod not found", string(id))
+				return errors.Wrapf(define.ErrInternal, "inconsistency in state - pod %s is in all pods bucket but pod not found", string(id))
 			}
 
 			pod := new(Pod)
@@ -2203,7 +2204,7 @@ func (s *BoltState) AllPods() ([]*Pod, error) {
 			pod.state = new(podState)
 
 			if err := s.getPodFromDB(id, pod, podBucket); err != nil {
-				if errors.Cause(err) != ErrNSMismatch {
+				if errors.Cause(err) != define.ErrNSMismatch {
 					logrus.Errorf("Error retrieving pod %s from the database: %v", string(id), err)
 				}
 			} else {
diff --git a/libpod/boltdb_state_internal.go b/libpod/boltdb_state_internal.go
index b7930e158..122bb5935 100644
--- a/libpod/boltdb_state_internal.go
+++ b/libpod/boltdb_state_internal.go
@@ -6,6 +6,7 @@ import (
 	"runtime"
 	"strings"
 
+	"github.com/containers/libpod/libpod/define"
 	"github.com/containers/libpod/pkg/rootless"
 	"github.com/containers/storage"
 	bolt "github.com/etcd-io/bbolt"
@@ -222,7 +223,7 @@ func readOnlyValidateConfig(bucket *bolt.Bucket, toCheck dbConfigValidation) (bo
 			return true, nil
 		}
 
-		return true, errors.Wrapf(ErrDBBadConfig, "database %s %q does not match our %s %q",
+		return true, errors.Wrapf(define.ErrDBBadConfig, "database %s %q does not match our %s %q",
 			toCheck.name, dbValue, toCheck.name, toCheck.runtimeValue)
 	}
 
@@ -260,7 +261,7 @@ func (s *BoltState) closeDBCon(db *bolt.DB) error {
 func getIDBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
 	bkt := tx.Bucket(idRegistryBkt)
 	if bkt == nil {
-		return nil, errors.Wrapf(ErrDBBadConfig, "id registry bucket not found in DB")
+		return nil, errors.Wrapf(define.ErrDBBadConfig, "id registry bucket not found in DB")
 	}
 	return bkt, nil
 }
@@ -268,7 +269,7 @@ func getIDBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
 func getNamesBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
 	bkt := tx.Bucket(nameRegistryBkt)
 	if bkt == nil {
-		return nil, errors.Wrapf(ErrDBBadConfig, "name registry bucket not found in DB")
+		return nil, errors.Wrapf(define.ErrDBBadConfig, "name registry bucket not found in DB")
 	}
 	return bkt, nil
 }
@@ -276,7 +277,7 @@ func getNamesBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
 func getNSBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
 	bkt := tx.Bucket(nsRegistryBkt)
 	if bkt == nil {
-		return nil, errors.Wrapf(ErrDBBadConfig, "namespace registry bucket not found in DB")
+		return nil, errors.Wrapf(define.ErrDBBadConfig, "namespace registry bucket not found in DB")
 	}
 	return bkt, nil
 }
@@ -284,7 +285,7 @@ func getNSBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
 func getCtrBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
 	bkt := tx.Bucket(ctrBkt)
 	if bkt == nil {
-		return nil, errors.Wrapf(ErrDBBadConfig, "containers bucket not found in DB")
+		return nil, errors.Wrapf(define.ErrDBBadConfig, "containers bucket not found in DB")
 	}
 	return bkt, nil
 }
@@ -292,7 +293,7 @@ func getCtrBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
 func getAllCtrsBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
 	bkt := tx.Bucket(allCtrsBkt)
 	if bkt == nil {
-		return nil, errors.Wrapf(ErrDBBadConfig, "all containers bucket not found in DB")
+		return nil, errors.Wrapf(define.ErrDBBadConfig, "all containers bucket not found in DB")
 	}
 	return bkt, nil
 }
@@ -300,7 +301,7 @@ func getAllCtrsBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
 func getPodBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
 	bkt := tx.Bucket(podBkt)
 	if bkt == nil {
-		return nil, errors.Wrapf(ErrDBBadConfig, "pods bucket not found in DB")
+		return nil, errors.Wrapf(define.ErrDBBadConfig, "pods bucket not found in DB")
 	}
 	return bkt, nil
 }
@@ -308,7 +309,7 @@ func getPodBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
 func getAllPodsBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
 	bkt := tx.Bucket(allPodsBkt)
 	if bkt == nil {
-		return nil, errors.Wrapf(ErrDBBadConfig, "all pods bucket not found in DB")
+		return nil, errors.Wrapf(define.ErrDBBadConfig, "all pods bucket not found in DB")
 	}
 	return bkt, nil
 }
@@ -316,7 +317,7 @@ func getAllPodsBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
 func getVolBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
 	bkt := tx.Bucket(volBkt)
 	if bkt == nil {
-		return nil, errors.Wrapf(ErrDBBadConfig, "volumes bucket not found in DB")
+		return nil, errors.Wrapf(define.ErrDBBadConfig, "volumes bucket not found in DB")
 	}
 	return bkt, nil
 }
@@ -324,7 +325,7 @@ func getVolBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
 func getAllVolsBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
 	bkt := tx.Bucket(allVolsBkt)
 	if bkt == nil {
-		return nil, errors.Wrapf(ErrDBBadConfig, "all volumes bucket not found in DB")
+		return nil, errors.Wrapf(define.ErrDBBadConfig, "all volumes bucket not found in DB")
 	}
 	return bkt, nil
 }
@@ -332,7 +333,7 @@ func getAllVolsBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
 func getRuntimeConfigBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
 	bkt := tx.Bucket(runtimeConfigBkt)
 	if bkt == nil {
-		return nil, errors.Wrapf(ErrDBBadConfig, "runtime configuration bucket not found in DB")
+		return nil, errors.Wrapf(define.ErrDBBadConfig, "runtime configuration bucket not found in DB")
 	}
 	return bkt, nil
 }
@@ -341,19 +342,19 @@ func (s *BoltState) getContainerFromDB(id []byte, ctr *Container, ctrsBkt *bolt.
 	valid := true
 	ctrBkt := ctrsBkt.Bucket(id)
 	if ctrBkt == nil {
-		return errors.Wrapf(ErrNoSuchCtr, "container %s not found in DB", string(id))
+		return errors.Wrapf(define.ErrNoSuchCtr, "container %s not found in DB", string(id))
 	}
 
 	if s.namespaceBytes != nil {
 		ctrNamespaceBytes := ctrBkt.Get(namespaceKey)
 		if !bytes.Equal(s.namespaceBytes, ctrNamespaceBytes) {
-			return errors.Wrapf(ErrNSMismatch, "cannot retrieve container %s as it is part of namespace %q and we are in namespace %q", string(id), string(ctrNamespaceBytes), s.namespace)
+			return errors.Wrapf(define.ErrNSMismatch, "cannot retrieve container %s as it is part of namespace %q and we are in namespace %q", string(id), string(ctrNamespaceBytes), s.namespace)
 		}
 	}
 
 	configBytes := ctrBkt.Get(configKey)
 	if configBytes == nil {
-		return errors.Wrapf(ErrInternal, "container %s missing config key in DB", string(id))
+		return errors.Wrapf(define.ErrInternal, "container %s missing config key in DB", string(id))
 	}
 
 	if err := json.Unmarshal(configBytes, ctr.config); err != nil {
@@ -379,7 +380,7 @@ func (s *BoltState) getContainerFromDB(id []byte, ctr *Container, ctrsBkt *bolt.
 
 		ociRuntime, ok := s.runtime.ociRuntimes[runtimeName]
 		if !ok {
-			return errors.Wrapf(ErrInternal, "container %s was created with OCI runtime %s, but that runtime is not available in the current configuration", ctr.ID(), ctr.config.OCIRuntime)
+			return errors.Wrapf(define.ErrInternal, "container %s was created with OCI runtime %s, but that runtime is not available in the current configuration", ctr.ID(), ctr.config.OCIRuntime)
 		}
 		ctr.ociRuntime = ociRuntime
 	}
@@ -393,19 +394,19 @@ func (s *BoltState) getContainerFromDB(id []byte, ctr *Container, ctrsBkt *bolt.
 func (s *BoltState) getPodFromDB(id []byte, pod *Pod, podBkt *bolt.Bucket) error {
 	podDB := podBkt.Bucket(id)
 	if podDB == nil {
-		return errors.Wrapf(ErrNoSuchPod, "pod with ID %s not found", string(id))
+		return errors.Wrapf(define.ErrNoSuchPod, "pod with ID %s not found", string(id))
 	}
 
 	if s.namespaceBytes != nil {
 		podNamespaceBytes := podDB.Get(namespaceKey)
 		if !bytes.Equal(s.namespaceBytes, podNamespaceBytes) {
-			return errors.Wrapf(ErrNSMismatch, "cannot retrieve pod %s as it is part of namespace %q and we are in namespace %q", string(id), string(podNamespaceBytes), s.namespace)
+			return errors.Wrapf(define.ErrNSMismatch, "cannot retrieve pod %s as it is part of namespace %q and we are in namespace %q", string(id), string(podNamespaceBytes), s.namespace)
 		}
 	}
 
 	podConfigBytes := podDB.Get(configKey)
 	if podConfigBytes == nil {
-		return errors.Wrapf(ErrInternal, "pod %s is missing configuration key in DB", string(id))
+		return errors.Wrapf(define.ErrInternal, "pod %s is missing configuration key in DB", string(id))
 	}
 
 	if err := json.Unmarshal(podConfigBytes, pod.config); err != nil {
@@ -428,12 +429,12 @@ func (s *BoltState) getPodFromDB(id []byte, pod *Pod, podBkt *bolt.Bucket) error
 func (s *BoltState) getVolumeFromDB(name []byte, volume *Volume, volBkt *bolt.Bucket) error {
 	volDB := volBkt.Bucket(name)
 	if volDB == nil {
-		return errors.Wrapf(ErrNoSuchVolume, "volume with name %s not found", string(name))
+		return errors.Wrapf(define.ErrNoSuchVolume, "volume with name %s not found", string(name))
 	}
 
 	volConfigBytes := volDB.Get(configKey)
 	if volConfigBytes == nil {
-		return errors.Wrapf(ErrInternal, "volume %s is missing configuration key in DB", string(name))
+		return errors.Wrapf(define.ErrInternal, "volume %s is missing configuration key in DB", string(name))
 	}
 
 	if err := json.Unmarshal(volConfigBytes, volume.config); err != nil {
@@ -450,7 +451,7 @@ func (s *BoltState) getVolumeFromDB(name []byte, volume *Volume, volBkt *bolt.Bu
 // If pod is not nil, the container is added to the pod as well
 func (s *BoltState) addContainer(ctr *Container, pod *Pod) error {
 	if s.namespace != "" && s.namespace != ctr.config.Namespace {
-		return errors.Wrapf(ErrNSMismatch, "cannot add container %s as it is in namespace %q and we are in namespace %q",
+		return errors.Wrapf(define.ErrNSMismatch, "cannot add container %s as it is in namespace %q and we are in namespace %q",
 			ctr.ID(), s.namespace, ctr.config.Namespace)
 	}
 
@@ -526,16 +527,16 @@ func (s *BoltState) addContainer(ctr *Container, pod *Pod) error {
 			podDB = podBucket.Bucket(podID)
 			if podDB == nil {
 				pod.valid = false
-				return errors.Wrapf(ErrNoSuchPod, "pod %s does not exist in database", pod.ID())
+				return errors.Wrapf(define.ErrNoSuchPod, "pod %s does not exist in database", pod.ID())
 			}
 			podCtrs = podDB.Bucket(containersBkt)
 			if podCtrs == nil {
-				return errors.Wrapf(ErrInternal, "pod %s does not have a containers bucket", pod.ID())
+				return errors.Wrapf(define.ErrInternal, "pod %s does not have a containers bucket", pod.ID())
 			}
 
 			podNS := podDB.Get(namespaceKey)
 			if !bytes.Equal(podNS, ctrNamespace) {
-				return errors.Wrapf(ErrNSMismatch, "container %s is in namespace %s and pod %s is in namespace %s",
+				return errors.Wrapf(define.ErrNSMismatch, "container %s is in namespace %s and pod %s is in namespace %s",
 					ctr.ID(), ctr.config.Namespace, pod.ID(), pod.config.Namespace)
 			}
 		}
@@ -543,11 +544,11 @@ func (s *BoltState) addContainer(ctr *Container, pod *Pod) error {
 		// Check if we already have a container with the given ID and name
 		idExist := idsBucket.Get(ctrID)
 		if idExist != nil {
-			return errors.Wrapf(ErrCtrExists, "ID %s is in use", ctr.ID())
+			return errors.Wrapf(define.ErrCtrExists, "ID %s is in use", ctr.ID())
 		}
 		nameExist := namesBucket.Get(ctrName)
 		if nameExist != nil {
-			return errors.Wrapf(ErrCtrExists, "name %s is in use", ctr.Name())
+			return errors.Wrapf(define.ErrCtrExists, "name %s is in use", ctr.Name())
 		}
 
 		// No overlapping containers
@@ -603,34 +604,34 @@ func (s *BoltState) addContainer(ctr *Container, pod *Pod) error {
 
 			depCtrBkt := ctrBucket.Bucket(depCtrID)
 			if depCtrBkt == nil {
-				return errors.Wrapf(ErrNoSuchCtr, "container %s depends on container %s, but it does not exist in the DB", ctr.ID(), dependsCtr)
+				return errors.Wrapf(define.ErrNoSuchCtr, "container %s depends on container %s, but it does not exist in the DB", ctr.ID(), dependsCtr)
 			}
 
 			depCtrPod := depCtrBkt.Get(podIDKey)
 			if pod != nil {
 				// If we're part of a pod, make sure the dependency is part of the same pod
 				if depCtrPod == nil {
-					return errors.Wrapf(ErrInvalidArg, "container %s depends on container %s which is not in pod %s", ctr.ID(), dependsCtr, pod.ID())
+					return errors.Wrapf(define.ErrInvalidArg, "container %s depends on container %s which is not in pod %s", ctr.ID(), dependsCtr, pod.ID())
 				}
 
 				if string(depCtrPod) != pod.ID() {
-					return errors.Wrapf(ErrInvalidArg, "container %s depends on container %s which is in a different pod (%s)", ctr.ID(), dependsCtr, string(depCtrPod))
+					return errors.Wrapf(define.ErrInvalidArg, "container %s depends on container %s which is in a different pod (%s)", ctr.ID(), dependsCtr, string(depCtrPod))
 				}
 			} else {
 				// If we're not part of a pod, we cannot depend on containers in a pod
 				if depCtrPod != nil {
-					return errors.Wrapf(ErrInvalidArg, "container %s depends on container %s which is in a pod - containers not in pods cannot depend on containers in pods", ctr.ID(), dependsCtr)
+					return errors.Wrapf(define.ErrInvalidArg, "container %s depends on container %s which is in a pod - containers not in pods cannot depend on containers in pods", ctr.ID(), dependsCtr)
 				}
 			}
 
 			depNamespace := depCtrBkt.Get(namespaceKey)
 			if !bytes.Equal(ctrNamespace, depNamespace) {
-				return errors.Wrapf(ErrNSMismatch, "container %s in namespace %q depends on container %s in namespace %q - namespaces must match", ctr.ID(), ctr.config.Namespace, dependsCtr, string(depNamespace))
+				return errors.Wrapf(define.ErrNSMismatch, "container %s in namespace %q depends on container %s in namespace %q - namespaces must match", ctr.ID(), ctr.config.Namespace, dependsCtr, string(depNamespace))
 			}
 
 			depCtrDependsBkt := depCtrBkt.Bucket(dependenciesBkt)
 			if depCtrDependsBkt == nil {
-				return errors.Wrapf(ErrInternal, "container %s does not have a dependencies bucket", dependsCtr)
+				return errors.Wrapf(define.ErrInternal, "container %s does not have a dependencies bucket", dependsCtr)
 			}
 			if err := depCtrDependsBkt.Put(ctrID, ctrName); err != nil {
 				return errors.Wrapf(err, "error adding ctr %s as dependency of container %s", ctr.ID(), dependsCtr)
@@ -648,7 +649,7 @@ func (s *BoltState) addContainer(ctr *Container, pod *Pod) error {
 		for _, vol := range ctr.config.NamedVolumes {
 			volDB := volBkt.Bucket([]byte(vol.Name))
 			if volDB == nil {
-				return errors.Wrapf(ErrNoSuchVolume, "no volume with name %s found in database when adding container %s", vol.Name, ctr.ID())
+				return errors.Wrapf(define.ErrNoSuchVolume, "no volume with name %s found in database when adding container %s", vol.Name, ctr.ID())
 			}
 
 			ctrDepsBkt := volDB.Bucket(volDependenciesBkt)
@@ -714,7 +715,7 @@ func (s *BoltState) removeContainer(ctr *Container, pod *Pod, tx *bolt.Tx) error
 		podDB = podBucket.Bucket(podID)
 		if podDB == nil {
 			pod.valid = false
-			return errors.Wrapf(ErrNoSuchPod, "no pod with ID %s found in DB", pod.ID())
+			return errors.Wrapf(define.ErrNoSuchPod, "no pod with ID %s found in DB", pod.ID())
 		}
 	}
 
@@ -722,17 +723,17 @@ func (s *BoltState) removeContainer(ctr *Container, pod *Pod, tx *bolt.Tx) error
 	ctrExists := ctrBucket.Bucket(ctrID)
 	if ctrExists == nil {
 		ctr.valid = false
-		return errors.Wrapf(ErrNoSuchCtr, "no container with ID %s found in DB", ctr.ID())
+		return errors.Wrapf(define.ErrNoSuchCtr, "no container with ID %s found in DB", ctr.ID())
 	}
 
 	// Compare namespace
 	// We can't remove containers not in our namespace
 	if s.namespace != "" {
 		if s.namespace != ctr.config.Namespace {
-			return errors.Wrapf(ErrNSMismatch, "container %s is in namespace %q, does not match our namespace %q", ctr.ID(), ctr.config.Namespace, s.namespace)
+			return errors.Wrapf(define.ErrNSMismatch, "container %s is in namespace %q, does not match our namespace %q", ctr.ID(), ctr.config.Namespace, s.namespace)
 		}
 		if pod != nil && s.namespace != pod.config.Namespace {
-			return errors.Wrapf(ErrNSMismatch, "pod %s is in namespace %q, does not match out namespace %q", pod.ID(), pod.config.Namespace, s.namespace)
+			return errors.Wrapf(define.ErrNSMismatch, "pod %s is in namespace %q, does not match out namespace %q", pod.ID(), pod.config.Namespace, s.namespace)
 		}
 	}
 
@@ -745,7 +746,7 @@ func (s *BoltState) removeContainer(ctr *Container, pod *Pod, tx *bolt.Tx) error
 		} else {
 			ctrInPod := podCtrs.Get(ctrID)
 			if ctrInPod == nil {
-				return errors.Wrapf(ErrNoSuchCtr, "container %s is not in pod %s", ctr.ID(), pod.ID())
+				return errors.Wrapf(define.ErrNoSuchCtr, "container %s is not in pod %s", ctr.ID(), pod.ID())
 			}
 			if err := podCtrs.Delete(ctrID); err != nil {
 				return errors.Wrapf(err, "error removing container %s from pod %s", ctr.ID(), pod.ID())
@@ -756,7 +757,7 @@ func (s *BoltState) removeContainer(ctr *Container, pod *Pod, tx *bolt.Tx) error
 	// Does the container have dependencies?
 	ctrDepsBkt := ctrExists.Bucket(dependenciesBkt)
 	if ctrDepsBkt == nil {
-		return errors.Wrapf(ErrInternal, "container %s does not have a dependencies bucket", ctr.ID())
+		return errors.Wrapf(define.ErrInternal, "container %s does not have a dependencies bucket", ctr.ID())
 	}
 	deps := []string{}
 	err = ctrDepsBkt.ForEach(func(id, value []byte) error {
@@ -768,11 +769,11 @@ func (s *BoltState) removeContainer(ctr *Container, pod *Pod, tx *bolt.Tx) error
 		return err
 	}
 	if len(deps) != 0 {
-		return errors.Wrapf(ErrCtrExists, "container %s is a dependency of the following containers: %s", ctr.ID(), strings.Join(deps, ", "))
+		return errors.Wrapf(define.ErrCtrExists, "container %s is a dependency of the following containers: %s", ctr.ID(), strings.Join(deps, ", "))
 	}
 
 	if err := ctrBucket.DeleteBucket(ctrID); err != nil {
-		return errors.Wrapf(ErrInternal, "error deleting container %s from DB", ctr.ID())
+		return errors.Wrapf(define.ErrInternal, "error deleting container %s from DB", ctr.ID())
 	}
 
 	if err := idsBucket.Delete(ctrID); err != nil {
diff --git a/libpod/container.go b/libpod/container.go
index 464b233d1..0c1315843 100644
--- a/libpod/container.go
+++ b/libpod/container.go
@@ -11,6 +11,7 @@ import (
 	"github.com/containernetworking/cni/pkg/types"
 	cnitypes "github.com/containernetworking/cni/pkg/types/current"
 	"github.com/containers/image/manifest"
+	"github.com/containers/libpod/libpod/define"
 	"github.com/containers/libpod/libpod/lock"
 	"github.com/containers/libpod/pkg/namespaces"
 	"github.com/containers/storage"
@@ -463,7 +464,7 @@ func StringToContainerStatus(status string) (ContainerStatus, error) {
 	case ContainerStateExited.String():
 		return ContainerStateExited, nil
 	default:
-		return ContainerStateUnknown, errors.Wrapf(ErrInvalidArg, "unknown container state: %s", status)
+		return ContainerStateUnknown, errors.Wrapf(define.ErrInvalidArg, "unknown container state: %s", status)
 	}
 }
 
@@ -962,7 +963,7 @@ func (c *Container) ExecSession(id string) (*ExecSession, error) {
 
 	session, ok := c.state.ExecSessions[id]
 	if !ok {
-		return nil, errors.Wrapf(ErrNoSuchCtr, "no exec session with ID %s found in container %s", id, c.ID())
+		return nil, errors.Wrapf(define.ErrNoSuchCtr, "no exec session with ID %s found in container %s", id, c.ID())
 	}
 
 	returnSession := new(ExecSession)
@@ -987,7 +988,7 @@ func (c *Container) IPs() ([]net.IPNet, error) {
 	}
 
 	if !c.config.CreateNetNS {
-		return nil, errors.Wrapf(ErrInvalidArg, "container %s network namespace is not managed by libpod", c.ID())
+		return nil, errors.Wrapf(define.ErrInvalidArg, "container %s network namespace is not managed by libpod", c.ID())
 	}
 
 	ips := make([]net.IPNet, 0)
@@ -1015,7 +1016,7 @@ func (c *Container) Routes() ([]types.Route, error) {
 	}
 
 	if !c.config.CreateNetNS {
-		return nil, errors.Wrapf(ErrInvalidArg, "container %s network namespace is not managed by libpod", c.ID())
+		return nil, errors.Wrapf(define.ErrInvalidArg, "container %s network namespace is not managed by libpod", c.ID())
 	}
 
 	routes := make([]types.Route, 0)
@@ -1092,11 +1093,11 @@ func (c *Container) NamespacePath(ns LinuxNS) (string, error) {
 	}
 
 	if c.state.State != ContainerStateRunning && c.state.State != ContainerStatePaused {
-		return "", errors.Wrapf(ErrCtrStopped, "cannot get namespace path unless container %s is running", c.ID())
+		return "", errors.Wrapf(define.ErrCtrStopped, "cannot get namespace path unless container %s is running", c.ID())
 	}
 
 	if ns == InvalidNS {
-		return "", errors.Wrapf(ErrInvalidArg, "invalid namespace requested from container %s", c.ID())
+		return "", errors.Wrapf(define.ErrInvalidArg, "invalid namespace requested from container %s", c.ID())
 	}
 
 	return fmt.Sprintf("/proc/%d/ns/%s", c.state.PID, ns.String()), nil
@@ -1110,7 +1111,7 @@ func (c *Container) CGroupPath() (string, error) {
 	case SystemdCgroupsManager:
 		return filepath.Join(c.config.CgroupParent, createUnitName("libpod", c.ID())), nil
 	default:
-		return "", errors.Wrapf(ErrInvalidArg, "unsupported CGroup manager %s in use", c.runtime.config.CgroupManager)
+		return "", errors.Wrapf(define.ErrInvalidArg, "unsupported CGroup manager %s in use", c.runtime.config.CgroupManager)
 	}
 }
 
diff --git a/libpod/container_api.go b/libpod/container_api.go
index 370e3e5d9..b8c339a39 100644
--- a/libpod/container_api.go
+++ b/libpod/container_api.go
@@ -10,6 +10,7 @@ import (
 	"sync"
 	"time"
 
+	"github.com/containers/libpod/libpod/define"
 	"github.com/containers/libpod/libpod/events"
 	"github.com/containers/libpod/pkg/lookup"
 	"github.com/containers/storage/pkg/stringid"
@@ -39,7 +40,7 @@ func (c *Container) Init(ctx context.Context) (err error) {
 	if !(c.state.State == ContainerStateConfigured ||
 		c.state.State == ContainerStateStopped ||
 		c.state.State == ContainerStateExited) {
-		return errors.Wrapf(ErrCtrStateInvalid, "container %s has already been created in runtime", c.ID())
+		return errors.Wrapf(define.ErrCtrStateInvalid, "container %s has already been created in runtime", c.ID())
 	}
 
 	// don't recursively start
@@ -180,12 +181,12 @@ func (c *Container) StopWithTimeout(timeout uint) error {
 	if c.state.State == ContainerStateConfigured ||
 		c.state.State == ContainerStateUnknown ||
 		c.state.State == ContainerStatePaused {
-		return errors.Wrapf(ErrCtrStateInvalid, "can only stop created, running, or stopped containers. %s is in state %s", c.ID(), c.state.State.String())
+		return errors.Wrapf(define.ErrCtrStateInvalid, "can only stop created, running, or stopped containers. %s is in state %s", c.ID(), c.state.State.String())
 	}
 
 	if c.state.State == ContainerStateStopped ||
 		c.state.State == ContainerStateExited {
-		return ErrCtrStopped
+		return define.ErrCtrStopped
 	}
 	defer c.newContainerEvent(events.Stop)
 	return c.stop(timeout)
@@ -203,7 +204,7 @@ func (c *Container) Kill(signal uint) error {
 	}
 
 	if c.state.State != ContainerStateRunning {
-		return errors.Wrapf(ErrCtrStateInvalid, "can only kill running containers. %s is in state %s", c.ID(), c.state.State.String())
+		return errors.Wrapf(define.ErrCtrStateInvalid, "can only kill running containers. %s is in state %s", c.ID(), c.state.State.String())
 	}
 
 	defer c.newContainerEvent(events.Kill)
@@ -241,7 +242,7 @@ func (c *Container) Exec(tty, privileged bool, env, cmd []string, user, workDir
 
 	// TODO can probably relax this once we track exec sessions
 	if conState != ContainerStateRunning {
-		return errors.Wrapf(ErrCtrStateInvalid, "cannot exec into container that is not running")
+		return errors.Wrapf(define.ErrCtrStateInvalid, "cannot exec into container that is not running")
 	}
 	if privileged || c.config.Privileged {
 		capList = caps.GetAllCapabilities()
@@ -401,7 +402,7 @@ func (c *Container) Attach(streams *AttachStreams, keys string, resize <-chan re
 	if c.state.State != ContainerStateCreated &&
 		c.state.State != ContainerStateRunning &&
 		c.state.State != ContainerStateExited {
-		return errors.Wrapf(ErrCtrStateInvalid, "can only attach to created or running containers")
+		return errors.Wrapf(define.ErrCtrStateInvalid, "can only attach to created or running containers")
 	}
 	defer c.newContainerEvent(events.Attach)
 	return c.attach(streams, keys, resize, false, nil)
@@ -440,12 +441,12 @@ func (c *Container) Unmount(force bool) error {
 		}
 		if mounted == 1 {
 			if c.state.State == ContainerStateRunning || c.state.State == ContainerStatePaused {
-				return errors.Wrapf(ErrCtrStateInvalid, "cannot unmount storage for container %s as it is running or paused", c.ID())
+				return errors.Wrapf(define.ErrCtrStateInvalid, "cannot unmount storage for container %s as it is running or paused", c.ID())
 			}
 			if len(c.state.ExecSessions) != 0 {
-				return errors.Wrapf(ErrCtrStateInvalid, "container %s has active exec sessions, refusing to unmount", c.ID())
+				return errors.Wrapf(define.ErrCtrStateInvalid, "container %s has active exec sessions, refusing to unmount", c.ID())
 			}
-			return errors.Wrapf(ErrInternal, "can't unmount %s last mount, it is still in use", c.ID())
+			return errors.Wrapf(define.ErrInternal, "can't unmount %s last mount, it is still in use", c.ID())
 		}
 	}
 	defer c.newContainerEvent(events.Unmount)
@@ -464,10 +465,10 @@ func (c *Container) Pause() error {
 	}
 
 	if c.state.State == ContainerStatePaused {
-		return errors.Wrapf(ErrCtrStateInvalid, "%q is already paused", c.ID())
+		return errors.Wrapf(define.ErrCtrStateInvalid, "%q is already paused", c.ID())
 	}
 	if c.state.State != ContainerStateRunning {
-		return errors.Wrapf(ErrCtrStateInvalid, "%q is not running, can't pause", c.state.State)
+		return errors.Wrapf(define.ErrCtrStateInvalid, "%q is not running, can't pause", c.state.State)
 	}
 	defer c.newContainerEvent(events.Pause)
 	return c.pause()
@@ -485,7 +486,7 @@ func (c *Container) Unpause() error {
 	}
 
 	if c.state.State != ContainerStatePaused {
-		return errors.Wrapf(ErrCtrStateInvalid, "%q is not paused, can't unpause", c.ID())
+		return errors.Wrapf(define.ErrCtrStateInvalid, "%q is not paused, can't unpause", c.ID())
 	}
 	defer c.newContainerEvent(events.Unpause)
 	return c.unpause()
@@ -509,7 +510,7 @@ func (c *Container) Export(path string) error {
 // AddArtifact creates and writes to an artifact file for the container
 func (c *Container) AddArtifact(name string, data []byte) error {
 	if !c.valid {
-		return ErrCtrRemoved
+		return define.ErrCtrRemoved
 	}
 
 	return ioutil.WriteFile(c.getArtifactPath(name), data, 0740)
@@ -518,7 +519,7 @@ func (c *Container) AddArtifact(name string, data []byte) error {
 // GetArtifact reads the specified artifact file from the container
 func (c *Container) GetArtifact(name string) ([]byte, error) {
 	if !c.valid {
-		return nil, ErrCtrRemoved
+		return nil, define.ErrCtrRemoved
 	}
 
 	return ioutil.ReadFile(c.getArtifactPath(name))
@@ -527,7 +528,7 @@ func (c *Container) GetArtifact(name string) ([]byte, error) {
 // RemoveArtifact deletes the specified artifacts file
 func (c *Container) RemoveArtifact(name string) error {
 	if !c.valid {
-		return ErrCtrRemoved
+		return define.ErrCtrRemoved
 	}
 
 	return os.Remove(c.getArtifactPath(name))
@@ -542,7 +543,7 @@ func (c *Container) Wait() (int32, error) {
 // code. The argument is the interval at which checks the container's status.
 func (c *Container) WaitWithInterval(waitTimeout time.Duration) (int32, error) {
 	if !c.valid {
-		return -1, ErrCtrRemoved
+		return -1, define.ErrCtrRemoved
 	}
 	err := wait.PollImmediateInfinite(waitTimeout,
 		func() (bool, error) {
@@ -578,7 +579,7 @@ func (c *Container) Cleanup(ctx context.Context) error {
 
 	// Check if state is good
 	if c.state.State == ContainerStateRunning || c.state.State == ContainerStatePaused {
-		return errors.Wrapf(ErrCtrStateInvalid, "container %s is running or paused, refusing to clean up", c.ID())
+		return errors.Wrapf(define.ErrCtrStateInvalid, "container %s is running or paused, refusing to clean up", c.ID())
 	}
 
 	// Handle restart policy.
@@ -596,7 +597,7 @@ func (c *Container) Cleanup(ctx context.Context) error {
 
 	// Check if we have active exec sessions
 	if len(c.state.ExecSessions) != 0 {
-		return errors.Wrapf(ErrCtrStateInvalid, "container %s has active exec sessions, refusing to clean up", c.ID())
+		return errors.Wrapf(define.ErrCtrStateInvalid, "container %s has active exec sessions, refusing to clean up", c.ID())
 	}
 	defer c.newContainerEvent(events.Cleanup)
 	return c.cleanup(ctx)
diff --git a/libpod/container_attach_linux.go b/libpod/container_attach_linux.go
index 7e9b7697b..5293480f0 100644
--- a/libpod/container_attach_linux.go
+++ b/libpod/container_attach_linux.go
@@ -10,6 +10,7 @@ import (
 	"path/filepath"
 	"sync"
 
+	"github.com/containers/libpod/libpod/define"
 	"github.com/containers/libpod/pkg/kubeutils"
 	"github.com/containers/libpod/utils"
 	"github.com/docker/docker/pkg/term"
@@ -34,7 +35,7 @@ const (
 // Does not check if state is appropriate
 func (c *Container) attach(streams *AttachStreams, keys string, resize <-chan remotecommand.TerminalSize, startContainer bool, wg *sync.WaitGroup) error {
 	if !streams.AttachOutput && !streams.AttachError && !streams.AttachInput {
-		return errors.Wrapf(ErrInvalidArg, "must provide at least one stream to attach to")
+		return errors.Wrapf(define.ErrInvalidArg, "must provide at least one stream to attach to")
 	}
 
 	// Check the validity of the provided keys first
@@ -57,7 +58,7 @@ func (c *Container) attach(streams *AttachStreams, keys string, resize <-chan re
 // TODO add a channel to allow interrupting
 func (c *Container) attachContainerSocket(resize <-chan remotecommand.TerminalSize, detachKeys []byte, streams *AttachStreams, startContainer bool, wg *sync.WaitGroup) error {
 	if startContainer && wg == nil {
-		return errors.Wrapf(ErrInternal, "wait group not passed when startContainer set")
+		return errors.Wrapf(define.ErrInternal, "wait group not passed when startContainer set")
 	}
 
 	kubeutils.HandleResizing(resize, func(size remotecommand.TerminalSize) {
@@ -118,7 +119,7 @@ func (c *Container) attachContainerSocket(resize <-chan remotecommand.TerminalSi
 	case err := <-receiveStdoutError:
 		return err
 	case err := <-stdinDone:
-		if err == ErrDetach {
+		if err == define.ErrDetach {
 			return err
 		}
 		if streams.AttachOutput || streams.AttachError {
diff --git a/libpod/container_attach_unsupported.go b/libpod/container_attach_unsupported.go
index 9e8badeaf..2c8718c67 100644
--- a/libpod/container_attach_unsupported.go
+++ b/libpod/container_attach_unsupported.go
@@ -5,9 +5,10 @@ package libpod
 import (
 	"sync"
 
+	"github.com/containers/libpod/libpod/define"
 	"k8s.io/client-go/tools/remotecommand"
 )
 
 func (c *Container) attach(streams *AttachStreams, keys string, resize <-chan remotecommand.TerminalSize, startContainer bool, wg *sync.WaitGroup) error {
-	return ErrNotImplemented
+	return define.ErrNotImplemented
 }
diff --git a/libpod/container_commit.go b/libpod/container_commit.go
index 5e6ddcbd1..82115455a 100644
--- a/libpod/container_commit.go
+++ b/libpod/container_commit.go
@@ -28,9 +28,6 @@ type ContainerCommitOptions struct {
 	Changes        []string
 }
 
-// ChangeCmds is the list of valid Changes commands to passed to the Commit call
-var ChangeCmds = []string{"CMD", "ENTRYPOINT", "ENV", "EXPOSE", "LABEL", "ONBUILD", "STOPSIGNAL", "USER", "VOLUME", "WORKDIR"}
-
 // Commit commits the changes between a container and its image, creating a new
 // image
 func (c *Container) Commit(ctx context.Context, destImage string, options ContainerCommitOptions) (*image.Image, error) {
diff --git a/libpod/container_graph.go b/libpod/container_graph.go
index da93be77d..c266c5227 100644
--- a/libpod/container_graph.go
+++ b/libpod/container_graph.go
@@ -4,6 +4,7 @@ import (
 	"context"
 	"strings"
 
+	"github.com/containers/libpod/libpod/define"
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 )
@@ -43,7 +44,7 @@ func buildContainerGraph(ctrs []*Container) (*containerGraph, error) {
 			// Get the dep's node
 			depNode, ok := graph.nodes[dep]
 			if !ok {
-				return nil, errors.Wrapf(ErrNoSuchCtr, "container %s depends on container %s not found in input list", node.id, dep)
+				return nil, errors.Wrapf(define.ErrNoSuchCtr, "container %s depends on container %s not found in input list", node.id, dep)
 			}
 
 			// Add the dependent node to the node's dependencies
@@ -68,7 +69,7 @@ func buildContainerGraph(ctrs []*Container) (*containerGraph, error) {
 	if err != nil {
 		return nil, err
 	} else if cycle {
-		return nil, errors.Wrapf(ErrInternal, "cycle found in container dependency graph")
+		return nil, errors.Wrapf(define.ErrInternal, "cycle found in container dependency graph")
 	}
 
 	return graph, nil
@@ -133,7 +134,7 @@ func detectCycles(graph *containerGraph) (bool, error) {
 		if info.lowLink == info.index {
 			l := len(stack)
 			if l == 0 {
-				return false, errors.Wrapf(ErrInternal, "empty stack in detectCycles")
+				return false, errors.Wrapf(define.ErrInternal, "empty stack in detectCycles")
 			}
 
 			// Pop off the stack
@@ -143,7 +144,7 @@ func detectCycles(graph *containerGraph) (bool, error) {
 			// Popped item is no longer on the stack, mark as such
 			topInfo, ok := nodes[topOfStack.id]
 			if !ok {
-				return false, errors.Wrapf(ErrInternal, "error finding node info for %s", topOfStack.id)
+				return false, errors.Wrapf(define.ErrInternal, "error finding node info for %s", topOfStack.id)
 			}
 			topInfo.onStack = false
 
@@ -186,7 +187,7 @@ func startNode(ctx context.Context, node *containerNode, setError bool, ctrError
 	if setError {
 		// Mark us as visited, and set an error
 		ctrsVisited[node.id] = true
-		ctrErrors[node.id] = errors.Wrapf(ErrCtrStateInvalid, "a dependency of container %s failed to start", node.id)
+		ctrErrors[node.id] = errors.Wrapf(define.ErrCtrStateInvalid, "a dependency of container %s failed to start", node.id)
 
 		// Hit anyone who depends on us, and set errors on them too
 		for _, successor := range node.dependedOn {
@@ -226,7 +227,7 @@ func startNode(ctx context.Context, node *containerNode, setError bool, ctrError
 	} else if len(depsStopped) > 0 {
 		// Our dependencies are not running
 		depsList := strings.Join(depsStopped, ",")
-		ctrErrors[node.id] = errors.Wrapf(ErrCtrStateInvalid, "the following dependencies of container %s are not running: %s", node.id, depsList)
+		ctrErrors[node.id] = errors.Wrapf(define.ErrCtrStateInvalid, "the following dependencies of container %s are not running: %s", node.id, depsList)
 		ctrErrored = true
 	}
 
diff --git a/libpod/container_internal.go b/libpod/container_internal.go
index 56fd27afb..2687bcdd1 100644
--- a/libpod/container_internal.go
+++ b/libpod/container_internal.go
@@ -12,6 +12,7 @@ import (
 	"strings"
 	"time"
 
+	"github.com/containers/libpod/libpod/define"
 	"github.com/containers/libpod/libpod/events"
 	"github.com/containers/libpod/pkg/ctime"
 	"github.com/containers/libpod/pkg/hooks"
@@ -23,7 +24,7 @@ import (
 	spec "github.com/opencontainers/runtime-spec/specs-go"
 	"github.com/opencontainers/runtime-tools/generate"
 	"github.com/opencontainers/selinux/go-selinux/label"
-	opentracing "github.com/opentracing/opentracing-go"
+	"github.com/opentracing/opentracing-go"
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 )
@@ -243,7 +244,7 @@ func (c *Container) handleRestartPolicy(ctx context.Context) (restarted bool, er
 	if c.state.State == ContainerStateRunning || c.state.State == ContainerStatePaused {
 		return false, nil
 	} else if c.state.State == ContainerStateUnknown {
-		return false, errors.Wrapf(ErrInternal, "invalid container state encountered in restart attempt!")
+		return false, errors.Wrapf(define.ErrInternal, "invalid container state encountered in restart attempt!")
 	}
 
 	c.newContainerEvent(events.Restart)
@@ -319,7 +320,7 @@ func (c *Container) syncContainer() error {
 	}
 
 	if !c.valid {
-		return errors.Wrapf(ErrCtrRemoved, "container %s is not valid", c.ID())
+		return errors.Wrapf(define.ErrCtrRemoved, "container %s is not valid", c.ID())
 	}
 
 	return nil
@@ -332,16 +333,16 @@ func (c *Container) setupStorage(ctx context.Context) error {
 	defer span.Finish()
 
 	if !c.valid {
-		return errors.Wrapf(ErrCtrRemoved, "container %s is not valid", c.ID())
+		return errors.Wrapf(define.ErrCtrRemoved, "container %s is not valid", c.ID())
 	}
 
 	if c.state.State != ContainerStateConfigured {
-		return errors.Wrapf(ErrCtrStateInvalid, "container %s must be in Configured state to have storage set up", c.ID())
+		return errors.Wrapf(define.ErrCtrStateInvalid, "container %s must be in Configured state to have storage set up", c.ID())
 	}
 
 	// Need both an image ID and image name, plus a bool telling us whether to use the image configuration
 	if c.config.Rootfs == "" && (c.config.RootfsImageID == "" || c.config.RootfsImageName == "") {
-		return errors.Wrapf(ErrInvalidArg, "must provide image ID and image name to use an image")
+		return errors.Wrapf(define.ErrInvalidArg, "must provide image ID and image name to use an image")
 	}
 
 	options := storage.ContainerOptions{
@@ -418,7 +419,7 @@ func (c *Container) setupStorage(ctx context.Context) error {
 // Tear down a container's storage prior to removal
 func (c *Container) teardownStorage() error {
 	if c.state.State == ContainerStateRunning || c.state.State == ContainerStatePaused {
-		return errors.Wrapf(ErrCtrStateInvalid, "cannot remove storage for container %s as it is running or paused", c.ID())
+		return errors.Wrapf(define.ErrCtrStateInvalid, "cannot remove storage for container %s as it is running or paused", c.ID())
 	}
 
 	artifacts := filepath.Join(c.config.StaticDir, artifactsDir)
@@ -478,7 +479,7 @@ func (c *Container) refresh() error {
 	}
 
 	if !c.valid {
-		return errors.Wrapf(ErrCtrRemoved, "container %s is not valid - may have been removed", c.ID())
+		return errors.Wrapf(define.ErrCtrRemoved, "container %s is not valid - may have been removed", c.ID())
 	}
 
 	// We need to get the container's temporary directory from c/storage
@@ -628,7 +629,7 @@ func (c *Container) prepareToStart(ctx context.Context, recursive bool) (err err
 		c.state.State == ContainerStateCreated ||
 		c.state.State == ContainerStateStopped ||
 		c.state.State == ContainerStateExited) {
-		return errors.Wrapf(ErrCtrStateInvalid, "container %s must be in Created or Stopped state to be started", c.ID())
+		return errors.Wrapf(define.ErrCtrStateInvalid, "container %s must be in Created or Stopped state to be started", c.ID())
 	}
 
 	if !recursive {
@@ -676,7 +677,7 @@ func (c *Container) checkDependenciesAndHandleError(ctx context.Context) error {
 	}
 	if len(notRunning) > 0 {
 		depString := strings.Join(notRunning, ",")
-		return errors.Wrapf(ErrCtrStateInvalid, "some dependencies of container %s are not started: %s", c.ID(), depString)
+		return errors.Wrapf(define.ErrCtrStateInvalid, "some dependencies of container %s are not started: %s", c.ID(), depString)
 	}
 
 	return nil
@@ -714,7 +715,7 @@ func (c *Container) startDependencies(ctx context.Context) error {
 		if len(graph.nodes) == 0 {
 			return nil
 		}
-		return errors.Wrapf(ErrNoSuchCtr, "All dependencies have dependencies of %s", c.ID())
+		return errors.Wrapf(define.ErrNoSuchCtr, "All dependencies have dependencies of %s", c.ID())
 	}
 
 	ctrErrors := make(map[string]error)
@@ -730,7 +731,7 @@ func (c *Container) startDependencies(ctx context.Context) error {
 		for _, e := range ctrErrors {
 			logrus.Errorf("%q", e)
 		}
-		return errors.Wrapf(ErrInternal, "error starting some containers")
+		return errors.Wrapf(define.ErrInternal, "error starting some containers")
 	}
 	return nil
 }
@@ -816,7 +817,7 @@ func (c *Container) checkDependenciesRunningLocked(depCtrs map[string]*Container
 	for _, dep := range deps {
 		depCtr, ok := depCtrs[dep]
 		if !ok {
-			return nil, errors.Wrapf(ErrNoSuchCtr, "container %s depends on container %s but it is not on containers passed to checkDependenciesRunning", c.ID(), dep)
+			return nil, errors.Wrapf(define.ErrNoSuchCtr, "container %s depends on container %s but it is not on containers passed to checkDependenciesRunning", c.ID(), dep)
 		}
 
 		if err := c.syncContainer(); err != nil {
@@ -964,7 +965,7 @@ func (c *Container) reinit(ctx context.Context, retainRetries bool) error {
 func (c *Container) initAndStart(ctx context.Context) (err error) {
 	// If we are ContainerStateUnknown, throw an error
 	if c.state.State == ContainerStateUnknown {
-		return errors.Wrapf(ErrCtrStateInvalid, "container %s is in an unknown state", c.ID())
+		return errors.Wrapf(define.ErrCtrStateInvalid, "container %s is in an unknown state", c.ID())
 	}
 
 	// If we are running, do nothing
@@ -973,7 +974,7 @@ func (c *Container) initAndStart(ctx context.Context) (err error) {
 	}
 	// If we are paused, throw an error
 	if c.state.State == ContainerStatePaused {
-		return errors.Wrapf(ErrCtrStateInvalid, "cannot start paused container %s", c.ID())
+		return errors.Wrapf(define.ErrCtrStateInvalid, "cannot start paused container %s", c.ID())
 	}
 
 	defer func() {
@@ -1080,7 +1081,7 @@ func (c *Container) unpause() error {
 // Internal, non-locking function to restart a container
 func (c *Container) restartWithTimeout(ctx context.Context, timeout uint) (err error) {
 	if c.state.State == ContainerStateUnknown || c.state.State == ContainerStatePaused {
-		return errors.Wrapf(ErrCtrStateInvalid, "unable to restart a container in a paused or unknown state")
+		return errors.Wrapf(define.ErrCtrStateInvalid, "unable to restart a container in a paused or unknown state")
 	}
 
 	c.newContainerEvent(events.Restart)
@@ -1489,16 +1490,16 @@ func (c *Container) copyWithTarFromImage(src, dest string) error {
 // Returns nil if safe to remove, or an error describing why it's unsafe if not.
 func (c *Container) checkReadyForRemoval() error {
 	if c.state.State == ContainerStateUnknown {
-		return errors.Wrapf(ErrCtrStateInvalid, "container %s is in invalid state", c.ID())
+		return errors.Wrapf(define.ErrCtrStateInvalid, "container %s is in invalid state", c.ID())
 	}
 
 	if c.state.State == ContainerStateRunning ||
 		c.state.State == ContainerStatePaused {
-		return errors.Wrapf(ErrCtrStateInvalid, "cannot remove container %s as it is %s - running or paused containers cannot be removed", c.ID(), c.state.State.String())
+		return errors.Wrapf(define.ErrCtrStateInvalid, "cannot remove container %s as it is %s - running or paused containers cannot be removed", c.ID(), c.state.State.String())
 	}
 
 	if len(c.state.ExecSessions) != 0 {
-		return errors.Wrapf(ErrCtrStateInvalid, "cannot remove container %s as it has active exec sessions", c.ID())
+		return errors.Wrapf(define.ErrCtrStateInvalid, "cannot remove container %s as it has active exec sessions", c.ID())
 	}
 
 	return nil
diff --git a/libpod/container_internal_linux.go b/libpod/container_internal_linux.go
index 50a2e2d44..1ea858886 100644
--- a/libpod/container_internal_linux.go
+++ b/libpod/container_internal_linux.go
@@ -20,6 +20,7 @@ import (
 	cnitypes "github.com/containernetworking/cni/pkg/types/current"
 	"github.com/containernetworking/plugins/pkg/ns"
 	"github.com/containers/buildah/pkg/secrets"
+	"github.com/containers/libpod/libpod/define"
 	crioAnnotations "github.com/containers/libpod/pkg/annotations"
 	"github.com/containers/libpod/pkg/apparmor"
 	"github.com/containers/libpod/pkg/criu"
@@ -568,7 +569,7 @@ func (c *Container) checkpoint(ctx context.Context, options ContainerCheckpointO
 	}
 
 	if c.state.State != ContainerStateRunning {
-		return errors.Wrapf(ErrCtrStateInvalid, "%q is not running, cannot checkpoint", c.state.State)
+		return errors.Wrapf(define.ErrCtrStateInvalid, "%q is not running, cannot checkpoint", c.state.State)
 	}
 
 	if err := c.checkpointRestoreLabelLog("dump.log"); err != nil {
@@ -659,7 +660,7 @@ func (c *Container) restore(ctx context.Context, options ContainerCheckpointOpti
 	}
 
 	if (c.state.State != ContainerStateConfigured) && (c.state.State != ContainerStateExited) {
-		return errors.Wrapf(ErrCtrStateInvalid, "container %s is running or paused, cannot restore", c.ID())
+		return errors.Wrapf(define.ErrCtrStateInvalid, "container %s is running or paused, cannot restore", c.ID())
 	}
 
 	if options.TargetFile != "" {
diff --git a/libpod/container_internal_unsupported.go b/libpod/container_internal_unsupported.go
index f707b350c..6fa19a778 100644
--- a/libpod/container_internal_unsupported.go
+++ b/libpod/container_internal_unsupported.go
@@ -5,35 +5,36 @@ package libpod
 import (
 	"context"
 
+	"github.com/containers/libpod/libpod/define"
 	spec "github.com/opencontainers/runtime-spec/specs-go"
 )
 
 func (c *Container) mountSHM(shmOptions string) error {
-	return ErrNotImplemented
+	return define.ErrNotImplemented
 }
 
 func (c *Container) unmountSHM(mount string) error {
-	return ErrNotImplemented
+	return define.ErrNotImplemented
 }
 
 func (c *Container) prepare() (err error) {
-	return ErrNotImplemented
+	return define.ErrNotImplemented
 }
 
 func (c *Container) cleanupNetwork() error {
-	return ErrNotImplemented
+	return define.ErrNotImplemented
 }
 
 func (c *Container) generateSpec(ctx context.Context) (*spec.Spec, error) {
-	return nil, ErrNotImplemented
+	return nil, define.ErrNotImplemented
 }
 
 func (c *Container) checkpoint(ctx context.Context, options ContainerCheckpointOptions) error {
-	return ErrNotImplemented
+	return define.ErrNotImplemented
 }
 
 func (c *Container) restore(ctx context.Context, options ContainerCheckpointOptions) error {
-	return ErrNotImplemented
+	return define.ErrNotImplemented
 }
 
 func (c *Container) copyOwnerAndPerms(source, dest string) error {
diff --git a/libpod/container_log_unsupported.go b/libpod/container_log_unsupported.go
index 0ec5740e2..380d317b5 100644
--- a/libpod/container_log_unsupported.go
+++ b/libpod/container_log_unsupported.go
@@ -3,9 +3,10 @@
 package libpod
 
 import (
+	"github.com/containers/libpod/libpod/define"
 	"github.com/pkg/errors"
 )
 
 func (c *Container) readFromJournal(options *LogOptions, logChannel chan *LogLine) error {
-	return errors.Wrapf(ErrOSNotSupported, "Journald logging only enabled with systemd on linux")
+	return errors.Wrapf(define.ErrOSNotSupported, "Journald logging only enabled with systemd on linux")
 }
diff --git a/libpod/container_top_unsupported.go b/libpod/container_top_unsupported.go
index 1e6fb836d..2117f913d 100644
--- a/libpod/container_top_unsupported.go
+++ b/libpod/container_top_unsupported.go
@@ -2,6 +2,8 @@
 
 package libpod
 
+import "github.com/containers/libpod/libpod/define"
+
 // GetContainerPidInformation returns process-related data of all processes in
 // the container.  The output data can be controlled via the `descriptors`
 // argument which expects format descriptors and supports all AIXformat
@@ -11,11 +13,11 @@ package libpod
 //
 // For more details, please refer to github.com/containers/psgo.
 func (c *Container) GetContainerPidInformation(descriptors []string) ([]string, error) {
-	return nil, ErrNotImplemented
+	return nil, define.ErrNotImplemented
 }
 
 // GetContainerPidInformationDescriptors returns a string slice of all supported
 // format descriptors of GetContainerPidInformation.
 func GetContainerPidInformationDescriptors() ([]string, error) {
-	return nil, ErrNotImplemented
+	return nil, define.ErrNotImplemented
 }
diff --git a/libpod/define/config.go b/libpod/define/config.go
new file mode 100644
index 000000000..256a4b21f
--- /dev/null
+++ b/libpod/define/config.go
@@ -0,0 +1,10 @@
+package define
+
+var (
+	// DefaultInitPath is the default path to the container-init binary
+	DefaultInitPath = "/usr/libexec/podman/catatonit"
+)
+
+// CtrRemoveTimeout is the default number of seconds to wait after stopping a container
+// before sending the kill signal
+const CtrRemoveTimeout = 10
diff --git a/libpod/errors.go b/libpod/define/errors.go
index cca0935ec..14643ced1 100644
--- a/libpod/errors.go
+++ b/libpod/define/errors.go
@@ -1,4 +1,4 @@
-package libpod
+package define
 
 import (
 	"errors"
diff --git a/libpod/healthcheck_unsupported.go b/libpod/healthcheck_unsupported.go
index d01d1ccd4..1eccc77ba 100644
--- a/libpod/healthcheck_unsupported.go
+++ b/libpod/healthcheck_unsupported.go
@@ -2,18 +2,20 @@
 
 package libpod
 
+import "github.com/containers/libpod/libpod/define"
+
 // createTimer systemd timers for healthchecks of a container
 func (c *Container) createTimer() error {
-	return ErrNotImplemented
+	return define.ErrNotImplemented
 }
 
 // startTimer starts a systemd timer for the healthchecks
 func (c *Container) startTimer() error {
-	return ErrNotImplemented
+	return define.ErrNotImplemented
 }
 
 // removeTimer removes the systemd timer and unit files
 // for the container
 func (c *Container) removeTimer() error {
-	return ErrNotImplemented
+	return define.ErrNotImplemented
 }
diff --git a/libpod/in_memory_state.go b/libpod/in_memory_state.go
index 2669206df..7c4abd25d 100644
--- a/libpod/in_memory_state.go
+++ b/libpod/in_memory_state.go
@@ -3,6 +3,7 @@ package libpod
 import (
 	"strings"
 
+	"github.com/containers/libpod/libpod/define"
 	"github.com/containers/libpod/pkg/registrar"
 	"github.com/containers/storage/pkg/truncindex"
 	"github.com/pkg/errors"
@@ -99,12 +100,12 @@ func (s *InMemoryState) SetNamespace(ns string) error {
 // Container retrieves a container from its full ID
 func (s *InMemoryState) Container(id string) (*Container, error) {
 	if id == "" {
-		return nil, ErrEmptyID
+		return nil, define.ErrEmptyID
 	}
 
 	ctr, ok := s.containers[id]
 	if !ok {
-		return nil, errors.Wrapf(ErrNoSuchCtr, "no container with ID %s found", id)
+		return nil, errors.Wrapf(define.ErrNoSuchCtr, "no container with ID %s found", id)
 	}
 
 	if err := s.checkNSMatch(ctr.ID(), ctr.Namespace()); err != nil {
@@ -122,7 +123,7 @@ func (s *InMemoryState) LookupContainer(idOrName string) (*Container, error) {
 	)
 
 	if idOrName == "" {
-		return nil, ErrEmptyID
+		return nil, define.ErrEmptyID
 	}
 
 	if s.namespace != "" {
@@ -130,7 +131,7 @@ func (s *InMemoryState) LookupContainer(idOrName string) (*Container, error) {
 		if !ok {
 			// We have no containers in the namespace
 			// Return false
-			return nil, errors.Wrapf(ErrNoSuchCtr, "no container found with name or ID %s", idOrName)
+			return nil, errors.Wrapf(define.ErrNoSuchCtr, "no container found with name or ID %s", idOrName)
 		}
 		nameIndex = nsIndex.nameIndex
 		idIndex = nsIndex.idIndex
@@ -146,7 +147,7 @@ func (s *InMemoryState) LookupContainer(idOrName string) (*Container, error) {
 			fullID, err = idIndex.Get(idOrName)
 			if err != nil {
 				if err == truncindex.ErrNotExist {
-					return nil, errors.Wrapf(ErrNoSuchCtr, "no container found with name or ID %s", idOrName)
+					return nil, errors.Wrapf(define.ErrNoSuchCtr, "no container found with name or ID %s", idOrName)
 				}
 				return nil, errors.Wrapf(err, "error performing truncindex lookup for ID %s", idOrName)
 			}
@@ -158,7 +159,7 @@ func (s *InMemoryState) LookupContainer(idOrName string) (*Container, error) {
 	ctr, ok := s.containers[fullID]
 	if !ok {
 		// It's a pod, not a container
-		return nil, errors.Wrapf(ErrNoSuchCtr, "name or ID %s is a pod, not a container", idOrName)
+		return nil, errors.Wrapf(define.ErrNoSuchCtr, "name or ID %s is a pod, not a container", idOrName)
 	}
 
 	return ctr, nil
@@ -167,7 +168,7 @@ func (s *InMemoryState) LookupContainer(idOrName string) (*Container, error) {
 // HasContainer checks if a container with the given ID is present in the state
 func (s *InMemoryState) HasContainer(id string) (bool, error) {
 	if id == "" {
-		return false, ErrEmptyID
+		return false, define.ErrEmptyID
 	}
 
 	ctr, ok := s.containers[id]
@@ -182,15 +183,15 @@ func (s *InMemoryState) HasContainer(id string) (bool, error) {
 // Containers in a pod cannot be added to the state
 func (s *InMemoryState) AddContainer(ctr *Container) error {
 	if !ctr.valid {
-		return errors.Wrapf(ErrCtrRemoved, "container with ID %s is not valid", ctr.ID())
+		return errors.Wrapf(define.ErrCtrRemoved, "container with ID %s is not valid", ctr.ID())
 	}
 
 	if _, ok := s.containers[ctr.ID()]; ok {
-		return errors.Wrapf(ErrCtrExists, "container with ID %s already exists in state", ctr.ID())
+		return errors.Wrapf(define.ErrCtrExists, "container with ID %s already exists in state", ctr.ID())
 	}
 
 	if ctr.config.Pod != "" {
-		return errors.Wrapf(ErrInvalidArg, "cannot add a container that is in a pod with AddContainer, use AddContainerToPod")
+		return errors.Wrapf(define.ErrInvalidArg, "cannot add a container that is in a pod with AddContainer, use AddContainerToPod")
 	}
 
 	if err := s.checkNSMatch(ctr.ID(), ctr.Namespace()); err != nil {
@@ -204,12 +205,12 @@ func (s *InMemoryState) AddContainer(ctr *Container) error {
 	for _, depID := range depCtrs {
 		depCtr, ok := s.containers[depID]
 		if !ok {
-			return errors.Wrapf(ErrNoSuchCtr, "cannot depend on nonexistent container %s", depID)
+			return errors.Wrapf(define.ErrNoSuchCtr, "cannot depend on nonexistent container %s", depID)
 		} else if depCtr.config.Pod != "" {
-			return errors.Wrapf(ErrInvalidArg, "cannot depend on container in a pod if not part of same pod")
+			return errors.Wrapf(define.ErrInvalidArg, "cannot depend on container in a pod if not part of same pod")
 		}
 		if depCtr.config.Namespace != ctr.config.Namespace {
-			return errors.Wrapf(ErrNSMismatch, "container %s is in namespace %s and cannot depend on container %s in namespace %s", ctr.ID(), ctr.config.Namespace, depID, depCtr.config.Namespace)
+			return errors.Wrapf(define.ErrNSMismatch, "container %s is in namespace %s and cannot depend on container %s in namespace %s", ctr.ID(), ctr.config.Namespace, depID, depCtr.config.Namespace)
 		}
 	}
 
@@ -270,12 +271,12 @@ func (s *InMemoryState) RemoveContainer(ctr *Container) error {
 	deps, ok := s.ctrDepends[ctr.ID()]
 	if ok && len(deps) != 0 {
 		depsStr := strings.Join(deps, ", ")
-		return errors.Wrapf(ErrCtrExists, "the following containers depend on container %s: %s", ctr.ID(), depsStr)
+		return errors.Wrapf(define.ErrCtrExists, "the following containers depend on container %s: %s", ctr.ID(), depsStr)
 	}
 
 	if _, ok := s.containers[ctr.ID()]; !ok {
 		ctr.valid = false
-		return errors.Wrapf(ErrNoSuchCtr, "no container exists in state with ID %s", ctr.ID())
+		return errors.Wrapf(define.ErrNoSuchCtr, "no container exists in state with ID %s", ctr.ID())
 	}
 
 	if err := s.idIndex.Delete(ctr.ID()); err != nil {
@@ -289,7 +290,7 @@ func (s *InMemoryState) RemoveContainer(ctr *Container) error {
 	if ctr.config.Namespace != "" {
 		nsIndex, ok := s.namespaceIndexes[ctr.config.Namespace]
 		if !ok {
-			return errors.Wrapf(ErrInternal, "error retrieving index for namespace %q", ctr.config.Namespace)
+			return errors.Wrapf(define.ErrInternal, "error retrieving index for namespace %q", ctr.config.Namespace)
 		}
 		if err := nsIndex.idIndex.Delete(ctr.ID()); err != nil {
 			return errors.Wrapf(err, "error removing container %s from namespace ID index", ctr.ID())
@@ -317,13 +318,13 @@ func (s *InMemoryState) RemoveContainer(ctr *Container) error {
 func (s *InMemoryState) UpdateContainer(ctr *Container) error {
 	// If the container is invalid, return error
 	if !ctr.valid {
-		return errors.Wrapf(ErrCtrRemoved, "container with ID %s is not valid", ctr.ID())
+		return errors.Wrapf(define.ErrCtrRemoved, "container with ID %s is not valid", ctr.ID())
 	}
 
 	// If the container does not exist, return error
 	if _, ok := s.containers[ctr.ID()]; !ok {
 		ctr.valid = false
-		return errors.Wrapf(ErrNoSuchCtr, "container with ID %s not found in state", ctr.ID())
+		return errors.Wrapf(define.ErrNoSuchCtr, "container with ID %s not found in state", ctr.ID())
 	}
 
 	return s.checkNSMatch(ctr.ID(), ctr.Namespace())
@@ -336,13 +337,13 @@ func (s *InMemoryState) UpdateContainer(ctr *Container) error {
 func (s *InMemoryState) SaveContainer(ctr *Container) error {
 	// If the container is invalid, return error
 	if !ctr.valid {
-		return errors.Wrapf(ErrCtrRemoved, "container with ID %s is not valid", ctr.ID())
+		return errors.Wrapf(define.ErrCtrRemoved, "container with ID %s is not valid", ctr.ID())
 	}
 
 	// If the container does not exist, return error
 	if _, ok := s.containers[ctr.ID()]; !ok {
 		ctr.valid = false
-		return errors.Wrapf(ErrNoSuchCtr, "container with ID %s not found in state", ctr.ID())
+		return errors.Wrapf(define.ErrNoSuchCtr, "container with ID %s not found in state", ctr.ID())
 	}
 
 	return s.checkNSMatch(ctr.ID(), ctr.Namespace())
@@ -351,13 +352,13 @@ func (s *InMemoryState) SaveContainer(ctr *Container) error {
 // ContainerInUse checks if the given container is being used by other containers
 func (s *InMemoryState) ContainerInUse(ctr *Container) ([]string, error) {
 	if !ctr.valid {
-		return nil, ErrCtrRemoved
+		return nil, define.ErrCtrRemoved
 	}
 
 	// If the container does not exist, return error
 	if _, ok := s.containers[ctr.ID()]; !ok {
 		ctr.valid = false
-		return nil, errors.Wrapf(ErrNoSuchCtr, "container with ID %s not found in state", ctr.ID())
+		return nil, errors.Wrapf(define.ErrNoSuchCtr, "container with ID %s not found in state", ctr.ID())
 	}
 
 	if err := s.checkNSMatch(ctr.ID(), ctr.Namespace()); err != nil {
@@ -389,14 +390,14 @@ func (s *InMemoryState) AllContainers() ([]*Container, error) {
 // Please read the full comment on it in state.go before using it.
 func (s *InMemoryState) RewriteContainerConfig(ctr *Container, newCfg *ContainerConfig) error {
 	if !ctr.valid {
-		return ErrCtrRemoved
+		return define.ErrCtrRemoved
 	}
 
 	// If the container does not exist, return error
 	stateCtr, ok := s.containers[ctr.ID()]
 	if !ok {
 		ctr.valid = false
-		return errors.Wrapf(ErrNoSuchCtr, "container with ID %s not found in state", ctr.ID())
+		return errors.Wrapf(define.ErrNoSuchCtr, "container with ID %s not found in state", ctr.ID())
 	}
 
 	stateCtr.config = newCfg
@@ -409,14 +410,14 @@ func (s *InMemoryState) RewriteContainerConfig(ctr *Container, newCfg *Container
 // Please read the full comment on it in state.go before using it.
 func (s *InMemoryState) RewritePodConfig(pod *Pod, newCfg *PodConfig) error {
 	if !pod.valid {
-		return ErrPodRemoved
+		return define.ErrPodRemoved
 	}
 
 	// If the pod does not exist, return error
 	statePod, ok := s.pods[pod.ID()]
 	if !ok {
 		pod.valid = false
-		return errors.Wrapf(ErrNoSuchPod, "pod with ID %s not found in state", pod.ID())
+		return errors.Wrapf(define.ErrNoSuchPod, "pod with ID %s not found in state", pod.ID())
 	}
 
 	statePod.config = newCfg
@@ -427,12 +428,12 @@ func (s *InMemoryState) RewritePodConfig(pod *Pod, newCfg *PodConfig) error {
 // Volume retrieves a volume from its full name
 func (s *InMemoryState) Volume(name string) (*Volume, error) {
 	if name == "" {
-		return nil, ErrEmptyID
+		return nil, define.ErrEmptyID
 	}
 
 	vol, ok := s.volumes[name]
 	if !ok {
-		return nil, errors.Wrapf(ErrNoSuchCtr, "no volume with name %s found", name)
+		return nil, errors.Wrapf(define.ErrNoSuchCtr, "no volume with name %s found", name)
 	}
 
 	return vol, nil
@@ -441,7 +442,7 @@ func (s *InMemoryState) Volume(name string) (*Volume, error) {
 // HasVolume checks if a volume with the given name is present in the state
 func (s *InMemoryState) HasVolume(name string) (bool, error) {
 	if name == "" {
-		return false, ErrEmptyID
+		return false, define.ErrEmptyID
 	}
 
 	_, ok := s.volumes[name]
@@ -455,11 +456,11 @@ func (s *InMemoryState) HasVolume(name string) (bool, error) {
 // AddVolume adds a volume to the state
 func (s *InMemoryState) AddVolume(volume *Volume) error {
 	if !volume.valid {
-		return errors.Wrapf(ErrVolumeRemoved, "volume with name %s is not valid", volume.Name())
+		return errors.Wrapf(define.ErrVolumeRemoved, "volume with name %s is not valid", volume.Name())
 	}
 
 	if _, ok := s.volumes[volume.Name()]; ok {
-		return errors.Wrapf(ErrVolumeExists, "volume with name %s already exists in state", volume.Name())
+		return errors.Wrapf(define.ErrVolumeExists, "volume with name %s already exists in state", volume.Name())
 	}
 
 	s.volumes[volume.Name()] = volume
@@ -473,12 +474,12 @@ func (s *InMemoryState) RemoveVolume(volume *Volume) error {
 	deps, ok := s.volumeDepends[volume.Name()]
 	if ok && len(deps) != 0 {
 		depsStr := strings.Join(deps, ", ")
-		return errors.Wrapf(ErrVolumeExists, "the following containers depend on volume %s: %s", volume.Name(), depsStr)
+		return errors.Wrapf(define.ErrVolumeExists, "the following containers depend on volume %s: %s", volume.Name(), depsStr)
 	}
 
 	if _, ok := s.volumes[volume.Name()]; !ok {
 		volume.valid = false
-		return errors.Wrapf(ErrVolumeRemoved, "no volume exists in state with name %s", volume.Name())
+		return errors.Wrapf(define.ErrVolumeRemoved, "no volume exists in state with name %s", volume.Name())
 	}
 
 	delete(s.volumes, volume.Name())
@@ -489,13 +490,13 @@ func (s *InMemoryState) RemoveVolume(volume *Volume) error {
 // VolumeInUse checks if the given volume is being used by at least one container
 func (s *InMemoryState) VolumeInUse(volume *Volume) ([]string, error) {
 	if !volume.valid {
-		return nil, ErrVolumeRemoved
+		return nil, define.ErrVolumeRemoved
 	}
 
 	// If the volume does not exist, return error
 	if _, ok := s.volumes[volume.Name()]; !ok {
 		volume.valid = false
-		return nil, errors.Wrapf(ErrNoSuchVolume, "volume with name %s not found in state", volume.Name())
+		return nil, errors.Wrapf(define.ErrNoSuchVolume, "volume with name %s not found in state", volume.Name())
 	}
 
 	arr, ok := s.volumeDepends[volume.Name()]
@@ -519,12 +520,12 @@ func (s *InMemoryState) AllVolumes() ([]*Volume, error) {
 // Pod retrieves a pod from the state from its full ID
 func (s *InMemoryState) Pod(id string) (*Pod, error) {
 	if id == "" {
-		return nil, ErrEmptyID
+		return nil, define.ErrEmptyID
 	}
 
 	pod, ok := s.pods[id]
 	if !ok {
-		return nil, errors.Wrapf(ErrNoSuchPod, "no pod with id %s found", id)
+		return nil, errors.Wrapf(define.ErrNoSuchPod, "no pod with id %s found", id)
 	}
 
 	if err := s.checkNSMatch(pod.ID(), pod.Namespace()); err != nil {
@@ -543,7 +544,7 @@ func (s *InMemoryState) LookupPod(idOrName string) (*Pod, error) {
 	)
 
 	if idOrName == "" {
-		return nil, ErrEmptyID
+		return nil, define.ErrEmptyID
 	}
 
 	if s.namespace != "" {
@@ -551,7 +552,7 @@ func (s *InMemoryState) LookupPod(idOrName string) (*Pod, error) {
 		if !ok {
 			// We have no containers in the namespace
 			// Return false
-			return nil, errors.Wrapf(ErrNoSuchCtr, "no container found with name or ID %s", idOrName)
+			return nil, errors.Wrapf(define.ErrNoSuchCtr, "no container found with name or ID %s", idOrName)
 		}
 		nameIndex = nsIndex.nameIndex
 		idIndex = nsIndex.idIndex
@@ -567,7 +568,7 @@ func (s *InMemoryState) LookupPod(idOrName string) (*Pod, error) {
 			fullID, err = idIndex.Get(idOrName)
 			if err != nil {
 				if err == truncindex.ErrNotExist {
-					return nil, errors.Wrapf(ErrNoSuchPod, "no pod found with name or ID %s", idOrName)
+					return nil, errors.Wrapf(define.ErrNoSuchPod, "no pod found with name or ID %s", idOrName)
 				}
 				return nil, errors.Wrapf(err, "error performing truncindex lookup for ID %s", idOrName)
 			}
@@ -579,7 +580,7 @@ func (s *InMemoryState) LookupPod(idOrName string) (*Pod, error) {
 	pod, ok := s.pods[fullID]
 	if !ok {
 		// It's a container not a pod
-		return nil, errors.Wrapf(ErrNoSuchPod, "id or name %s is a container not a pod", idOrName)
+		return nil, errors.Wrapf(define.ErrNoSuchPod, "id or name %s is a container not a pod", idOrName)
 	}
 
 	return pod, nil
@@ -588,7 +589,7 @@ func (s *InMemoryState) LookupPod(idOrName string) (*Pod, error) {
 // HasPod checks if a pod with the given ID is present in the state
 func (s *InMemoryState) HasPod(id string) (bool, error) {
 	if id == "" {
-		return false, ErrEmptyID
+		return false, define.ErrEmptyID
 	}
 
 	pod, ok := s.pods[id]
@@ -602,11 +603,11 @@ func (s *InMemoryState) HasPod(id string) (bool, error) {
 // PodHasContainer checks if the given pod has a container with the given ID
 func (s *InMemoryState) PodHasContainer(pod *Pod, ctrID string) (bool, error) {
 	if !pod.valid {
-		return false, errors.Wrapf(ErrPodRemoved, "pod %s is not valid", pod.ID())
+		return false, errors.Wrapf(define.ErrPodRemoved, "pod %s is not valid", pod.ID())
 	}
 
 	if ctrID == "" {
-		return false, ErrEmptyID
+		return false, define.ErrEmptyID
 	}
 
 	if err := s.checkNSMatch(pod.ID(), pod.Namespace()); err != nil {
@@ -616,7 +617,7 @@ func (s *InMemoryState) PodHasContainer(pod *Pod, ctrID string) (bool, error) {
 	podCtrs, ok := s.podContainers[pod.ID()]
 	if !ok {
 		pod.valid = false
-		return false, errors.Wrapf(ErrNoSuchPod, "no pod with ID %s found in state", pod.ID())
+		return false, errors.Wrapf(define.ErrNoSuchPod, "no pod with ID %s found in state", pod.ID())
 	}
 
 	_, ok = podCtrs[ctrID]
@@ -626,7 +627,7 @@ func (s *InMemoryState) PodHasContainer(pod *Pod, ctrID string) (bool, error) {
 // PodContainersByID returns the IDs of all containers in the given pod
 func (s *InMemoryState) PodContainersByID(pod *Pod) ([]string, error) {
 	if !pod.valid {
-		return nil, errors.Wrapf(ErrPodRemoved, "pod %s is not valid", pod.ID())
+		return nil, errors.Wrapf(define.ErrPodRemoved, "pod %s is not valid", pod.ID())
 	}
 
 	if err := s.checkNSMatch(pod.ID(), pod.Namespace()); err != nil {
@@ -636,7 +637,7 @@ func (s *InMemoryState) PodContainersByID(pod *Pod) ([]string, error) {
 	podCtrs, ok := s.podContainers[pod.ID()]
 	if !ok {
 		pod.valid = false
-		return nil, errors.Wrapf(ErrNoSuchPod, "no pod with ID %s found in state", pod.ID())
+		return nil, errors.Wrapf(define.ErrNoSuchPod, "no pod with ID %s found in state", pod.ID())
 	}
 
 	length := len(podCtrs)
@@ -655,7 +656,7 @@ func (s *InMemoryState) PodContainersByID(pod *Pod) ([]string, error) {
 // PodContainers retrieves the containers from a pod
 func (s *InMemoryState) PodContainers(pod *Pod) ([]*Container, error) {
 	if !pod.valid {
-		return nil, errors.Wrapf(ErrPodRemoved, "pod %s is not valid", pod.ID())
+		return nil, errors.Wrapf(define.ErrPodRemoved, "pod %s is not valid", pod.ID())
 	}
 
 	if err := s.checkNSMatch(pod.ID(), pod.Namespace()); err != nil {
@@ -665,7 +666,7 @@ func (s *InMemoryState) PodContainers(pod *Pod) ([]*Container, error) {
 	podCtrs, ok := s.podContainers[pod.ID()]
 	if !ok {
 		pod.valid = false
-		return nil, errors.Wrapf(ErrNoSuchPod, "no pod with ID %s found in state", pod.ID())
+		return nil, errors.Wrapf(define.ErrNoSuchPod, "no pod with ID %s found in state", pod.ID())
 	}
 
 	length := len(podCtrs)
@@ -684,7 +685,7 @@ func (s *InMemoryState) PodContainers(pod *Pod) ([]*Container, error) {
 // AddPod adds a given pod to the state
 func (s *InMemoryState) AddPod(pod *Pod) error {
 	if !pod.valid {
-		return errors.Wrapf(ErrPodRemoved, "pod %s is not valid and cannot be added", pod.ID())
+		return errors.Wrapf(define.ErrPodRemoved, "pod %s is not valid and cannot be added", pod.ID())
 	}
 
 	if err := s.checkNSMatch(pod.ID(), pod.Namespace()); err != nil {
@@ -692,11 +693,11 @@ func (s *InMemoryState) AddPod(pod *Pod) error {
 	}
 
 	if _, ok := s.pods[pod.ID()]; ok {
-		return errors.Wrapf(ErrPodExists, "pod with ID %s already exists in state", pod.ID())
+		return errors.Wrapf(define.ErrPodExists, "pod with ID %s already exists in state", pod.ID())
 	}
 
 	if _, ok := s.podContainers[pod.ID()]; ok {
-		return errors.Wrapf(ErrPodExists, "pod with ID %s already exists in state", pod.ID())
+		return errors.Wrapf(define.ErrPodExists, "pod with ID %s already exists in state", pod.ID())
 	}
 
 	if err := s.nameIndex.Reserve(pod.Name(), pod.ID()); err != nil {
@@ -746,15 +747,15 @@ func (s *InMemoryState) RemovePod(pod *Pod) error {
 
 	if _, ok := s.pods[pod.ID()]; !ok {
 		pod.valid = false
-		return errors.Wrapf(ErrNoSuchPod, "no pod exists in state with ID %s", pod.ID())
+		return errors.Wrapf(define.ErrNoSuchPod, "no pod exists in state with ID %s", pod.ID())
 	}
 	podCtrs, ok := s.podContainers[pod.ID()]
 	if !ok {
 		pod.valid = false
-		return errors.Wrapf(ErrNoSuchPod, "no pod exists in state with ID %s", pod.ID())
+		return errors.Wrapf(define.ErrNoSuchPod, "no pod exists in state with ID %s", pod.ID())
 	}
 	if len(podCtrs) != 0 {
-		return errors.Wrapf(ErrCtrExists, "pod %s is not empty and cannot be removed", pod.ID())
+		return errors.Wrapf(define.ErrCtrExists, "pod %s is not empty and cannot be removed", pod.ID())
 	}
 
 	if err := s.idIndex.Delete(pod.ID()); err != nil {
@@ -767,7 +768,7 @@ func (s *InMemoryState) RemovePod(pod *Pod) error {
 	if pod.config.Namespace != "" {
 		nsIndex, ok := s.namespaceIndexes[pod.config.Namespace]
 		if !ok {
-			return errors.Wrapf(ErrInternal, "error retrieving index for namespace %q", pod.config.Namespace)
+			return errors.Wrapf(define.ErrInternal, "error retrieving index for namespace %q", pod.config.Namespace)
 		}
 		if err := nsIndex.idIndex.Delete(pod.ID()); err != nil {
 			return errors.Wrapf(err, "error removing container %s from namespace ID index", pod.ID())
@@ -784,7 +785,7 @@ func (s *InMemoryState) RemovePod(pod *Pod) error {
 // Will only remove containers if no dependencies outside of the pod are present
 func (s *InMemoryState) RemovePodContainers(pod *Pod) error {
 	if !pod.valid {
-		return errors.Wrapf(ErrPodRemoved, "pod %s is not valid", pod.ID())
+		return errors.Wrapf(define.ErrPodRemoved, "pod %s is not valid", pod.ID())
 	}
 
 	if err := s.checkNSMatch(pod.ID(), pod.Namespace()); err != nil {
@@ -795,7 +796,7 @@ func (s *InMemoryState) RemovePodContainers(pod *Pod) error {
 	podCtrs, ok := s.podContainers[pod.ID()]
 	if !ok {
 		pod.valid = false
-		return errors.Wrapf(ErrNoSuchPod, "no pod exists in state with ID %s", pod.ID())
+		return errors.Wrapf(define.ErrNoSuchPod, "no pod exists in state with ID %s", pod.ID())
 	}
 
 	// Go through container dependencies. Check to see if any are outside the pod.
@@ -804,7 +805,7 @@ func (s *InMemoryState) RemovePodContainers(pod *Pod) error {
 		if ok {
 			for _, dep := range ctrDeps {
 				if _, ok := podCtrs[dep]; !ok {
-					return errors.Wrapf(ErrCtrExists, "container %s has dependency %s outside of pod %s", ctr, dep, pod.ID())
+					return errors.Wrapf(define.ErrCtrExists, "container %s has dependency %s outside of pod %s", ctr, dep, pod.ID())
 				}
 			}
 		}
@@ -830,18 +831,18 @@ func (s *InMemoryState) RemovePodContainers(pod *Pod) error {
 // state
 func (s *InMemoryState) AddContainerToPod(pod *Pod, ctr *Container) error {
 	if !pod.valid {
-		return errors.Wrapf(ErrPodRemoved, "pod %s is not valid", pod.ID())
+		return errors.Wrapf(define.ErrPodRemoved, "pod %s is not valid", pod.ID())
 	}
 	if !ctr.valid {
-		return errors.Wrapf(ErrCtrRemoved, "container %s is not valid", ctr.ID())
+		return errors.Wrapf(define.ErrCtrRemoved, "container %s is not valid", ctr.ID())
 	}
 
 	if ctr.config.Pod != pod.ID() {
-		return errors.Wrapf(ErrInvalidArg, "container %s is not in pod %s", ctr.ID(), pod.ID())
+		return errors.Wrapf(define.ErrInvalidArg, "container %s is not in pod %s", ctr.ID(), pod.ID())
 	}
 
 	if ctr.config.Namespace != pod.config.Namespace {
-		return errors.Wrapf(ErrNSMismatch, "container %s is in namespace %s and pod %s is in namespace %s",
+		return errors.Wrapf(define.ErrNSMismatch, "container %s is in namespace %s and pod %s is in namespace %s",
 			ctr.ID(), ctr.config.Namespace, pod.ID(), pod.config.Namespace)
 	}
 
@@ -853,12 +854,12 @@ func (s *InMemoryState) AddContainerToPod(pod *Pod, ctr *Container) error {
 	podCtrs, ok := s.podContainers[pod.ID()]
 	if !ok {
 		pod.valid = false
-		return errors.Wrapf(ErrPodRemoved, "pod %s not found in state", pod.ID())
+		return errors.Wrapf(define.ErrPodRemoved, "pod %s not found in state", pod.ID())
 	}
 
 	// Is the container already in the pod?
 	if _, ok = podCtrs[ctr.ID()]; ok {
-		return errors.Wrapf(ErrCtrExists, "container with ID %s already exists in pod %s", ctr.ID(), pod.ID())
+		return errors.Wrapf(define.ErrCtrExists, "container with ID %s already exists in pod %s", ctr.ID(), pod.ID())
 	}
 
 	// There are potential race conditions with this
@@ -867,20 +868,20 @@ func (s *InMemoryState) AddContainerToPod(pod *Pod, ctr *Container) error {
 	depCtrs := ctr.Dependencies()
 	for _, depCtr := range depCtrs {
 		if _, ok = s.containers[depCtr]; !ok {
-			return errors.Wrapf(ErrNoSuchCtr, "cannot depend on nonexistent container %s", depCtr)
+			return errors.Wrapf(define.ErrNoSuchCtr, "cannot depend on nonexistent container %s", depCtr)
 		}
 		depCtrStruct, ok := podCtrs[depCtr]
 		if !ok {
-			return errors.Wrapf(ErrInvalidArg, "cannot depend on container %s as it is not in pod %s", depCtr, pod.ID())
+			return errors.Wrapf(define.ErrInvalidArg, "cannot depend on container %s as it is not in pod %s", depCtr, pod.ID())
 		}
 		if depCtrStruct.config.Namespace != ctr.config.Namespace {
-			return errors.Wrapf(ErrNSMismatch, "container %s is in namespace %s and cannot depend on container %s in namespace %s", ctr.ID(), ctr.config.Namespace, depCtr, depCtrStruct.config.Namespace)
+			return errors.Wrapf(define.ErrNSMismatch, "container %s is in namespace %s and cannot depend on container %s in namespace %s", ctr.ID(), ctr.config.Namespace, depCtr, depCtrStruct.config.Namespace)
 		}
 	}
 
 	// Add container to state
 	if _, ok = s.containers[ctr.ID()]; ok {
-		return errors.Wrapf(ErrCtrExists, "container with ID %s already exists in state", ctr.ID())
+		return errors.Wrapf(define.ErrCtrExists, "container with ID %s already exists in state", ctr.ID())
 	}
 
 	if err := s.nameIndex.Reserve(ctr.Name(), ctr.ID()); err != nil {
@@ -928,10 +929,10 @@ func (s *InMemoryState) AddContainerToPod(pod *Pod, ctr *Container) error {
 // The container is also removed from the state
 func (s *InMemoryState) RemoveContainerFromPod(pod *Pod, ctr *Container) error {
 	if !pod.valid {
-		return errors.Wrapf(ErrPodRemoved, "pod %s is not valid and containers cannot be removed", pod.ID())
+		return errors.Wrapf(define.ErrPodRemoved, "pod %s is not valid and containers cannot be removed", pod.ID())
 	}
 	if !ctr.valid {
-		return errors.Wrapf(ErrCtrRemoved, "container %s is not valid and cannot be removed from the pod", ctr.ID())
+		return errors.Wrapf(define.ErrCtrRemoved, "container %s is not valid and cannot be removed from the pod", ctr.ID())
 	}
 
 	if err := s.checkNSMatch(ctr.ID(), ctr.Namespace()); err != nil {
@@ -942,30 +943,30 @@ func (s *InMemoryState) RemoveContainerFromPod(pod *Pod, ctr *Container) error {
 	deps, ok := s.ctrDepends[ctr.ID()]
 	if ok && len(deps) != 0 {
 		depsStr := strings.Join(deps, ", ")
-		return errors.Wrapf(ErrCtrExists, "the following containers depend on container %s: %s", ctr.ID(), depsStr)
+		return errors.Wrapf(define.ErrCtrExists, "the following containers depend on container %s: %s", ctr.ID(), depsStr)
 	}
 
 	// Retrieve pod containers
 	podCtrs, ok := s.podContainers[pod.ID()]
 	if !ok {
 		pod.valid = false
-		return errors.Wrapf(ErrPodRemoved, "pod %s has been removed", pod.ID())
+		return errors.Wrapf(define.ErrPodRemoved, "pod %s has been removed", pod.ID())
 	}
 
 	// Does the container exist?
 	if _, ok := s.containers[ctr.ID()]; !ok {
 		ctr.valid = false
-		return errors.Wrapf(ErrNoSuchCtr, "container %s does not exist in state", ctr.ID())
+		return errors.Wrapf(define.ErrNoSuchCtr, "container %s does not exist in state", ctr.ID())
 	}
 
 	// Is the container in the pod?
 	if _, ok := podCtrs[ctr.ID()]; !ok {
-		return errors.Wrapf(ErrNoSuchCtr, "container with ID %s not found in pod %s", ctr.ID(), pod.ID())
+		return errors.Wrapf(define.ErrNoSuchCtr, "container with ID %s not found in pod %s", ctr.ID(), pod.ID())
 	}
 
 	// Remove container from state
 	if _, ok := s.containers[ctr.ID()]; !ok {
-		return errors.Wrapf(ErrNoSuchCtr, "no container exists in state with ID %s", ctr.ID())
+		return errors.Wrapf(define.ErrNoSuchCtr, "no container exists in state with ID %s", ctr.ID())
 	}
 
 	if err := s.idIndex.Delete(ctr.ID()); err != nil {
@@ -980,7 +981,7 @@ func (s *InMemoryState) RemoveContainerFromPod(pod *Pod, ctr *Container) error {
 	if ctr.config.Namespace != "" {
 		nsIndex, ok := s.namespaceIndexes[ctr.config.Namespace]
 		if !ok {
-			return errors.Wrapf(ErrInternal, "error retrieving index for namespace %q", ctr.config.Namespace)
+			return errors.Wrapf(define.ErrInternal, "error retrieving index for namespace %q", ctr.config.Namespace)
 		}
 		if err := nsIndex.idIndex.Delete(ctr.ID()); err != nil {
 			return errors.Wrapf(err, "error removing container %s from namespace ID index", ctr.ID())
@@ -1001,7 +1002,7 @@ func (s *InMemoryState) RemoveContainerFromPod(pod *Pod, ctr *Container) error {
 // This is a no-op as there is no backing store
 func (s *InMemoryState) UpdatePod(pod *Pod) error {
 	if !pod.valid {
-		return ErrPodRemoved
+		return define.ErrPodRemoved
 	}
 
 	if err := s.checkNSMatch(pod.ID(), pod.Namespace()); err != nil {
@@ -1010,7 +1011,7 @@ func (s *InMemoryState) UpdatePod(pod *Pod) error {
 
 	if _, ok := s.pods[pod.ID()]; !ok {
 		pod.valid = false
-		return errors.Wrapf(ErrNoSuchPod, "no pod exists in state with ID %s", pod.ID())
+		return errors.Wrapf(define.ErrNoSuchPod, "no pod exists in state with ID %s", pod.ID())
 	}
 
 	return nil
@@ -1020,7 +1021,7 @@ func (s *InMemoryState) UpdatePod(pod *Pod) error {
 // This is a no-op at there is no backing store
 func (s *InMemoryState) SavePod(pod *Pod) error {
 	if !pod.valid {
-		return ErrPodRemoved
+		return define.ErrPodRemoved
 	}
 
 	if err := s.checkNSMatch(pod.ID(), pod.Namespace()); err != nil {
@@ -1029,7 +1030,7 @@ func (s *InMemoryState) SavePod(pod *Pod) error {
 
 	if _, ok := s.pods[pod.ID()]; !ok {
 		pod.valid = false
-		return errors.Wrapf(ErrNoSuchPod, "no pod exists in state with ID %s", pod.ID())
+		return errors.Wrapf(define.ErrNoSuchPod, "no pod exists in state with ID %s", pod.ID())
 	}
 
 	return nil
@@ -1133,7 +1134,7 @@ func (s *InMemoryState) removeCtrFromVolDependsMap(depCtrID, volName string) {
 // namespaces.
 func (s *InMemoryState) checkNSMatch(id, ns string) error {
 	if s.namespace != "" && s.namespace != ns {
-		return errors.Wrapf(ErrNSMismatch, "cannot access %s as it is in namespace %q and we are in namespace %q",
+		return errors.Wrapf(define.ErrNSMismatch, "cannot access %s as it is in namespace %q and we are in namespace %q",
 			id, ns, s.namespace)
 	}
 	return nil
diff --git a/libpod/kube.go b/libpod/kube.go
index 283662059..1622246d5 100644
--- a/libpod/kube.go
+++ b/libpod/kube.go
@@ -7,6 +7,7 @@ import (
 	"strings"
 	"time"
 
+	"github.com/containers/libpod/libpod/define"
 	"github.com/containers/libpod/pkg/lookup"
 	"github.com/containers/libpod/pkg/util"
 	"github.com/cri-o/ocicni/pkg/ocicni"
@@ -214,7 +215,7 @@ func containerToV1Container(c *Container) (v1.Container, error) {
 			return kubeContainer, err
 		}
 		kubeContainer.VolumeDevices = devices
-		return kubeContainer, errors.Wrapf(ErrNotImplemented, "linux devices")
+		return kubeContainer, errors.Wrapf(define.ErrNotImplemented, "linux devices")
 	}
 
 	if len(c.config.UserVolumes) > 0 {
diff --git a/libpod/networking_unsupported.go b/libpod/networking_unsupported.go
index 1e46ca40b..d9b3730aa 100644
--- a/libpod/networking_unsupported.go
+++ b/libpod/networking_unsupported.go
@@ -2,20 +2,22 @@
 
 package libpod
 
+import "github.com/containers/libpod/libpod/define"
+
 func (r *Runtime) setupRootlessNetNS(ctr *Container) (err error) {
-	return ErrNotImplemented
+	return define.ErrNotImplemented
 }
 
 func (r *Runtime) setupNetNS(ctr *Container) (err error) {
-	return ErrNotImplemented
+	return define.ErrNotImplemented
 }
 
 func (r *Runtime) teardownNetNS(ctr *Container) error {
-	return ErrNotImplemented
+	return define.ErrNotImplemented
 }
 
 func (r *Runtime) createNetNS(ctr *Container) (err error) {
-	return ErrNotImplemented
+	return define.ErrNotImplemented
 }
 
 func (c *Container) getContainerNetworkInfo(data *InspectContainerData) *InspectContainerData {
diff --git a/libpod/oci.go b/libpod/oci.go
index 36c1dea84..343738a3a 100644
--- a/libpod/oci.go
+++ b/libpod/oci.go
@@ -11,6 +11,7 @@ import (
 	"strings"
 	"time"
 
+	"github.com/containers/libpod/libpod/define"
 	"github.com/containers/libpod/pkg/util"
 	"github.com/cri-o/ocicni/pkg/ocicni"
 	spec "github.com/opencontainers/runtime-spec/specs-go"
@@ -79,7 +80,7 @@ type ociError struct {
 // The first path that points to a valid executable will be used.
 func newOCIRuntime(name string, paths []string, conmonPath string, runtimeCfg *RuntimeConfig, supportsJSON bool) (*OCIRuntime, error) {
 	if name == "" {
-		return nil, errors.Wrapf(ErrInvalidArg, "the OCI runtime must be provided a non-empty name")
+		return nil, errors.Wrapf(define.ErrInvalidArg, "the OCI runtime must be provided a non-empty name")
 	}
 
 	runtime := new(OCIRuntime)
@@ -114,14 +115,14 @@ func newOCIRuntime(name string, paths []string, conmonPath string, runtimeCfg *R
 		break
 	}
 	if !foundPath {
-		return nil, errors.Wrapf(ErrInvalidArg, "no valid executable found for OCI runtime %s", name)
+		return nil, errors.Wrapf(define.ErrInvalidArg, "no valid executable found for OCI runtime %s", name)
 	}
 
 	runtime.exitsDir = filepath.Join(runtime.tmpDir, "exits")
 	runtime.socketsDir = filepath.Join(runtime.tmpDir, "socket")
 
 	if runtime.cgroupManager != CgroupfsCgroupsManager && runtime.cgroupManager != SystemdCgroupsManager {
-		return nil, errors.Wrapf(ErrInvalidArg, "invalid cgroup manager specified: %s", runtime.cgroupManager)
+		return nil, errors.Wrapf(define.ErrInvalidArg, "invalid cgroup manager specified: %s", runtime.cgroupManager)
 	}
 
 	// Create the exit files and attach sockets directories
@@ -290,7 +291,7 @@ func (r *OCIRuntime) updateContainerStatus(ctr *Container, useRuntime bool) erro
 	case "stopped":
 		ctr.state.State = ContainerStateStopped
 	default:
-		return errors.Wrapf(ErrInternal, "unrecognized status returned by runtime for container %s: %s",
+		return errors.Wrapf(define.ErrInternal, "unrecognized status returned by runtime for container %s: %s",
 			ctr.ID(), state.Status)
 	}
 
@@ -390,11 +391,11 @@ func (r *OCIRuntime) unpauseContainer(ctr *Container) error {
 // TODO: add --pid-file and use that to generate exec session tracking
 func (r *OCIRuntime) execContainer(c *Container, cmd, capAdd, env []string, tty bool, cwd, user, sessionID string, streams *AttachStreams, preserveFDs int) (*exec.Cmd, error) {
 	if len(cmd) == 0 {
-		return nil, errors.Wrapf(ErrInvalidArg, "must provide a command to execute")
+		return nil, errors.Wrapf(define.ErrInvalidArg, "must provide a command to execute")
 	}
 
 	if sessionID == "" {
-		return nil, errors.Wrapf(ErrEmptyID, "must provide a session ID for exec")
+		return nil, errors.Wrapf(define.ErrEmptyID, "must provide a session ID for exec")
 	}
 
 	runtimeDir, err := util.GetRootlessRuntimeDir()
diff --git a/libpod/oci_linux.go b/libpod/oci_linux.go
index b7efa742a..07bc4e5f3 100644
--- a/libpod/oci_linux.go
+++ b/libpod/oci_linux.go
@@ -16,6 +16,7 @@ import (
 	"time"
 
 	"github.com/containerd/cgroups"
+	"github.com/containers/libpod/libpod/define"
 	"github.com/containers/libpod/pkg/rootless"
 	"github.com/containers/libpod/pkg/util"
 	"github.com/containers/libpod/utils"
@@ -434,19 +435,19 @@ func (r *OCIRuntime) createOCIContainer(ctr *Container, cgroupParent string, res
 				if err == nil {
 					var ociErr ociError
 					if err := json.Unmarshal(data, &ociErr); err == nil {
-						return errors.Wrapf(ErrOCIRuntime, "%s", strings.Trim(ociErr.Msg, "\n"))
+						return errors.Wrapf(define.ErrOCIRuntime, "%s", strings.Trim(ociErr.Msg, "\n"))
 					}
 				}
 			}
 			// If we failed to parse the JSON errors, then print the output as it is
 			if ss.si.Message != "" {
-				return errors.Wrapf(ErrOCIRuntime, "%s", ss.si.Message)
+				return errors.Wrapf(define.ErrOCIRuntime, "%s", ss.si.Message)
 			}
-			return errors.Wrapf(ErrInternal, "container create failed")
+			return errors.Wrapf(define.ErrInternal, "container create failed")
 		}
 		ctr.state.PID = ss.si.Pid
 	case <-time.After(ContainerCreateTimeout):
-		return errors.Wrapf(ErrInternal, "container creation timeout")
+		return errors.Wrapf(define.ErrInternal, "container creation timeout")
 	}
 	return nil
 }
diff --git a/libpod/oci_unsupported.go b/libpod/oci_unsupported.go
index 12183faf3..cfdf70bc6 100644
--- a/libpod/oci_unsupported.go
+++ b/libpod/oci_unsupported.go
@@ -5,18 +5,20 @@ package libpod
 import (
 	"os"
 	"os/exec"
+
+	"github.com/containers/libpod/libpod/define"
 )
 
 func (r *OCIRuntime) moveConmonToCgroup(ctr *Container, cgroupParent string, cmd *exec.Cmd) error {
-	return ErrOSNotSupported
+	return define.ErrOSNotSupported
 }
 
 func newPipe() (parent *os.File, child *os.File, err error) {
-	return nil, nil, ErrNotImplemented
+	return nil, nil, define.ErrNotImplemented
 }
 
 func (r *OCIRuntime) createContainer(ctr *Container, cgroupParent string, restoreOptions *ContainerCheckpointOptions) (err error) {
-	return ErrNotImplemented
+	return define.ErrNotImplemented
 }
 
 func (r *OCIRuntime) pathPackage() string {
@@ -28,13 +30,13 @@ func (r *OCIRuntime) conmonPackage() string {
 }
 
 func (r *OCIRuntime) createOCIContainer(ctr *Container, cgroupParent string, restoreOptions *ContainerCheckpointOptions) (err error) {
-	return ErrOSNotSupported
+	return define.ErrOSNotSupported
 }
 
 func (r *OCIRuntime) execStopContainer(ctr *Container, timeout uint) error {
-	return ErrOSNotSupported
+	return define.ErrOSNotSupported
 }
 
 func (r *OCIRuntime) stopContainer(ctr *Container, timeout uint) error {
-	return ErrOSNotSupported
+	return define.ErrOSNotSupported
 }
diff --git a/libpod/options.go b/libpod/options.go
index cdac09654..0f23a6c97 100644
--- a/libpod/options.go
+++ b/libpod/options.go
@@ -8,6 +8,7 @@ import (
 	"syscall"
 
 	"github.com/containers/image/manifest"
+	config2 "github.com/containers/libpod/libpod/define"
 	"github.com/containers/libpod/pkg/namespaces"
 	"github.com/containers/libpod/pkg/rootless"
 	"github.com/containers/libpod/pkg/util"
@@ -19,7 +20,7 @@ import (
 
 var (
 	nameRegex  = regexp.MustCompile("^[a-zA-Z0-9][a-zA-Z0-9_.-]*$")
-	regexError = errors.Wrapf(ErrInvalidArg, "names must match [a-zA-Z0-9][a-zA-Z0-9_.-]*")
+	regexError = errors.Wrapf(config2.ErrInvalidArg, "names must match [a-zA-Z0-9][a-zA-Z0-9_.-]*")
 )
 
 // Runtime Creation Options
@@ -30,7 +31,7 @@ var (
 func WithStorageConfig(config storage.StoreOptions) RuntimeOption {
 	return func(rt *Runtime) error {
 		if rt.valid {
-			return ErrRuntimeFinalized
+			return config2.ErrRuntimeFinalized
 		}
 
 		setField := false
@@ -104,7 +105,7 @@ func WithStorageConfig(config storage.StoreOptions) RuntimeOption {
 func WithDefaultTransport(defaultTransport string) RuntimeOption {
 	return func(rt *Runtime) error {
 		if rt.valid {
-			return ErrRuntimeFinalized
+			return config2.ErrRuntimeFinalized
 		}
 
 		rt.config.ImageDefaultTransport = defaultTransport
@@ -120,7 +121,7 @@ func WithDefaultTransport(defaultTransport string) RuntimeOption {
 func WithSignaturePolicy(path string) RuntimeOption {
 	return func(rt *Runtime) error {
 		if rt.valid {
-			return ErrRuntimeFinalized
+			return config2.ErrRuntimeFinalized
 		}
 
 		rt.config.SignaturePolicyPath = path
@@ -136,11 +137,11 @@ func WithSignaturePolicy(path string) RuntimeOption {
 func WithStateType(storeType RuntimeStateStore) RuntimeOption {
 	return func(rt *Runtime) error {
 		if rt.valid {
-			return ErrRuntimeFinalized
+			return config2.ErrRuntimeFinalized
 		}
 
 		if storeType == InvalidStateStore {
-			return errors.Wrapf(ErrInvalidArg, "must provide a valid state store type")
+			return errors.Wrapf(config2.ErrInvalidArg, "must provide a valid state store type")
 		}
 
 		rt.config.StateType = storeType
@@ -153,11 +154,11 @@ func WithStateType(storeType RuntimeStateStore) RuntimeOption {
 func WithOCIRuntime(runtime string) RuntimeOption {
 	return func(rt *Runtime) error {
 		if rt.valid {
-			return ErrRuntimeFinalized
+			return config2.ErrRuntimeFinalized
 		}
 
 		if runtime == "" {
-			return errors.Wrapf(ErrInvalidArg, "must provide a valid path")
+			return errors.Wrapf(config2.ErrInvalidArg, "must provide a valid path")
 		}
 
 		rt.config.OCIRuntime = runtime
@@ -172,11 +173,11 @@ func WithOCIRuntime(runtime string) RuntimeOption {
 func WithConmonPath(path string) RuntimeOption {
 	return func(rt *Runtime) error {
 		if rt.valid {
-			return ErrRuntimeFinalized
+			return config2.ErrRuntimeFinalized
 		}
 
 		if path == "" {
-			return errors.Wrapf(ErrInvalidArg, "must provide a valid path")
+			return errors.Wrapf(config2.ErrInvalidArg, "must provide a valid path")
 		}
 
 		rt.config.ConmonPath = []string{path}
@@ -189,7 +190,7 @@ func WithConmonPath(path string) RuntimeOption {
 func WithConmonEnv(environment []string) RuntimeOption {
 	return func(rt *Runtime) error {
 		if rt.valid {
-			return ErrRuntimeFinalized
+			return config2.ErrRuntimeFinalized
 		}
 
 		rt.config.ConmonEnvVars = make([]string, len(environment))
@@ -204,7 +205,7 @@ func WithConmonEnv(environment []string) RuntimeOption {
 func WithNetworkCmdPath(path string) RuntimeOption {
 	return func(rt *Runtime) error {
 		if rt.valid {
-			return ErrRuntimeFinalized
+			return config2.ErrRuntimeFinalized
 		}
 
 		rt.config.NetworkCmdPath = path
@@ -219,11 +220,11 @@ func WithNetworkCmdPath(path string) RuntimeOption {
 func WithCgroupManager(manager string) RuntimeOption {
 	return func(rt *Runtime) error {
 		if rt.valid {
-			return ErrRuntimeFinalized
+			return config2.ErrRuntimeFinalized
 		}
 
 		if manager != CgroupfsCgroupsManager && manager != SystemdCgroupsManager {
-			return errors.Wrapf(ErrInvalidArg, "CGroup manager must be one of %s and %s",
+			return errors.Wrapf(config2.ErrInvalidArg, "CGroup manager must be one of %s and %s",
 				CgroupfsCgroupsManager, SystemdCgroupsManager)
 		}
 
@@ -238,7 +239,7 @@ func WithCgroupManager(manager string) RuntimeOption {
 func WithStaticDir(dir string) RuntimeOption {
 	return func(rt *Runtime) error {
 		if rt.valid {
-			return ErrRuntimeFinalized
+			return config2.ErrRuntimeFinalized
 		}
 
 		rt.config.StaticDir = dir
@@ -252,12 +253,12 @@ func WithStaticDir(dir string) RuntimeOption {
 func WithHooksDir(hooksDirs ...string) RuntimeOption {
 	return func(rt *Runtime) error {
 		if rt.valid {
-			return ErrRuntimeFinalized
+			return config2.ErrRuntimeFinalized
 		}
 
 		for _, hooksDir := range hooksDirs {
 			if hooksDir == "" {
-				return errors.Wrap(ErrInvalidArg, "empty-string hook directories are not supported")
+				return errors.Wrap(config2.ErrInvalidArg, "empty-string hook directories are not supported")
 			}
 		}
 
@@ -273,11 +274,11 @@ func WithHooksDir(hooksDirs ...string) RuntimeOption {
 func WithDefaultMountsFile(mountsFile string) RuntimeOption {
 	return func(rt *Runtime) error {
 		if rt.valid {
-			return ErrRuntimeFinalized
+			return config2.ErrRuntimeFinalized
 		}
 
 		if mountsFile == "" {
-			return ErrInvalidArg
+			return config2.ErrInvalidArg
 		}
 		rt.config.DefaultMountsFile = mountsFile
 		return nil
@@ -290,7 +291,7 @@ func WithDefaultMountsFile(mountsFile string) RuntimeOption {
 func WithTmpDir(dir string) RuntimeOption {
 	return func(rt *Runtime) error {
 		if rt.valid {
-			return ErrRuntimeFinalized
+			return config2.ErrRuntimeFinalized
 		}
 		rt.config.TmpDir = dir
 		rt.configuredFrom.libpodTmpDirSet = true
@@ -304,7 +305,7 @@ func WithTmpDir(dir string) RuntimeOption {
 func WithMaxLogSize(limit int64) RuntimeOption {
 	return func(rt *Runtime) error {
 		if rt.valid {
-			return ErrRuntimeFinalized
+			return config2.ErrRuntimeFinalized
 		}
 
 		rt.config.MaxLogSize = limit
@@ -318,7 +319,7 @@ func WithMaxLogSize(limit int64) RuntimeOption {
 func WithNoPivotRoot(noPivot bool) RuntimeOption {
 	return func(rt *Runtime) error {
 		if rt.valid {
-			return ErrRuntimeFinalized
+			return config2.ErrRuntimeFinalized
 		}
 
 		rt.config.NoPivotRoot = true
@@ -331,7 +332,7 @@ func WithNoPivotRoot(noPivot bool) RuntimeOption {
 func WithCNIConfigDir(dir string) RuntimeOption {
 	return func(rt *Runtime) error {
 		if rt.valid {
-			return ErrRuntimeFinalized
+			return config2.ErrRuntimeFinalized
 		}
 
 		rt.config.CNIConfigDir = dir
@@ -344,7 +345,7 @@ func WithCNIConfigDir(dir string) RuntimeOption {
 func WithCNIPluginDir(dir string) RuntimeOption {
 	return func(rt *Runtime) error {
 		if rt.valid {
-			return ErrRuntimeFinalized
+			return config2.ErrRuntimeFinalized
 		}
 
 		rt.config.CNIPluginDir = []string{dir}
@@ -364,7 +365,7 @@ func WithCNIPluginDir(dir string) RuntimeOption {
 func WithNamespace(ns string) RuntimeOption {
 	return func(rt *Runtime) error {
 		if rt.valid {
-			return ErrRuntimeFinalized
+			return config2.ErrRuntimeFinalized
 		}
 
 		rt.config.Namespace = ns
@@ -380,7 +381,7 @@ func WithNamespace(ns string) RuntimeOption {
 func WithVolumePath(volPath string) RuntimeOption {
 	return func(rt *Runtime) error {
 		if rt.valid {
-			return ErrRuntimeFinalized
+			return config2.ErrRuntimeFinalized
 		}
 
 		rt.config.VolumePath = volPath
@@ -398,7 +399,7 @@ func WithVolumePath(volPath string) RuntimeOption {
 func WithDefaultInfraImage(img string) RuntimeOption {
 	return func(rt *Runtime) error {
 		if rt.valid {
-			return ErrRuntimeFinalized
+			return config2.ErrRuntimeFinalized
 		}
 
 		rt.config.InfraImage = img
@@ -412,7 +413,7 @@ func WithDefaultInfraImage(img string) RuntimeOption {
 func WithDefaultInfraCommand(cmd string) RuntimeOption {
 	return func(rt *Runtime) error {
 		if rt.valid {
-			return ErrRuntimeFinalized
+			return config2.ErrRuntimeFinalized
 		}
 
 		rt.config.InfraCommand = cmd
@@ -428,7 +429,7 @@ func WithDefaultInfraCommand(cmd string) RuntimeOption {
 func WithRenumber() RuntimeOption {
 	return func(rt *Runtime) error {
 		if rt.valid {
-			return ErrRuntimeFinalized
+			return config2.ErrRuntimeFinalized
 		}
 
 		rt.doRenumber = true
@@ -443,7 +444,7 @@ func WithRenumber() RuntimeOption {
 func WithMigrate() RuntimeOption {
 	return func(rt *Runtime) error {
 		if rt.valid {
-			return ErrRuntimeFinalized
+			return config2.ErrRuntimeFinalized
 		}
 
 		rt.doMigrate = true
@@ -458,7 +459,7 @@ func WithMigrate() RuntimeOption {
 func WithShmDir(dir string) CtrCreateOption {
 	return func(ctr *Container) error {
 		if ctr.valid {
-			return ErrCtrFinalized
+			return config2.ErrCtrFinalized
 		}
 
 		ctr.config.ShmDir = dir
@@ -470,7 +471,7 @@ func WithShmDir(dir string) CtrCreateOption {
 func WithSystemd() CtrCreateOption {
 	return func(ctr *Container) error {
 		if ctr.valid {
-			return ErrCtrFinalized
+			return config2.ErrCtrFinalized
 		}
 
 		ctr.config.Systemd = true
@@ -482,7 +483,7 @@ func WithSystemd() CtrCreateOption {
 func WithShmSize(size int64) CtrCreateOption {
 	return func(ctr *Container) error {
 		if ctr.valid {
-			return ErrCtrFinalized
+			return config2.ErrCtrFinalized
 		}
 
 		ctr.config.ShmSize = size
@@ -494,7 +495,7 @@ func WithShmSize(size int64) CtrCreateOption {
 func WithPrivileged(privileged bool) CtrCreateOption {
 	return func(ctr *Container) error {
 		if ctr.valid {
-			return ErrCtrFinalized
+			return config2.ErrCtrFinalized
 		}
 
 		ctr.config.Privileged = privileged
@@ -506,7 +507,7 @@ func WithPrivileged(privileged bool) CtrCreateOption {
 func WithSecLabels(labelOpts []string) CtrCreateOption {
 	return func(ctr *Container) error {
 		if ctr.valid {
-			return ErrCtrFinalized
+			return config2.ErrCtrFinalized
 		}
 		ctr.config.LabelOpts = labelOpts
 		return nil
@@ -518,7 +519,7 @@ func WithSecLabels(labelOpts []string) CtrCreateOption {
 func WithUser(user string) CtrCreateOption {
 	return func(ctr *Container) error {
 		if ctr.valid {
-			return ErrCtrFinalized
+			return config2.ErrCtrFinalized
 		}
 
 		ctr.config.User = user
@@ -534,14 +535,14 @@ func WithUser(user string) CtrCreateOption {
 func WithRootFSFromImage(imageID string, imageName string, useImageVolumes bool) CtrCreateOption {
 	return func(ctr *Container) error {
 		if ctr.valid {
-			return ErrCtrFinalized
+			return config2.ErrCtrFinalized
 		}
 
 		if ctr.config.RootfsImageID != "" || ctr.config.RootfsImageName != "" {
-			return errors.Wrapf(ErrInvalidArg, "container already configured with root filesystem")
+			return errors.Wrapf(config2.ErrInvalidArg, "container already configured with root filesystem")
 		}
 		if ctr.config.Rootfs != "" {
-			return errors.Wrapf(ErrInvalidArg, "cannot set both an image ID and a rootfs for a container")
+			return errors.Wrapf(config2.ErrInvalidArg, "cannot set both an image ID and a rootfs for a container")
 		}
 
 		ctr.config.RootfsImageID = imageID
@@ -556,7 +557,7 @@ func WithRootFSFromImage(imageID string, imageName string, useImageVolumes bool)
 func WithStdin() CtrCreateOption {
 	return func(ctr *Container) error {
 		if ctr.valid {
-			return ErrCtrFinalized
+			return config2.ErrCtrFinalized
 		}
 
 		ctr.config.Stdin = true
@@ -572,11 +573,11 @@ func WithStdin() CtrCreateOption {
 func (r *Runtime) WithPod(pod *Pod) CtrCreateOption {
 	return func(ctr *Container) error {
 		if ctr.valid {
-			return ErrCtrFinalized
+			return config2.ErrCtrFinalized
 		}
 
 		if pod == nil {
-			return ErrInvalidArg
+			return config2.ErrInvalidArg
 		}
 
 		ctr.config.Pod = pod.ID()
@@ -589,7 +590,7 @@ func (r *Runtime) WithPod(pod *Pod) CtrCreateOption {
 func WithLabels(labels map[string]string) CtrCreateOption {
 	return func(ctr *Container) error {
 		if ctr.valid {
-			return ErrCtrFinalized
+			return config2.ErrCtrFinalized
 		}
 
 		ctr.config.Labels = make(map[string]string)
@@ -605,7 +606,7 @@ func WithLabels(labels map[string]string) CtrCreateOption {
 func WithName(name string) CtrCreateOption {
 	return func(ctr *Container) error {
 		if ctr.valid {
-			return ErrCtrFinalized
+			return config2.ErrCtrFinalized
 		}
 
 		// Check the name against a regex
@@ -623,13 +624,13 @@ func WithName(name string) CtrCreateOption {
 func WithStopSignal(signal syscall.Signal) CtrCreateOption {
 	return func(ctr *Container) error {
 		if ctr.valid {
-			return ErrCtrFinalized
+			return config2.ErrCtrFinalized
 		}
 
 		if signal == 0 {
-			return errors.Wrapf(ErrInvalidArg, "stop signal cannot be 0")
+			return errors.Wrapf(config2.ErrInvalidArg, "stop signal cannot be 0")
 		} else if signal > 64 {
-			return errors.Wrapf(ErrInvalidArg, "stop signal cannot be greater than 64 (SIGRTMAX)")
+			return errors.Wrapf(config2.ErrInvalidArg, "stop signal cannot be greater than 64 (SIGRTMAX)")
 		}
 
 		ctr.config.StopSignal = uint(signal)
@@ -643,7 +644,7 @@ func WithStopSignal(signal syscall.Signal) CtrCreateOption {
 func WithStopTimeout(timeout uint) CtrCreateOption {
 	return func(ctr *Container) error {
 		if ctr.valid {
-			return ErrCtrFinalized
+			return config2.ErrCtrFinalized
 		}
 
 		ctr.config.StopTimeout = timeout
@@ -656,7 +657,7 @@ func WithStopTimeout(timeout uint) CtrCreateOption {
 func WithIDMappings(idmappings storage.IDMappingOptions) CtrCreateOption {
 	return func(ctr *Container) error {
 		if ctr.valid {
-			return ErrCtrFinalized
+			return config2.ErrCtrFinalized
 		}
 
 		ctr.config.IDMappings = idmappings
@@ -668,7 +669,7 @@ func WithIDMappings(idmappings storage.IDMappingOptions) CtrCreateOption {
 func WithExitCommand(exitCommand []string) CtrCreateOption {
 	return func(ctr *Container) error {
 		if ctr.valid {
-			return ErrCtrFinalized
+			return config2.ErrCtrFinalized
 		}
 
 		ctr.config.ExitCommand = append(exitCommand, ctr.ID())
@@ -681,7 +682,7 @@ func WithExitCommand(exitCommand []string) CtrCreateOption {
 func WithUTSNSFromPod(p *Pod) CtrCreateOption {
 	return func(ctr *Container) error {
 		if ctr.valid {
-			return ErrCtrFinalized
+			return config2.ErrCtrFinalized
 		}
 
 		if err := validPodNSOption(p, ctr.config.Pod); err != nil {
@@ -705,19 +706,19 @@ func WithUTSNSFromPod(p *Pod) CtrCreateOption {
 func WithIPCNSFrom(nsCtr *Container) CtrCreateOption {
 	return func(ctr *Container) error {
 		if ctr.valid {
-			return ErrCtrFinalized
+			return config2.ErrCtrFinalized
 		}
 
 		if !nsCtr.valid {
-			return ErrCtrRemoved
+			return config2.ErrCtrRemoved
 		}
 
 		if nsCtr.ID() == ctr.ID() {
-			return errors.Wrapf(ErrInvalidArg, "must specify another container")
+			return errors.Wrapf(config2.ErrInvalidArg, "must specify another container")
 		}
 
 		if ctr.config.Pod != "" && nsCtr.config.Pod != ctr.config.Pod {
-			return errors.Wrapf(ErrInvalidArg, "container has joined pod %s and dependency container %s is not a member of the pod", ctr.config.Pod, nsCtr.ID())
+			return errors.Wrapf(config2.ErrInvalidArg, "container has joined pod %s and dependency container %s is not a member of the pod", ctr.config.Pod, nsCtr.ID())
 		}
 
 		ctr.config.IPCNsCtr = nsCtr.ID()
@@ -733,19 +734,19 @@ func WithIPCNSFrom(nsCtr *Container) CtrCreateOption {
 func WithMountNSFrom(nsCtr *Container) CtrCreateOption {
 	return func(ctr *Container) error {
 		if ctr.valid {
-			return ErrCtrFinalized
+			return config2.ErrCtrFinalized
 		}
 
 		if !nsCtr.valid {
-			return ErrCtrRemoved
+			return config2.ErrCtrRemoved
 		}
 
 		if nsCtr.ID() == ctr.ID() {
-			return errors.Wrapf(ErrInvalidArg, "must specify another container")
+			return errors.Wrapf(config2.ErrInvalidArg, "must specify another container")
 		}
 
 		if ctr.config.Pod != "" && nsCtr.config.Pod != ctr.config.Pod {
-			return errors.Wrapf(ErrInvalidArg, "container has joined pod %s and dependency container %s is not a member of the pod", ctr.config.Pod, nsCtr.ID())
+			return errors.Wrapf(config2.ErrInvalidArg, "container has joined pod %s and dependency container %s is not a member of the pod", ctr.config.Pod, nsCtr.ID())
 		}
 
 		ctr.config.MountNsCtr = nsCtr.ID()
@@ -761,23 +762,23 @@ func WithMountNSFrom(nsCtr *Container) CtrCreateOption {
 func WithNetNSFrom(nsCtr *Container) CtrCreateOption {
 	return func(ctr *Container) error {
 		if ctr.valid {
-			return ErrCtrFinalized
+			return config2.ErrCtrFinalized
 		}
 
 		if !nsCtr.valid {
-			return ErrCtrRemoved
+			return config2.ErrCtrRemoved
 		}
 
 		if nsCtr.ID() == ctr.ID() {
-			return errors.Wrapf(ErrInvalidArg, "must specify another container")
+			return errors.Wrapf(config2.ErrInvalidArg, "must specify another container")
 		}
 
 		if ctr.config.CreateNetNS {
-			return errors.Wrapf(ErrInvalidArg, "cannot join another container's net ns as we are making a new net ns")
+			return errors.Wrapf(config2.ErrInvalidArg, "cannot join another container's net ns as we are making a new net ns")
 		}
 
 		if ctr.config.Pod != "" && nsCtr.config.Pod != ctr.config.Pod {
-			return errors.Wrapf(ErrInvalidArg, "container has joined pod %s and dependency container %s is not a member of the pod", ctr.config.Pod, nsCtr.ID())
+			return errors.Wrapf(config2.ErrInvalidArg, "container has joined pod %s and dependency container %s is not a member of the pod", ctr.config.Pod, nsCtr.ID())
 		}
 
 		ctr.config.NetNsCtr = nsCtr.ID()
@@ -793,19 +794,19 @@ func WithNetNSFrom(nsCtr *Container) CtrCreateOption {
 func WithPIDNSFrom(nsCtr *Container) CtrCreateOption {
 	return func(ctr *Container) error {
 		if ctr.valid {
-			return ErrCtrFinalized
+			return config2.ErrCtrFinalized
 		}
 
 		if !nsCtr.valid {
-			return ErrCtrRemoved
+			return config2.ErrCtrRemoved
 		}
 
 		if nsCtr.ID() == ctr.ID() {
-			return errors.Wrapf(ErrInvalidArg, "must specify another container")
+			return errors.Wrapf(config2.ErrInvalidArg, "must specify another container")
 		}
 
 		if ctr.config.Pod != "" && nsCtr.config.Pod != ctr.config.Pod {
-			return errors.Wrapf(ErrInvalidArg, "container has joined pod %s and dependency container %s is not a member of the pod", ctr.config.Pod, nsCtr.ID())
+			return errors.Wrapf(config2.ErrInvalidArg, "container has joined pod %s and dependency container %s is not a member of the pod", ctr.config.Pod, nsCtr.ID())
 		}
 
 		ctr.config.PIDNsCtr = nsCtr.ID()
@@ -821,19 +822,19 @@ func WithPIDNSFrom(nsCtr *Container) CtrCreateOption {
 func WithUserNSFrom(nsCtr *Container) CtrCreateOption {
 	return func(ctr *Container) error {
 		if ctr.valid {
-			return ErrCtrFinalized
+			return config2.ErrCtrFinalized
 		}
 
 		if !nsCtr.valid {
-			return ErrCtrRemoved
+			return config2.ErrCtrRemoved
 		}
 
 		if nsCtr.ID() == ctr.ID() {
-			return errors.Wrapf(ErrInvalidArg, "must specify another container")
+			return errors.Wrapf(config2.ErrInvalidArg, "must specify another container")
 		}
 
 		if ctr.config.Pod != "" && nsCtr.config.Pod != ctr.config.Pod {
-			return errors.Wrapf(ErrInvalidArg, "container has joined pod %s and dependency container %s is not a member of the pod", ctr.config.Pod, nsCtr.ID())
+			return errors.Wrapf(config2.ErrInvalidArg, "container has joined pod %s and dependency container %s is not a member of the pod", ctr.config.Pod, nsCtr.ID())
 		}
 
 		ctr.config.UserNsCtr = nsCtr.ID()
@@ -849,19 +850,19 @@ func WithUserNSFrom(nsCtr *Container) CtrCreateOption {
 func WithUTSNSFrom(nsCtr *Container) CtrCreateOption {
 	return func(ctr *Container) error {
 		if ctr.valid {
-			return ErrCtrFinalized
+			return config2.ErrCtrFinalized
 		}
 
 		if !nsCtr.valid {
-			return ErrCtrRemoved
+			return config2.ErrCtrRemoved
 		}
 
 		if nsCtr.ID() == ctr.ID() {
-			return errors.Wrapf(ErrInvalidArg, "must specify another container")
+			return errors.Wrapf(config2.ErrInvalidArg, "must specify another container")
 		}
 
 		if ctr.config.Pod != "" && nsCtr.config.Pod != ctr.config.Pod {
-			return errors.Wrapf(ErrInvalidArg, "container has joined pod %s and dependency container %s is not a member of the pod", ctr.config.Pod, nsCtr.ID())
+			return errors.Wrapf(config2.ErrInvalidArg, "container has joined pod %s and dependency container %s is not a member of the pod", ctr.config.Pod, nsCtr.ID())
 		}
 
 		ctr.config.UTSNsCtr = nsCtr.ID()
@@ -877,19 +878,19 @@ func WithUTSNSFrom(nsCtr *Container) CtrCreateOption {
 func WithCgroupNSFrom(nsCtr *Container) CtrCreateOption {
 	return func(ctr *Container) error {
 		if ctr.valid {
-			return ErrCtrFinalized
+			return config2.ErrCtrFinalized
 		}
 
 		if !nsCtr.valid {
-			return ErrCtrRemoved
+			return config2.ErrCtrRemoved
 		}
 
 		if nsCtr.ID() == ctr.ID() {
-			return errors.Wrapf(ErrInvalidArg, "must specify another container")
+			return errors.Wrapf(config2.ErrInvalidArg, "must specify another container")
 		}
 
 		if ctr.config.Pod != "" && nsCtr.config.Pod != ctr.config.Pod {
-			return errors.Wrapf(ErrInvalidArg, "container has joined pod %s and dependency container %s is not a member of the pod", ctr.config.Pod, nsCtr.ID())
+			return errors.Wrapf(config2.ErrInvalidArg, "container has joined pod %s and dependency container %s is not a member of the pod", ctr.config.Pod, nsCtr.ID())
 		}
 
 		ctr.config.CgroupNsCtr = nsCtr.ID()
@@ -903,22 +904,22 @@ func WithCgroupNSFrom(nsCtr *Container) CtrCreateOption {
 func WithDependencyCtrs(ctrs []*Container) CtrCreateOption {
 	return func(ctr *Container) error {
 		if ctr.valid {
-			return ErrCtrFinalized
+			return config2.ErrCtrFinalized
 		}
 
 		deps := make([]string, 0, len(ctrs))
 
 		for _, dep := range ctrs {
 			if !dep.valid {
-				return errors.Wrapf(ErrCtrRemoved, "container %s is not valid", dep.ID())
+				return errors.Wrapf(config2.ErrCtrRemoved, "container %s is not valid", dep.ID())
 			}
 
 			if dep.ID() == ctr.ID() {
-				return errors.Wrapf(ErrInvalidArg, "must specify another container")
+				return errors.Wrapf(config2.ErrInvalidArg, "must specify another container")
 			}
 
 			if ctr.config.Pod != "" && dep.config.Pod != ctr.config.Pod {
-				return errors.Wrapf(ErrInvalidArg, "container has joined pod %s and dependency container %s is not a member of the pod", ctr.config.Pod, dep.ID())
+				return errors.Wrapf(config2.ErrInvalidArg, "container has joined pod %s and dependency container %s is not a member of the pod", ctr.config.Pod, dep.ID())
 			}
 
 			deps = append(deps, dep.ID())
@@ -937,11 +938,11 @@ func WithDependencyCtrs(ctrs []*Container) CtrCreateOption {
 func WithNetNS(portMappings []ocicni.PortMapping, postConfigureNetNS bool, netmode string, networks []string) CtrCreateOption {
 	return func(ctr *Container) error {
 		if ctr.valid {
-			return ErrCtrFinalized
+			return config2.ErrCtrFinalized
 		}
 
 		if ctr.config.NetNsCtr != "" {
-			return errors.Wrapf(ErrInvalidArg, "container is already set to join another container's net ns, cannot create a new net ns")
+			return errors.Wrapf(config2.ErrInvalidArg, "container is already set to join another container's net ns, cannot create a new net ns")
 		}
 
 		ctr.config.PostConfigureNetNS = postConfigureNetNS
@@ -962,15 +963,15 @@ func WithNetNS(portMappings []ocicni.PortMapping, postConfigureNetNS bool, netmo
 func WithStaticIP(ip net.IP) CtrCreateOption {
 	return func(ctr *Container) error {
 		if ctr.valid {
-			return ErrCtrFinalized
+			return config2.ErrCtrFinalized
 		}
 
 		if !ctr.config.CreateNetNS {
-			return errors.Wrapf(ErrInvalidArg, "cannot set a static IP if the container is not creating a network namespace")
+			return errors.Wrapf(config2.ErrInvalidArg, "cannot set a static IP if the container is not creating a network namespace")
 		}
 
 		if len(ctr.config.Networks) != 0 {
-			return errors.Wrapf(ErrInvalidArg, "cannot set a static IP if joining additional CNI networks")
+			return errors.Wrapf(config2.ErrInvalidArg, "cannot set a static IP if joining additional CNI networks")
 		}
 
 		ctr.config.StaticIP = ip
@@ -983,15 +984,15 @@ func WithStaticIP(ip net.IP) CtrCreateOption {
 func WithLogDriver(driver string) CtrCreateOption {
 	return func(ctr *Container) error {
 		if ctr.valid {
-			return ErrCtrFinalized
+			return config2.ErrCtrFinalized
 		}
 		switch driver {
 		case "":
-			return errors.Wrapf(ErrInvalidArg, "log driver must be set")
+			return errors.Wrapf(config2.ErrInvalidArg, "log driver must be set")
 		case JournaldLogging, KubernetesLogging, JSONLogging:
 			break
 		default:
-			return errors.Wrapf(ErrInvalidArg, "invalid log driver")
+			return errors.Wrapf(config2.ErrInvalidArg, "invalid log driver")
 		}
 
 		ctr.config.LogDriver = driver
@@ -1004,10 +1005,10 @@ func WithLogDriver(driver string) CtrCreateOption {
 func WithLogPath(path string) CtrCreateOption {
 	return func(ctr *Container) error {
 		if ctr.valid {
-			return ErrCtrFinalized
+			return config2.ErrCtrFinalized
 		}
 		if path == "" {
-			return errors.Wrapf(ErrInvalidArg, "log path must be set")
+			return errors.Wrapf(config2.ErrInvalidArg, "log path must be set")
 		}
 
 		ctr.config.LogPath = path
@@ -1020,11 +1021,11 @@ func WithLogPath(path string) CtrCreateOption {
 func WithCgroupParent(parent string) CtrCreateOption {
 	return func(ctr *Container) error {
 		if ctr.valid {
-			return ErrCtrFinalized
+			return config2.ErrCtrFinalized
 		}
 
 		if parent == "" {
-			return errors.Wrapf(ErrInvalidArg, "cgroup parent cannot be empty")
+			return errors.Wrapf(config2.ErrInvalidArg, "cgroup parent cannot be empty")
 		}
 
 		ctr.config.CgroupParent = parent
@@ -1037,10 +1038,10 @@ func WithCgroupParent(parent string) CtrCreateOption {
 func WithDNSSearch(searchDomains []string) CtrCreateOption {
 	return func(ctr *Container) error {
 		if ctr.valid {
-			return ErrCtrFinalized
+			return config2.ErrCtrFinalized
 		}
 		if ctr.config.UseImageResolvConf {
-			return errors.Wrapf(ErrInvalidArg, "cannot add DNS search domains if container will not create /etc/resolv.conf")
+			return errors.Wrapf(config2.ErrInvalidArg, "cannot add DNS search domains if container will not create /etc/resolv.conf")
 		}
 		ctr.config.DNSSearch = searchDomains
 		return nil
@@ -1051,16 +1052,16 @@ func WithDNSSearch(searchDomains []string) CtrCreateOption {
 func WithDNS(dnsServers []string) CtrCreateOption {
 	return func(ctr *Container) error {
 		if ctr.valid {
-			return ErrCtrFinalized
+			return config2.ErrCtrFinalized
 		}
 		if ctr.config.UseImageResolvConf {
-			return errors.Wrapf(ErrInvalidArg, "cannot add DNS servers if container will not create /etc/resolv.conf")
+			return errors.Wrapf(config2.ErrInvalidArg, "cannot add DNS servers if container will not create /etc/resolv.conf")
 		}
 		var dns []net.IP
 		for _, i := range dnsServers {
 			result := net.ParseIP(i)
 			if result == nil {
-				return errors.Wrapf(ErrInvalidArg, "invalid IP address %s", i)
+				return errors.Wrapf(config2.ErrInvalidArg, "invalid IP address %s", i)
 			}
 			dns = append(dns, result)
 		}
@@ -1073,10 +1074,10 @@ func WithDNS(dnsServers []string) CtrCreateOption {
 func WithDNSOption(dnsOptions []string) CtrCreateOption {
 	return func(ctr *Container) error {
 		if ctr.valid {
-			return ErrCtrFinalized
+			return config2.ErrCtrFinalized
 		}
 		if ctr.config.UseImageResolvConf {
-			return errors.Wrapf(ErrInvalidArg, "cannot add DNS options if container will not create /etc/resolv.conf")
+			return errors.Wrapf(config2.ErrInvalidArg, "cannot add DNS options if container will not create /etc/resolv.conf")
 		}
 		ctr.config.DNSOption = dnsOptions
 		return nil
@@ -1087,11 +1088,11 @@ func WithDNSOption(dnsOptions []string) CtrCreateOption {
 func WithHosts(hosts []string) CtrCreateOption {
 	return func(ctr *Container) error {
 		if ctr.valid {
-			return ErrCtrFinalized
+			return config2.ErrCtrFinalized
 		}
 
 		if ctr.config.UseImageHosts {
-			return errors.Wrapf(ErrInvalidArg, "cannot add hosts if container will not create /etc/hosts")
+			return errors.Wrapf(config2.ErrInvalidArg, "cannot add hosts if container will not create /etc/hosts")
 		}
 
 		ctr.config.HostAdd = hosts
@@ -1104,7 +1105,7 @@ func WithHosts(hosts []string) CtrCreateOption {
 func WithConmonPidFile(path string) CtrCreateOption {
 	return func(ctr *Container) error {
 		if ctr.valid {
-			return ErrCtrFinalized
+			return config2.ErrCtrFinalized
 		}
 		ctr.config.ConmonPidFile = path
 		return nil
@@ -1116,7 +1117,7 @@ func WithConmonPidFile(path string) CtrCreateOption {
 func WithGroups(groups []string) CtrCreateOption {
 	return func(ctr *Container) error {
 		if ctr.valid {
-			return ErrCtrFinalized
+			return config2.ErrCtrFinalized
 		}
 		ctr.config.Groups = groups
 		return nil
@@ -1134,11 +1135,11 @@ func WithGroups(groups []string) CtrCreateOption {
 func WithUserVolumes(volumes []string) CtrCreateOption {
 	return func(ctr *Container) error {
 		if ctr.valid {
-			return ErrCtrFinalized
+			return config2.ErrCtrFinalized
 		}
 
 		if volumes == nil {
-			return ErrInvalidArg
+			return config2.ErrInvalidArg
 		}
 
 		ctr.config.UserVolumes = make([]string, 0, len(volumes))
@@ -1158,7 +1159,7 @@ func WithUserVolumes(volumes []string) CtrCreateOption {
 func WithEntrypoint(entrypoint []string) CtrCreateOption {
 	return func(ctr *Container) error {
 		if ctr.valid {
-			return ErrCtrFinalized
+			return config2.ErrCtrFinalized
 		}
 
 		ctr.config.Entrypoint = make([]string, 0, len(entrypoint))
@@ -1178,7 +1179,7 @@ func WithEntrypoint(entrypoint []string) CtrCreateOption {
 func WithCommand(command []string) CtrCreateOption {
 	return func(ctr *Container) error {
 		if ctr.valid {
-			return ErrCtrFinalized
+			return config2.ErrCtrFinalized
 		}
 
 		ctr.config.Command = make([]string, 0, len(command))
@@ -1195,13 +1196,13 @@ func WithCommand(command []string) CtrCreateOption {
 func WithRootFS(rootfs string) CtrCreateOption {
 	return func(ctr *Container) error {
 		if ctr.valid {
-			return ErrCtrFinalized
+			return config2.ErrCtrFinalized
 		}
 		if _, err := os.Stat(rootfs); err != nil {
 			return errors.Wrapf(err, "error checking path %q", rootfs)
 		}
 		if ctr.config.RootfsImageID != "" {
-			return errors.Wrapf(ErrInvalidArg, "cannot set both an image ID and a rootfs for a container")
+			return errors.Wrapf(config2.ErrInvalidArg, "cannot set both an image ID and a rootfs for a container")
 		}
 		ctr.config.Rootfs = rootfs
 		return nil
@@ -1215,7 +1216,7 @@ func WithRootFS(rootfs string) CtrCreateOption {
 func WithCtrNamespace(ns string) CtrCreateOption {
 	return func(ctr *Container) error {
 		if ctr.valid {
-			return ErrCtrFinalized
+			return config2.ErrCtrFinalized
 		}
 
 		ctr.config.Namespace = ns
@@ -1229,13 +1230,13 @@ func WithCtrNamespace(ns string) CtrCreateOption {
 func WithUseImageResolvConf() CtrCreateOption {
 	return func(ctr *Container) error {
 		if ctr.valid {
-			return ErrCtrFinalized
+			return config2.ErrCtrFinalized
 		}
 
 		if len(ctr.config.DNSServer) != 0 ||
 			len(ctr.config.DNSSearch) != 0 ||
 			len(ctr.config.DNSOption) != 0 {
-			return errors.Wrapf(ErrInvalidArg, "not creating resolv.conf conflicts with DNS options")
+			return errors.Wrapf(config2.ErrInvalidArg, "not creating resolv.conf conflicts with DNS options")
 		}
 
 		ctr.config.UseImageResolvConf = true
@@ -1249,11 +1250,11 @@ func WithUseImageResolvConf() CtrCreateOption {
 func WithUseImageHosts() CtrCreateOption {
 	return func(ctr *Container) error {
 		if ctr.valid {
-			return ErrCtrFinalized
+			return config2.ErrCtrFinalized
 		}
 
 		if len(ctr.config.HostAdd) != 0 {
-			return errors.Wrapf(ErrInvalidArg, "not creating /etc/hosts conflicts with adding to the hosts file")
+			return errors.Wrapf(config2.ErrInvalidArg, "not creating /etc/hosts conflicts with adding to the hosts file")
 		}
 
 		ctr.config.UseImageHosts = true
@@ -1268,14 +1269,14 @@ func WithUseImageHosts() CtrCreateOption {
 func WithRestartPolicy(policy string) CtrCreateOption {
 	return func(ctr *Container) error {
 		if ctr.valid {
-			return ErrCtrFinalized
+			return config2.ErrCtrFinalized
 		}
 
 		switch policy {
 		case RestartPolicyNone, RestartPolicyNo, RestartPolicyOnFailure, RestartPolicyAlways:
 			ctr.config.RestartPolicy = policy
 		default:
-			return errors.Wrapf(ErrInvalidArg, "%q is not a valid restart policy", policy)
+			return errors.Wrapf(config2.ErrInvalidArg, "%q is not a valid restart policy", policy)
 		}
 
 		return nil
@@ -1288,7 +1289,7 @@ func WithRestartPolicy(policy string) CtrCreateOption {
 func WithRestartRetries(tries uint) CtrCreateOption {
 	return func(ctr *Container) error {
 		if ctr.valid {
-			return ErrCtrFinalized
+			return config2.ErrCtrFinalized
 		}
 
 		ctr.config.RestartRetries = tries
@@ -1302,7 +1303,7 @@ func WithRestartRetries(tries uint) CtrCreateOption {
 func withIsInfra() CtrCreateOption {
 	return func(ctr *Container) error {
 		if ctr.valid {
-			return ErrCtrFinalized
+			return config2.ErrCtrFinalized
 		}
 
 		ctr.config.IsInfra = true
@@ -1315,7 +1316,7 @@ func withIsInfra() CtrCreateOption {
 func WithNamedVolumes(volumes []*ContainerNamedVolume) CtrCreateOption {
 	return func(ctr *Container) error {
 		if ctr.valid {
-			return ErrCtrFinalized
+			return config2.ErrCtrFinalized
 		}
 
 		destinations := make(map[string]bool)
@@ -1325,7 +1326,7 @@ func WithNamedVolumes(volumes []*ContainerNamedVolume) CtrCreateOption {
 			// If they don't we will automatically create them.
 
 			if _, ok := destinations[vol.Dest]; ok {
-				return errors.Wrapf(ErrInvalidArg, "two volumes found with destination %s", vol.Dest)
+				return errors.Wrapf(config2.ErrInvalidArg, "two volumes found with destination %s", vol.Dest)
 			}
 			destinations[vol.Dest] = true
 
@@ -1346,7 +1347,7 @@ func WithNamedVolumes(volumes []*ContainerNamedVolume) CtrCreateOption {
 func WithVolumeName(name string) VolumeCreateOption {
 	return func(volume *Volume) error {
 		if volume.valid {
-			return ErrVolumeFinalized
+			return config2.ErrVolumeFinalized
 		}
 
 		// Check the name against a regex
@@ -1363,7 +1364,7 @@ func WithVolumeName(name string) VolumeCreateOption {
 func WithVolumeLabels(labels map[string]string) VolumeCreateOption {
 	return func(volume *Volume) error {
 		if volume.valid {
-			return ErrVolumeFinalized
+			return config2.ErrVolumeFinalized
 		}
 
 		volume.config.Labels = make(map[string]string)
@@ -1379,7 +1380,7 @@ func WithVolumeLabels(labels map[string]string) VolumeCreateOption {
 func WithVolumeDriver(driver string) VolumeCreateOption {
 	return func(volume *Volume) error {
 		if volume.valid {
-			return ErrVolumeFinalized
+			return config2.ErrVolumeFinalized
 		}
 
 		volume.config.Driver = driver
@@ -1392,7 +1393,7 @@ func WithVolumeDriver(driver string) VolumeCreateOption {
 func WithVolumeOptions(options map[string]string) VolumeCreateOption {
 	return func(volume *Volume) error {
 		if volume.valid {
-			return ErrVolumeFinalized
+			return config2.ErrVolumeFinalized
 		}
 
 		volume.config.Options = make(map[string]string)
@@ -1408,7 +1409,7 @@ func WithVolumeOptions(options map[string]string) VolumeCreateOption {
 func WithVolumeUID(uid int) VolumeCreateOption {
 	return func(volume *Volume) error {
 		if volume.valid {
-			return ErrVolumeFinalized
+			return config2.ErrVolumeFinalized
 		}
 
 		volume.config.UID = uid
@@ -1421,7 +1422,7 @@ func WithVolumeUID(uid int) VolumeCreateOption {
 func WithVolumeGID(gid int) VolumeCreateOption {
 	return func(volume *Volume) error {
 		if volume.valid {
-			return ErrVolumeFinalized
+			return config2.ErrVolumeFinalized
 		}
 
 		volume.config.GID = gid
@@ -1437,7 +1438,7 @@ func WithVolumeGID(gid int) VolumeCreateOption {
 func withSetCtrSpecific() VolumeCreateOption {
 	return func(volume *Volume) error {
 		if volume.valid {
-			return ErrVolumeFinalized
+			return config2.ErrVolumeFinalized
 		}
 
 		volume.config.IsCtrSpecific = true
@@ -1452,7 +1453,7 @@ func withSetCtrSpecific() VolumeCreateOption {
 func WithPodName(name string) PodCreateOption {
 	return func(pod *Pod) error {
 		if pod.valid {
-			return ErrPodFinalized
+			return config2.ErrPodFinalized
 		}
 
 		// Check the name against a regex
@@ -1470,7 +1471,7 @@ func WithPodName(name string) PodCreateOption {
 func WithPodLabels(labels map[string]string) PodCreateOption {
 	return func(pod *Pod) error {
 		if pod.valid {
-			return ErrPodFinalized
+			return config2.ErrPodFinalized
 		}
 
 		pod.config.Labels = make(map[string]string)
@@ -1486,7 +1487,7 @@ func WithPodLabels(labels map[string]string) PodCreateOption {
 func WithPodCgroupParent(path string) PodCreateOption {
 	return func(pod *Pod) error {
 		if pod.valid {
-			return ErrPodFinalized
+			return config2.ErrPodFinalized
 		}
 
 		pod.config.CgroupParent = path
@@ -1502,7 +1503,7 @@ func WithPodCgroupParent(path string) PodCreateOption {
 func WithPodCgroups() PodCreateOption {
 	return func(pod *Pod) error {
 		if pod.valid {
-			return ErrPodFinalized
+			return config2.ErrPodFinalized
 		}
 
 		pod.config.UsePodCgroup = true
@@ -1519,7 +1520,7 @@ func WithPodCgroups() PodCreateOption {
 func WithPodNamespace(ns string) PodCreateOption {
 	return func(pod *Pod) error {
 		if pod.valid {
-			return ErrPodFinalized
+			return config2.ErrPodFinalized
 		}
 
 		pod.config.Namespace = ns
@@ -1535,7 +1536,7 @@ func WithPodNamespace(ns string) PodCreateOption {
 func WithPodIPC() PodCreateOption {
 	return func(pod *Pod) error {
 		if pod.valid {
-			return ErrPodFinalized
+			return config2.ErrPodFinalized
 		}
 
 		pod.config.UsePodIPC = true
@@ -1551,7 +1552,7 @@ func WithPodIPC() PodCreateOption {
 func WithPodNet() PodCreateOption {
 	return func(pod *Pod) error {
 		if pod.valid {
-			return ErrPodFinalized
+			return config2.ErrPodFinalized
 		}
 
 		pod.config.UsePodNet = true
@@ -1569,7 +1570,7 @@ func WithPodNet() PodCreateOption {
 func WithPodMount() PodCreateOption {
 	return func(pod *Pod) error {
 		if pod.valid {
-			return ErrPodFinalized
+			return config2.ErrPodFinalized
 		}
 
 		pod.config.UsePodMount = true
@@ -1587,7 +1588,7 @@ func WithPodMount() PodCreateOption {
 func WithPodUser() PodCreateOption {
 	return func(pod *Pod) error {
 		if pod.valid {
-			return ErrPodFinalized
+			return config2.ErrPodFinalized
 		}
 
 		pod.config.UsePodUser = true
@@ -1603,7 +1604,7 @@ func WithPodUser() PodCreateOption {
 func WithPodPID() PodCreateOption {
 	return func(pod *Pod) error {
 		if pod.valid {
-			return ErrPodFinalized
+			return config2.ErrPodFinalized
 		}
 
 		pod.config.UsePodPID = true
@@ -1619,7 +1620,7 @@ func WithPodPID() PodCreateOption {
 func WithPodUTS() PodCreateOption {
 	return func(pod *Pod) error {
 		if pod.valid {
-			return ErrPodFinalized
+			return config2.ErrPodFinalized
 		}
 
 		pod.config.UsePodUTS = true
@@ -1632,7 +1633,7 @@ func WithPodUTS() PodCreateOption {
 func WithInfraContainer() PodCreateOption {
 	return func(pod *Pod) error {
 		if pod.valid {
-			return ErrPodFinalized
+			return config2.ErrPodFinalized
 		}
 
 		pod.config.InfraContainer.HasInfraContainer = true
@@ -1645,7 +1646,7 @@ func WithInfraContainer() PodCreateOption {
 func WithInfraContainerPorts(bindings []ocicni.PortMapping) PodCreateOption {
 	return func(pod *Pod) error {
 		if pod.valid {
-			return ErrPodFinalized
+			return config2.ErrPodFinalized
 		}
 		pod.config.InfraContainer.PortBindings = bindings
 		return nil
@@ -1656,7 +1657,7 @@ func WithInfraContainerPorts(bindings []ocicni.PortMapping) PodCreateOption {
 func WithHealthCheck(healthCheck *manifest.Schema2HealthConfig) CtrCreateOption {
 	return func(ctr *Container) error {
 		if ctr.valid {
-			return ErrCtrFinalized
+			return config2.ErrCtrFinalized
 		}
 		ctr.config.HealthCheckConfig = healthCheck
 		return nil
diff --git a/libpod/pod.go b/libpod/pod.go
index c319c449f..60626bfd7 100644
--- a/libpod/pod.go
+++ b/libpod/pod.go
@@ -3,6 +3,7 @@ package libpod
 import (
 	"time"
 
+	"github.com/containers/libpod/libpod/define"
 	"github.com/containers/libpod/libpod/lock"
 	"github.com/cri-o/ocicni/pkg/ocicni"
 	"github.com/pkg/errors"
@@ -190,7 +191,7 @@ func (p *Pod) CgroupPath() (string, error) {
 // HasContainer checks if a container is present in the pod
 func (p *Pod) HasContainer(id string) (bool, error) {
 	if !p.valid {
-		return false, ErrPodRemoved
+		return false, define.ErrPodRemoved
 	}
 
 	return p.runtime.state.PodHasContainer(p, id)
@@ -202,7 +203,7 @@ func (p *Pod) AllContainersByID() ([]string, error) {
 	defer p.lock.Unlock()
 
 	if !p.valid {
-		return nil, ErrPodRemoved
+		return nil, define.ErrPodRemoved
 	}
 
 	return p.runtime.state.PodContainersByID(p)
@@ -211,7 +212,7 @@ func (p *Pod) AllContainersByID() ([]string, error) {
 // AllContainers retrieves the containers in the pod
 func (p *Pod) AllContainers() ([]*Container, error) {
 	if !p.valid {
-		return nil, ErrPodRemoved
+		return nil, define.ErrPodRemoved
 	}
 	p.lock.Lock()
 	defer p.lock.Unlock()
@@ -280,7 +281,7 @@ func (p *Pod) GetPodStats(previousContainerStats map[string]*ContainerStats) (ma
 		newStats, err := c.GetContainerStats(prevStat)
 		// If the container wasn't running, don't include it
 		// but also suppress the error
-		if err != nil && errors.Cause(err) != ErrCtrStateInvalid {
+		if err != nil && errors.Cause(err) != define.ErrCtrStateInvalid {
 			return nil, err
 		}
 		if err == nil {
diff --git a/libpod/pod_api.go b/libpod/pod_api.go
index b913857dd..3126ced4c 100644
--- a/libpod/pod_api.go
+++ b/libpod/pod_api.go
@@ -3,6 +3,7 @@ package libpod
 import (
 	"context"
 
+	"github.com/containers/libpod/libpod/define"
 	"github.com/containers/libpod/libpod/events"
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
@@ -27,7 +28,7 @@ func (p *Pod) Start(ctx context.Context) (map[string]error, error) {
 	defer p.lock.Unlock()
 
 	if !p.valid {
-		return nil, ErrPodRemoved
+		return nil, define.ErrPodRemoved
 	}
 
 	allCtrs, err := p.runtime.state.PodContainers(p)
@@ -47,7 +48,7 @@ func (p *Pod) Start(ctx context.Context) (map[string]error, error) {
 	// If there are no containers without dependencies, we can't start
 	// Error out
 	if len(graph.noDepNodes) == 0 {
-		return nil, errors.Wrapf(ErrNoSuchCtr, "no containers in pod %s have no dependencies, cannot start pod", p.ID())
+		return nil, errors.Wrapf(define.ErrNoSuchCtr, "no containers in pod %s have no dependencies, cannot start pod", p.ID())
 	}
 
 	// Traverse the graph beginning at nodes with no dependencies
@@ -56,7 +57,7 @@ func (p *Pod) Start(ctx context.Context) (map[string]error, error) {
 	}
 
 	if len(ctrErrors) > 0 {
-		return ctrErrors, errors.Wrapf(ErrCtrExists, "error starting some containers")
+		return ctrErrors, errors.Wrapf(define.ErrCtrExists, "error starting some containers")
 	}
 	defer p.newPodEvent(events.Start)
 	return nil, nil
@@ -88,7 +89,7 @@ func (p *Pod) StopWithTimeout(ctx context.Context, cleanup bool, timeout int) (m
 	defer p.lock.Unlock()
 
 	if !p.valid {
-		return nil, ErrPodRemoved
+		return nil, define.ErrPodRemoved
 	}
 
 	allCtrs, err := p.runtime.state.PodContainers(p)
@@ -136,7 +137,7 @@ func (p *Pod) StopWithTimeout(ctx context.Context, cleanup bool, timeout int) (m
 	}
 
 	if len(ctrErrors) > 0 {
-		return ctrErrors, errors.Wrapf(ErrCtrExists, "error stopping some containers")
+		return ctrErrors, errors.Wrapf(define.ErrCtrExists, "error stopping some containers")
 	}
 	defer p.newPodEvent(events.Stop)
 	return nil, nil
@@ -159,7 +160,7 @@ func (p *Pod) Pause() (map[string]error, error) {
 	defer p.lock.Unlock()
 
 	if !p.valid {
-		return nil, ErrPodRemoved
+		return nil, define.ErrPodRemoved
 	}
 
 	allCtrs, err := p.runtime.state.PodContainers(p)
@@ -195,7 +196,7 @@ func (p *Pod) Pause() (map[string]error, error) {
 	}
 
 	if len(ctrErrors) > 0 {
-		return ctrErrors, errors.Wrapf(ErrCtrExists, "error pausing some containers")
+		return ctrErrors, errors.Wrapf(define.ErrCtrExists, "error pausing some containers")
 	}
 	defer p.newPodEvent(events.Pause)
 	return nil, nil
@@ -218,7 +219,7 @@ func (p *Pod) Unpause() (map[string]error, error) {
 	defer p.lock.Unlock()
 
 	if !p.valid {
-		return nil, ErrPodRemoved
+		return nil, define.ErrPodRemoved
 	}
 
 	allCtrs, err := p.runtime.state.PodContainers(p)
@@ -254,7 +255,7 @@ func (p *Pod) Unpause() (map[string]error, error) {
 	}
 
 	if len(ctrErrors) > 0 {
-		return ctrErrors, errors.Wrapf(ErrCtrExists, "error unpausing some containers")
+		return ctrErrors, errors.Wrapf(define.ErrCtrExists, "error unpausing some containers")
 	}
 
 	defer p.newPodEvent(events.Unpause)
@@ -279,7 +280,7 @@ func (p *Pod) Restart(ctx context.Context) (map[string]error, error) {
 	defer p.lock.Unlock()
 
 	if !p.valid {
-		return nil, ErrPodRemoved
+		return nil, define.ErrPodRemoved
 	}
 
 	allCtrs, err := p.runtime.state.PodContainers(p)
@@ -299,7 +300,7 @@ func (p *Pod) Restart(ctx context.Context) (map[string]error, error) {
 	// If there are no containers without dependencies, we can't start
 	// Error out
 	if len(graph.noDepNodes) == 0 {
-		return nil, errors.Wrapf(ErrNoSuchCtr, "no containers in pod %s have no dependencies, cannot start pod", p.ID())
+		return nil, errors.Wrapf(define.ErrNoSuchCtr, "no containers in pod %s have no dependencies, cannot start pod", p.ID())
 	}
 
 	// Traverse the graph beginning at nodes with no dependencies
@@ -308,7 +309,7 @@ func (p *Pod) Restart(ctx context.Context) (map[string]error, error) {
 	}
 
 	if len(ctrErrors) > 0 {
-		return ctrErrors, errors.Wrapf(ErrCtrExists, "error stopping some containers")
+		return ctrErrors, errors.Wrapf(define.ErrCtrExists, "error stopping some containers")
 	}
 	p.newPodEvent(events.Stop)
 	p.newPodEvent(events.Start)
@@ -331,7 +332,7 @@ func (p *Pod) Kill(signal uint) (map[string]error, error) {
 	defer p.lock.Unlock()
 
 	if !p.valid {
-		return nil, ErrPodRemoved
+		return nil, define.ErrPodRemoved
 	}
 
 	allCtrs, err := p.runtime.state.PodContainers(p)
@@ -374,7 +375,7 @@ func (p *Pod) Kill(signal uint) (map[string]error, error) {
 	}
 
 	if len(ctrErrors) > 0 {
-		return ctrErrors, errors.Wrapf(ErrCtrExists, "error killing some containers")
+		return ctrErrors, errors.Wrapf(define.ErrCtrExists, "error killing some containers")
 	}
 	defer p.newPodEvent(events.Kill)
 	return nil, nil
@@ -387,7 +388,7 @@ func (p *Pod) Status() (map[string]ContainerStatus, error) {
 	defer p.lock.Unlock()
 
 	if !p.valid {
-		return nil, ErrPodRemoved
+		return nil, define.ErrPodRemoved
 	}
 
 	allCtrs, err := p.runtime.state.PodContainers(p)
diff --git a/libpod/pod_internal.go b/libpod/pod_internal.go
index 23359d841..7aacda482 100644
--- a/libpod/pod_internal.go
+++ b/libpod/pod_internal.go
@@ -5,6 +5,7 @@ import (
 	"path/filepath"
 	"time"
 
+	"github.com/containers/libpod/libpod/define"
 	"github.com/containers/storage/pkg/stringid"
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
@@ -52,7 +53,7 @@ func (p *Pod) refresh() error {
 	}
 
 	if !p.valid {
-		return ErrPodRemoved
+		return define.ErrPodRemoved
 	}
 
 	// Retrieve the pod's lock
@@ -76,7 +77,7 @@ func (p *Pod) refresh() error {
 
 			logrus.Debugf("setting pod cgroup to %s", p.state.CgroupPath)
 		default:
-			return errors.Wrapf(ErrInvalidArg, "unknown cgroups manager %s specified", p.runtime.config.CgroupManager)
+			return errors.Wrapf(define.ErrInvalidArg, "unknown cgroups manager %s specified", p.runtime.config.CgroupManager)
 		}
 	}
 
diff --git a/libpod/pod_top_unsupported.go b/libpod/pod_top_unsupported.go
index d44470523..9a3333275 100644
--- a/libpod/pod_top_unsupported.go
+++ b/libpod/pod_top_unsupported.go
@@ -2,7 +2,9 @@
 
 package libpod
 
+import "github.com/containers/libpod/libpod/define"
+
 // GetPodPidInformation is exclusive to linux
 func (p *Pod) GetPodPidInformation(descriptors []string) ([]string, error) {
-	return nil, ErrNotImplemented
+	return nil, define.ErrNotImplemented
 }
diff --git a/libpod/runtime.go b/libpod/runtime.go
index 52ce8062b..152af031a 100644
--- a/libpod/runtime.go
+++ b/libpod/runtime.go
@@ -14,6 +14,7 @@ import (
 	"github.com/BurntSushi/toml"
 	is "github.com/containers/image/storage"
 	"github.com/containers/image/types"
+	"github.com/containers/libpod/libpod/define"
 	"github.com/containers/libpod/libpod/events"
 	"github.com/containers/libpod/libpod/image"
 	"github.com/containers/libpod/libpod/lock"
@@ -76,9 +77,6 @@ var (
 	// DefaultInfraCommand to be run in an infra container
 	DefaultInfraCommand = "/pause"
 
-	// DefaultInitPath is the default path to the container-init binary
-	DefaultInitPath = "/usr/libexec/podman/catatonit"
-
 	// DefaultSHMLockPath is the default path for SHM locks
 	DefaultSHMLockPath = "/libpod_lock"
 	// DefaultRootlessSHMLockPath is the default path for rootless SHM locks
@@ -299,7 +297,7 @@ func defaultRuntimeConfig() (RuntimeConfig, error) {
 		ConmonEnvVars: []string{
 			"PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
 		},
-		InitPath:              DefaultInitPath,
+		InitPath:              define.DefaultInitPath,
 		CgroupManager:         SystemdCgroupsManager,
 		StaticDir:             filepath.Join(storeOpts.GraphRoot, "libpod"),
 		TmpDir:                "",
@@ -655,7 +653,7 @@ func makeRuntime(ctx context.Context, runtime *Runtime) (err error) {
 		break
 	}
 	if !foundConmon {
-		return errors.Wrapf(ErrInvalidArg,
+		return errors.Wrapf(define.ErrInvalidArg,
 			"could not find a working conmon binary (configured options: %v)",
 			runtime.config.ConmonPath)
 	}
@@ -678,7 +676,7 @@ func makeRuntime(ctx context.Context, runtime *Runtime) (err error) {
 		}
 		runtime.state = state
 	case SQLiteStateStore:
-		return errors.Wrapf(ErrInvalidArg, "SQLite state is currently disabled")
+		return errors.Wrapf(define.ErrInvalidArg, "SQLite state is currently disabled")
 	case BoltDBStateStore:
 		dbPath := filepath.Join(runtime.config.StaticDir, "bolt_state.db")
 
@@ -688,7 +686,7 @@ func makeRuntime(ctx context.Context, runtime *Runtime) (err error) {
 		}
 		runtime.state = state
 	default:
-		return errors.Wrapf(ErrInvalidArg, "unrecognized state type passed")
+		return errors.Wrapf(define.ErrInvalidArg, "unrecognized state type passed")
 	}
 
 	// Grab config from the database so we can reset some defaults
@@ -848,7 +846,7 @@ func makeRuntime(ctx context.Context, runtime *Runtime) (err error) {
 		}
 
 		if len(runtime.config.RuntimePath) == 0 {
-			return errors.Wrapf(ErrInvalidArg, "empty runtime path array passed")
+			return errors.Wrapf(define.ErrInvalidArg, "empty runtime path array passed")
 		}
 
 		name := filepath.Base(runtime.config.RuntimePath[0])
@@ -873,7 +871,7 @@ func makeRuntime(ctx context.Context, runtime *Runtime) (err error) {
 	// Initialize remaining OCI runtimes
 	for name, paths := range runtime.config.OCIRuntimes {
 		if len(paths) == 0 {
-			return errors.Wrapf(ErrInvalidArg, "must provide at least 1 path to OCI runtime %s", name)
+			return errors.Wrapf(define.ErrInvalidArg, "must provide at least 1 path to OCI runtime %s", name)
 		}
 
 		supportsJSON := false
@@ -922,7 +920,7 @@ func makeRuntime(ctx context.Context, runtime *Runtime) (err error) {
 		} else {
 			ociRuntime, ok := runtime.ociRuntimes[runtime.config.OCIRuntime]
 			if !ok {
-				return errors.Wrapf(ErrInvalidArg, "default OCI runtime %q not found", runtime.config.OCIRuntime)
+				return errors.Wrapf(define.ErrInvalidArg, "default OCI runtime %q not found", runtime.config.OCIRuntime)
 			}
 			runtime.defaultOCIRuntime = ociRuntime
 		}
@@ -930,12 +928,12 @@ func makeRuntime(ctx context.Context, runtime *Runtime) (err error) {
 
 	// Do we have at least one valid OCI runtime?
 	if len(runtime.ociRuntimes) == 0 {
-		return errors.Wrapf(ErrInvalidArg, "no OCI runtime has been configured")
+		return errors.Wrapf(define.ErrInvalidArg, "no OCI runtime has been configured")
 	}
 
 	// Do we have a default runtime?
 	if runtime.defaultOCIRuntime == nil {
-		return errors.Wrapf(ErrInvalidArg, "no default OCI runtime was configured")
+		return errors.Wrapf(define.ErrInvalidArg, "no default OCI runtime was configured")
 	}
 
 	// Make the per-boot files directory if it does not exist
@@ -1087,7 +1085,7 @@ func (r *Runtime) GetConfig() (*RuntimeConfig, error) {
 	defer r.lock.RUnlock()
 
 	if !r.valid {
-		return nil, ErrRuntimeStopped
+		return nil, define.ErrRuntimeStopped
 	}
 
 	config := new(RuntimeConfig)
@@ -1109,7 +1107,7 @@ func (r *Runtime) Shutdown(force bool) error {
 	defer r.lock.Unlock()
 
 	if !r.valid {
-		return ErrRuntimeStopped
+		return define.ErrRuntimeStopped
 	}
 
 	r.valid = false
@@ -1121,7 +1119,7 @@ func (r *Runtime) Shutdown(force bool) error {
 			logrus.Errorf("Error retrieving containers from database: %v", err)
 		} else {
 			for _, ctr := range ctrs {
-				if err := ctr.StopWithTimeout(CtrRemoveTimeout); err != nil {
+				if err := ctr.StopWithTimeout(define.CtrRemoveTimeout); err != nil {
 					logrus.Errorf("Error stopping container %s: %v", ctr.ID(), err)
 				}
 			}
@@ -1242,7 +1240,7 @@ func (r *Runtime) generateName() (string, error) {
 		if _, err := r.state.LookupContainer(name); err == nil {
 			continue
 		} else {
-			if errors.Cause(err) != ErrNoSuchCtr {
+			if errors.Cause(err) != define.ErrNoSuchCtr {
 				return "", err
 			}
 		}
@@ -1250,7 +1248,7 @@ func (r *Runtime) generateName() (string, error) {
 		if _, err := r.state.LookupPod(name); err == nil {
 			continue
 		} else {
-			if errors.Cause(err) != ErrNoSuchPod {
+			if errors.Cause(err) != define.ErrNoSuchPod {
 				return "", err
 			}
 		}
diff --git a/libpod/runtime_cstorage.go b/libpod/runtime_cstorage.go
index 569f63322..586db5a1e 100644
--- a/libpod/runtime_cstorage.go
+++ b/libpod/runtime_cstorage.go
@@ -1,6 +1,7 @@
 package libpod
 
 import (
+	"github.com/containers/libpod/libpod/define"
 	"github.com/containers/storage"
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
@@ -56,7 +57,7 @@ func (r *Runtime) RemoveStorageContainer(idOrName string, force bool) error {
 	targetID, err := r.store.Lookup(idOrName)
 	if err != nil {
 		if err == storage.ErrLayerUnknown {
-			return errors.Wrapf(ErrNoSuchCtr, "no container with ID or name %q found", idOrName)
+			return errors.Wrapf(define.ErrNoSuchCtr, "no container with ID or name %q found", idOrName)
 		}
 		return errors.Wrapf(err, "error looking up container %q", idOrName)
 	}
@@ -66,7 +67,7 @@ func (r *Runtime) RemoveStorageContainer(idOrName string, force bool) error {
 	ctr, err := r.store.Container(targetID)
 	if err != nil {
 		if err == storage.ErrContainerUnknown {
-			return errors.Wrapf(ErrNoSuchCtr, "%q does not refer to a container", idOrName)
+			return errors.Wrapf(define.ErrNoSuchCtr, "%q does not refer to a container", idOrName)
 		}
 		return errors.Wrapf(err, "error retrieving container %q", idOrName)
 	}
@@ -77,7 +78,7 @@ func (r *Runtime) RemoveStorageContainer(idOrName string, force bool) error {
 		return err
 	}
 	if exists {
-		return errors.Wrapf(ErrCtrExists, "refusing to remove %q as it exists in libpod as container %s", idOrName, ctr.ID)
+		return errors.Wrapf(define.ErrCtrExists, "refusing to remove %q as it exists in libpod as container %s", idOrName, ctr.ID)
 	}
 
 	if !force {
@@ -92,7 +93,7 @@ func (r *Runtime) RemoveStorageContainer(idOrName string, force bool) error {
 			return errors.Wrapf(err, "error looking up container %q mounts", idOrName)
 		}
 		if timesMounted > 0 {
-			return errors.Wrapf(ErrCtrStateInvalid, "container %q is mounted and cannot be removed without using force", idOrName)
+			return errors.Wrapf(define.ErrCtrStateInvalid, "container %q is mounted and cannot be removed without using force", idOrName)
 		}
 	} else {
 		if _, err := r.store.Unmount(ctr.ID, true); err != nil {
diff --git a/libpod/runtime_ctr.go b/libpod/runtime_ctr.go
index 271d4160d..bd1d8a198 100644
--- a/libpod/runtime_ctr.go
+++ b/libpod/runtime_ctr.go
@@ -8,20 +8,17 @@ import (
 	"strings"
 	"time"
 
+	config2 "github.com/containers/libpod/libpod/define"
 	"github.com/containers/libpod/libpod/events"
 	"github.com/containers/libpod/pkg/rootless"
 	"github.com/containers/storage/pkg/stringid"
 	spec "github.com/opencontainers/runtime-spec/specs-go"
 	"github.com/opencontainers/runtime-tools/generate"
-	opentracing "github.com/opentracing/opentracing-go"
+	"github.com/opentracing/opentracing-go"
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 )
 
-// CtrRemoveTimeout is the default number of seconds to wait after stopping a container
-// before sending the kill signal
-const CtrRemoveTimeout = 10
-
 // Contains the public Runtime API for containers
 
 // A CtrCreateOption is a functional option which alters the Container created
@@ -38,7 +35,7 @@ func (r *Runtime) NewContainer(ctx context.Context, rSpec *spec.Spec, options ..
 	r.lock.Lock()
 	defer r.lock.Unlock()
 	if !r.valid {
-		return nil, ErrRuntimeStopped
+		return nil, config2.ErrRuntimeStopped
 	}
 	return r.newContainer(ctx, rSpec, options...)
 }
@@ -48,7 +45,7 @@ func (r *Runtime) RestoreContainer(ctx context.Context, rSpec *spec.Spec, config
 	r.lock.Lock()
 	defer r.lock.Unlock()
 	if !r.valid {
-		return nil, ErrRuntimeStopped
+		return nil, config2.ErrRuntimeStopped
 	}
 
 	ctr, err := r.initContainerVariables(rSpec, config)
@@ -60,7 +57,7 @@ func (r *Runtime) RestoreContainer(ctx context.Context, rSpec *spec.Spec, config
 
 func (r *Runtime) initContainerVariables(rSpec *spec.Spec, config *ContainerConfig) (c *Container, err error) {
 	if rSpec == nil {
-		return nil, errors.Wrapf(ErrInvalidArg, "must provide a valid runtime spec to create container")
+		return nil, errors.Wrapf(config2.ErrInvalidArg, "must provide a valid runtime spec to create container")
 	}
 	ctr := new(Container)
 	ctr.config = new(ContainerConfig)
@@ -92,7 +89,7 @@ func (r *Runtime) initContainerVariables(rSpec *spec.Spec, config *ContainerConf
 
 	ctr.state.BindMounts = make(map[string]string)
 
-	ctr.config.StopTimeout = CtrRemoveTimeout
+	ctr.config.StopTimeout = config2.CtrRemoveTimeout
 
 	ctr.config.OCIRuntime = r.defaultOCIRuntime.name
 
@@ -144,7 +141,7 @@ func (r *Runtime) setupContainer(ctx context.Context, ctr *Container, restore bo
 	} else {
 		ociRuntime, ok := r.ociRuntimes[ctr.config.OCIRuntime]
 		if !ok {
-			return nil, errors.Wrapf(ErrInvalidArg, "requested OCI runtime %s is not available", ctr.config.OCIRuntime)
+			return nil, errors.Wrapf(config2.ErrInvalidArg, "requested OCI runtime %s is not available", ctr.config.OCIRuntime)
 		}
 		ctr.ociRuntime = ociRuntime
 	}
@@ -177,14 +174,14 @@ func (r *Runtime) setupContainer(ctx context.Context, ctr *Container, restore bo
 					return nil, errors.Wrapf(err, "error retrieving pod %s cgroup", pod.ID())
 				}
 				if podCgroup == "" {
-					return nil, errors.Wrapf(ErrInternal, "pod %s cgroup is not set", pod.ID())
+					return nil, errors.Wrapf(config2.ErrInternal, "pod %s cgroup is not set", pod.ID())
 				}
 				ctr.config.CgroupParent = podCgroup
 			} else {
 				ctr.config.CgroupParent = CgroupfsDefaultCgroupParent
 			}
 		} else if strings.HasSuffix(path.Base(ctr.config.CgroupParent), ".slice") {
-			return nil, errors.Wrapf(ErrInvalidArg, "systemd slice received as cgroup parent when using cgroupfs")
+			return nil, errors.Wrapf(config2.ErrInvalidArg, "systemd slice received as cgroup parent when using cgroupfs")
 		}
 	case SystemdCgroupsManager:
 		if ctr.config.CgroupParent == "" {
@@ -198,10 +195,10 @@ func (r *Runtime) setupContainer(ctx context.Context, ctr *Container, restore bo
 				ctr.config.CgroupParent = SystemdDefaultCgroupParent
 			}
 		} else if len(ctr.config.CgroupParent) < 6 || !strings.HasSuffix(path.Base(ctr.config.CgroupParent), ".slice") {
-			return nil, errors.Wrapf(ErrInvalidArg, "did not receive systemd slice as cgroup parent when using systemd to manage cgroups")
+			return nil, errors.Wrapf(config2.ErrInvalidArg, "did not receive systemd slice as cgroup parent when using systemd to manage cgroups")
 		}
 	default:
-		return nil, errors.Wrapf(ErrInvalidArg, "unsupported CGroup manager: %s - cannot validate cgroup parent", r.config.CgroupManager)
+		return nil, errors.Wrapf(config2.ErrInvalidArg, "unsupported CGroup manager: %s - cannot validate cgroup parent", r.config.CgroupManager)
 	}
 
 	if restore {
@@ -241,7 +238,7 @@ func (r *Runtime) setupContainer(ctx context.Context, ctr *Container, restore bo
 		if err == nil {
 			// The volume exists, we're good
 			continue
-		} else if errors.Cause(err) != ErrNoSuchVolume {
+		} else if errors.Cause(err) != config2.ErrNoSuchVolume {
 			return nil, errors.Wrapf(err, "error retrieving named volume %s for new container", vol.Name)
 		}
 
@@ -355,7 +352,7 @@ func (r *Runtime) removeContainer(ctx context.Context, c *Container, force bool,
 	}
 
 	if !r.valid {
-		return ErrRuntimeStopped
+		return config2.ErrRuntimeStopped
 	}
 
 	// Update the container to get current state
@@ -413,7 +410,7 @@ func (r *Runtime) removeContainer(ctx context.Context, c *Container, force bool,
 		}
 		if len(deps) != 0 {
 			depsStr := strings.Join(deps, ", ")
-			return errors.Wrapf(ErrCtrExists, "container %s has dependent containers which must be removed before it: %s", c.ID(), depsStr)
+			return errors.Wrapf(config2.ErrCtrExists, "container %s has dependent containers which must be removed before it: %s", c.ID(), depsStr)
 		}
 	}
 
@@ -496,7 +493,7 @@ func (r *Runtime) removeContainer(ctx context.Context, c *Container, force bool,
 			if !volume.IsCtrSpecific() {
 				continue
 			}
-			if err := runtime.removeVolume(ctx, volume, false); err != nil && err != ErrNoSuchVolume && err != ErrVolumeBeingUsed {
+			if err := runtime.removeVolume(ctx, volume, false); err != nil && err != config2.ErrNoSuchVolume && err != config2.ErrVolumeBeingUsed {
 				logrus.Errorf("cleanup volume (%s): %v", v, err)
 			}
 		}
@@ -511,7 +508,7 @@ func (r *Runtime) GetContainer(id string) (*Container, error) {
 	defer r.lock.RUnlock()
 
 	if !r.valid {
-		return nil, ErrRuntimeStopped
+		return nil, config2.ErrRuntimeStopped
 	}
 
 	return r.state.Container(id)
@@ -523,7 +520,7 @@ func (r *Runtime) HasContainer(id string) (bool, error) {
 	defer r.lock.RUnlock()
 
 	if !r.valid {
-		return false, ErrRuntimeStopped
+		return false, config2.ErrRuntimeStopped
 	}
 
 	return r.state.HasContainer(id)
@@ -536,7 +533,7 @@ func (r *Runtime) LookupContainer(idOrName string) (*Container, error) {
 	defer r.lock.RUnlock()
 
 	if !r.valid {
-		return nil, ErrRuntimeStopped
+		return nil, config2.ErrRuntimeStopped
 	}
 	return r.state.LookupContainer(idOrName)
 }
@@ -550,7 +547,7 @@ func (r *Runtime) GetContainers(filters ...ContainerFilter) ([]*Container, error
 	defer r.lock.RUnlock()
 
 	if !r.valid {
-		return nil, ErrRuntimeStopped
+		return nil, config2.ErrRuntimeStopped
 	}
 
 	ctrs, err := r.state.AllContainers()
@@ -611,7 +608,7 @@ func (r *Runtime) GetLatestContainer() (*Container, error) {
 		return nil, errors.Wrapf(err, "unable to find latest container")
 	}
 	if len(ctrs) == 0 {
-		return nil, ErrNoSuchCtr
+		return nil, config2.ErrNoSuchCtr
 	}
 	for containerIndex, ctr := range ctrs {
 		createdTime := ctr.config.CreatedTime
diff --git a/libpod/runtime_img.go b/libpod/runtime_img.go
index 7cc7de270..4055734eb 100644
--- a/libpod/runtime_img.go
+++ b/libpod/runtime_img.go
@@ -10,6 +10,7 @@ import (
 	"os"
 
 	"github.com/containers/buildah/imagebuildah"
+	"github.com/containers/libpod/libpod/define"
 	"github.com/containers/libpod/libpod/image"
 	"github.com/containers/libpod/pkg/util"
 	"github.com/containers/storage"
@@ -31,7 +32,7 @@ func (r *Runtime) RemoveImage(ctx context.Context, img *image.Image, force bool)
 	defer r.lock.Unlock()
 
 	if !r.valid {
-		return "", ErrRuntimeStopped
+		return "", define.ErrRuntimeStopped
 	}
 
 	// Get all containers, filter to only those using the image, and remove those containers
diff --git a/libpod/runtime_pod.go b/libpod/runtime_pod.go
index b3dd7dabd..66f9b10c9 100644
--- a/libpod/runtime_pod.go
+++ b/libpod/runtime_pod.go
@@ -4,6 +4,7 @@ import (
 	"context"
 	"time"
 
+	"github.com/containers/libpod/libpod/define"
 	"github.com/containers/libpod/pkg/util"
 	"github.com/pkg/errors"
 )
@@ -30,7 +31,7 @@ func (r *Runtime) RemovePod(ctx context.Context, p *Pod, removeCtrs, force bool)
 	defer r.lock.Unlock()
 
 	if !r.valid {
-		return ErrRuntimeStopped
+		return define.ErrRuntimeStopped
 	}
 
 	if !p.valid {
@@ -53,7 +54,7 @@ func (r *Runtime) GetPod(id string) (*Pod, error) {
 	defer r.lock.RUnlock()
 
 	if !r.valid {
-		return nil, ErrRuntimeStopped
+		return nil, define.ErrRuntimeStopped
 	}
 
 	return r.state.Pod(id)
@@ -65,7 +66,7 @@ func (r *Runtime) HasPod(id string) (bool, error) {
 	defer r.lock.RUnlock()
 
 	if !r.valid {
-		return false, ErrRuntimeStopped
+		return false, define.ErrRuntimeStopped
 	}
 
 	return r.state.HasPod(id)
@@ -78,7 +79,7 @@ func (r *Runtime) LookupPod(idOrName string) (*Pod, error) {
 	defer r.lock.RUnlock()
 
 	if !r.valid {
-		return nil, ErrRuntimeStopped
+		return nil, define.ErrRuntimeStopped
 	}
 
 	return r.state.LookupPod(idOrName)
@@ -93,7 +94,7 @@ func (r *Runtime) Pods(filters ...PodFilter) ([]*Pod, error) {
 	defer r.lock.RUnlock()
 
 	if !r.valid {
-		return nil, ErrRuntimeStopped
+		return nil, define.ErrRuntimeStopped
 	}
 
 	pods, err := r.state.AllPods()
@@ -122,7 +123,7 @@ func (r *Runtime) GetAllPods() ([]*Pod, error) {
 	defer r.lock.RUnlock()
 
 	if !r.valid {
-		return nil, ErrRuntimeStopped
+		return nil, define.ErrRuntimeStopped
 	}
 
 	return r.state.AllPods()
@@ -137,7 +138,7 @@ func (r *Runtime) GetLatestPod() (*Pod, error) {
 		return nil, errors.Wrapf(err, "unable to get all pods")
 	}
 	if len(pods) == 0 {
-		return nil, ErrNoSuchPod
+		return nil, define.ErrNoSuchPod
 	}
 	for podIndex, pod := range pods {
 		createdTime := pod.config.CreatedTime
@@ -159,7 +160,7 @@ func (r *Runtime) GetRunningPods() ([]*Pod, error) {
 	defer r.lock.RUnlock()
 
 	if !r.valid {
-		return nil, ErrRuntimeStopped
+		return nil, define.ErrRuntimeStopped
 	}
 	containers, err := r.GetRunningContainers()
 	if err != nil {
@@ -171,7 +172,7 @@ func (r *Runtime) GetRunningPods() ([]*Pod, error) {
 			pods = append(pods, c.PodID())
 			pod, err := r.GetPod(c.PodID())
 			if err != nil {
-				if errors.Cause(err) == ErrPodRemoved || errors.Cause(err) == ErrNoSuchPod {
+				if errors.Cause(err) == define.ErrPodRemoved || errors.Cause(err) == define.ErrNoSuchPod {
 					continue
 				}
 				return nil, err
diff --git a/libpod/runtime_pod_infra_linux.go b/libpod/runtime_pod_infra_linux.go
index 0a5f78cf8..da35b7f93 100644
--- a/libpod/runtime_pod_infra_linux.go
+++ b/libpod/runtime_pod_infra_linux.go
@@ -6,6 +6,7 @@ import (
 	"context"
 	"strings"
 
+	"github.com/containers/libpod/libpod/define"
 	"github.com/containers/libpod/libpod/image"
 	"github.com/containers/libpod/pkg/rootless"
 	"github.com/opencontainers/image-spec/specs-go/v1"
@@ -104,7 +105,7 @@ func (r *Runtime) makeInfraContainer(ctx context.Context, p *Pod, imgName, imgID
 // containers in the pod.
 func (r *Runtime) createInfraContainer(ctx context.Context, p *Pod) (*Container, error) {
 	if !r.valid {
-		return nil, ErrRuntimeStopped
+		return nil, define.ErrRuntimeStopped
 	}
 
 	newImage, err := r.ImageRuntime().New(ctx, r.config.InfraImage, "", "", nil, nil, image.SigningOptions{}, false, nil)
diff --git a/libpod/runtime_pod_linux.go b/libpod/runtime_pod_linux.go
index 124d0daf8..d1d303ad5 100644
--- a/libpod/runtime_pod_linux.go
+++ b/libpod/runtime_pod_linux.go
@@ -10,6 +10,7 @@ import (
 	"strings"
 
 	"github.com/containerd/cgroups"
+	"github.com/containers/libpod/libpod/define"
 	"github.com/containers/libpod/libpod/events"
 	spec "github.com/opencontainers/runtime-spec/specs-go"
 	"github.com/pkg/errors"
@@ -22,7 +23,7 @@ func (r *Runtime) NewPod(ctx context.Context, options ...PodCreateOption) (*Pod,
 	defer r.lock.Unlock()
 
 	if !r.valid {
-		return nil, ErrRuntimeStopped
+		return nil, define.ErrRuntimeStopped
 	}
 
 	pod, err := newPod(r)
@@ -66,7 +67,7 @@ func (r *Runtime) NewPod(ctx context.Context, options ...PodCreateOption) (*Pod,
 		if pod.config.CgroupParent == "" {
 			pod.config.CgroupParent = CgroupfsDefaultCgroupParent
 		} else if strings.HasSuffix(path.Base(pod.config.CgroupParent), ".slice") {
-			return nil, errors.Wrapf(ErrInvalidArg, "systemd slice received as cgroup parent when using cgroupfs")
+			return nil, errors.Wrapf(define.ErrInvalidArg, "systemd slice received as cgroup parent when using cgroupfs")
 		}
 		// If we are set to use pod cgroups, set the cgroup parent that
 		// all containers in the pod will share
@@ -79,7 +80,7 @@ func (r *Runtime) NewPod(ctx context.Context, options ...PodCreateOption) (*Pod,
 		if pod.config.CgroupParent == "" {
 			pod.config.CgroupParent = SystemdDefaultCgroupParent
 		} else if len(pod.config.CgroupParent) < 6 || !strings.HasSuffix(path.Base(pod.config.CgroupParent), ".slice") {
-			return nil, errors.Wrapf(ErrInvalidArg, "did not receive systemd slice as cgroup parent when using systemd to manage cgroups")
+			return nil, errors.Wrapf(define.ErrInvalidArg, "did not receive systemd slice as cgroup parent when using systemd to manage cgroups")
 		}
 		// If we are set to use pod cgroups, set the cgroup parent that
 		// all containers in the pod will share
@@ -91,7 +92,7 @@ func (r *Runtime) NewPod(ctx context.Context, options ...PodCreateOption) (*Pod,
 			pod.state.CgroupPath = cgroupPath
 		}
 	default:
-		return nil, errors.Wrapf(ErrInvalidArg, "unsupported CGroup manager: %s - cannot validate cgroup parent", r.config.CgroupManager)
+		return nil, errors.Wrapf(define.ErrInvalidArg, "unsupported CGroup manager: %s - cannot validate cgroup parent", r.config.CgroupManager)
 	}
 
 	if pod.config.UsePodCgroup {
@@ -146,7 +147,7 @@ func (r *Runtime) removePod(ctx context.Context, p *Pod, removeCtrs, force bool)
 		force = true
 	}
 	if !removeCtrs && numCtrs > 0 {
-		return errors.Wrapf(ErrCtrExists, "pod %s contains containers and cannot be removed", p.ID())
+		return errors.Wrapf(define.ErrCtrExists, "pod %s contains containers and cannot be removed", p.ID())
 	}
 
 	// Go through and lock all containers so we can operate on them all at
@@ -290,7 +291,7 @@ func (r *Runtime) removePod(ctx context.Context, p *Pod, removeCtrs, force bool)
 			// keep going so we make sure to evict the pod before
 			// ending up with an inconsistent state.
 			if removalErr == nil {
-				removalErr = errors.Wrapf(ErrInternal, "unrecognized cgroup manager %s when removing pod %s cgroups", p.runtime.config.CgroupManager, p.ID())
+				removalErr = errors.Wrapf(define.ErrInternal, "unrecognized cgroup manager %s when removing pod %s cgroups", p.runtime.config.CgroupManager, p.ID())
 			} else {
 				logrus.Errorf("Unknown cgroups manager %s specified - cannot remove pod %s cgroup", p.runtime.config.CgroupManager, p.ID())
 			}
diff --git a/libpod/runtime_pod_unsupported.go b/libpod/runtime_pod_unsupported.go
index d2629d5ab..5f0811822 100644
--- a/libpod/runtime_pod_unsupported.go
+++ b/libpod/runtime_pod_unsupported.go
@@ -4,13 +4,15 @@ package libpod
 
 import (
 	"context"
+
+	"github.com/containers/libpod/libpod/define"
 )
 
 // NewPod makes a new, empty pod
 func (r *Runtime) NewPod(ctx context.Context, options ...PodCreateOption) (*Pod, error) {
-	return nil, ErrOSNotSupported
+	return nil, define.ErrOSNotSupported
 }
 
 func (r *Runtime) removePod(ctx context.Context, p *Pod, removeCtrs, force bool) error {
-	return ErrOSNotSupported
+	return define.ErrOSNotSupported
 }
diff --git a/libpod/runtime_volume.go b/libpod/runtime_volume.go
index 68c6c107e..5c087faca 100644
--- a/libpod/runtime_volume.go
+++ b/libpod/runtime_volume.go
@@ -4,6 +4,7 @@ import (
 	"context"
 	"strings"
 
+	"github.com/containers/libpod/libpod/define"
 	"github.com/containers/libpod/libpod/events"
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
@@ -26,7 +27,7 @@ func (r *Runtime) RemoveVolume(ctx context.Context, v *Volume, force bool) error
 	defer r.lock.Unlock()
 
 	if !r.valid {
-		return ErrRuntimeStopped
+		return define.ErrRuntimeStopped
 	}
 
 	if !v.valid {
@@ -77,7 +78,7 @@ func (r *Runtime) GetVolume(name string) (*Volume, error) {
 	defer r.lock.RUnlock()
 
 	if !r.valid {
-		return nil, ErrRuntimeStopped
+		return nil, define.ErrRuntimeStopped
 	}
 
 	vol, err := r.state.Volume(name)
@@ -103,7 +104,7 @@ func (r *Runtime) HasVolume(name string) (bool, error) {
 	defer r.lock.RUnlock()
 
 	if !r.valid {
-		return false, ErrRuntimeStopped
+		return false, define.ErrRuntimeStopped
 	}
 
 	return r.state.HasVolume(name)
@@ -118,7 +119,7 @@ func (r *Runtime) Volumes(filters ...VolumeFilter) ([]*Volume, error) {
 	defer r.lock.RUnlock()
 
 	if !r.valid {
-		return nil, ErrRuntimeStopped
+		return nil, define.ErrRuntimeStopped
 	}
 
 	vols, err := r.state.AllVolumes()
@@ -147,7 +148,7 @@ func (r *Runtime) GetAllVolumes() ([]*Volume, error) {
 	defer r.lock.RUnlock()
 
 	if !r.valid {
-		return nil, ErrRuntimeStopped
+		return nil, define.ErrRuntimeStopped
 	}
 
 	return r.state.AllVolumes()
@@ -167,7 +168,7 @@ func (r *Runtime) PruneVolumes(ctx context.Context) ([]string, []error) {
 
 	for _, vol := range vols {
 		if err := r.RemoveVolume(ctx, vol, false); err != nil {
-			if errors.Cause(err) != ErrVolumeBeingUsed && errors.Cause(err) != ErrVolumeRemoved {
+			if errors.Cause(err) != define.ErrVolumeBeingUsed && errors.Cause(err) != define.ErrVolumeRemoved {
 				pruneErrors = append(pruneErrors, err)
 			}
 			continue
diff --git a/libpod/runtime_volume_linux.go b/libpod/runtime_volume_linux.go
index a326ed0e0..ac6fd02c3 100644
--- a/libpod/runtime_volume_linux.go
+++ b/libpod/runtime_volume_linux.go
@@ -8,6 +8,7 @@ import (
 	"path/filepath"
 	"strings"
 
+	"github.com/containers/libpod/libpod/define"
 	"github.com/containers/libpod/libpod/events"
 	"github.com/containers/storage/pkg/stringid"
 	"github.com/pkg/errors"
@@ -20,7 +21,7 @@ func (r *Runtime) NewVolume(ctx context.Context, options ...VolumeCreateOption)
 	defer r.lock.Unlock()
 
 	if !r.valid {
-		return nil, ErrRuntimeStopped
+		return nil, define.ErrRuntimeStopped
 	}
 	return r.newVolume(ctx, options...)
 }
@@ -86,7 +87,7 @@ func (r *Runtime) removeVolume(ctx context.Context, v *Volume, force bool) error
 		if ok, _ := r.state.HasVolume(v.Name()); !ok {
 			return nil
 		}
-		return ErrVolumeRemoved
+		return define.ErrVolumeRemoved
 	}
 
 	deps, err := r.state.VolumeInUse(v)
@@ -96,7 +97,7 @@ func (r *Runtime) removeVolume(ctx context.Context, v *Volume, force bool) error
 	if len(deps) != 0 {
 		depsStr := strings.Join(deps, ", ")
 		if !force {
-			return errors.Wrapf(ErrVolumeBeingUsed, "volume %s is being used by the following container(s): %s", v.Name(), depsStr)
+			return errors.Wrapf(define.ErrVolumeBeingUsed, "volume %s is being used by the following container(s): %s", v.Name(), depsStr)
 		}
 
 		// We need to remove all containers using the volume
@@ -105,7 +106,7 @@ func (r *Runtime) removeVolume(ctx context.Context, v *Volume, force bool) error
 			if err != nil {
 				// If the container's removed, no point in
 				// erroring.
-				if errors.Cause(err) == ErrNoSuchCtr || errors.Cause(err) == ErrCtrRemoved {
+				if errors.Cause(err) == define.ErrNoSuchCtr || errors.Cause(err) == define.ErrCtrRemoved {
 					continue
 				}
 
diff --git a/libpod/runtime_volume_unsupported.go b/libpod/runtime_volume_unsupported.go
index 5fe487114..1cbf2699a 100644
--- a/libpod/runtime_volume_unsupported.go
+++ b/libpod/runtime_volume_unsupported.go
@@ -4,16 +4,18 @@ package libpod
 
 import (
 	"context"
+
+	"github.com/containers/libpod/libpod/define"
 )
 
 func (r *Runtime) removeVolume(ctx context.Context, v *Volume, force bool) error {
-	return ErrNotImplemented
+	return define.ErrNotImplemented
 }
 
 func (r *Runtime) newVolume(ctx context.Context, options ...VolumeCreateOption) (*Volume, error) {
-	return nil, ErrNotImplemented
+	return nil, define.ErrNotImplemented
 }
 
 func (r *Runtime) NewVolume(ctx context.Context, options ...VolumeCreateOption) (*Volume, error) {
-	return nil, ErrNotImplemented
+	return nil, define.ErrNotImplemented
 }
diff --git a/libpod/stats.go b/libpod/stats.go
index c58a46135..926a1a511 100644
--- a/libpod/stats.go
+++ b/libpod/stats.go
@@ -8,6 +8,7 @@ import (
 	"time"
 
 	"github.com/containerd/cgroups"
+	"github.com/containers/libpod/libpod/define"
 	"github.com/pkg/errors"
 )
 
@@ -26,7 +27,7 @@ func (c *Container) GetContainerStats(previousStats *ContainerStats) (*Container
 	}
 
 	if c.state.State != ContainerStateRunning {
-		return stats, ErrCtrStateInvalid
+		return stats, define.ErrCtrStateInvalid
 	}
 
 	cgroupPath, err := c.CGroupPath()
diff --git a/libpod/stats_unsupported.go b/libpod/stats_unsupported.go
index 7117413eb..ec19a89a1 100644
--- a/libpod/stats_unsupported.go
+++ b/libpod/stats_unsupported.go
@@ -2,7 +2,9 @@
 
 package libpod
 
+import "github.com/containers/libpod/libpod/define"
+
 // GetContainerStats gets the running stats for a given container
 func (c *Container) GetContainerStats(previousStats *ContainerStats) (*ContainerStats, error) {
-	return nil, ErrOSNotSupported
+	return nil, define.ErrOSNotSupported
 }
diff --git a/libpod/storage.go b/libpod/storage.go
index 1a7b13da6..0814672be 100644
--- a/libpod/storage.go
+++ b/libpod/storage.go
@@ -6,9 +6,10 @@ import (
 
 	istorage "github.com/containers/image/storage"
 	"github.com/containers/image/types"
+	"github.com/containers/libpod/libpod/define"
 	"github.com/containers/storage"
 	"github.com/opencontainers/image-spec/specs-go/v1"
-	opentracing "github.com/opentracing/opentracing-go"
+	"github.com/opentracing/opentracing-go"
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 )
@@ -71,7 +72,7 @@ func (r *storageService) CreateContainerStorage(ctx context.Context, systemConte
 	if imageName != "" {
 		var ref types.ImageReference
 		if containerName == "" {
-			return ContainerInfo{}, ErrEmptyID
+			return ContainerInfo{}, define.ErrEmptyID
 		}
 		// Check if we have the specified image.
 		ref, err := istorage.Transport.ParseStoreReference(r.store, imageID)
@@ -175,7 +176,7 @@ func (r *storageService) CreateContainerStorage(ctx context.Context, systemConte
 
 func (r *storageService) DeleteContainer(idOrName string) error {
 	if idOrName == "" {
-		return ErrEmptyID
+		return define.ErrEmptyID
 	}
 	container, err := r.store.Container(idOrName)
 	if err != nil {
@@ -214,7 +215,7 @@ func (r *storageService) MountContainerImage(idOrName string) (string, error) {
 	container, err := r.store.Container(idOrName)
 	if err != nil {
 		if errors.Cause(err) == storage.ErrContainerUnknown {
-			return "", ErrNoSuchCtr
+			return "", define.ErrNoSuchCtr
 		}
 		return "", err
 	}
@@ -233,7 +234,7 @@ func (r *storageService) MountContainerImage(idOrName string) (string, error) {
 
 func (r *storageService) UnmountContainerImage(idOrName string, force bool) (bool, error) {
 	if idOrName == "" {
-		return false, ErrEmptyID
+		return false, define.ErrEmptyID
 	}
 	container, err := r.store.Container(idOrName)
 	if err != nil {
@@ -260,7 +261,7 @@ func (r *storageService) UnmountContainerImage(idOrName string, force bool) (boo
 
 func (r *storageService) MountedContainerImage(idOrName string) (int, error) {
 	if idOrName == "" {
-		return 0, ErrEmptyID
+		return 0, define.ErrEmptyID
 	}
 	container, err := r.store.Container(idOrName)
 	if err != nil {
@@ -277,7 +278,7 @@ func (r *storageService) GetMountpoint(id string) (string, error) {
 	container, err := r.store.Container(id)
 	if err != nil {
 		if errors.Cause(err) == storage.ErrContainerUnknown {
-			return "", ErrNoSuchCtr
+			return "", define.ErrNoSuchCtr
 		}
 		return "", err
 	}
@@ -293,7 +294,7 @@ func (r *storageService) GetWorkDir(id string) (string, error) {
 	container, err := r.store.Container(id)
 	if err != nil {
 		if errors.Cause(err) == storage.ErrContainerUnknown {
-			return "", ErrNoSuchCtr
+			return "", define.ErrNoSuchCtr
 		}
 		return "", err
 	}
@@ -304,7 +305,7 @@ func (r *storageService) GetRunDir(id string) (string, error) {
 	container, err := r.store.Container(id)
 	if err != nil {
 		if errors.Cause(err) == storage.ErrContainerUnknown {
-			return "", ErrNoSuchCtr
+			return "", define.ErrNoSuchCtr
 		}
 		return "", err
 	}
diff --git a/libpod/util.go b/libpod/util.go
index 3a15f9e39..7b3a03785 100644
--- a/libpod/util.go
+++ b/libpod/util.go
@@ -11,6 +11,7 @@ import (
 
 	"github.com/containers/image/signature"
 	"github.com/containers/image/types"
+	"github.com/containers/libpod/libpod/define"
 	"github.com/fsnotify/fsnotify"
 	spec "github.com/opencontainers/runtime-spec/specs-go"
 	"github.com/pkg/errors"
@@ -126,7 +127,7 @@ func WaitForFile(path string, chWait chan error, timeout time.Duration) (bool, e
 				return false, errors.Wrapf(err, "checking file %s", path)
 			}
 		case <-timeoutChan:
-			return false, errors.Wrapf(ErrInternal, "timed out waiting for file %s", path)
+			return false, errors.Wrapf(define.ErrInternal, "timed out waiting for file %s", path)
 		}
 	}
 }
@@ -156,15 +157,15 @@ func sortMounts(m []spec.Mount) []spec.Mount {
 
 func validPodNSOption(p *Pod, ctrPod string) error {
 	if p == nil {
-		return errors.Wrapf(ErrInvalidArg, "pod passed in was nil. Container may not be associated with a pod")
+		return errors.Wrapf(define.ErrInvalidArg, "pod passed in was nil. Container may not be associated with a pod")
 	}
 
 	if ctrPod == "" {
-		return errors.Wrapf(ErrInvalidArg, "container is not a member of any pod")
+		return errors.Wrapf(define.ErrInvalidArg, "container is not a member of any pod")
 	}
 
 	if ctrPod != p.ID() {
-		return errors.Wrapf(ErrInvalidArg, "pod passed in is not the pod the container is associated with")
+		return errors.Wrapf(define.ErrInvalidArg, "pod passed in is not the pod the container is associated with")
 	}
 	return nil
 }
diff --git a/libpod/util_linux.go b/libpod/util_linux.go
index a801df2ee..8752eba20 100644
--- a/libpod/util_linux.go
+++ b/libpod/util_linux.go
@@ -7,6 +7,7 @@ import (
 	"strings"
 
 	"github.com/containerd/cgroups"
+	"github.com/containers/libpod/libpod/define"
 	"github.com/containers/libpod/pkg/util"
 	spec "github.com/opencontainers/runtime-spec/specs-go"
 	"github.com/opencontainers/selinux/go-selinux/label"
@@ -61,7 +62,7 @@ func assembleSystemdCgroupName(baseSlice, newSlice string) (string, error) {
 	const sliceSuffix = ".slice"
 
 	if !strings.HasSuffix(baseSlice, sliceSuffix) {
-		return "", errors.Wrapf(ErrInvalidArg, "cannot assemble cgroup path with base %q - must end in .slice", baseSlice)
+		return "", errors.Wrapf(define.ErrInvalidArg, "cannot assemble cgroup path with base %q - must end in .slice", baseSlice)
 	}
 
 	noSlice := strings.TrimSuffix(baseSlice, sliceSuffix)
diff --git a/libpod/util_unsupported.go b/libpod/util_unsupported.go
index 940006e69..58b0dfbcd 100644
--- a/libpod/util_unsupported.go
+++ b/libpod/util_unsupported.go
@@ -3,27 +3,28 @@
 package libpod
 
 import (
+	"github.com/containers/libpod/libpod/define"
 	"github.com/pkg/errors"
 )
 
 func systemdSliceFromPath(parent, name string) (string, error) {
-	return "", errors.Wrapf(ErrOSNotSupported, "cgroups are not supported on non-linux OSes")
+	return "", errors.Wrapf(define.ErrOSNotSupported, "cgroups are not supported on non-linux OSes")
 }
 
 func makeSystemdCgroup(path string) error {
-	return errors.Wrapf(ErrOSNotSupported, "cgroups are not supported on non-linux OSes")
+	return errors.Wrapf(define.ErrOSNotSupported, "cgroups are not supported on non-linux OSes")
 }
 
 func deleteSystemdCgroup(path string) error {
-	return errors.Wrapf(ErrOSNotSupported, "cgroups are not supported on non-linux OSes")
+	return errors.Wrapf(define.ErrOSNotSupported, "cgroups are not supported on non-linux OSes")
 }
 
 func assembleSystemdCgroupName(baseSlice, newSlice string) (string, error) {
-	return "", errors.Wrapf(ErrOSNotSupported, "cgroups are not supported on non-linux OSes")
+	return "", errors.Wrapf(define.ErrOSNotSupported, "cgroups are not supported on non-linux OSes")
 }
 
 // LabelVolumePath takes a mount path for a volume and gives it an
 // selinux label of either shared or not
 func LabelVolumePath(path string, shared bool) error {
-	return ErrNotImplemented
+	return define.ErrNotImplemented
 }