Check in gVisor.

PiperOrigin-RevId: 194583126
Change-Id: Ica1d8821a90f74e7e745962d71801c598c652463

3 files changed, 305 insertions, 0 deletions

diff --git a/pkg/syserror/BUILD b/pkg/syserror/BUILD
new file mode 100644
index 000000000..68ddec786
--- /dev/null
+++ b/pkg/syserror/BUILD
@@ -0,0 +1,18 @@
+package(licenses = ["notice"])  # Apache 2.0
+
+load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test")
+
+go_library(
+    name = "syserror",
+    srcs = ["syserror.go"],
+    importpath = "gvisor.googlesource.com/gvisor/pkg/syserror",
+    visibility = ["//visibility:public"],
+)
+
+go_test(
+    name = "syserror_test",
+    srcs = ["syserror_test.go"],
+    deps = [
+        ":syserror",
+    ],
+)
diff --git a/pkg/syserror/syserror.go b/pkg/syserror/syserror.go
new file mode 100644
index 000000000..6f8a7a319
--- /dev/null
+++ b/pkg/syserror/syserror.go
@@ -0,0 +1,151 @@
+// Copyright 2018 Google 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 syserror contains syscall error codes exported as error interface
+// instead of Errno. This allows for fast comparison and returns when the
+// comparand or return value is of type error because there is no need to
+// convert from Errno to an interface, i.e., runtime.convT2I isn't called.
+package syserror
+
+import (
+	"errors"
+	"syscall"
+)
+
+// The following variables have the same meaning as their syscall equivalent.
+var (
+	E2BIG        = error(syscall.E2BIG)
+	EACCES       = error(syscall.EACCES)
+	EAGAIN       = error(syscall.EAGAIN)
+	EBADF        = error(syscall.EBADF)
+	EBUSY        = error(syscall.EBUSY)
+	ECHILD       = error(syscall.ECHILD)
+	ECONNREFUSED = error(syscall.ECONNREFUSED)
+	ECONNRESET   = error(syscall.ECONNRESET)
+	EEXIST       = error(syscall.EEXIST)
+	EFAULT       = error(syscall.EFAULT)
+	EFBIG        = error(syscall.EFBIG)
+	EIDRM        = error(syscall.EIDRM)
+	EINTR        = error(syscall.EINTR)
+	EINVAL       = error(syscall.EINVAL)
+	EIO          = error(syscall.EIO)
+	EISDIR       = error(syscall.EISDIR)
+	ELIBBAD      = error(syscall.ELIBBAD)
+	ELOOP        = error(syscall.ELOOP)
+	EMFILE       = error(syscall.EMFILE)
+	ENAMETOOLONG = error(syscall.ENAMETOOLONG)
+	ENOATTR      = ENODATA
+	ENODATA      = error(syscall.ENODATA)
+	ENODEV       = error(syscall.ENODEV)
+	ENOENT       = error(syscall.ENOENT)
+	ENOEXEC      = error(syscall.ENOEXEC)
+	ENOLCK       = error(syscall.ENOLCK)
+	ENOLINK      = error(syscall.ENOLINK)
+	ENOMEM       = error(syscall.ENOMEM)
+	ENOSPC       = error(syscall.ENOSPC)
+	ENOSYS       = error(syscall.ENOSYS)
+	ENOTDIR      = error(syscall.ENOTDIR)
+	ENOTEMPTY    = error(syscall.ENOTEMPTY)
+	ENOTSUP      = error(syscall.ENOTSUP)
+	ENOTTY       = error(syscall.ENOTTY)
+	ENXIO        = error(syscall.ENXIO)
+	EOPNOTSUPP   = error(syscall.EOPNOTSUPP)
+	EOVERFLOW    = error(syscall.EOVERFLOW)
+	EPERM        = error(syscall.EPERM)
+	EPIPE        = error(syscall.EPIPE)
+	ERANGE       = error(syscall.ERANGE)
+	EROFS        = error(syscall.EROFS)
+	ESPIPE       = error(syscall.ESPIPE)
+	ESRCH        = error(syscall.ESRCH)
+	ETIMEDOUT    = error(syscall.ETIMEDOUT)
+	EUSERS       = error(syscall.EUSERS)
+	EWOULDBLOCK  = error(syscall.EWOULDBLOCK)
+	EXDEV        = error(syscall.EXDEV)
+)
+
+var (
+	// ErrWouldBlock is an internal error used to indicate that an operation
+	// cannot be satisfied immediately, and should be retried at a later
+	// time, possibly when the caller has received a notification that the
+	// operation may be able to complete. It is used by implementations of
+	// the kio.File interface.
+	ErrWouldBlock = errors.New("request would block")
+
+	// ErrInterrupted is returned if a request is interrupted before it can
+	// complete.
+	ErrInterrupted = errors.New("request was interrupted")
+
+	// ErrExceedsFileSizeLimit is returned if a request would exceed the
+	// file's size limit.
+	ErrExceedsFileSizeLimit = errors.New("exceeds file size limit")
+)
+
+// errorMap is the map used to convert generic errors into errnos.
+var errorMap = map[error]syscall.Errno{}
+
+// errorUnwrappers is an array of unwrap functions to extract typed errors.
+var errorUnwrappers = []func(error) (syscall.Errno, bool){}
+
+// AddErrorTranslation allows modules to populate the error map by adding their
+// own translations during initialization. Returns if the error translation is
+// accepted or not. A pre-existing translation will not be overwritten by the
+// new translation.
+func AddErrorTranslation(from error, to syscall.Errno) bool {
+	if _, ok := errorMap[from]; ok {
+		return false
+	}
+
+	errorMap[from] = to
+	return true
+}
+
+// AddErrorUnwrapper registers an unwrap method that can extract a concrete error
+// from a typed, but not initialized, error.
+func AddErrorUnwrapper(unwrap func(e error) (syscall.Errno, bool)) {
+	errorUnwrappers = append(errorUnwrappers, unwrap)
+}
+
+// TranslateError translates errors to errnos, it will return false if
+// the error was not registered.
+func TranslateError(from error) (syscall.Errno, bool) {
+	err, ok := errorMap[from]
+	if ok {
+		return err, ok
+	}
+	// Try to unwrap the error if we couldn't match an error
+	// exactly.  This might mean that a package has its own
+	// error type.
+	for _, unwrap := range errorUnwrappers {
+		err, ok := unwrap(from)
+		if ok {
+			return err, ok
+		}
+	}
+	return 0, false
+}
+
+// ConvertIntr converts the provided error code (err) to another one (intr) if
+// the first error corresponds to an interrupted operation.
+func ConvertIntr(err, intr error) error {
+	if err == ErrInterrupted {
+		return intr
+	}
+	return err
+}
+
+func init() {
+	AddErrorTranslation(ErrWouldBlock, syscall.EWOULDBLOCK)
+	AddErrorTranslation(ErrInterrupted, syscall.EINTR)
+	AddErrorTranslation(ErrExceedsFileSizeLimit, syscall.EFBIG)
+}
diff --git a/pkg/syserror/syserror_test.go b/pkg/syserror/syserror_test.go
new file mode 100644
index 000000000..fb7d8d5ee
--- /dev/null
+++ b/pkg/syserror/syserror_test.go
@@ -0,0 +1,136 @@
+// Copyright 2018 Google 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 syserror_test
+
+import (
+	"errors"
+	"syscall"
+	"testing"
+
+	"gvisor.googlesource.com/gvisor/pkg/syserror"
+)
+
+var globalError error
+
+func returnErrnoAsError() error {
+	return syscall.EINVAL
+}
+
+func returnError() error {
+	return syserror.EINVAL
+}
+
+func BenchmarkReturnErrnoAsError(b *testing.B) {
+	for i := b.N; i > 0; i-- {
+		returnErrnoAsError()
+	}
+}
+
+func BenchmarkReturnError(b *testing.B) {
+	for i := b.N; i > 0; i-- {
+		returnError()
+	}
+}
+
+func BenchmarkCompareErrno(b *testing.B) {
+	j := 0
+	for i := b.N; i > 0; i-- {
+		if globalError == syscall.EINVAL {
+			j++
+		}
+	}
+}
+
+func BenchmarkCompareError(b *testing.B) {
+	j := 0
+	for i := b.N; i > 0; i-- {
+		if globalError == syserror.EINVAL {
+			j++
+		}
+	}
+}
+
+func BenchmarkSwitchErrno(b *testing.B) {
+	j := 0
+	for i := b.N; i > 0; i-- {
+		switch globalError {
+		case syscall.EINVAL:
+			j += 1
+		case syscall.EINTR:
+			j += 2
+		case syscall.EAGAIN:
+			j += 3
+		}
+	}
+}
+
+func BenchmarkSwitchError(b *testing.B) {
+	j := 0
+	for i := b.N; i > 0; i-- {
+		switch globalError {
+		case syserror.EINVAL:
+			j += 1
+		case syserror.EINTR:
+			j += 2
+		case syserror.EAGAIN:
+			j += 3
+		}
+	}
+}
+
+type translationTestTable struct {
+	fn                  string
+	errIn               error
+	syscallErrorIn      syscall.Errno
+	expectedBool        bool
+	expectedTranslation syscall.Errno
+}
+
+func TestErrorTranslation(t *testing.T) {
+	myError := errors.New("My test error")
+	myError2 := errors.New("Another test error")
+	testTable := []translationTestTable{
+		{"TranslateError", myError, 0, false, 0},
+		{"TranslateError", myError2, 0, false, 0},
+		{"AddErrorTranslation", myError, syscall.EAGAIN, true, 0},
+		{"AddErrorTranslation", myError, syscall.EAGAIN, false, 0},
+		{"AddErrorTranslation", myError, syscall.EPERM, false, 0},
+		{"TranslateError", myError, 0, true, syscall.EAGAIN},
+		{"TranslateError", myError2, 0, false, 0},
+		{"AddErrorTranslation", myError2, syscall.EPERM, true, 0},
+		{"AddErrorTranslation", myError2, syscall.EPERM, false, 0},
+		{"AddErrorTranslation", myError2, syscall.EAGAIN, false, 0},
+		{"TranslateError", myError, 0, true, syscall.EAGAIN},
+		{"TranslateError", myError2, 0, true, syscall.EPERM},
+	}
+	for _, tt := range testTable {
+		switch tt.fn {
+		case "TranslateError":
+			err, ok := syserror.TranslateError(tt.errIn)
+			if ok != tt.expectedBool {
+				t.Fatalf("%v(%v) => %v expected %v", tt.fn, tt.errIn, ok, tt.expectedBool)
+			} else if err != tt.expectedTranslation {
+				t.Fatalf("%v(%v) (error) => %v expected %v", tt.fn, tt.errIn, err, tt.expectedTranslation)
+			}
+		case "AddErrorTranslation":
+			ok := syserror.AddErrorTranslation(tt.errIn, tt.syscallErrorIn)
+			if ok != tt.expectedBool {
+				t.Fatalf("%v(%v) => %v expected %v", tt.fn, tt.errIn, ok, tt.expectedBool)
+			}
+		default:
+			t.Fatalf("Unknown function %v", tt.fn)
+		}
+	}
+}