From cef992a395ce701b5ae3eb2a611123ed28a0f1a1 Mon Sep 17 00:00:00 2001
From: kannappanr <30541348+kannappanr@users.noreply.github.com>
Date: Tue, 10 Apr 2018 09:36:37 -0700
Subject: [PATCH] Remove error package and cause functions (#5784)

---
 cmd/api-errors.go                       |   2 -
 cmd/bucket-handlers.go                  |   4 +-
 cmd/bucket-notification-handlers.go     |   3 +-
 cmd/bucket-policy-handlers.go           |   2 -
 cmd/bucket-policy.go                    |  14 +--
 cmd/disk-cache-fs.go                    |   3 +-
 cmd/disk-cache.go                       |  13 +-
 cmd/format-xl.go                        |   9 +-
 cmd/format-xl_test.go                   |   4 +-
 cmd/fs-v1-helpers.go                    |   3 -
 cmd/fs-v1-helpers_test.go               |  37 +++---
 cmd/fs-v1-multipart.go                  |  11 +-
 cmd/fs-v1-multipart_test.go             |  11 +-
 cmd/fs-v1.go                            |  12 +-
 cmd/fs-v1_test.go                       |  38 +++---
 cmd/gateway/azure/gateway-azure.go      |   3 +-
 cmd/gateway/azure/gateway-azure_test.go |   3 +-
 cmd/gateway/oss/gateway-oss_test.go     |   7 +-
 cmd/gateway/s3/gateway-s3_test.go       |   9 +-
 cmd/handler-utils_test.go               |   4 +-
 cmd/lock-instrument_test.go             |  18 ++-
 cmd/notification.go                     |   9 +-
 cmd/object-api-errors.go                |  14 ---
 cmd/object-api-input-checks.go          |   3 +-
 cmd/object-api-multipart_test.go        |   4 +-
 cmd/object-api-putobject_test.go        |   4 -
 cmd/object-handlers.go                  |   2 -
 cmd/object_api_suite_test.go            |   8 +-
 cmd/os-reliable_test.go                 |  12 +-
 cmd/prepare-storage.go                  |   3 +-
 cmd/storage-rpc-server_test.go          |   6 +-
 cmd/utils.go                            |  15 +++
 cmd/utils_test.go                       |  24 ++++
 cmd/web-handlers.go                     |   8 +-
 cmd/xl-sets.go                          |   7 +-
 cmd/xl-v1-bucket.go                     |  11 +-
 cmd/xl-v1-common.go                     |   3 +-
 cmd/xl-v1-healing.go                    |  21 ++--
 cmd/xl-v1-healing_test.go               |   5 +-
 cmd/xl-v1-list-objects.go               |   6 +-
 cmd/xl-v1-metadata.go                   |   9 +-
 cmd/xl-v1-metadata_test.go              |   8 +-
 cmd/xl-v1-multipart.go                  |  11 +-
 cmd/xl-v1-multipart_test.go             |   3 -
 cmd/xl-v1-object.go                     |   5 +-
 cmd/xl-v1-object_test.go                |   5 -
 cmd/xl-v1-utils.go                      |   3 +-
 cmd/xl-v1-utils_test.go                 |   9 +-
 cmd/xl-v1.go                            |   3 +-
 pkg/errors/errors.go                    | 154 ------------------------
 pkg/errors/errors_test.go               | 120 ------------------
 51 files changed, 186 insertions(+), 519 deletions(-)
 delete mode 100644 pkg/errors/errors.go
 delete mode 100644 pkg/errors/errors_test.go

diff --git a/cmd/api-errors.go b/cmd/api-errors.go
index 9fe818786..8f140f80b 100644
--- a/cmd/api-errors.go
+++ b/cmd/api-errors.go
@@ -22,7 +22,6 @@ import (
 	"net/http"
 
 	"github.com/minio/minio/pkg/auth"
-	"github.com/minio/minio/pkg/errors"
 	"github.com/minio/minio/pkg/event"
 	"github.com/minio/minio/pkg/hash"
 )
@@ -853,7 +852,6 @@ func toAPIErrorCode(err error) (apiErr APIErrorCode) {
 		return ErrNone
 	}
 
-	err = errors.Cause(err)
 	// Verify if the underlying error is signature mismatch.
 	switch err {
 	case errSignatureMismatch:
diff --git a/cmd/bucket-handlers.go b/cmd/bucket-handlers.go
index f0fac21a1..8e3a20327 100644
--- a/cmd/bucket-handlers.go
+++ b/cmd/bucket-handlers.go
@@ -34,7 +34,6 @@ import (
 	"github.com/minio/minio-go/pkg/policy"
 	"github.com/minio/minio-go/pkg/set"
 	"github.com/minio/minio/cmd/logger"
-	"github.com/minio/minio/pkg/errors"
 	"github.com/minio/minio/pkg/event"
 	"github.com/minio/minio/pkg/hash"
 )
@@ -45,7 +44,6 @@ func enforceBucketPolicy(ctx context.Context, bucket, action, resource, referer,
 	// Verify if bucket actually exists
 	objAPI := newObjectLayerFn()
 	if err := checkBucketExist(ctx, bucket, objAPI); err != nil {
-		err = errors.Cause(err)
 		switch err.(type) {
 		case BucketNameInvalid:
 			// Return error for invalid bucket name.
@@ -357,7 +355,7 @@ func (api objectAPIHandlers) DeleteMultipleObjectsHandler(w http.ResponseWriter,
 			deletedObjects = append(deletedObjects, object)
 			continue
 		}
-		if _, ok := errors.Cause(err).(ObjectNotFound); ok {
+		if _, ok := err.(ObjectNotFound); ok {
 			// If the object is not found it should be
 			// accounted as deleted as per S3 spec.
 			deletedObjects = append(deletedObjects, object)
diff --git a/cmd/bucket-notification-handlers.go b/cmd/bucket-notification-handlers.go
index 4996acfd6..98bf8dc16 100644
--- a/cmd/bucket-notification-handlers.go
+++ b/cmd/bucket-notification-handlers.go
@@ -24,7 +24,6 @@ import (
 
 	"github.com/gorilla/mux"
 	"github.com/minio/minio/cmd/logger"
-	xerrors "github.com/minio/minio/pkg/errors"
 	"github.com/minio/minio/pkg/event"
 	"github.com/minio/minio/pkg/event/target"
 	xnet "github.com/minio/minio/pkg/net"
@@ -72,7 +71,7 @@ func (api objectAPIHandlers) GetBucketNotificationHandler(w http.ResponseWriter,
 	nConfig, err := readNotificationConfig(ctx, objAPI, bucketName)
 	if err != nil {
 		// Ignore errNoSuchNotifications to comply with AWS S3.
-		if xerrors.Cause(err) != errNoSuchNotifications {
+		if err != errNoSuchNotifications {
 			writeErrorResponse(w, toAPIErrorCode(err), r.URL)
 			return
 		}
diff --git a/cmd/bucket-policy-handlers.go b/cmd/bucket-policy-handlers.go
index 389c5e05f..813fde7ee 100644
--- a/cmd/bucket-policy-handlers.go
+++ b/cmd/bucket-policy-handlers.go
@@ -29,7 +29,6 @@ import (
 	mux "github.com/gorilla/mux"
 	"github.com/minio/minio-go/pkg/policy"
 	"github.com/minio/minio/cmd/logger"
-	"github.com/minio/minio/pkg/errors"
 	"github.com/minio/minio/pkg/wildcard"
 )
 
@@ -277,7 +276,6 @@ func (api objectAPIHandlers) PutBucketPolicyHandler(w http.ResponseWriter, r *ht
 	}
 
 	if err = objAPI.SetBucketPolicy(ctx, bucket, policyInfo); err != nil {
-		err = errors.Cause(err)
 		switch err.(type) {
 		case NotImplemented:
 			// Return error for invalid bucket name.
diff --git a/cmd/bucket-policy.go b/cmd/bucket-policy.go
index c098844e6..ad1b978c9 100644
--- a/cmd/bucket-policy.go
+++ b/cmd/bucket-policy.go
@@ -26,7 +26,6 @@ import (
 
 	"github.com/minio/minio-go/pkg/policy"
 	"github.com/minio/minio/cmd/logger"
-	"github.com/minio/minio/pkg/errors"
 	"github.com/minio/minio/pkg/hash"
 )
 
@@ -86,7 +85,7 @@ func initBucketPolicies(objAPI ObjectLayer) (*bucketPolicies, error) {
 	// List buckets to proceed loading all notification configuration.
 	buckets, err := objAPI.ListBuckets(context.Background())
 	if err != nil {
-		return nil, errors.Cause(err)
+		return nil, err
 	}
 
 	policies := make(map[string]policy.BucketAccessPolicy)
@@ -96,9 +95,9 @@ func initBucketPolicies(objAPI ObjectLayer) (*bucketPolicies, error) {
 		if pErr != nil {
 			// net.Dial fails for rpc client or any
 			// other unexpected errors during net.Dial.
-			if !errors.IsErrIgnored(pErr, errDiskNotFound) {
+			if !IsErrIgnored(pErr, errDiskNotFound) {
 				if !isErrBucketPolicyNotFound(pErr) {
-					return nil, errors.Cause(pErr)
+					return nil, pErr
 				}
 			}
 			// Continue to load other bucket policies if possible.
@@ -126,7 +125,7 @@ func readBucketPolicyJSON(bucket string, objAPI ObjectLayer) (bucketPolicyReader
 		if isErrObjectNotFound(err) || isErrIncompleteBody(err) {
 			return nil, PolicyNotFound{Bucket: bucket}
 		}
-		return nil, errors.Cause(err)
+		return nil, err
 	}
 
 	return &buffer, nil
@@ -156,7 +155,6 @@ func removeBucketPolicy(ctx context.Context, bucket string, objAPI ObjectLayer)
 	policyPath := pathJoin(bucketConfigPrefix, bucket, bucketPolicyConfig)
 	err := objAPI.DeleteObject(ctx, minioMetaBucket, policyPath)
 	if err != nil {
-		err = errors.Cause(err)
 		if _, ok := err.(ObjectNotFound); ok {
 			return BucketPolicyNotFound{Bucket: bucket}
 		}
@@ -177,11 +175,11 @@ func writeBucketPolicy(ctx context.Context, bucket string, objAPI ObjectLayer, b
 	hashReader, err := hash.NewReader(bytes.NewReader(buf), int64(len(buf)), "", getSHA256Hash(buf))
 	if err != nil {
 		logger.LogIf(ctx, err)
-		return errors.Cause(err)
+		return err
 	}
 
 	if _, err = objAPI.PutObject(ctx, minioMetaBucket, policyPath, hashReader, nil); err != nil {
-		return errors.Cause(err)
+		return err
 	}
 	return nil
 }
diff --git a/cmd/disk-cache-fs.go b/cmd/disk-cache-fs.go
index abf66c8f3..20ed5dbe4 100644
--- a/cmd/disk-cache-fs.go
+++ b/cmd/disk-cache-fs.go
@@ -30,7 +30,6 @@ import (
 
 	"github.com/minio/minio/cmd/logger"
 	"github.com/minio/minio/pkg/disk"
-	errors2 "github.com/minio/minio/pkg/errors"
 	"github.com/minio/minio/pkg/hash"
 	"github.com/minio/minio/pkg/lock"
 )
@@ -279,7 +278,7 @@ func (cfs *cacheFSObjects) Put(ctx context.Context, bucket, object string, data
 	}
 	_, err := cfs.PutObject(ctx, bucket, object, data, metadata)
 	// if err is due to disk being offline , mark cache drive as offline
-	if errors2.IsErr(err, baseErrs...) {
+	if IsErr(err, baseErrs...) {
 		cfs.setOnline(false)
 	}
 	return err
diff --git a/cmd/disk-cache.go b/cmd/disk-cache.go
index 5495df569..9c28d417e 100644
--- a/cmd/disk-cache.go
+++ b/cmd/disk-cache.go
@@ -32,7 +32,6 @@ import (
 	"github.com/djherbis/atime"
 
 	"github.com/minio/minio/cmd/logger"
-	errors2 "github.com/minio/minio/pkg/errors"
 	"github.com/minio/minio/pkg/wildcard"
 
 	"github.com/minio/minio/pkg/hash"
@@ -104,8 +103,8 @@ type CacheObjectLayer interface {
 
 // backendDownError returns true if err is due to backend failure or faulty disk if in server mode
 func backendDownError(err error) bool {
-	_, backendDown := errors2.Cause(err).(BackendDown)
-	return backendDown || errors2.IsErr(err, baseErrs...)
+	_, backendDown := err.(BackendDown)
+	return backendDown || IsErr(err, baseErrs...)
 }
 
 // get cache disk where object is currently cached for a GET operation. If object does not exist at that location,
@@ -192,7 +191,7 @@ func (c cacheObjects) GetObject(ctx context.Context, bucket, object string, star
 	objInfo, err := GetObjectInfoFn(ctx, bucket, object)
 	backendDown := backendDownError(err)
 	if err != nil && !backendDown {
-		if _, ok := errors2.Cause(err).(ObjectNotFound); ok {
+		if _, ok := err.(ObjectNotFound); ok {
 			// Delete the cached entry if backend object was deleted.
 			dcache.Delete(ctx, bucket, object)
 		}
@@ -256,7 +255,7 @@ func (c cacheObjects) GetObjectInfo(ctx context.Context, bucket, object string)
 	}
 	objInfo, err := getObjectInfoFn(ctx, bucket, object)
 	if err != nil {
-		if _, ok := errors2.Cause(err).(ObjectNotFound); ok {
+		if _, ok := err.(ObjectNotFound); ok {
 			// Delete the cached entry if backend object was deleted.
 			dcache.Delete(ctx, bucket, object)
 			return ObjectInfo{}, err
@@ -379,7 +378,7 @@ func (c cacheObjects) listCacheObjects(ctx context.Context, bucket, prefix, mark
 			fs, err := c.cache.getCacheFS(ctx, bucket, entry)
 			if err != nil {
 				// Ignore errFileNotFound
-				if errors2.Cause(err) == errFileNotFound {
+				if err == errFileNotFound {
 					continue
 				}
 				return result, toObjectErr(err, bucket, prefix)
@@ -387,7 +386,7 @@ func (c cacheObjects) listCacheObjects(ctx context.Context, bucket, prefix, mark
 			objInfo, err = fs.getObjectInfo(ctx, bucket, entry)
 			if err != nil {
 				// Ignore errFileNotFound
-				if errors2.Cause(err) == errFileNotFound {
+				if err == errFileNotFound {
 					continue
 				}
 				return result, toObjectErr(err, bucket, prefix)
diff --git a/cmd/format-xl.go b/cmd/format-xl.go
index f645c7952..18d936378 100644
--- a/cmd/format-xl.go
+++ b/cmd/format-xl.go
@@ -27,7 +27,6 @@ import (
 	"encoding/hex"
 
 	humanize "github.com/dustin/go-humanize"
-	"github.com/minio/minio/pkg/errors"
 	sha256 "github.com/minio/sha256-simd"
 )
 
@@ -303,7 +302,7 @@ func hasAnyErrors(errs []error) bool {
 func countErrs(errs []error, err error) int {
 	var i = 0
 	for _, err1 := range errs {
-		if errors.Cause(err1) == err {
+		if err1 == err {
 			i++
 		}
 	}
@@ -644,17 +643,17 @@ func initFormatXL(ctx context.Context, storageDisks []StorageAPI, setCount, disk
 func makeFormatXLMetaVolumes(disk StorageAPI) error {
 	// Attempt to create `.minio.sys`.
 	if err := disk.MakeVol(minioMetaBucket); err != nil {
-		if !errors.IsErrIgnored(err, initMetaVolIgnoredErrs...) {
+		if !IsErrIgnored(err, initMetaVolIgnoredErrs...) {
 			return err
 		}
 	}
 	if err := disk.MakeVol(minioMetaTmpBucket); err != nil {
-		if !errors.IsErrIgnored(err, initMetaVolIgnoredErrs...) {
+		if !IsErrIgnored(err, initMetaVolIgnoredErrs...) {
 			return err
 		}
 	}
 	if err := disk.MakeVol(minioMetaMultipartBucket); err != nil {
-		if !errors.IsErrIgnored(err, initMetaVolIgnoredErrs...) {
+		if !IsErrIgnored(err, initMetaVolIgnoredErrs...) {
 			return err
 		}
 	}
diff --git a/cmd/format-xl_test.go b/cmd/format-xl_test.go
index 3e0e832eb..6084d097f 100644
--- a/cmd/format-xl_test.go
+++ b/cmd/format-xl_test.go
@@ -22,8 +22,6 @@ import (
 	"os"
 	"reflect"
 	"testing"
-
-	"github.com/minio/minio/pkg/errors"
 )
 
 // Test get offline/online uuids.
@@ -114,7 +112,7 @@ func TestFixFormatV3(t *testing.T) {
 
 	newFormats, errs := loadFormatXLAll(storageDisks)
 	for _, err := range errs {
-		if err != nil && errors.Cause(err) != errUnformattedDisk {
+		if err != nil && err != errUnformattedDisk {
 			t.Fatal(err)
 		}
 	}
diff --git a/cmd/fs-v1-helpers.go b/cmd/fs-v1-helpers.go
index 7ebeb0d0c..664776d5c 100644
--- a/cmd/fs-v1-helpers.go
+++ b/cmd/fs-v1-helpers.go
@@ -24,7 +24,6 @@ import (
 	"runtime"
 
 	"github.com/minio/minio/cmd/logger"
-	"github.com/minio/minio/pkg/errors"
 	"github.com/minio/minio/pkg/lock"
 )
 
@@ -175,7 +174,6 @@ func fsStat(ctx context.Context, statLoc string) (os.FileInfo, error) {
 func fsStatVolume(ctx context.Context, volume string) (os.FileInfo, error) {
 	fi, err := fsStat(ctx, volume)
 	if err != nil {
-		err = errors.Cause(err)
 		if os.IsNotExist(err) {
 			return nil, errVolumeNotFound
 		} else if os.IsPermission(err) {
@@ -200,7 +198,6 @@ func osErrToFSFileErr(err error) error {
 	if err == nil {
 		return nil
 	}
-	err = errors.Cause(err)
 	if os.IsNotExist(err) {
 		return errFileNotFound
 	}
diff --git a/cmd/fs-v1-helpers_test.go b/cmd/fs-v1-helpers_test.go
index ac44e744f..6bbd41eb7 100644
--- a/cmd/fs-v1-helpers_test.go
+++ b/cmd/fs-v1-helpers_test.go
@@ -25,7 +25,6 @@ import (
 	"path"
 	"testing"
 
-	"github.com/minio/minio/pkg/errors"
 	"github.com/minio/minio/pkg/lock"
 )
 
@@ -43,13 +42,13 @@ func TestFSRenameFile(t *testing.T) {
 	if err = fsRenameFile(context.Background(), pathJoin(path, "testvolume1"), pathJoin(path, "testvolume2")); err != nil {
 		t.Fatal(err)
 	}
-	if err = fsRenameFile(context.Background(), pathJoin(path, "testvolume1"), pathJoin(path, "testvolume2")); errors.Cause(err) != errFileNotFound {
+	if err = fsRenameFile(context.Background(), pathJoin(path, "testvolume1"), pathJoin(path, "testvolume2")); err != errFileNotFound {
 		t.Fatal(err)
 	}
-	if err = fsRenameFile(context.Background(), pathJoin(path, "my-obj-del-0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001"), pathJoin(path, "testvolume2")); errors.Cause(err) != errFileNameTooLong {
+	if err = fsRenameFile(context.Background(), pathJoin(path, "my-obj-del-0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001"), pathJoin(path, "testvolume2")); err != errFileNameTooLong {
 		t.Fatal("Unexpected error", err)
 	}
-	if err = fsRenameFile(context.Background(), pathJoin(path, "testvolume1"), pathJoin(path, "my-obj-del-0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001")); errors.Cause(err) != errFileNameTooLong {
+	if err = fsRenameFile(context.Background(), pathJoin(path, "testvolume1"), pathJoin(path, "my-obj-del-0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001")); err != errFileNameTooLong {
 		t.Fatal("Unexpected error", err)
 	}
 }
@@ -64,11 +63,11 @@ func TestFSStats(t *testing.T) {
 
 	// Setup test environment.
 
-	if err = fsMkdir(context.Background(), ""); errors.Cause(err) != errInvalidArgument {
+	if err = fsMkdir(context.Background(), ""); err != errInvalidArgument {
 		t.Fatal("Unexpected error", err)
 	}
 
-	if err = fsMkdir(context.Background(), pathJoin(path, "my-obj-del-0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001")); errors.Cause(err) != errFileNameTooLong {
+	if err = fsMkdir(context.Background(), pathJoin(path, "my-obj-del-0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001")); err != errFileNameTooLong {
 		t.Fatal("Unexpected error", err)
 	}
 
@@ -83,7 +82,7 @@ func TestFSStats(t *testing.T) {
 	// Seek back.
 	reader.Seek(0, 0)
 
-	if err = fsMkdir(context.Background(), pathJoin(path, "success-vol", "success-file")); errors.Cause(err) != errVolumeExists {
+	if err = fsMkdir(context.Background(), pathJoin(path, "success-vol", "success-file")); err != errVolumeExists {
 		t.Fatal("Unexpected error", err)
 	}
 
@@ -171,11 +170,11 @@ func TestFSStats(t *testing.T) {
 	for i, testCase := range testCases {
 		if testCase.srcPath != "" {
 			if _, err := fsStatFile(context.Background(), pathJoin(testCase.srcFSPath, testCase.srcVol,
-				testCase.srcPath)); errors.Cause(err) != testCase.expectedErr {
+				testCase.srcPath)); err != testCase.expectedErr {
 				t.Fatalf("TestPosix case %d: Expected: \"%s\", got: \"%s\"", i+1, testCase.expectedErr, err)
 			}
 		} else {
-			if _, err := fsStatVolume(context.Background(), pathJoin(testCase.srcFSPath, testCase.srcVol)); errors.Cause(err) != testCase.expectedErr {
+			if _, err := fsStatVolume(context.Background(), pathJoin(testCase.srcFSPath, testCase.srcVol)); err != testCase.expectedErr {
 				t.Fatalf("TestPosix case %d: Expected: \"%s\", got: \"%s\"", i+1, testCase.expectedErr, err)
 			}
 		}
@@ -194,11 +193,11 @@ func TestFSCreateAndOpen(t *testing.T) {
 		t.Fatalf("Unable to create directory, %s", err)
 	}
 
-	if _, err = fsCreateFile(context.Background(), "", nil, nil, 0); errors.Cause(err) != errInvalidArgument {
+	if _, err = fsCreateFile(context.Background(), "", nil, nil, 0); err != errInvalidArgument {
 		t.Fatal("Unexpected error", err)
 	}
 
-	if _, _, err = fsOpenFile(context.Background(), "", -1); errors.Cause(err) != errInvalidArgument {
+	if _, _, err = fsOpenFile(context.Background(), "", -1); err != errInvalidArgument {
 		t.Fatal("Unexpected error", err)
 	}
 
@@ -232,17 +231,17 @@ func TestFSCreateAndOpen(t *testing.T) {
 
 	for i, testCase := range testCases {
 		_, err = fsCreateFile(context.Background(), pathJoin(path, testCase.srcVol, testCase.srcPath), reader, nil, 0)
-		if errors.Cause(err) != testCase.expectedErr {
+		if err != testCase.expectedErr {
 			t.Errorf("Test case %d: Expected: \"%s\", got: \"%s\"", i+1, testCase.expectedErr, err)
 		}
 		_, _, err = fsOpenFile(context.Background(), pathJoin(path, testCase.srcVol, testCase.srcPath), 0)
-		if errors.Cause(err) != testCase.expectedErr {
+		if err != testCase.expectedErr {
 			t.Errorf("Test case %d: Expected: \"%s\", got: \"%s\"", i+1, testCase.expectedErr, err)
 		}
 	}
 
 	// Attempt to open a directory.
-	if _, _, err = fsOpenFile(context.Background(), pathJoin(path), 0); errors.Cause(err) != errIsNotRegular {
+	if _, _, err = fsOpenFile(context.Background(), pathJoin(path), 0); err != errIsNotRegular {
 		t.Fatal("Unexpected error", err)
 	}
 }
@@ -344,7 +343,7 @@ func TestFSDeletes(t *testing.T) {
 	}
 
 	for i, testCase := range testCases {
-		if err = fsDeleteFile(context.Background(), testCase.basePath, pathJoin(testCase.basePath, testCase.srcVol, testCase.srcPath)); errors.Cause(err) != testCase.expectedErr {
+		if err = fsDeleteFile(context.Background(), testCase.basePath, pathJoin(testCase.basePath, testCase.srcVol, testCase.srcPath)); err != testCase.expectedErr {
 			t.Errorf("Test case %d: Expected: \"%s\", got: \"%s\"", i+1, testCase.expectedErr, err)
 		}
 	}
@@ -478,11 +477,11 @@ func TestFSRemoves(t *testing.T) {
 
 	for i, testCase := range testCases {
 		if testCase.srcPath != "" {
-			if err = fsRemoveFile(context.Background(), pathJoin(testCase.srcFSPath, testCase.srcVol, testCase.srcPath)); errors.Cause(err) != testCase.expectedErr {
+			if err = fsRemoveFile(context.Background(), pathJoin(testCase.srcFSPath, testCase.srcVol, testCase.srcPath)); err != testCase.expectedErr {
 				t.Errorf("Test case %d: Expected: \"%s\", got: \"%s\"", i+1, testCase.expectedErr, err)
 			}
 		} else {
-			if err = fsRemoveDir(context.Background(), pathJoin(testCase.srcFSPath, testCase.srcVol, testCase.srcPath)); errors.Cause(err) != testCase.expectedErr {
+			if err = fsRemoveDir(context.Background(), pathJoin(testCase.srcFSPath, testCase.srcVol, testCase.srcPath)); err != testCase.expectedErr {
 				t.Error(err)
 			}
 		}
@@ -492,11 +491,11 @@ func TestFSRemoves(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	if err = fsRemoveAll(context.Background(), ""); errors.Cause(err) != errInvalidArgument {
+	if err = fsRemoveAll(context.Background(), ""); err != errInvalidArgument {
 		t.Fatal(err)
 	}
 
-	if err = fsRemoveAll(context.Background(), "my-obj-del-0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001"); errors.Cause(err) != errFileNameTooLong {
+	if err = fsRemoveAll(context.Background(), "my-obj-del-0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001"); err != errFileNameTooLong {
 		t.Fatal(err)
 	}
 }
diff --git a/cmd/fs-v1-multipart.go b/cmd/fs-v1-multipart.go
index 2153a6a71..fa468c84c 100644
--- a/cmd/fs-v1-multipart.go
+++ b/cmd/fs-v1-multipart.go
@@ -30,7 +30,6 @@ import (
 	"time"
 
 	"github.com/minio/minio/cmd/logger"
-	"github.com/minio/minio/pkg/errors"
 	mioutil "github.com/minio/minio/pkg/ioutil"
 
 	"github.com/minio/minio/pkg/hash"
@@ -304,7 +303,7 @@ func (fs *FSObjects) PutObjectPart(ctx context.Context, bucket, object, uploadID
 	// Just check if the uploadID exists to avoid copy if it doesn't.
 	_, err := fsStatFile(ctx, pathJoin(uploadIDDir, fs.metaJSONFile))
 	if err != nil {
-		if errors.Cause(err) == errFileNotFound || errors.Cause(err) == errFileAccessDenied {
+		if err == errFileNotFound || err == errFileAccessDenied {
 			return pi, InvalidUploadID{UploadID: uploadID}
 		}
 		return pi, toObjectErr(err, bucket, object)
@@ -384,7 +383,7 @@ func (fs *FSObjects) ListObjectParts(ctx context.Context, bucket, object, upload
 	uploadIDDir := fs.getUploadIDDir(bucket, object, uploadID)
 	_, err := fsStatFile(ctx, pathJoin(uploadIDDir, fs.metaJSONFile))
 	if err != nil {
-		if errors.Cause(err) == errFileNotFound || errors.Cause(err) == errFileAccessDenied {
+		if err == errFileNotFound || err == errFileAccessDenied {
 			return result, InvalidUploadID{UploadID: uploadID}
 		}
 		return result, toObjectErr(err, bucket, object)
@@ -498,7 +497,7 @@ func (fs *FSObjects) CompleteMultipartUpload(ctx context.Context, bucket string,
 	// Just check if the uploadID exists to avoid copy if it doesn't.
 	_, err := fsStatFile(ctx, pathJoin(uploadIDDir, fs.metaJSONFile))
 	if err != nil {
-		if errors.Cause(err) == errFileNotFound || errors.Cause(err) == errFileAccessDenied {
+		if err == errFileNotFound || err == errFileAccessDenied {
 			return oi, InvalidUploadID{UploadID: uploadID}
 		}
 		return oi, toObjectErr(err, bucket, object)
@@ -523,7 +522,7 @@ func (fs *FSObjects) CompleteMultipartUpload(ctx context.Context, bucket string,
 		var fi os.FileInfo
 		fi, err = fsStatFile(ctx, partPath)
 		if err != nil {
-			if errors.Cause(err) == errFileNotFound || errors.Cause(err) == errFileAccessDenied {
+			if err == errFileNotFound || err == errFileAccessDenied {
 				return oi, InvalidPart{}
 			}
 			return oi, err
@@ -698,7 +697,7 @@ func (fs *FSObjects) AbortMultipartUpload(ctx context.Context, bucket, object, u
 	// Just check if the uploadID exists to avoid copy if it doesn't.
 	_, err := fsStatFile(ctx, pathJoin(uploadIDDir, fs.metaJSONFile))
 	if err != nil {
-		if errors.Cause(err) == errFileNotFound || errors.Cause(err) == errFileAccessDenied {
+		if err == errFileNotFound || err == errFileAccessDenied {
 			return InvalidUploadID{UploadID: uploadID}
 		}
 		return toObjectErr(err, bucket, object)
diff --git a/cmd/fs-v1-multipart_test.go b/cmd/fs-v1-multipart_test.go
index 6edc85f93..ccc2dcab9 100644
--- a/cmd/fs-v1-multipart_test.go
+++ b/cmd/fs-v1-multipart_test.go
@@ -23,8 +23,6 @@ import (
 	"path/filepath"
 	"testing"
 	"time"
-
-	"github.com/minio/minio/pkg/errors"
 )
 
 // Tests cleanup multipart uploads for filesystem backend.
@@ -60,7 +58,6 @@ func TestFSCleanupMultipartUploadsInRoutine(t *testing.T) {
 
 	// Check if upload id was already purged.
 	if err = obj.AbortMultipartUpload(context.Background(), bucketName, objectName, uploadID); err != nil {
-		err = errors.Cause(err)
 		if _, ok := err.(InvalidUploadID); !ok {
 			t.Fatal("Unexpected err: ", err)
 		}
@@ -85,7 +82,7 @@ func TestNewMultipartUploadFaultyDisk(t *testing.T) {
 	// Test with disk removed.
 	fs.fsPath = filepath.Join(globalTestTmpDir, "minio-"+nextSuffix())
 	if _, err := fs.NewMultipartUpload(context.Background(), bucketName, objectName, map[string]string{"X-Amz-Meta-xid": "3f"}); err != nil {
-		if !isSameType(errors.Cause(err), BucketNotFound{}) {
+		if !isSameType(err, BucketNotFound{}) {
 			t.Fatal("Unexpected error ", err)
 		}
 	}
@@ -123,7 +120,7 @@ func TestPutObjectPartFaultyDisk(t *testing.T) {
 
 	fs.fsPath = filepath.Join(globalTestTmpDir, "minio-"+nextSuffix())
 	_, err = fs.PutObjectPart(context.Background(), bucketName, objectName, uploadID, 1, mustGetHashReader(t, bytes.NewReader(data), dataLen, md5Hex, sha256sum))
-	if !isSameType(errors.Cause(err), BucketNotFound{}) {
+	if !isSameType(err, BucketNotFound{}) {
 		t.Fatal("Unexpected error ", err)
 	}
 }
@@ -154,7 +151,7 @@ func TestCompleteMultipartUploadFaultyDisk(t *testing.T) {
 	parts := []CompletePart{{PartNumber: 1, ETag: md5Hex}}
 	fs.fsPath = filepath.Join(globalTestTmpDir, "minio-"+nextSuffix())
 	if _, err := fs.CompleteMultipartUpload(context.Background(), bucketName, objectName, uploadID, parts); err != nil {
-		if !isSameType(errors.Cause(err), BucketNotFound{}) {
+		if !isSameType(err, BucketNotFound{}) {
 			t.Fatal("Unexpected error ", err)
 		}
 	}
@@ -249,7 +246,7 @@ func TestListMultipartUploadsFaultyDisk(t *testing.T) {
 
 	fs.fsPath = filepath.Join(globalTestTmpDir, "minio-"+nextSuffix())
 	if _, err := fs.ListMultipartUploads(context.Background(), bucketName, objectName, "", "", "", 1000); err != nil {
-		if !isSameType(errors.Cause(err), BucketNotFound{}) {
+		if !isSameType(err, BucketNotFound{}) {
 			t.Fatal("Unexpected error ", err)
 		}
 	}
diff --git a/cmd/fs-v1.go b/cmd/fs-v1.go
index 6d8883014..76ec0d37a 100644
--- a/cmd/fs-v1.go
+++ b/cmd/fs-v1.go
@@ -31,7 +31,6 @@ import (
 
 	"github.com/minio/minio-go/pkg/policy"
 	"github.com/minio/minio/cmd/logger"
-	"github.com/minio/minio/pkg/errors"
 	"github.com/minio/minio/pkg/hash"
 	"github.com/minio/minio/pkg/lock"
 	"github.com/minio/minio/pkg/madmin"
@@ -527,7 +526,7 @@ func (fs *FSObjects) getObject(ctx context.Context, bucket, object string, offse
 func (fs *FSObjects) getObjectInfo(ctx context.Context, bucket, object string) (oi ObjectInfo, e error) {
 	fsMeta := fsMetaV1{}
 	fi, err := fsStatDir(ctx, pathJoin(fs.fsPath, bucket, object))
-	if err != nil && errors.Cause(err) != errFileAccessDenied {
+	if err != nil && err != errFileAccessDenied {
 		return oi, toObjectErr(err, bucket, object)
 	}
 	if fi != nil {
@@ -552,7 +551,7 @@ func (fs *FSObjects) getObjectInfo(ctx context.Context, bucket, object string) (
 			// `fs.json` can be empty due to previously failed
 			// PutObject() transaction, if we arrive at such
 			// a situation we just ignore and continue.
-			if errors.Cause(rerr) != io.EOF {
+			if rerr != io.EOF {
 				return oi, toObjectErr(rerr, bucket, object)
 			}
 		}
@@ -807,7 +806,7 @@ func (fs *FSObjects) DeleteObject(ctx context.Context, bucket, object string) er
 	if bucket != minioMetaBucket {
 		// Delete the metadata object.
 		err := fsDeleteFile(ctx, minioMetaBucketDir, fsMetaPath)
-		if err != nil && errors.Cause(err) != errFileNotFound {
+		if err != nil && err != errFileNotFound {
 			return toObjectErr(err, bucket, object)
 		}
 	}
@@ -980,7 +979,7 @@ func (fs *FSObjects) ListObjects(ctx context.Context, bucket, prefix, marker, de
 		// For any walk error return right away.
 		if walkResult.err != nil {
 			// File not found is a valid case.
-			if errors.Cause(walkResult.err) == errFileNotFound {
+			if walkResult.err == errFileNotFound {
 				return loi, nil
 			}
 			return loi, toObjectErr(walkResult.err, bucket, prefix)
@@ -1020,7 +1019,8 @@ func (fs *FSObjects) ListObjects(ctx context.Context, bucket, prefix, marker, de
 
 // ReloadFormat - no-op for fs, Valid only for XL.
 func (fs *FSObjects) ReloadFormat(ctx context.Context, dryRun bool) error {
-	return errors.Trace(NotImplemented{})
+	logger.LogIf(ctx, NotImplemented{})
+	return NotImplemented{}
 }
 
 // HealFormat - no-op for fs, Valid only for XL.
diff --git a/cmd/fs-v1_test.go b/cmd/fs-v1_test.go
index 30e836909..6f6dfecea 100644
--- a/cmd/fs-v1_test.go
+++ b/cmd/fs-v1_test.go
@@ -23,8 +23,6 @@ import (
 	"os"
 	"path/filepath"
 	"testing"
-
-	"github.com/minio/minio/pkg/errors"
 )
 
 // Tests for if parent directory is object
@@ -181,7 +179,7 @@ func TestFSGetBucketInfo(t *testing.T) {
 
 	// Test with inexistant bucket
 	_, err = fs.GetBucketInfo(context.Background(), "a")
-	if !isSameType(errors.Cause(err), BucketNameInvalid{}) {
+	if !isSameType(err, BucketNameInvalid{}) {
 		t.Fatal("BucketNameInvalid error not returned")
 	}
 
@@ -189,7 +187,7 @@ func TestFSGetBucketInfo(t *testing.T) {
 	fs.fsPath = filepath.Join(globalTestTmpDir, "minio-"+nextSuffix())
 
 	_, err = fs.GetBucketInfo(context.Background(), bucketName)
-	if !isSameType(errors.Cause(err), BucketNotFound{}) {
+	if !isSameType(err, BucketNotFound{}) {
 		t.Fatal("BucketNotFound error not returned")
 	}
 }
@@ -212,7 +210,7 @@ func TestFSPutObject(t *testing.T) {
 	if err == nil {
 		t.Fatal("Unexpected should fail here, bucket doesn't exist")
 	}
-	if _, ok := errors.Cause(err).(BucketNotFound); !ok {
+	if _, ok := err.(BucketNotFound); !ok {
 		t.Fatalf("Expected error type BucketNotFound, got %#v", err)
 	}
 
@@ -221,7 +219,7 @@ func TestFSPutObject(t *testing.T) {
 	if err == nil {
 		t.Fatal("Unexpected should fail here, bucket doesn't exist")
 	}
-	if _, ok := errors.Cause(err).(BucketNotFound); !ok {
+	if _, ok := err.(BucketNotFound); !ok {
 		t.Fatalf("Expected error type BucketNotFound, got %#v", err)
 	}
 
@@ -233,7 +231,7 @@ func TestFSPutObject(t *testing.T) {
 	if err == nil {
 		t.Fatal("Unexpected should fail here, backend corruption occurred")
 	}
-	if nerr, ok := errors.Cause(err).(PrefixAccessDenied); !ok {
+	if nerr, ok := err.(PrefixAccessDenied); !ok {
 		t.Fatalf("Expected PrefixAccessDenied, got %#v", err)
 	} else {
 		if nerr.Bucket != "bucket" {
@@ -248,7 +246,7 @@ func TestFSPutObject(t *testing.T) {
 	if err == nil {
 		t.Fatal("Unexpected should fail here, backned corruption occurred")
 	}
-	if nerr, ok := errors.Cause(err).(PrefixAccessDenied); !ok {
+	if nerr, ok := err.(PrefixAccessDenied); !ok {
 		t.Fatalf("Expected PrefixAccessDenied, got %#v", err)
 	} else {
 		if nerr.Bucket != "bucket" {
@@ -275,19 +273,19 @@ func TestFSDeleteObject(t *testing.T) {
 	obj.PutObject(context.Background(), bucketName, objectName, mustGetHashReader(t, bytes.NewReader([]byte("abcd")), int64(len("abcd")), "", ""), nil)
 
 	// Test with invalid bucket name
-	if err := fs.DeleteObject(context.Background(), "fo", objectName); !isSameType(errors.Cause(err), BucketNameInvalid{}) {
+	if err := fs.DeleteObject(context.Background(), "fo", objectName); !isSameType(err, BucketNameInvalid{}) {
 		t.Fatal("Unexpected error: ", err)
 	}
 	// Test with bucket does not exist
-	if err := fs.DeleteObject(context.Background(), "foobucket", "fooobject"); !isSameType(errors.Cause(err), BucketNotFound{}) {
+	if err := fs.DeleteObject(context.Background(), "foobucket", "fooobject"); !isSameType(err, BucketNotFound{}) {
 		t.Fatal("Unexpected error: ", err)
 	}
 	// Test with invalid object name
-	if err := fs.DeleteObject(context.Background(), bucketName, "\\"); !isSameType(errors.Cause(err), ObjectNameInvalid{}) {
+	if err := fs.DeleteObject(context.Background(), bucketName, "\\"); !isSameType(err, ObjectNameInvalid{}) {
 		t.Fatal("Unexpected error: ", err)
 	}
 	// Test with object does not exist.
-	if err := fs.DeleteObject(context.Background(), bucketName, "foooobject"); !isSameType(errors.Cause(err), ObjectNotFound{}) {
+	if err := fs.DeleteObject(context.Background(), bucketName, "foooobject"); !isSameType(err, ObjectNotFound{}) {
 		t.Fatal("Unexpected error: ", err)
 	}
 	// Test with valid condition
@@ -298,7 +296,7 @@ func TestFSDeleteObject(t *testing.T) {
 	// Delete object should err disk not found.
 	fs.fsPath = filepath.Join(globalTestTmpDir, "minio-"+nextSuffix())
 	if err := fs.DeleteObject(context.Background(), bucketName, objectName); err != nil {
-		if !isSameType(errors.Cause(err), BucketNotFound{}) {
+		if !isSameType(err, BucketNotFound{}) {
 			t.Fatal("Unexpected error: ", err)
 		}
 	}
@@ -321,11 +319,11 @@ func TestFSDeleteBucket(t *testing.T) {
 	}
 
 	// Test with an invalid bucket name
-	if err = fs.DeleteBucket(context.Background(), "fo"); !isSameType(errors.Cause(err), BucketNameInvalid{}) {
+	if err = fs.DeleteBucket(context.Background(), "fo"); !isSameType(err, BucketNameInvalid{}) {
 		t.Fatal("Unexpected error: ", err)
 	}
 	// Test with an inexistant bucket
-	if err = fs.DeleteBucket(context.Background(), "foobucket"); !isSameType(errors.Cause(err), BucketNotFound{}) {
+	if err = fs.DeleteBucket(context.Background(), "foobucket"); !isSameType(err, BucketNotFound{}) {
 		t.Fatal("Unexpected error: ", err)
 	}
 	// Test with a valid case
@@ -338,7 +336,7 @@ func TestFSDeleteBucket(t *testing.T) {
 	// Delete bucket should get error disk not found.
 	fs.fsPath = filepath.Join(globalTestTmpDir, "minio-"+nextSuffix())
 	if err = fs.DeleteBucket(context.Background(), bucketName); err != nil {
-		if !isSameType(errors.Cause(err), BucketNotFound{}) {
+		if !isSameType(err, BucketNotFound{}) {
 			t.Fatal("Unexpected error: ", err)
 		}
 	}
@@ -381,7 +379,7 @@ func TestFSListBuckets(t *testing.T) {
 	fs.fsPath = filepath.Join(globalTestTmpDir, "minio-"+nextSuffix())
 
 	if _, err := fs.ListBuckets(context.Background()); err != nil {
-		if errors.Cause(err) != errDiskNotFound {
+		if err != errDiskNotFound {
 			t.Fatal("Unexpected error: ", err)
 		}
 	}
@@ -389,7 +387,7 @@ func TestFSListBuckets(t *testing.T) {
 	longPath := fmt.Sprintf("%0256d", 1)
 	fs.fsPath = longPath
 	if _, err := fs.ListBuckets(context.Background()); err != nil {
-		if errors.Cause(err) != errFileNameTooLong {
+		if err != errFileNameTooLong {
 			t.Fatal("Unexpected error: ", err)
 		}
 	}
@@ -402,7 +400,7 @@ func TestFSHealObject(t *testing.T) {
 
 	obj := initFSObjects(disk, t)
 	_, err := obj.HealObject(context.Background(), "bucket", "object", false)
-	if err == nil || !isSameType(errors.Cause(err), NotImplemented{}) {
+	if err == nil || !isSameType(err, NotImplemented{}) {
 		t.Fatalf("Heal Object should return NotImplemented error ")
 	}
 }
@@ -414,7 +412,7 @@ func TestFSListObjectsHeal(t *testing.T) {
 
 	obj := initFSObjects(disk, t)
 	_, err := obj.ListObjectsHeal(context.Background(), "bucket", "prefix", "marker", "delimiter", 1000)
-	if err == nil || !isSameType(errors.Cause(err), NotImplemented{}) {
+	if err == nil || !isSameType(err, NotImplemented{}) {
 		t.Fatalf("Heal Object should return NotImplemented error ")
 	}
 }
diff --git a/cmd/gateway/azure/gateway-azure.go b/cmd/gateway/azure/gateway-azure.go
index eecfe70e3..333d4d5f6 100644
--- a/cmd/gateway/azure/gateway-azure.go
+++ b/cmd/gateway/azure/gateway-azure.go
@@ -37,7 +37,6 @@ import (
 	"github.com/minio/minio-go/pkg/policy"
 	"github.com/minio/minio/cmd/logger"
 	"github.com/minio/minio/pkg/auth"
-	"github.com/minio/minio/pkg/errors"
 	"github.com/minio/minio/pkg/hash"
 	sha256 "github.com/minio/sha256-simd"
 
@@ -714,7 +713,7 @@ func (a *azureObjects) checkUploadIDExists(ctx context.Context, bucketName, obje
 		Bucket: bucketName,
 		Object: objectName,
 	}
-	if errors.Cause(err) == oerr {
+	if err == oerr {
 		logger.LogIf(ctx, minio.InvalidUploadID{UploadID: uploadID})
 		err = minio.InvalidUploadID{
 			UploadID: uploadID,
diff --git a/cmd/gateway/azure/gateway-azure_test.go b/cmd/gateway/azure/gateway-azure_test.go
index 957882e51..dcae19a7a 100644
--- a/cmd/gateway/azure/gateway-azure_test.go
+++ b/cmd/gateway/azure/gateway-azure_test.go
@@ -25,7 +25,6 @@ import (
 
 	"github.com/Azure/azure-sdk-for-go/storage"
 	minio "github.com/minio/minio/cmd"
-	"github.com/minio/minio/pkg/errors"
 )
 
 // Test canonical metadata.
@@ -67,7 +66,7 @@ func TestS3MetaToAzureProperties(t *testing.T) {
 		"invalid--meta": "value",
 	}
 	_, _, err = s3MetaToAzureProperties(context.Background(), headers)
-	if err = errors.Cause(err); err != nil {
+	if err != nil {
 		if _, ok := err.(minio.UnsupportedMetadata); !ok {
 			t.Fatalf("Test failed with unexpected error %s, expected UnsupportedMetadata", err)
 		}
diff --git a/cmd/gateway/oss/gateway-oss_test.go b/cmd/gateway/oss/gateway-oss_test.go
index f90c019b7..4c95dda3f 100644
--- a/cmd/gateway/oss/gateway-oss_test.go
+++ b/cmd/gateway/oss/gateway-oss_test.go
@@ -26,7 +26,6 @@ import (
 	"github.com/aliyun/aliyun-oss-go-sdk/oss"
 
 	minio "github.com/minio/minio/cmd"
-	"github.com/minio/minio/pkg/errors"
 )
 
 func ossErrResponse(code string) error {
@@ -104,8 +103,8 @@ func TestOSSToObjectError(t *testing.T) {
 
 	for i, tc := range testCases {
 		actualErr := ossToObjectError(tc.inputErr, tc.bucket, tc.object)
-		if e, ok := actualErr.(*errors.Error); ok && e.Cause != tc.expectedErr {
-			t.Errorf("Test case %d: Expected error '%v' but received error '%v'", i+1, tc.expectedErr, e.Cause)
+		if actualErr != nil && tc.expectedErr != nil && actualErr.Error() != tc.expectedErr.Error() {
+			t.Errorf("Test case %d: Expected error '%v' but received error '%v'", i+1, tc.expectedErr, actualErr)
 		}
 	}
 }
@@ -118,7 +117,7 @@ func TestS3MetaToOSSOptions(t *testing.T) {
 		"x-amz-meta-invalid_meta": "value",
 	}
 	_, err = appendS3MetaToOSSOptions(context.Background(), nil, headers)
-	if err = errors.Cause(err); err != nil {
+	if err != nil {
 		if _, ok := err.(minio.UnsupportedMetadata); !ok {
 			t.Fatalf("Test failed with unexpected error %s, expected UnsupportedMetadata", err)
 		}
diff --git a/cmd/gateway/s3/gateway-s3_test.go b/cmd/gateway/s3/gateway-s3_test.go
index 93c04f8d2..d361f883e 100644
--- a/cmd/gateway/s3/gateway-s3_test.go
+++ b/cmd/gateway/s3/gateway-s3_test.go
@@ -21,7 +21,6 @@ import (
 	"testing"
 
 	miniogo "github.com/minio/minio-go"
-	"github.com/minio/minio/pkg/errors"
 	"github.com/minio/minio/pkg/hash"
 
 	minio "github.com/minio/minio/cmd"
@@ -110,17 +109,11 @@ func TestS3ToObjectError(t *testing.T) {
 			inputErr:    fmt.Errorf("not a minio.ErrorResponse"),
 			expectedErr: fmt.Errorf("not a minio.ErrorResponse"),
 		},
-		// Special test case for error value that is not of
-		// type (*Error)
-		{
-			inputErr:    fmt.Errorf("not a *Error"),
-			expectedErr: fmt.Errorf("not a *Error"),
-		},
 	}
 
 	for i, tc := range testCases {
 		actualErr := minio.ErrorRespToObjectError(tc.inputErr, tc.bucket, tc.object)
-		if e, ok := actualErr.(*errors.Error); ok && e.Cause.Error() != tc.expectedErr.Error() {
+		if actualErr != nil && tc.expectedErr != nil && actualErr.Error() != tc.expectedErr.Error() {
 			t.Errorf("Test case %d: Expected error %v but received error %v", i+1, tc.expectedErr, actualErr)
 		}
 	}
diff --git a/cmd/handler-utils_test.go b/cmd/handler-utils_test.go
index 9b359a858..74ddbd654 100644
--- a/cmd/handler-utils_test.go
+++ b/cmd/handler-utils_test.go
@@ -26,8 +26,6 @@ import (
 	"reflect"
 	"strings"
 	"testing"
-
-	"github.com/minio/minio/pkg/errors"
 )
 
 // Tests validate bucket LocationConstraint.
@@ -117,7 +115,7 @@ func TestValidateFormFieldSize(t *testing.T) {
 	for i, testCase := range testCases {
 		err := validateFormFieldSize(context.Background(), testCase.header)
 		if err != nil {
-			if errors.Cause(err).Error() != testCase.err.Error() {
+			if err.Error() != testCase.err.Error() {
 				t.Errorf("Test %d: Expected error %s, got %s", i+1, testCase.err, err)
 			}
 		}
diff --git a/cmd/lock-instrument_test.go b/cmd/lock-instrument_test.go
index 9401657d8..611890fc3 100644
--- a/cmd/lock-instrument_test.go
+++ b/cmd/lock-instrument_test.go
@@ -18,8 +18,6 @@ package cmd
 
 import (
 	"testing"
-
-	"github.com/minio/minio/pkg/errors"
 )
 
 type lockStateCase struct {
@@ -282,7 +280,7 @@ func TestNsLockMapStatusBlockedToRunning(t *testing.T) {
 		testCases[0].opsID, testCases[0].readLock)
 
 	expectedErr := LockInfoVolPathMissing{testCases[0].volume, testCases[0].path}
-	if errors.Cause(actualErr) != expectedErr {
+	if actualErr != expectedErr {
 		t.Fatalf("Errors mismatch: Expected \"%s\", got \"%s\"", expectedErr, actualErr)
 	}
 
@@ -302,7 +300,7 @@ func TestNsLockMapStatusBlockedToRunning(t *testing.T) {
 		testCases[0].opsID, testCases[0].readLock)
 
 	expectedOpsErr := LockInfoOpsIDNotFound{testCases[0].volume, testCases[0].path, testCases[0].opsID}
-	if errors.Cause(actualErr) != expectedOpsErr {
+	if actualErr != expectedOpsErr {
 		t.Fatalf("Errors mismatch: Expected \"%s\", got \"%s\"", expectedOpsErr, actualErr)
 	}
 
@@ -325,7 +323,7 @@ func TestNsLockMapStatusBlockedToRunning(t *testing.T) {
 		testCases[0].opsID, testCases[0].readLock)
 
 	expectedBlockErr := LockInfoStateNotBlocked{testCases[0].volume, testCases[0].path, testCases[0].opsID}
-	if errors.Cause(actualErr) != expectedBlockErr {
+	if actualErr != expectedBlockErr {
 		t.Fatalf("Errors mismatch: Expected: \"%s\", got: \"%s\"", expectedBlockErr, actualErr)
 	}
 
@@ -346,7 +344,7 @@ func TestNsLockMapStatusBlockedToRunning(t *testing.T) {
 		}
 		// invoking the method under test.
 		actualErr = globalNSMutex.statusBlockedToRunning(param, testCase.lockSource, testCase.opsID, testCase.readLock)
-		if errors.Cause(actualErr) != testCase.expectedErr {
+		if actualErr != testCase.expectedErr {
 			t.Fatalf("Test %d: Errors mismatch: Expected: \"%s\", got: \"%s\"", i+1, testCase.expectedErr, actualErr)
 		}
 		// In case of no error proceed with validating the lock state information.
@@ -465,7 +463,7 @@ func TestNsLockMapStatusNoneToBlocked(t *testing.T) {
 		testCases[0].opsID, testCases[0].readLock)
 
 	expectedErr := LockInfoVolPathMissing{testCases[0].volume, testCases[0].path}
-	if errors.Cause(actualErr) != expectedErr {
+	if actualErr != expectedErr {
 		t.Fatalf("Errors mismatch: Expected \"%s\", got \"%s\"", expectedErr, actualErr)
 	}
 
@@ -509,7 +507,7 @@ func TestNsLockMapDeleteLockInfoEntryForOps(t *testing.T) {
 	actualErr := globalNSMutex.deleteLockInfoEntryForOps(param, testCases[0].opsID)
 
 	expectedErr := LockInfoVolPathMissing{testCases[0].volume, testCases[0].path}
-	if errors.Cause(actualErr) != expectedErr {
+	if actualErr != expectedErr {
 		t.Fatalf("Errors mismatch: Expected \"%s\", got \"%s\"", expectedErr, actualErr)
 	}
 
@@ -528,7 +526,7 @@ func TestNsLockMapDeleteLockInfoEntryForOps(t *testing.T) {
 	actualErr = globalNSMutex.deleteLockInfoEntryForOps(param, "non-existent-OpsID")
 
 	expectedOpsIDErr := LockInfoOpsIDNotFound{param.volume, param.path, "non-existent-OpsID"}
-	if errors.Cause(actualErr) != expectedOpsIDErr {
+	if actualErr != expectedOpsIDErr {
 		t.Fatalf("Errors mismatch: Expected \"%s\", got \"%s\"", expectedOpsIDErr, actualErr)
 	}
 	// case - 4.
@@ -592,7 +590,7 @@ func TestNsLockMapDeleteLockInfoEntryForVolumePath(t *testing.T) {
 	param := nsParam{testCases[0].volume, testCases[0].path}
 	actualErr := globalNSMutex.deleteLockInfoEntryForVolumePath(param)
 	expectedNilErr := LockInfoVolPathMissing{param.volume, param.path}
-	if errors.Cause(actualErr) != expectedNilErr {
+	if actualErr != expectedNilErr {
 		t.Fatalf("Errors mismatch: Expected \"%s\", got \"%s\"", expectedNilErr, actualErr)
 	}
 
diff --git a/cmd/notification.go b/cmd/notification.go
index 0fdf216c0..b666db9d0 100644
--- a/cmd/notification.go
+++ b/cmd/notification.go
@@ -27,7 +27,6 @@ import (
 	"sync"
 
 	"github.com/minio/minio/cmd/logger"
-	xerrors "github.com/minio/minio/pkg/errors"
 	"github.com/minio/minio/pkg/event"
 	"github.com/minio/minio/pkg/hash"
 	xnet "github.com/minio/minio/pkg/net"
@@ -183,7 +182,7 @@ func (sys *NotificationSys) initListeners(ctx context.Context, objAPI ObjectLaye
 	defer objLock.Unlock()
 
 	reader, err := readConfig(ctx, objAPI, configFile)
-	if err != nil && !xerrors.IsErrIgnored(err, errDiskNotFound, errNoSuchNotifications) {
+	if err != nil && !IsErrIgnored(err, errDiskNotFound, errNoSuchNotifications) {
 		return err
 	}
 
@@ -263,7 +262,7 @@ func (sys *NotificationSys) Init(objAPI ObjectLayer) error {
 		ctx := logger.SetReqInfo(context.Background(), &logger.ReqInfo{BucketName: bucket.Name})
 		config, err := readNotificationConfig(ctx, objAPI, bucket.Name)
 		if err != nil {
-			if !xerrors.IsErrIgnored(err, errDiskNotFound, errNoSuchNotifications) {
+			if !IsErrIgnored(err, errDiskNotFound, errNoSuchNotifications) {
 				return err
 			}
 		} else {
@@ -551,7 +550,7 @@ func SaveListener(objAPI ObjectLayer, bucketName string, eventNames []event.Name
 	defer objLock.Unlock()
 
 	reader, err := readConfig(ctx, objAPI, configFile)
-	if err != nil && !xerrors.IsErrIgnored(err, errDiskNotFound, errNoSuchNotifications) {
+	if err != nil && !IsErrIgnored(err, errDiskNotFound, errNoSuchNotifications) {
 		return err
 	}
 
@@ -602,7 +601,7 @@ func RemoveListener(objAPI ObjectLayer, bucketName string, targetID event.Target
 	defer objLock.Unlock()
 
 	reader, err := readConfig(ctx, objAPI, configFile)
-	if err != nil && !xerrors.IsErrIgnored(err, errDiskNotFound, errNoSuchNotifications) {
+	if err != nil && !IsErrIgnored(err, errDiskNotFound, errNoSuchNotifications) {
 		return err
 	}
 
diff --git a/cmd/object-api-errors.go b/cmd/object-api-errors.go
index fe09ed926..37936e03f 100644
--- a/cmd/object-api-errors.go
+++ b/cmd/object-api-errors.go
@@ -19,19 +19,12 @@ package cmd
 import (
 	"fmt"
 	"io"
-
-	"github.com/minio/minio/pkg/errors"
 )
 
 // Converts underlying storage error. Convenience function written to
 // handle all cases where we have known types of errors returned by
 // underlying storage layer.
 func toObjectErr(err error, params ...string) error {
-	e, ok := err.(*errors.Error)
-	if ok {
-		err = e.Cause
-	}
-
 	switch err {
 	case errVolumeNotFound:
 		if len(params) >= 1 {
@@ -96,10 +89,6 @@ func toObjectErr(err error, params ...string) error {
 	case io.ErrUnexpectedEOF, io.ErrShortWrite:
 		err = IncompleteBody{}
 	}
-	if ok {
-		e.Cause = err
-		return e
-	}
 	return err
 }
 
@@ -400,7 +389,6 @@ func (e BackendDown) Error() string {
 
 // isErrIncompleteBody - Check if error type is IncompleteBody.
 func isErrIncompleteBody(err error) bool {
-	err = errors.Cause(err)
 	switch err.(type) {
 	case IncompleteBody:
 		return true
@@ -410,7 +398,6 @@ func isErrIncompleteBody(err error) bool {
 
 // isErrBucketPolicyNotFound - Check if error type is BucketPolicyNotFound.
 func isErrBucketPolicyNotFound(err error) bool {
-	err = errors.Cause(err)
 	switch err.(type) {
 	case PolicyNotFound:
 		return true
@@ -420,7 +407,6 @@ func isErrBucketPolicyNotFound(err error) bool {
 
 // isErrObjectNotFound - Check if error type is ObjectNotFound.
 func isErrObjectNotFound(err error) bool {
-	err = errors.Cause(err)
 	switch err.(type) {
 	case ObjectNotFound:
 		return true
diff --git a/cmd/object-api-input-checks.go b/cmd/object-api-input-checks.go
index a78de4737..ad9d32714 100644
--- a/cmd/object-api-input-checks.go
+++ b/cmd/object-api-input-checks.go
@@ -20,7 +20,6 @@ import (
 	"context"
 
 	"github.com/minio/minio/cmd/logger"
-	"github.com/minio/minio/pkg/errors"
 	"github.com/skyrings/skyring-common/tools/uuid"
 )
 
@@ -214,7 +213,7 @@ func checkPutObjectArgs(ctx context.Context, bucket, object string, obj ObjectLa
 func checkBucketExist(ctx context.Context, bucket string, obj ObjectLayer) error {
 	_, err := obj.GetBucketInfo(ctx, bucket)
 	if err != nil {
-		return errors.Cause(err)
+		return err
 	}
 	return nil
 }
diff --git a/cmd/object-api-multipart_test.go b/cmd/object-api-multipart_test.go
index 4a1abdbfb..05e065f9d 100644
--- a/cmd/object-api-multipart_test.go
+++ b/cmd/object-api-multipart_test.go
@@ -25,7 +25,6 @@ import (
 	"testing"
 
 	humanize "github.com/dustin/go-humanize"
-	"github.com/minio/minio/pkg/errors"
 	"github.com/minio/minio/pkg/hash"
 )
 
@@ -124,7 +123,7 @@ func testObjectAbortMultipartUpload(obj ObjectLayer, instanceType string, t Test
 		if testCase.expectedErrType == nil && err != nil {
 			t.Errorf("Test %d, unexpected err is received: %v, expected:%v\n", i+1, err, testCase.expectedErrType)
 		}
-		if testCase.expectedErrType != nil && !isSameType(errors.Cause(err), testCase.expectedErrType) {
+		if testCase.expectedErrType != nil && !isSameType(err, testCase.expectedErrType) {
 			t.Errorf("Test %d, unexpected err is received: %v, expected:%v\n", i+1, err, testCase.expectedErrType)
 		}
 	}
@@ -153,7 +152,6 @@ func testObjectAPIIsUploadIDExists(obj ObjectLayer, instanceType string, t TestE
 	}
 
 	err = obj.AbortMultipartUpload(context.Background(), bucket, object, "abc")
-	err = errors.Cause(err)
 	switch err.(type) {
 	case InvalidUploadID:
 	default:
diff --git a/cmd/object-api-putobject_test.go b/cmd/object-api-putobject_test.go
index 444af8c7c..6c63354f1 100644
--- a/cmd/object-api-putobject_test.go
+++ b/cmd/object-api-putobject_test.go
@@ -27,7 +27,6 @@ import (
 	"testing"
 
 	humanize "github.com/dustin/go-humanize"
-	"github.com/minio/minio/pkg/errors"
 	"github.com/minio/minio/pkg/hash"
 )
 
@@ -164,7 +163,6 @@ func testObjectAPIPutObject(obj ObjectLayer, instanceType string, t TestErrHandl
 
 	for i, testCase := range testCases {
 		objInfo, actualErr := obj.PutObject(context.Background(), testCase.bucketName, testCase.objName, mustGetHashReader(t, bytes.NewReader(testCase.inputData), testCase.intputDataSize, testCase.inputMeta["etag"], testCase.inputSHA256), testCase.inputMeta)
-		actualErr = errors.Cause(actualErr)
 		if actualErr != nil && testCase.expectedError == nil {
 			t.Errorf("Test %d: %s: Expected to pass, but failed with: error %s.", i+1, instanceType, actualErr.Error())
 		}
@@ -238,7 +236,6 @@ func testObjectAPIPutObjectDiskNotFound(obj ObjectLayer, instanceType string, di
 	sha256sum := ""
 	for i, testCase := range testCases {
 		objInfo, actualErr := obj.PutObject(context.Background(), testCase.bucketName, testCase.objName, mustGetHashReader(t, bytes.NewReader(testCase.inputData), testCase.intputDataSize, testCase.inputMeta["etag"], sha256sum), testCase.inputMeta)
-		actualErr = errors.Cause(actualErr)
 		if actualErr != nil && testCase.shouldPass {
 			t.Errorf("Test %d: %s: Expected to pass, but failed with: <ERROR> %s.", i+1, instanceType, actualErr.Error())
 		}
@@ -288,7 +285,6 @@ func testObjectAPIPutObjectDiskNotFound(obj ObjectLayer, instanceType string, di
 	}
 
 	_, actualErr := obj.PutObject(context.Background(), testCase.bucketName, testCase.objName, mustGetHashReader(t, bytes.NewReader(testCase.inputData), testCase.intputDataSize, testCase.inputMeta["etag"], sha256sum), testCase.inputMeta)
-	actualErr = errors.Cause(actualErr)
 	if actualErr != nil && testCase.shouldPass {
 		t.Errorf("Test %d: %s: Expected to pass, but failed with: <ERROR> %s.", len(testCases)+1, instanceType, actualErr.Error())
 	}
diff --git a/cmd/object-handlers.go b/cmd/object-handlers.go
index 354bac345..3cc6e63d4 100644
--- a/cmd/object-handlers.go
+++ b/cmd/object-handlers.go
@@ -33,7 +33,6 @@ import (
 
 	mux "github.com/gorilla/mux"
 	"github.com/minio/minio/cmd/logger"
-	"github.com/minio/minio/pkg/errors"
 	"github.com/minio/minio/pkg/event"
 	"github.com/minio/minio/pkg/handlers"
 	"github.com/minio/minio/pkg/hash"
@@ -1386,7 +1385,6 @@ func (api objectAPIHandlers) CompleteMultipartUploadHandler(w http.ResponseWrite
 	}
 	objInfo, err := completeMultiPartUpload(ctx, bucket, object, uploadID, completeParts)
 	if err != nil {
-		err = errors.Cause(err)
 		switch oErr := err.(type) {
 		case PartTooSmall:
 			// Write part too small error.
diff --git a/cmd/object_api_suite_test.go b/cmd/object_api_suite_test.go
index f1d038b61..49b1544ae 100644
--- a/cmd/object_api_suite_test.go
+++ b/cmd/object_api_suite_test.go
@@ -25,7 +25,6 @@ import (
 	"testing"
 
 	humanize "github.com/dustin/go-humanize"
-	"github.com/minio/minio/pkg/errors"
 )
 
 // Return pointer to testOneByteReadEOF{}
@@ -755,11 +754,8 @@ func testGetDirectoryReturnsObjectNotFound(obj ObjectLayer, instanceType string,
 
 	for i, testCase := range testCases {
 		_, expectedErr := obj.GetObjectInfo(context.Background(), bucketName, testCase.dir)
-		if expectedErr != nil {
-			expectedErr = errors.Cause(expectedErr)
-			if expectedErr.Error() != testCase.err.Error() {
-				t.Errorf("Test %d, %s: Expected error %s, got %s", i+1, instanceType, testCase.err, expectedErr)
-			}
+		if expectedErr != nil && expectedErr.Error() != testCase.err.Error() {
+			t.Errorf("Test %d, %s: Expected error %s, got %s", i+1, instanceType, testCase.err, expectedErr)
 		}
 	}
 }
diff --git a/cmd/os-reliable_test.go b/cmd/os-reliable_test.go
index f5405c0b0..f285474cb 100644
--- a/cmd/os-reliable_test.go
+++ b/cmd/os-reliable_test.go
@@ -19,8 +19,6 @@ package cmd
 import (
 	"os"
 	"testing"
-
-	"github.com/minio/minio/pkg/errors"
 )
 
 // Tests - mkdirAll()
@@ -32,11 +30,11 @@ func TestOSMkdirAll(t *testing.T) {
 	}
 	defer os.RemoveAll(path)
 
-	if err = mkdirAll("", 0777); errors.Cause(err) != errInvalidArgument {
+	if err = mkdirAll("", 0777); err != errInvalidArgument {
 		t.Fatal("Unexpected error", err)
 	}
 
-	if err = mkdirAll(pathJoin(path, "my-obj-del-0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001"), 0777); errors.Cause(err) != errFileNameTooLong {
+	if err = mkdirAll(pathJoin(path, "my-obj-del-0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001"), 0777); err != errFileNameTooLong {
 		t.Fatal("Unexpected error", err)
 	}
 
@@ -66,13 +64,13 @@ func TestOSRenameAll(t *testing.T) {
 	if err = renameAll(pathJoin(path, "testvolume1"), pathJoin(path, "testvolume2")); err != nil {
 		t.Fatal(err)
 	}
-	if err = renameAll(pathJoin(path, "testvolume1"), pathJoin(path, "testvolume2")); errors.Cause(err) != errFileNotFound {
+	if err = renameAll(pathJoin(path, "testvolume1"), pathJoin(path, "testvolume2")); err != errFileNotFound {
 		t.Fatal(err)
 	}
-	if err = renameAll(pathJoin(path, "my-obj-del-0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001"), pathJoin(path, "testvolume2")); errors.Cause(err) != errFileNameTooLong {
+	if err = renameAll(pathJoin(path, "my-obj-del-0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001"), pathJoin(path, "testvolume2")); err != errFileNameTooLong {
 		t.Fatal("Unexpected error", err)
 	}
-	if err = renameAll(pathJoin(path, "testvolume1"), pathJoin(path, "my-obj-del-0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001")); errors.Cause(err) != errFileNameTooLong {
+	if err = renameAll(pathJoin(path, "testvolume1"), pathJoin(path, "my-obj-del-0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001")); err != errFileNameTooLong {
 		t.Fatal("Unexpected error", err)
 	}
 }
diff --git a/cmd/prepare-storage.go b/cmd/prepare-storage.go
index 29bfa8463..9f04f5b3d 100644
--- a/cmd/prepare-storage.go
+++ b/cmd/prepare-storage.go
@@ -24,7 +24,6 @@ import (
 
 	"github.com/minio/mc/pkg/console"
 	"github.com/minio/minio/cmd/logger"
-	"github.com/minio/minio/pkg/errors"
 )
 
 var printEndpointError = func() func(Endpoint, error) {
@@ -142,7 +141,7 @@ func connectLoadInitFormats(firstDisk bool, endpoints EndpointList, setCount, dr
 	}
 
 	for i, sErr := range sErrs {
-		if _, ok := formatCriticalErrors[errors.Cause(sErr)]; ok {
+		if _, ok := formatCriticalErrors[sErr]; ok {
 			return nil, fmt.Errorf("Disk %s: %s", endpoints[i], sErr)
 		}
 	}
diff --git a/cmd/storage-rpc-server_test.go b/cmd/storage-rpc-server_test.go
index ca7500ee6..bbc8709cb 100644
--- a/cmd/storage-rpc-server_test.go
+++ b/cmd/storage-rpc-server_test.go
@@ -21,7 +21,6 @@ import (
 	"testing"
 
 	"github.com/minio/minio/pkg/disk"
-	"github.com/minio/minio/pkg/errors"
 )
 
 type testStorageRPCServer struct {
@@ -68,9 +67,8 @@ func createTestStorageServer(t *testing.T) *testStorageRPCServer {
 }
 
 func errorIfInvalidToken(t *testing.T, err error) {
-	realErr := errors.Cause(err)
-	if realErr != errInvalidToken {
-		t.Errorf("Expected to fail with %s but failed with %s", errInvalidToken, realErr)
+	if err != errInvalidToken {
+		t.Errorf("Expected to fail with %s but failed with %s", errInvalidToken, err)
 	}
 }
 
diff --git a/cmd/utils.go b/cmd/utils.go
index 7e892304e..c39d4f3e9 100644
--- a/cmd/utils.go
+++ b/cmd/utils.go
@@ -41,6 +41,21 @@ import (
 	"github.com/pkg/profile"
 )
 
+// IsErrIgnored returns whether given error is ignored or not.
+func IsErrIgnored(err error, ignoredErrs ...error) bool {
+	return IsErr(err, ignoredErrs...)
+}
+
+// IsErr returns whether given error is exact error.
+func IsErr(err error, errs ...error) bool {
+	for _, exactErr := range errs {
+		if err == exactErr {
+			return true
+		}
+	}
+	return false
+}
+
 // Close Http tracing file.
 func stopHTTPTrace() {
 	if globalHTTPTraceFile != nil {
diff --git a/cmd/utils_test.go b/cmd/utils_test.go
index 01f3fc2a2..0e643fc90 100644
--- a/cmd/utils_test.go
+++ b/cmd/utils_test.go
@@ -20,6 +20,7 @@ import (
 	"bytes"
 	"encoding/json"
 	"errors"
+	"fmt"
 	"io/ioutil"
 	"net/http"
 	"net/url"
@@ -428,3 +429,26 @@ func TestCeilFrac(t *testing.T) {
 		}
 	}
 }
+
+// Test if isErrIgnored works correctly.
+func TestIsErrIgnored(t *testing.T) {
+	var errIgnored = fmt.Errorf("ignored error")
+	var testCases = []struct {
+		err     error
+		ignored bool
+	}{
+		{
+			err:     nil,
+			ignored: false,
+		},
+		{
+			err:     errIgnored,
+			ignored: true,
+		},
+	}
+	for i, testCase := range testCases {
+		if ok := IsErrIgnored(testCase.err, errIgnored); ok != testCase.ignored {
+			t.Errorf("Test: %d, Expected %t, got %t", i+1, testCase.ignored, ok)
+		}
+	}
+}
diff --git a/cmd/web-handlers.go b/cmd/web-handlers.go
index 630c3552f..68172229f 100644
--- a/cmd/web-handlers.go
+++ b/cmd/web-handlers.go
@@ -37,7 +37,6 @@ import (
 	"github.com/minio/minio/browser"
 	"github.com/minio/minio/cmd/logger"
 	"github.com/minio/minio/pkg/auth"
-	"github.com/minio/minio/pkg/errors"
 	"github.com/minio/minio/pkg/event"
 	"github.com/minio/minio/pkg/hash"
 )
@@ -759,7 +758,7 @@ func (web *webAPIHandlers) GetBucketPolicy(r *http.Request, args *GetBucketPolic
 
 	var policyInfo, err = objectAPI.GetBucketPolicy(context.Background(), args.BucketName)
 	if err != nil {
-		_, ok := errors.Cause(err).(BucketPolicyNotFound)
+		_, ok := err.(BucketPolicyNotFound)
 		if !ok {
 			return toJSONError(err, args.BucketName)
 		}
@@ -801,7 +800,7 @@ func (web *webAPIHandlers) ListAllBucketPolicies(r *http.Request, args *ListAllB
 	}
 	var policyInfo, err = objectAPI.GetBucketPolicy(context.Background(), args.BucketName)
 	if err != nil {
-		_, ok := errors.Cause(err).(PolicyNotFound)
+		_, ok := err.(PolicyNotFound)
 		if !ok {
 			return toJSONError(err, args.BucketName)
 		}
@@ -848,7 +847,7 @@ func (web *webAPIHandlers) SetBucketPolicy(r *http.Request, args *SetBucketPolic
 
 	var policyInfo, err = objectAPI.GetBucketPolicy(context.Background(), args.BucketName)
 	if err != nil {
-		if _, ok := errors.Cause(err).(PolicyNotFound); !ok {
+		if _, ok := err.(PolicyNotFound); !ok {
 			return toJSONError(err, args.BucketName)
 		}
 		policyInfo = policy.BucketAccessPolicy{Version: "2012-10-17"}
@@ -1007,7 +1006,6 @@ func toJSONError(err error, params ...string) (jerr *json2.Error) {
 
 // toWebAPIError - convert into error into APIError.
 func toWebAPIError(err error) APIError {
-	err = errors.Cause(err)
 	if err == errAuthentication {
 		return APIError{
 			Code:           "AccessDenied",
diff --git a/cmd/xl-sets.go b/cmd/xl-sets.go
index abca85493..a7a947f70 100644
--- a/cmd/xl-sets.go
+++ b/cmd/xl-sets.go
@@ -30,7 +30,6 @@ import (
 	"github.com/minio/minio-go/pkg/policy"
 	"github.com/minio/minio/cmd/logger"
 	"github.com/minio/minio/pkg/bpool"
-	"github.com/minio/minio/pkg/errors"
 	"github.com/minio/minio/pkg/hash"
 	"github.com/minio/minio/pkg/madmin"
 	"github.com/minio/minio/pkg/sync/errgroup"
@@ -661,7 +660,7 @@ func listDirSetsFactory(ctx context.Context, isLeaf isLeafFunc, treeWalkIgnoredE
 			if err != nil {
 				// For any reason disk was deleted or goes offline, continue
 				// and list from other disks if possible.
-				if errors.IsErrIgnored(err, treeWalkIgnoredErrs...) {
+				if IsErrIgnored(err, treeWalkIgnoredErrs...) {
 					continue
 				}
 				logger.LogIf(ctx, err)
@@ -779,7 +778,7 @@ func (s *xlSets) ListObjects(ctx context.Context, bucket, prefix, marker, delimi
 			// Ignore errFileNotFound as the object might have got
 			// deleted in the interim period of listing and getObjectInfo(),
 			// ignore quorum error as it might be an entry from an outdated disk.
-			switch errors.Cause(err) {
+			switch err {
 			case errFileNotFound, errXLReadQuorum:
 				continue
 			}
@@ -1407,7 +1406,7 @@ func (s *xlSets) listObjectsHeal(ctx context.Context, bucket, prefix, marker, de
 		}
 		if err != nil {
 			// Ignore errFileNotFound
-			if errors.Cause(err) == errFileNotFound {
+			if err == errFileNotFound {
 				continue
 			}
 			return loi, toObjectErr(err, bucket, prefix)
diff --git a/cmd/xl-v1-bucket.go b/cmd/xl-v1-bucket.go
index f9f7621f2..6b58cdaa2 100644
--- a/cmd/xl-v1-bucket.go
+++ b/cmd/xl-v1-bucket.go
@@ -24,7 +24,6 @@ import (
 
 	"github.com/minio/minio-go/pkg/policy"
 	"github.com/minio/minio/cmd/logger"
-	"github.com/minio/minio/pkg/errors"
 )
 
 // list all errors that can be ignore in a bucket operation.
@@ -75,7 +74,7 @@ func (xl xlObjects) MakeBucketWithLocation(ctx context.Context, bucket, location
 
 	writeQuorum := len(xl.getDisks())/2 + 1
 	err := reduceWriteQuorumErrs(ctx, dErrs, bucketOpIgnoredErrs, writeQuorum)
-	if errors.Cause(err) == errXLWriteQuorum {
+	if err == errXLWriteQuorum {
 		// Purge successfully created buckets if we don't have writeQuorum.
 		undoMakeBucket(xl.getDisks(), bucket)
 	}
@@ -142,7 +141,7 @@ func (xl xlObjects) getBucketInfo(ctx context.Context, bucketName string) (bucke
 		logger.LogIf(ctx, serr)
 		err = serr
 		// For any reason disk went offline continue and pick the next one.
-		if errors.IsErrIgnored(err, bucketMetadataOpIgnoredErrs...) {
+		if IsErrIgnored(err, bucketMetadataOpIgnoredErrs...) {
 			bucketErrs = append(bucketErrs, err)
 			continue
 		}
@@ -208,7 +207,7 @@ func (xl xlObjects) listBuckets(ctx context.Context) (bucketsInfo []BucketInfo,
 		}
 		logger.LogIf(ctx, err)
 		// Ignore any disks not found.
-		if errors.IsErrIgnored(err, bucketMetadataOpIgnoredErrs...) {
+		if IsErrIgnored(err, bucketMetadataOpIgnoredErrs...) {
 			continue
 		}
 		break
@@ -268,7 +267,7 @@ func (xl xlObjects) DeleteBucket(ctx context.Context, bucket string) error {
 			err = cleanupDir(ctx, disk, minioMetaMultipartBucket, bucket)
 
 			if err != nil {
-				if errors.Cause(err) == errVolumeNotFound {
+				if err == errVolumeNotFound {
 					return
 				}
 				dErrs[index] = err
@@ -281,7 +280,7 @@ func (xl xlObjects) DeleteBucket(ctx context.Context, bucket string) error {
 
 	writeQuorum := len(xl.getDisks())/2 + 1
 	err := reduceWriteQuorumErrs(ctx, dErrs, bucketOpIgnoredErrs, writeQuorum)
-	if errors.Cause(err) == errXLWriteQuorum {
+	if err == errXLWriteQuorum {
 		xl.undoDeleteBucket(bucket)
 	}
 	if err != nil {
diff --git a/cmd/xl-v1-common.go b/cmd/xl-v1-common.go
index 3d28c0ac8..6de5ec96c 100644
--- a/cmd/xl-v1-common.go
+++ b/cmd/xl-v1-common.go
@@ -21,7 +21,6 @@ import (
 	"path"
 
 	"github.com/minio/minio/cmd/logger"
-	"github.com/minio/minio/pkg/errors"
 )
 
 // getLoadBalancedDisks - fetches load balanced (sufficiently randomized) disk slice.
@@ -65,7 +64,7 @@ func (xl xlObjects) isObject(bucket, prefix string) (ok bool) {
 			return true
 		}
 		// Ignore for file not found,  disk not found or faulty disk.
-		if errors.IsErrIgnored(err, xlTreeWalkIgnoredErrs...) {
+		if IsErrIgnored(err, xlTreeWalkIgnoredErrs...) {
 			continue
 		}
 		reqInfo := &logger.ReqInfo{BucketName: bucket}
diff --git a/cmd/xl-v1-healing.go b/cmd/xl-v1-healing.go
index d42eb9ab7..81d541f71 100644
--- a/cmd/xl-v1-healing.go
+++ b/cmd/xl-v1-healing.go
@@ -23,12 +23,12 @@ import (
 	"sync"
 
 	"github.com/minio/minio/cmd/logger"
-	"github.com/minio/minio/pkg/errors"
 	"github.com/minio/minio/pkg/madmin"
 )
 
 func (xl xlObjects) ReloadFormat(ctx context.Context, dryRun bool) error {
-	return errors.Trace(NotImplemented{})
+	logger.LogIf(ctx, NotImplemented{})
+	return NotImplemented{}
 }
 
 func (xl xlObjects) HealFormat(ctx context.Context, dryRun bool) (madmin.HealResultItem, error) {
@@ -120,13 +120,13 @@ func healBucket(ctx context.Context, storageDisks []StorageAPI, bucket string, w
 		go func(index int, disk StorageAPI) {
 			defer wg.Done()
 			if _, serr := disk.StatVol(bucket); serr != nil {
-				if errors.Cause(serr) == errDiskNotFound {
+				if serr == errDiskNotFound {
 					beforeState[index] = madmin.DriveStateOffline
 					afterState[index] = madmin.DriveStateOffline
 					dErrs[index] = serr
 					return
 				}
-				if errors.Cause(serr) != errVolumeNotFound {
+				if serr != errVolumeNotFound {
 					beforeState[index] = madmin.DriveStateCorrupt
 					afterState[index] = madmin.DriveStateCorrupt
 					dErrs[index] = serr
@@ -190,7 +190,7 @@ func healBucket(ctx context.Context, storageDisks []StorageAPI, bucket string, w
 	}
 
 	reducedErr := reduceWriteQuorumErrs(ctx, dErrs, bucketOpIgnoredErrs, writeQuorum)
-	if errors.Cause(reducedErr) == errXLWriteQuorum {
+	if reducedErr == errXLWriteQuorum {
 		// Purge successfully created buckets if we don't have writeQuorum.
 		undoMakeBucket(storageDisks, bucket)
 	}
@@ -256,7 +256,7 @@ func listAllBuckets(storageDisks []StorageAPI) (buckets map[string]VolInfo,
 		var volsInfo []VolInfo
 		volsInfo, err = disk.ListVols()
 		if err != nil {
-			if errors.IsErrIgnored(err, bucketMetadataOpIgnoredErrs...) {
+			if IsErrIgnored(err, bucketMetadataOpIgnoredErrs...) {
 				continue
 			}
 			return nil, nil, err
@@ -330,11 +330,11 @@ func healObject(ctx context.Context, storageDisks []StorageAPI, bucket string, o
 			result.ObjectSize = partsMetadata[i].Stat.Size
 			result.ParityBlocks = partsMetadata[i].Erasure.ParityBlocks
 			result.DataBlocks = partsMetadata[i].Erasure.DataBlocks
-		case errors.Cause(errs[i]) == errDiskNotFound:
+		case errs[i] == errDiskNotFound:
 			driveState = madmin.DriveStateOffline
-		case errors.Cause(errs[i]) == errFileNotFound, errors.Cause(errs[i]) == errVolumeNotFound:
+		case errs[i] == errFileNotFound, errs[i] == errVolumeNotFound:
 			fallthrough
-		case errors.Cause(dataErrs[i]) == errFileNotFound, errors.Cause(dataErrs[i]) == errVolumeNotFound:
+		case dataErrs[i] == errFileNotFound, dataErrs[i] == errVolumeNotFound:
 			driveState = madmin.DriveStateMissing
 		default:
 			// all remaining cases imply corrupt data/metadata
@@ -412,8 +412,7 @@ func healObject(ctx context.Context, storageDisks []StorageAPI, bucket string, o
 			continue
 		}
 
-		// List and delete the object directory, ignoring
-		// errors.
+		// List and delete the object directory,
 		files, derr := disk.ListDir(bucket, object)
 		if derr == nil {
 			for _, entry := range files {
diff --git a/cmd/xl-v1-healing_test.go b/cmd/xl-v1-healing_test.go
index 252a92262..95aa905fc 100644
--- a/cmd/xl-v1-healing_test.go
+++ b/cmd/xl-v1-healing_test.go
@@ -22,8 +22,6 @@ import (
 	"os"
 	"path/filepath"
 	"testing"
-
-	"github.com/minio/minio/pkg/errors"
 )
 
 // Tests undoes and validates if the undoing completes successfully.
@@ -57,7 +55,6 @@ func TestUndoMakeBucket(t *testing.T) {
 	// Validate if bucket was deleted properly.
 	_, err = obj.GetBucketInfo(context.Background(), bucketName)
 	if err != nil {
-		err = errors.Cause(err)
 		switch err.(type) {
 		case BucketNotFound:
 		default:
@@ -147,7 +144,7 @@ func TestHealObjectXL(t *testing.T) {
 	// Try healing now, expect to receive errDiskNotFound.
 	_, err = obj.HealObject(context.Background(), bucket, object, false)
 	// since majority of xl.jsons are not available, object quorum can't be read properly and error will be errXLReadQuorum
-	if errors.Cause(err) != errXLReadQuorum {
+	if err != errXLReadQuorum {
 		t.Errorf("Expected %v but received %v", errDiskNotFound, err)
 	}
 }
diff --git a/cmd/xl-v1-list-objects.go b/cmd/xl-v1-list-objects.go
index d430bccd7..bb3d876ec 100644
--- a/cmd/xl-v1-list-objects.go
+++ b/cmd/xl-v1-list-objects.go
@@ -19,8 +19,6 @@ package cmd
 import (
 	"context"
 	"sort"
-
-	"github.com/minio/minio/pkg/errors"
 )
 
 // Returns function "listDir" of the type listDirFunc.
@@ -39,7 +37,7 @@ func listDirFactory(ctx context.Context, isLeaf isLeafFunc, treeWalkIgnoredErrs
 			if err != nil {
 				// For any reason disk was deleted or goes offline, continue
 				// and list from other disks if possible.
-				if errors.IsErrIgnored(err, treeWalkIgnoredErrs...) {
+				if IsErrIgnored(err, treeWalkIgnoredErrs...) {
 					continue
 				}
 				return nil, false, err
@@ -114,7 +112,7 @@ func (xl xlObjects) listObjects(ctx context.Context, bucket, prefix, marker, del
 				// Ignore errFileNotFound as the object might have got
 				// deleted in the interim period of listing and getObjectInfo(),
 				// ignore quorum error as it might be an entry from an outdated disk.
-				switch errors.Cause(err) {
+				switch err {
 				case errFileNotFound, errXLReadQuorum:
 					continue
 				}
diff --git a/cmd/xl-v1-metadata.go b/cmd/xl-v1-metadata.go
index 087a9e66d..dc0722227 100644
--- a/cmd/xl-v1-metadata.go
+++ b/cmd/xl-v1-metadata.go
@@ -30,7 +30,6 @@ import (
 
 	"github.com/minio/highwayhash"
 	"github.com/minio/minio/cmd/logger"
-	"github.com/minio/minio/pkg/errors"
 	sha256 "github.com/minio/sha256-simd"
 	"golang.org/x/crypto/blake2b"
 )
@@ -416,7 +415,7 @@ func (xl xlObjects) readXLMetaParts(ctx context.Context, bucket, object string)
 		}
 		// For any reason disk or bucket is not available continue
 		// and read from other disks.
-		if errors.IsErrIgnored(err, objMetadataOpIgnoredErrs...) {
+		if IsErrIgnored(err, objMetadataOpIgnoredErrs...) {
 			ignoredErrs = append(ignoredErrs, err)
 			continue
 		}
@@ -444,7 +443,7 @@ func (xl xlObjects) readXLMetaStat(ctx context.Context, bucket, object string) (
 		}
 		// For any reason disk or bucket is not available continue
 		// and read from other disks.
-		if errors.IsErrIgnored(err, objMetadataOpIgnoredErrs...) {
+		if IsErrIgnored(err, objMetadataOpIgnoredErrs...) {
 			ignoredErrs = append(ignoredErrs, err)
 			continue
 		}
@@ -542,7 +541,7 @@ func writeUniqueXLMetadata(ctx context.Context, disks []StorageAPI, bucket, pref
 	wg.Wait()
 
 	err := reduceWriteQuorumErrs(ctx, mErrs, objectOpIgnoredErrs, quorum)
-	if errors.Cause(err) == errXLWriteQuorum {
+	if err == errXLWriteQuorum {
 		// Delete all `xl.json` successfully renamed.
 		deleteAllXLMetadata(ctx, disks, bucket, prefix, mErrs)
 	}
@@ -581,7 +580,7 @@ func writeSameXLMetadata(ctx context.Context, disks []StorageAPI, bucket, prefix
 	wg.Wait()
 
 	err := reduceWriteQuorumErrs(ctx, mErrs, objectOpIgnoredErrs, writeQuorum)
-	if errors.Cause(err) == errXLWriteQuorum {
+	if err == errXLWriteQuorum {
 		// Delete all `xl.json` successfully renamed.
 		deleteAllXLMetadata(ctx, disks, bucket, prefix, mErrs)
 	}
diff --git a/cmd/xl-v1-metadata_test.go b/cmd/xl-v1-metadata_test.go
index ce4d08ddb..d5371112f 100644
--- a/cmd/xl-v1-metadata_test.go
+++ b/cmd/xl-v1-metadata_test.go
@@ -27,7 +27,6 @@ import (
 	"time"
 
 	humanize "github.com/dustin/go-humanize"
-	errors2 "github.com/minio/minio/pkg/errors"
 )
 
 // Tests for reading XL object info.
@@ -95,7 +94,7 @@ func testXLReadStat(obj ObjectLayer, instanceType string, disks []string, t *tes
 	}
 
 	_, _, err = obj.(*xlObjects).readXLMetaStat(context.Background(), bucketName, objectName)
-	if errors2.Cause(err) != errVolumeNotFound {
+	if err != errVolumeNotFound {
 		t.Fatal(err)
 	}
 }
@@ -180,7 +179,7 @@ func testXLReadMetaParts(obj ObjectLayer, instanceType string, disks []string, t
 	}
 
 	_, _, err = obj.(*xlObjects).readXLMetaParts(context.Background(), minioMetaMultipartBucket, uploadIDPath)
-	if errors2.Cause(err) != errFileNotFound {
+	if err != errFileNotFound {
 		t.Fatal(err)
 	}
 }
@@ -299,7 +298,6 @@ func TestObjectToPartOffset(t *testing.T) {
 	// Test them.
 	for _, testCase := range testCases {
 		index, offset, err := xlMeta.ObjectToPartOffset(context.Background(), testCase.offset)
-		err = errors2.Cause(err)
 		if err != testCase.expectedErr {
 			t.Fatalf("%+v: expected = %s, got: %s", testCase, testCase.expectedErr, err)
 		}
@@ -357,7 +355,7 @@ func TestPickValidXLMeta(t *testing.T) {
 	for i, test := range testCases {
 		xlMeta, err := pickValidXLMeta(context.Background(), test.metaArr, test.modTime)
 		if test.expectedErr != nil {
-			if errors2.Cause(err).Error() != test.expectedErr.Error() {
+			if err.Error() != test.expectedErr.Error() {
 				t.Errorf("Test %d: Expected to fail with %v but received %v",
 					i+1, test.expectedErr, err)
 			}
diff --git a/cmd/xl-v1-multipart.go b/cmd/xl-v1-multipart.go
index fbb51148c..a02437793 100644
--- a/cmd/xl-v1-multipart.go
+++ b/cmd/xl-v1-multipart.go
@@ -27,7 +27,6 @@ import (
 	"time"
 
 	"github.com/minio/minio/cmd/logger"
-	"github.com/minio/minio/pkg/errors"
 	"github.com/minio/minio/pkg/hash"
 	"github.com/minio/minio/pkg/mimedb"
 )
@@ -79,7 +78,7 @@ func (xl xlObjects) statPart(ctx context.Context, bucket, object, uploadID, part
 			return fileInfo, nil
 		}
 		// For any reason disk was deleted or goes offline we continue to next disk.
-		if errors.IsErrIgnored(err, objMetadataOpIgnoredErrs...) {
+		if IsErrIgnored(err, objMetadataOpIgnoredErrs...) {
 			ignoredErrs = append(ignoredErrs, err)
 			continue
 		}
@@ -129,7 +128,7 @@ func commitXLMetadata(ctx context.Context, disks []StorageAPI, srcBucket, srcPre
 	wg.Wait()
 
 	err := reduceWriteQuorumErrs(ctx, mErrs, objectOpIgnoredErrs, quorum)
-	if errors.Cause(err) == errXLWriteQuorum {
+	if err == errXLWriteQuorum {
 		// Delete all `xl.json` successfully renamed.
 		deleteAllXLMetadata(ctx, disks, dstBucket, dstPrefix, mErrs)
 	}
@@ -337,7 +336,7 @@ func (xl xlObjects) PutObjectPart(ctx context.Context, bucket, object, uploadID
 	}
 
 	reducedErr := reduceWriteQuorumErrs(ctx, errs, objectOpIgnoredErrs, writeQuorum)
-	if errors.Cause(reducedErr) == errXLWriteQuorum {
+	if reducedErr == errXLWriteQuorum {
 		preUploadIDLock.RUnlock()
 		return pi, toObjectErr(reducedErr, bucket, object)
 	}
@@ -413,7 +412,7 @@ func (xl xlObjects) PutObjectPart(ctx context.Context, bucket, object, uploadID
 	// Read metadata again because it might be updated with parallel upload of another part.
 	partsMetadata, errs = readAllXLMetadata(ctx, onlineDisks, minioMetaMultipartBucket, uploadIDPath)
 	reducedErr = reduceWriteQuorumErrs(ctx, errs, objectOpIgnoredErrs, writeQuorum)
-	if errors.Cause(reducedErr) == errXLWriteQuorum {
+	if reducedErr == errXLWriteQuorum {
 		return pi, toObjectErr(reducedErr, bucket, object)
 	}
 
@@ -610,7 +609,7 @@ func (xl xlObjects) CompleteMultipartUpload(ctx context.Context, bucket string,
 	}
 
 	reducedErr := reduceWriteQuorumErrs(ctx, errs, objectOpIgnoredErrs, writeQuorum)
-	if errors.Cause(reducedErr) == errXLWriteQuorum {
+	if reducedErr == errXLWriteQuorum {
 		return oi, toObjectErr(reducedErr, bucket, object)
 	}
 
diff --git a/cmd/xl-v1-multipart_test.go b/cmd/xl-v1-multipart_test.go
index f2befbd9d..076e39398 100644
--- a/cmd/xl-v1-multipart_test.go
+++ b/cmd/xl-v1-multipart_test.go
@@ -21,8 +21,6 @@ import (
 	"os"
 	"testing"
 	"time"
-
-	"github.com/minio/minio/pkg/errors"
 )
 
 // Tests cleanup multipart uploads for erasure coded backend.
@@ -68,7 +66,6 @@ func TestXLCleanupStaleMultipartUploads(t *testing.T) {
 
 	// Check if upload id was already purged.
 	if err = obj.AbortMultipartUpload(context.Background(), bucketName, objectName, uploadID); err != nil {
-		err = errors.Cause(err)
 		if _, ok := err.(InvalidUploadID); !ok {
 			t.Fatal("Unexpected err: ", err)
 		}
diff --git a/cmd/xl-v1-object.go b/cmd/xl-v1-object.go
index f67c9bd56..ddf3bf3d0 100644
--- a/cmd/xl-v1-object.go
+++ b/cmd/xl-v1-object.go
@@ -26,7 +26,6 @@ import (
 	"sync"
 
 	"github.com/minio/minio/cmd/logger"
-	"github.com/minio/minio/pkg/errors"
 	"github.com/minio/minio/pkg/hash"
 	"github.com/minio/minio/pkg/mimedb"
 )
@@ -468,7 +467,7 @@ func rename(ctx context.Context, disks []StorageAPI, srcBucket, srcEntry, dstBuc
 	// We can safely allow RenameFile errors up to len(xl.getDisks()) - writeQuorum
 	// otherwise return failure. Cleanup successful renames.
 	err := reduceWriteQuorumErrs(ctx, errs, objectOpIgnoredErrs, writeQuorum)
-	if errors.Cause(err) == errXLWriteQuorum {
+	if err == errXLWriteQuorum {
 		// Undo all the partial rename operations.
 		undoRename(disks, srcBucket, srcEntry, dstBucket, dstEntry, isDir, errs)
 	}
@@ -783,7 +782,7 @@ func (xl xlObjects) deleteObject(ctx context.Context, bucket, object string) err
 			} else {
 				e = cleanupDir(ctx, disk, bucket, object)
 			}
-			if e != nil && errors.Cause(e) != errVolumeNotFound {
+			if e != nil && e != errVolumeNotFound {
 				dErrs[index] = e
 			}
 		}(index, disk, isDir)
diff --git a/cmd/xl-v1-object_test.go b/cmd/xl-v1-object_test.go
index a0a3aa6cd..49855256c 100644
--- a/cmd/xl-v1-object_test.go
+++ b/cmd/xl-v1-object_test.go
@@ -28,7 +28,6 @@ import (
 	"time"
 
 	humanize "github.com/dustin/go-humanize"
-	"github.com/minio/minio/pkg/errors"
 )
 
 func TestRepeatPutObjectPart(t *testing.T) {
@@ -98,7 +97,6 @@ func TestXLDeleteObjectBasic(t *testing.T) {
 	}
 	for i, test := range testCases {
 		actualErr := xl.DeleteObject(context.Background(), test.bucket, test.object)
-		actualErr = errors.Cause(actualErr)
 		if test.expectedErr != nil && actualErr != test.expectedErr {
 			t.Errorf("Test %d: Expected to fail with %s, but failed with %s", i+1, test.expectedErr, actualErr)
 		}
@@ -154,7 +152,6 @@ func TestXLDeleteObjectDiskNotFound(t *testing.T) {
 	xl.storageDisks[7] = nil
 	xl.storageDisks[8] = nil
 	err = obj.DeleteObject(context.Background(), bucket, object)
-	err = errors.Cause(err)
 	// since majority of disks are not available, metaquorum is not achieved and hence errXLReadQuorum error
 	if err != toObjectErr(errXLReadQuorum, bucket, object) {
 		t.Errorf("Expected deleteObject to fail with %v, but failed with %v", toObjectErr(errXLReadQuorum, bucket, object), err)
@@ -205,7 +202,6 @@ func TestGetObjectNoQuorum(t *testing.T) {
 		}
 		// Fetch object from store.
 		err = xl.GetObject(context.Background(), bucket, object, 0, int64(len("abcd")), ioutil.Discard, "")
-		err = errors.Cause(err)
 		if err != toObjectErr(errXLReadQuorum, bucket, object) {
 			t.Errorf("Expected putObject to fail with %v, but failed with %v", toObjectErr(errXLWriteQuorum, bucket, object), err)
 		}
@@ -256,7 +252,6 @@ func TestPutObjectNoQuorum(t *testing.T) {
 		}
 		// Upload new content to same object "object"
 		_, err = obj.PutObject(context.Background(), bucket, object, mustGetHashReader(t, bytes.NewReader([]byte("abcd")), int64(len("abcd")), "", ""), nil)
-		err = errors.Cause(err)
 		if err != toObjectErr(errXLWriteQuorum, bucket, object) {
 			t.Errorf("Expected putObject to fail with %v, but failed with %v", toObjectErr(errXLWriteQuorum, bucket, object), err)
 		}
diff --git a/cmd/xl-v1-utils.go b/cmd/xl-v1-utils.go
index 5325981b3..2e2b97817 100644
--- a/cmd/xl-v1-utils.go
+++ b/cmd/xl-v1-utils.go
@@ -26,7 +26,6 @@ import (
 	"time"
 
 	"github.com/minio/minio/cmd/logger"
-	errors2 "github.com/minio/minio/pkg/errors"
 	"github.com/tidwall/gjson"
 )
 
@@ -39,7 +38,7 @@ import (
 func reduceErrs(errs []error, ignoredErrs []error) (maxCount int, maxErr error) {
 	errorCounts := make(map[error]int)
 	for _, err := range errs {
-		if errors2.IsErrIgnored(err, ignoredErrs...) {
+		if IsErrIgnored(err, ignoredErrs...) {
 			continue
 		}
 		errorCounts[err]++
diff --git a/cmd/xl-v1-utils_test.go b/cmd/xl-v1-utils_test.go
index e07172d2a..a55171acf 100644
--- a/cmd/xl-v1-utils_test.go
+++ b/cmd/xl-v1-utils_test.go
@@ -26,7 +26,6 @@ import (
 	"testing"
 
 	humanize "github.com/dustin/go-humanize"
-	"github.com/minio/minio/pkg/errors"
 )
 
 // Tests caclculating disk count.
@@ -93,11 +92,11 @@ func TestReduceErrs(t *testing.T) {
 	// Validates list of all the testcases for returning valid errors.
 	for i, testCase := range testCases {
 		gotErr := reduceReadQuorumErrs(context.Background(), testCase.errs, testCase.ignoredErrs, 5)
-		if errors.Cause(gotErr) != testCase.err {
+		if gotErr != testCase.err {
 			t.Errorf("Test %d : expected %s, got %s", i+1, testCase.err, gotErr)
 		}
 		gotNewErr := reduceWriteQuorumErrs(context.Background(), testCase.errs, testCase.ignoredErrs, 6)
-		if errors.Cause(gotNewErr) != errXLWriteQuorum {
+		if gotNewErr != errXLWriteQuorum {
 			t.Errorf("Test %d : expected %s, got %s", i+1, errXLWriteQuorum, gotErr)
 		}
 	}
@@ -388,8 +387,8 @@ func TestGetPartSizeFromIdx(t *testing.T) {
 		if err == nil {
 			t.Errorf("Test %d: Expected to failed but passed. %s", i+1, err)
 		}
-		if err != nil && errors.Cause(err) != testCaseFailure.err {
-			t.Errorf("Test %d: Expected err %s, but got %s", i+1, testCaseFailure.err, errors.Cause(err))
+		if err != nil && err != testCaseFailure.err {
+			t.Errorf("Test %d: Expected err %s, but got %s", i+1, testCaseFailure.err, err)
 		}
 	}
 }
diff --git a/cmd/xl-v1.go b/cmd/xl-v1.go
index c26f539ec..53bb50a28 100644
--- a/cmd/xl-v1.go
+++ b/cmd/xl-v1.go
@@ -24,7 +24,6 @@ import (
 	"github.com/minio/minio/cmd/logger"
 	"github.com/minio/minio/pkg/bpool"
 	"github.com/minio/minio/pkg/disk"
-	"github.com/minio/minio/pkg/errors"
 )
 
 // XL constants.
@@ -142,7 +141,7 @@ func getDisksInfo(disks []StorageAPI) (disksInfo []disk.Info, onlineDisks int, o
 		info, err := storageDisk.DiskInfo()
 		if err != nil {
 			logger.LogIf(context.Background(), err)
-			if errors.IsErr(err, baseErrs...) {
+			if IsErr(err, baseErrs...) {
 				offlineDisks++
 				continue
 			}
diff --git a/pkg/errors/errors.go b/pkg/errors/errors.go
deleted file mode 100644
index 696f2a281..000000000
--- a/pkg/errors/errors.go
+++ /dev/null
@@ -1,154 +0,0 @@
-/*
- * Minio Cloud Storage, (C) 2017 Minio, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package errors
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-	"runtime"
-	"strings"
-)
-
-var (
-	// Package path of the project.
-	pkgPath string
-)
-
-// Init - initialize package path.
-func Init(gopath string, p string) {
-	pkgPath = filepath.Join(gopath, "src", p) + string(os.PathSeparator)
-}
-
-// stackInfo - Represents a stack frame in the stack trace.
-type stackInfo struct {
-	Filename string `json:"fileName"` // File where error occurred
-	Line     int    `json:"line"`     // Line where error occurred
-	Name     string `json:"name"`     // Name of the function where error occurred
-}
-
-// Error - error type containing cause and the stack trace.
-type Error struct {
-	Cause error       // Holds the cause error
-	stack []stackInfo // Stack trace info.
-	errs  []error     // Useful for XL to hold errors from all disks
-}
-
-// Implement error interface.
-func (e Error) Error() string {
-	return e.Cause.Error()
-}
-
-// Stack - returns slice of stack trace.
-func (e Error) Stack() []string {
-	var stack []string
-	for _, info := range e.stack {
-		stack = append(stack, fmt.Sprintf("%s:%d:%s()", info.Filename, info.Line, info.Name))
-	}
-	return stack
-}
-
-// Trace - return new Error type.
-func Trace(e error, errs ...error) error {
-	// Error is nil nothing to do return nil.
-	if e == nil {
-		return nil
-	}
-
-	// Already a trace error should be returned as is.
-	if _, ok := e.(*Error); ok {
-		return e
-	}
-
-	err := &Error{}
-	err.Cause = e
-	err.errs = errs
-
-	stack := make([]uintptr, 40)
-	length := runtime.Callers(2, stack)
-	if length > len(stack) {
-		length = len(stack)
-	}
-	stack = stack[:length]
-
-	for _, pc := range stack {
-		pc = pc - 1
-		fn := runtime.FuncForPC(pc)
-		file, line := fn.FileLine(pc)
-
-		var suffixFound bool
-		for _, ignoreName := range []string{
-			"runtime.",
-			"testing.",
-		} {
-			if strings.HasPrefix(fn.Name(), ignoreName) {
-				suffixFound = true
-				break
-			}
-		}
-		if suffixFound {
-			continue
-		}
-		_, name := filepath.Split(fn.Name())
-		name = strings.SplitN(name, ".", 2)[1]
-		file = filepath.FromSlash(strings.TrimPrefix(filepath.ToSlash(file), filepath.ToSlash(pkgPath)))
-		err.stack = append(err.stack, stackInfo{
-			Filename: file,
-			Line:     line,
-			Name:     name,
-		})
-	}
-
-	return err
-}
-
-// Cause - Returns the underlying cause error.
-func Cause(err error) error {
-	if e, ok := err.(*Error); ok {
-		err = e.Cause
-	}
-	return err
-}
-
-// Causes - Returns slice of underlying cause error.
-func Causes(errs []error) (cerrs []error) {
-	for _, err := range errs {
-		cerrs = append(cerrs, Cause(err))
-	}
-	return cerrs
-}
-
-// IsErrIgnored returns whether given error is ignored or not.
-func IsErrIgnored(err error, ignoredErrs ...error) bool {
-	return IsErr(err, ignoredErrs...)
-}
-
-// IsErr returns whether given error is exact error.
-func IsErr(err error, errs ...error) bool {
-	err = Cause(err)
-	for _, exactErr := range errs {
-		if err == exactErr {
-			return true
-		}
-	}
-	return false
-}
-
-// Tracef behaves like fmt.Errorf but adds traces to the returned error.
-func Tracef(format string, args ...interface{}) error {
-	return Trace(fmt.Errorf(format, args...))
-}
diff --git a/pkg/errors/errors_test.go b/pkg/errors/errors_test.go
deleted file mode 100644
index 8e5005520..000000000
--- a/pkg/errors/errors_test.go
+++ /dev/null
@@ -1,120 +0,0 @@
-/*
- * Minio Cloud Storage, (C) 2017 Minio, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package errors
-
-import (
-	"fmt"
-	"go/build"
-	"path/filepath"
-	"reflect"
-	"strings"
-	"testing"
-)
-
-// Test trace errors.
-func TestTrace(t *testing.T) {
-	var errExpectedCause = fmt.Errorf("traceable error")
-	var testCases = []struct {
-		expectedCauseErr error
-	}{
-		{
-			expectedCauseErr: nil,
-		},
-		{
-			expectedCauseErr: errExpectedCause,
-		},
-		{
-			expectedCauseErr: Trace(errExpectedCause),
-		},
-	}
-	for i, testCase := range testCases {
-		if err := Trace(testCase.expectedCauseErr); err != nil {
-			if errGotCause := Cause(err); errGotCause != Cause(testCase.expectedCauseErr) {
-				t.Errorf("Test: %d Expected %s, got %s", i+1, testCase.expectedCauseErr, errGotCause)
-			}
-		}
-	}
-}
-
-// Test if isErrIgnored works correctly.
-func TestIsErrIgnored(t *testing.T) {
-	var errIgnored = fmt.Errorf("ignored error")
-	var testCases = []struct {
-		err     error
-		ignored bool
-	}{
-		{
-			err:     nil,
-			ignored: false,
-		},
-		{
-			err:     errIgnored,
-			ignored: true,
-		},
-		{
-			err:     Trace(errIgnored),
-			ignored: true,
-		},
-	}
-	for i, testCase := range testCases {
-		if ok := IsErrIgnored(testCase.err, errIgnored); ok != testCase.ignored {
-			t.Errorf("Test: %d, Expected %t, got %t", i+1, testCase.ignored, ok)
-		}
-	}
-}
-
-// Tests if pkgPath is set properly in init.
-func TestInit(t *testing.T) {
-	Init("/home/test/go", "test")
-	if filepath.ToSlash(pkgPath) != "/home/test/go/src/test/" {
-		t.Fatalf("Expected pkgPath to be \"/home/test/go/src/test/\", found %s", pkgPath)
-	}
-}
-
-// Tests stack output.
-func TestStack(t *testing.T) {
-	Init(build.Default.GOPATH, "github.com/minio/minio")
-
-	err := Trace(fmt.Errorf("traceable error"))
-	if terr, ok := err.(*Error); ok {
-		if !strings.HasSuffix(terr.Stack()[0], "TestStack()") {
-			t.Errorf("Expected suffix \"TestStack()\", got %s", terr.Stack()[0])
-		}
-	}
-	// Test if the cause error is returned properly with the underlying string.
-	if err.Error() != "traceable error" {
-		t.Errorf("Expected \"traceable error\", got %s", err.Error())
-	}
-}
-
-// Tests converting error causes.
-func TestErrCauses(t *testing.T) {
-	errTraceableError := fmt.Errorf("traceable error")
-	var errs = []error{
-		errTraceableError,
-		errTraceableError,
-		errTraceableError,
-	}
-	var terrs []error
-	for _, err := range errs {
-		terrs = append(terrs, Trace(err))
-	}
-	cerrs := Causes(terrs)
-	if !reflect.DeepEqual(errs, cerrs) {
-		t.Errorf("Expected %#v, got %#v", errs, cerrs)
-	}
-}