syserror

Documentation

Overview

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.

Index

• Constants
• Variables
• func AddErrorTranslation(from error, to syscall.Errno) bool
• func AddErrorUnwrapper(unwrap func(e error) (syscall.Errno, bool))
• func ConvertIntr(err, intr error) error
• func TranslateError(from error) (syscall.Errno, bool)
• type SyscallRestartErrno
  • func SyscallRestartErrnoFromReturn(rv uintptr) (SyscallRestartErrno, bool)
  • func (e SyscallRestartErrno) Error() string

Constants

const (
	// 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 = SyscallRestartErrno(512)

	// ERESTARTNOINTR is returned by an interrupted syscall to indicate that it
	// should always be restarted.
	ERESTARTNOINTR = SyscallRestartErrno(513)

	// 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 = SyscallRestartErrno(514)

	// 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 = SyscallRestartErrno(516)
)

These numeric values are significant because ptrace syscall exit tracing can observe them.

For all of the following errnos, if the syscall is not interrupted by a signal delivered to a user handler, the syscall is restarted.

Variables

var (
	E2BIG        = error(syscall.E2BIG)
	EACCES       = error(syscall.EACCES)
	EADDRINUSE   = error(syscall.EADDRINUSE)
	EAGAIN       = error(syscall.EAGAIN)
	EBADF        = error(syscall.EBADF)
	EBADFD       = error(syscall.EBADFD)
	EBUSY        = error(syscall.EBUSY)
	ECHILD       = error(syscall.ECHILD)
	ECONNABORTED = error(syscall.ECONNABORTED)
	ECONNREFUSED = error(syscall.ECONNREFUSED)
	ECONNRESET   = error(syscall.ECONNRESET)
	EDEADLK      = error(syscall.EDEADLK)
	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)
	EMLINK       = error(syscall.EMLINK)
	EMSGSIZE     = error(syscall.EMSGSIZE)
	ENAMETOOLONG = error(syscall.ENAMETOOLONG)
	ENOATTR      = ENODATA
	ENOBUFS      = error(syscall.ENOBUFS)
	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)
	ENOTCONN     = error(syscall.ENOTCONN)
	ENOTDIR      = error(syscall.ENOTDIR)
	ENOTEMPTY    = error(syscall.ENOTEMPTY)
	ENOTSOCK     = error(syscall.ENOTSOCK)
	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)
	EREMOTE      = error(syscall.EREMOTE)
	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)
)

The following variables have the same meaning as their syscall equivalent.

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")
)

Functions

func AddErrorTranslation

func AddErrorTranslation(from error, to 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 AddErrorUnwrapper

func AddErrorUnwrapper(unwrap func(e error) (syscall.Errno, bool))

AddErrorUnwrapper registers an unwrap method that can extract a concrete error from a typed, but not initialized, error.

func ConvertIntr

func ConvertIntr(err, intr error) error

ConvertIntr converts the provided error code (err) to another one (intr) if the first error corresponds to an interrupted operation.

func TranslateError

func TranslateError(from error) (syscall.Errno, bool)

TranslateError translates errors to errnos, it will return false if the error was not registered.

Types

type SyscallRestartErrno

type SyscallRestartErrno int

SyscallRestartErrno represents a ERESTART* errno defined in the Linux's kernel include/linux/errno.h. These errnos are never returned to userspace directly, but are used to communicate the expected behavior of an interrupted syscall from the syscall to signal handling.

func SyscallRestartErrnoFromReturn

func SyscallRestartErrnoFromReturn(rv uintptr) (SyscallRestartErrno, bool)

SyscallRestartErrnoFromReturn returns the SyscallRestartErrno represented by rv, the value in a syscall return register.

func (SyscallRestartErrno) Error

func (e SyscallRestartErrno) Error() string

Error implements error.Error.