summaryrefslogtreecommitdiffhomepage
path: root/pkg/errors/linuxerr
diff options
context:
space:
mode:
Diffstat (limited to 'pkg/errors/linuxerr')
-rw-r--r--pkg/errors/linuxerr/BUILD2
-rw-r--r--pkg/errors/linuxerr/internal.go120
-rw-r--r--pkg/errors/linuxerr/linuxerr_test.go90
3 files changed, 147 insertions, 65 deletions
diff --git a/pkg/errors/linuxerr/BUILD b/pkg/errors/linuxerr/BUILD
index f99544afd..e73b0e28a 100644
--- a/pkg/errors/linuxerr/BUILD
+++ b/pkg/errors/linuxerr/BUILD
@@ -5,6 +5,7 @@ package(licenses = ["notice"])
go_library(
name = "linuxerr",
srcs = [
+ "internal.go",
"linuxerr.go",
],
visibility = ["//visibility:public"],
@@ -22,7 +23,6 @@ go_test(
":linuxerr",
"//pkg/abi/linux/errno",
"//pkg/errors",
- "//pkg/syserror",
"@org_golang_x_sys//unix:go_default_library",
],
)
diff --git a/pkg/errors/linuxerr/internal.go b/pkg/errors/linuxerr/internal.go
new file mode 100644
index 000000000..127bba0df
--- /dev/null
+++ b/pkg/errors/linuxerr/internal.go
@@ -0,0 +1,120 @@
+// Copyright 2021 The gVisor Authors.
+//
+// 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 linuxerr
+
+import (
+ "gvisor.dev/gvisor/pkg/abi/linux/errno"
+ "gvisor.dev/gvisor/pkg/errors"
+)
+
+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(errno.EWOULDBLOCK, "request would block")
+
+ // ErrInterrupted is returned if a request is interrupted before it can
+ // complete.
+ ErrInterrupted = errors.New(errno.EINTR, "request was interrupted")
+
+ // ErrExceedsFileSizeLimit is returned if a request would exceed the
+ // file's size limit.
+ ErrExceedsFileSizeLimit = errors.New(errno.E2BIG, "exceeds file size limit")
+)
+
+var errorMap = map[error]*errors.Error{
+ ErrWouldBlock: EWOULDBLOCK,
+ ErrInterrupted: EINTR,
+ ErrExceedsFileSizeLimit: EFBIG,
+}
+
+// errorUnwrappers is an array of unwrap functions to extract typed errors.
+var errorUnwrappers = []func(error) (*errors.Error, bool){}
+
+// AddErrorUnwrapper registers an unwrap method that can extract a concrete error
+// from a typed, but not initialized, error.
+func AddErrorUnwrapper(unwrap func(e error) (*errors.Error, bool)) {
+ errorUnwrappers = append(errorUnwrappers, unwrap)
+}
+
+// TranslateError translates errors to errnos, it will return false if
+// the error was not registered.
+func TranslateError(from error) (*errors.Error, bool) {
+ if err, ok := errorMap[from]; ok {
+ return err, true
+ }
+ // 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 {
+ if err, ok := unwrap(from); ok {
+ return err, true
+ }
+ }
+ return nil, false
+}
+
+// These errors are significant because ptrace syscall exit tracing can
+// observe them.
+//
+// For all of the following errors, if the syscall is not interrupted by a
+// signal delivered to a user handler, the syscall is restarted.
+var (
+ // ERESTARTSYS is returned by an interrupted syscall to indicate that it
+ // should be converted to EINTR if interrupted by a signal delivered to a
+ // user handler without SA_RESTART set, and restarted otherwise.
+ ERESTARTSYS = errors.New(errno.ERESTARTSYS, "to be restarted if SA_RESTART is set")
+
+ // ERESTARTNOINTR is returned by an interrupted syscall to indicate that it
+ // should always be restarted.
+ ERESTARTNOINTR = errors.New(errno.ERESTARTNOINTR, "to be restarted")
+
+ // ERESTARTNOHAND is returned by an interrupted syscall to indicate that it
+ // should be converted to EINTR if interrupted by a signal delivered to a
+ // user handler, and restarted otherwise.
+ ERESTARTNOHAND = errors.New(errno.ERESTARTNOHAND, "to be restarted if no handler")
+
+ // ERESTART_RESTARTBLOCK is returned by an interrupted syscall to indicate
+ // that it should be restarted using a custom function. The interrupted
+ // syscall must register a custom restart function by calling
+ // Task.SetRestartSyscallFn.
+ ERESTART_RESTARTBLOCK = errors.New(errno.ERESTART_RESTARTBLOCK, "interrupted by signal")
+)
+
+var restartMap = map[int]*errors.Error{
+ -int(errno.ERESTARTSYS): ERESTARTSYS,
+ -int(errno.ERESTARTNOINTR): ERESTARTNOINTR,
+ -int(errno.ERESTARTNOHAND): ERESTARTNOHAND,
+ -int(errno.ERESTART_RESTARTBLOCK): ERESTART_RESTARTBLOCK,
+}
+
+// IsRestartError checks if a given error is a restart error.
+func IsRestartError(err error) bool {
+ switch err {
+ case ERESTARTSYS, ERESTARTNOINTR, ERESTARTNOHAND, ERESTART_RESTARTBLOCK:
+ return true
+ default:
+ return false
+ }
+}
+
+// SyscallRestartErrorFromReturn returns the SyscallRestartErrno represented by
+// rv, the value in a syscall return register.
+func SyscallRestartErrorFromReturn(rv uintptr) (*errors.Error, bool) {
+ err, ok := restartMap[int(rv)]
+ return err, ok
+}
diff --git a/pkg/errors/linuxerr/linuxerr_test.go b/pkg/errors/linuxerr/linuxerr_test.go
index 5390c8a12..df7cd1c5a 100644
--- a/pkg/errors/linuxerr/linuxerr_test.go
+++ b/pkg/errors/linuxerr/linuxerr_test.go
@@ -12,10 +12,11 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-package syserror_test
+package linuxerr_test
import (
"errors"
+ "fmt"
"io"
"io/fs"
"syscall"
@@ -25,7 +26,6 @@ import (
"gvisor.dev/gvisor/pkg/abi/linux/errno"
gErrors "gvisor.dev/gvisor/pkg/errors"
"gvisor.dev/gvisor/pkg/errors/linuxerr"
- "gvisor.dev/gvisor/pkg/syserror"
)
var globalError error
@@ -42,12 +42,6 @@ func BenchmarkAssignLinuxerr(b *testing.B) {
}
}
-func BenchmarkAssignSyserror(b *testing.B) {
- for i := b.N; i > 0; i-- {
- globalError = linuxerr.ENOMSG
- }
-}
-
func BenchmarkCompareUnix(b *testing.B) {
globalError = unix.EAGAIN
j := 0
@@ -68,16 +62,6 @@ func BenchmarkCompareLinuxerr(b *testing.B) {
}
}
-func BenchmarkCompareSyserror(b *testing.B) {
- globalError = linuxerr.EAGAIN
- j := 0
- for i := b.N; i > 0; i-- {
- if globalError == linuxerr.EACCES {
- j++
- }
- }
-}
-
func BenchmarkSwitchUnix(b *testing.B) {
globalError = unix.EPERM
j := 0
@@ -108,21 +92,6 @@ func BenchmarkSwitchLinuxerr(b *testing.B) {
}
}
-func BenchmarkSwitchSyserror(b *testing.B) {
- globalError = linuxerr.EPERM
- j := 0
- for i := b.N; i > 0; i-- {
- switch globalError {
- case linuxerr.EACCES:
- j++
- case linuxerr.EINTR:
- j += 2
- case linuxerr.EAGAIN:
- j += 3
- }
- }
-}
-
func BenchmarkReturnUnix(b *testing.B) {
var localError error
f := func() error {
@@ -170,47 +139,40 @@ func BenchmarkConvertUnixLinuxerrZero(b *testing.B) {
}
type translationTestTable struct {
- fn string
errIn error
- syscallErrorIn unix.Errno
expectedBool bool
- expectedTranslation unix.Errno
+ expectedTranslation *gErrors.Error
}
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, unix.EAGAIN, true, 0},
- {"AddErrorTranslation", myError, unix.EAGAIN, false, 0},
- {"AddErrorTranslation", myError, unix.EPERM, false, 0},
- {"TranslateError", myError, 0, true, unix.EAGAIN},
- {"TranslateError", myError2, 0, false, 0},
- {"AddErrorTranslation", myError2, unix.EPERM, true, 0},
- {"AddErrorTranslation", myError2, unix.EPERM, false, 0},
- {"AddErrorTranslation", myError2, unix.EAGAIN, false, 0},
- {"TranslateError", myError, 0, true, unix.EAGAIN},
- {"TranslateError", myError2, 0, true, unix.EPERM},
+ {
+ errIn: linuxerr.ENOENT,
+ },
+ {
+ errIn: unix.ENOENT,
+ },
+ {
+ errIn: linuxerr.ErrInterrupted,
+ expectedBool: true,
+ expectedTranslation: linuxerr.EINTR,
+ },
+ {
+ errIn: linuxerr.ERESTART_RESTARTBLOCK,
+ },
+ {
+ errIn: errors.New("some new error"),
+ },
}
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)
+ t.Run(fmt.Sprintf("err: %v %T", tt.errIn, tt.errIn), func(t *testing.T) {
+ err, ok := linuxerr.TranslateError(tt.errIn)
+ if (!tt.expectedBool && err != nil) || (tt.expectedBool != ok) {
+ t.Fatalf("%v => %v %v expected %v err: nil", tt.errIn, err, 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)
+ t.Fatalf("%v => %v expected %v", tt.errIn, err, tt.expectedTranslation)
}
- default:
- t.Fatalf("Unknown function %v", tt.fn)
- }
+ })
}
}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-30 16:35:54 +0000