2 files changed, 21 insertions, 12 deletions
diff --git a/pkg/syserr/BUILD b/pkg/syserr/BUILD
index ceee494fc..d8c4c9613 100644
--- a/pkg/syserr/BUILD
+++ b/pkg/syserr/BUILD
@@ -14,7 +14,7 @@ go_library(
         "//pkg/abi/linux/errno",
         "//pkg/errors",
         "//pkg/errors/linuxerr",
-        "//pkg/syserror",
+        "//pkg/safecopy",
         "//pkg/tcpip",
         "@org_golang_x_sys//unix:go_default_library",
     ],
diff --git a/pkg/syserr/syserr.go b/pkg/syserr/syserr.go
index 558240008..b679f3046 100644
--- a/pkg/syserr/syserr.go
+++ b/pkg/syserr/syserr.go
@@ -24,7 +24,7 @@ import (
 	"gvisor.dev/gvisor/pkg/abi/linux/errno"
 	"gvisor.dev/gvisor/pkg/errors"
 	"gvisor.dev/gvisor/pkg/errors/linuxerr"
-	"gvisor.dev/gvisor/pkg/syserror"
+	"gvisor.dev/gvisor/pkg/safecopy"
 )
 
 // Error represents an internal error.
@@ -52,12 +52,12 @@ func New(message string, linuxTranslation errno.Errno) *Error {
 	}
 
 	e := error(unix.Errno(err.errno))
-	// syserror.ErrWouldBlock gets translated to linuxerr.EWOULDBLOCK and
+	// linuxerr.ErrWouldBlock gets translated to linuxerr.EWOULDBLOCK and
 	// enables proper blocking semantics. This should temporary address the
 	// class of blocking bugs that keep popping up with the current state of
 	// the error space.
 	if err.errno == linuxerr.EWOULDBLOCK.Errno() {
-		e = syserror.ErrWouldBlock
+		e = linuxerr.ErrWouldBlock
 	}
 	linuxBackwardsTranslations[err.errno] = linuxBackwardsTranslation{err: e, ok: true}
 
@@ -279,16 +279,25 @@ func FromError(err error) *Error {
 	if err == nil {
 		return nil
 	}
-	if errno, ok := err.(unix.Errno); ok {
-		return FromHost(errno)
-	}
 
-	if linuxErr, ok := err.(*errors.Error); ok {
-		return FromHost(unix.Errno(linuxErr.Errno()))
+	switch e := err.(type) {
+	case unix.Errno:
+		return FromHost(e)
+	case *errors.Error:
+		return FromHost(unix.Errno(e.Errno()))
+	case safecopy.SegvError, safecopy.BusError, safecopy.AlignmentError:
+		return FromHost(unix.EFAULT)
 	}
 
-	if errno, ok := syserror.TranslateError(err); ok {
-		return FromHost(errno)
+	msg := fmt.Sprintf("err: %s type: %T", err.Error(), err)
+	panic(msg)
+}
+
+// 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 == linuxerr.ErrInterrupted {
+		return intr
 	}
-	panic("unknown error: " + err.Error())
+	return err
 }