david/ipxe
david
/
ipxe
Archived
1
0
Fork 0
Code

Add per-file error identifiers

This commit is contained in:
Michael Brown 2007-07-24 17:11:31 +01:00
parent f0acd8d7a7
commit 9aa61ad5a2
16 changed files with 393 additions and 178 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
src/arch/i386/include/bits/errfile.h Normal file
View File

@ -0,0 +1,31 @@
#ifndef _BITS_ERRFILE_H
#define _BITS_ERRFILE_H
/**
* @addtogroup errfile Error file identifiers
* @{
*/
#define ERRFILE_umalloc ( ERRFILE_ARCH | ERRFILE_CORE | 0x00000000 )
#define ERRFILE_memmap ( ERRFILE_ARCH | ERRFILE_CORE | 0x00010000 )
#define ERRFILE_pnpbios ( ERRFILE_ARCH | ERRFILE_CORE | 0x00020000 )
#define ERRFILE_smbios ( ERRFILE_ARCH | ERRFILE_CORE | 0x00030000 )
#define ERRFILE_biosint ( ERRFILE_ARCH | ERRFILE_CORE | 0x00040000 )
#define ERRFILE_int13 ( ERRFILE_ARCH | ERRFILE_CORE | 0x00050000 )
#define ERRFILE_bootsector ( ERRFILE_ARCH | ERRFILE_IMAGE | 0x00000000 )
#define ERRFILE_bzimage ( ERRFILE_ARCH | ERRFILE_IMAGE | 0x00010000 )
#define ERRFILE_eltorito ( ERRFILE_ARCH | ERRFILE_IMAGE | 0x00020000 )
#define ERRFILE_multiboot ( ERRFILE_ARCH | ERRFILE_IMAGE | 0x00030000 )
#define ERRFILE_nbi ( ERRFILE_ARCH | ERRFILE_IMAGE | 0x00040000 )
#define ERRFILE_pxe_image ( ERRFILE_ARCH | ERRFILE_IMAGE | 0x00050000 )
#define ERRFILE_undi ( ERRFILE_ARCH | ERRFILE_NET | 0x00000000 )
#define ERRFILE_undiload ( ERRFILE_ARCH | ERRFILE_NET | 0x00010000 )
#define ERRFILE_undinet ( ERRFILE_ARCH | ERRFILE_NET | 0x00020000 )
#define ERRFILE_undionly ( ERRFILE_ARCH | ERRFILE_NET | 0x00030000 )
#define ERRFILE_undirom ( ERRFILE_ARCH | ERRFILE_NET | 0x00040000 )
/** @} */
#endif /* _BITS_ERRFILE_H */

20
src/core/iobuf.c
View File

@ -17,6 +17,7 @@
*/ */
#include <stdint.h> #include <stdint.h>
#include <errno.h>
#include <gpxe/malloc.h> #include <gpxe/malloc.h>
#include <gpxe/iobuf.h> #include <gpxe/iobuf.h>
@ -72,3 +73,22 @@ void free_iob ( struct io_buffer *iobuf ) {
( iobuf->end - iobuf->head ) + sizeof ( *iobuf ) ); ( iobuf->end - iobuf->head ) + sizeof ( *iobuf ) );
} }
} }
/**
* Ensure I/O buffer has sufficient headroom
*
* @v iobuf I/O buffer
* @v len Required headroom
*
* This function currently only checks for the required headroom; it
* does not reallocate the I/O buffer if required. If we ever have a
* code path that requires this functionality, it's a fairly trivial
* change to make.
*/
int iob_ensure_headroom ( struct io_buffer *iobuf, size_t len ) {
if ( iob_headroom ( iobuf ) >= len )
return 0;
return -ENOBUFS;
}

1
src/crypto/axtls_aes.c
View File

@ -1,5 +1,6 @@
#include "crypto/axtls/crypto.h" #include "crypto/axtls/crypto.h"
#include <string.h> #include <string.h>
#include <errno.h>
#include <gpxe/crypto.h> #include <gpxe/crypto.h>
#include <gpxe/aes.h> #include <gpxe/aes.h>

24
src/crypto/cipher.c Normal file
View File

@ -0,0 +1,24 @@
#include <stdint.h>
#include <errno.h>
#include <gpxe/crypto.h>
int cipher_encrypt ( struct crypto_algorithm *crypto,
void *ctx, const void *src, void *dst,
size_t len ) {
if ( ( len & ( crypto->blocksize - 1 ) ) ) {
return -EINVAL;
}
crypto->encode ( ctx, src, dst, len );
return 0;
}
int cipher_decrypt ( struct crypto_algorithm *crypto,
void *ctx, const void *src, void *dst,
size_t len ) {
if ( ( len & ( crypto->blocksize - 1 ) ) ) {
return -EINVAL;
}
crypto->decode ( ctx, src, dst, len );
return 0;
}

15
src/hci/strerror.c
View File

@ -60,15 +60,7 @@ static struct errortab * find_closest_error ( int errno ) {
/* Second, try masking off the gPXE-specific bit and seeing if /* Second, try masking off the gPXE-specific bit and seeing if
* we have an entry for the generic POSIX error message. * we have an entry for the generic POSIX error message.
*/ */
if ( ( errortab = find_error ( errno, 0x0000ffff ) ) != NULL ) if ( ( errortab = find_error ( errno, 0x4f0000ff ) ) != NULL )
return errortab;
/* Lastly, try masking off the POSIX bits and seeing if we
* have a match just based on the PXENV component. This
* allows us to report errors from underlying PXE stacks.
*/
if ( ( errortab = find_error ( ( errno & 0x000000ff ),
0xffff00ff ) ) != NULL )
return errortab; return errortab;
return NULL; return NULL;
@ -109,6 +101,10 @@ const char * strerror ( int errno ) {
return errbuf; return errbuf;
} }
/* Do not include ERRFILE portion in the numbers in the error table */
#undef ERRFILE
#define ERRFILE 0
/** The most common errors */ /** The most common errors */
struct errortab common_errors[] __errortab = { struct errortab common_errors[] __errortab = {
{ 0, "No error" }, { 0, "No error" },
@ -121,4 +117,5 @@ struct errortab common_errors[] __errortab = {
{ ENETUNREACH, "Network unreachable" }, { ENETUNREACH, "Network unreachable" },
{ ETIMEDOUT, "Connection timed out" }, { ETIMEDOUT, "Connection timed out" },
{ EPIPE, "Broken pipe" }, { EPIPE, "Broken pipe" },
{ ECANCELED, "Operation cancelled" },
}; };

3
src/include/compiler.h
View File

@ -267,6 +267,9 @@ extern void dbg_hex_dump_da ( unsigned long dispaddr,
#define NDEBUG #define NDEBUG
#endif #endif
/** Select file identifier for errno.h (if used) */
#define ERRFILE PREFIX_OBJECT ( ERRFILE_ )
/** Declare a data structure as packed. */ /** Declare a data structure as packed. */
#define PACKED __attribute__ (( packed )) #define PACKED __attribute__ (( packed ))

281
src/include/errno.h
View File

@ -7,35 +7,53 @@
* *
* Return status codes as used within gPXE are designed to allow for * Return status codes as used within gPXE are designed to allow for
* maximum visibility into the source of an error even in an end-user * maximum visibility into the source of an error even in an end-user
* build with no debugging. They are constructed in three parts: a * build with no debugging. They are constructed as follows:
* PXE error code, a POSIX error code, and a gPXE-specific error code.
* *
* The low byte is the closest equivalent PXE error code * Bits 7-0 : PXE error code
*
* This is the closest equivalent PXE error code
* (e.g. PXENV_STATUS_OUT_OF_RESOURCES), and is the only part of the * (e.g. PXENV_STATUS_OUT_OF_RESOURCES), and is the only part of the
* error that will be returned via the PXE API, since PXE has * error that will be returned via the PXE API, since PXE has
* predefined error codes. * predefined error codes.
* *
* The next byte is the closest equivalent POSIX error code * Bits 12-8 : Per-file disambiguator
* (e.g. ENOMEM). *
* When the same error number can be generated from multiple points
* within a file, this field can be used to identify the unique
* instance.
*
* Bits 23-13 : File identifier
*
* This is a unique identifier for the file generating the error
* (e.g. ERRFILE_tcp for tcp.c).
*
* Bits 30-24 : POSIX error code
*
* This is the closest equivalent POSIX error code (e.g. ENOMEM).
*
* Bit 31 : Reserved
*
* Errors are usually return as negative error numbers (e.g. -EINVAL);
* bit 31 is therefore unusable.
* *
* The remaining bytes are the gPXE-specific error code, which allow
* us to disambiguate between errors which should have the same POSIX
* error code but which mean very different things to the user
* (e.g. ENOENT due to a DNS name not existing versus ENOENT due to
* a web server returning HTTP/404 Not Found).
* *
* The convention within the code is that errors are negative and * The convention within the code is that errors are negative and
* expressed as the bitwise OR of a POSIX error code and (optionally) * expressed using the POSIX error code and (optionally) a per-file
* a gPXE error code, as in * disambiguator, e.g.
* *
* return -( ENOENT | NO_SUCH_FILE ); * return -EINVAL;
* *
* The POSIX error code is #defined to include the closest matching * or
* PXE error code (which, in most cases, is just
* PXENV_STATUS_FAILURE), so we don't need to litter the codebase with
* PXEisms.
* *
* Functions that wish to return failure should be declared as * #define ETCP_BAD_CHECKSUM EUNIQ_02
* return -( EINVAL | ETCP_BAD_CHECKSUM )
*
* By various bits of preprocessor magic, the PXE error code and file
* identifier are already incorporated into the definition of the
* POSIX error code, which keeps the code relatively clean.
*
*
* Functions that wish to return failures should be declared as
* returning an integer @c rc "Return status code". A return value of * returning an integer @c rc "Return status code". A return value of
* zero indicates success, a non-zero value indicates failure. The * zero indicates success, a non-zero value indicates failure. The
* return value can be passed directly to strerror() in order to * return value can be passed directly to strerror() in order to
@ -51,6 +69,20 @@
* *
*/ */
/* Get definitions for file identifiers */
#include <gpxe/errfile.h>
/* If we do not have a valid file identifier, generate a compiler
* warning upon usage of any error codes. (Don't just use a #warning,
* because some files include errno.h but don't ever actually use any
* error codes.)
*/
#if ! ERRFILE
extern char missing_errfile_declaration[] __attribute__ (( deprecated ));
#undef ERRFILE
#define ERRFILE ( 0 * ( ( int ) missing_errfile_declaration ) )
#endif
/** Derive PXENV_STATUS code from gPXE error number */ /** Derive PXENV_STATUS code from gPXE error number */
#define PXENV_STATUS( rc ) ( (-(rc)) & 0x00ff ) #define PXENV_STATUS( rc ) ( (-(rc)) & 0x00ff )
@ -178,262 +210,297 @@
*/ */
/** Operation completed successfully */ /** Operation completed successfully */
#define ENOERR ( PXENV_STATUS_SUCCESS | 0x0000 ) #define ENOERR ( ERRFILE | PXENV_STATUS_SUCCESS | 0x00000000 )
/** Arg list too long */ /** Arg list too long */
#define E2BIG ( PXENV_STATUS_BAD_FUNC | 0x0100 ) #define E2BIG ( ERRFILE | PXENV_STATUS_BAD_FUNC | 0x01000000 )
/** Permission denied */ /** Permission denied */
#define EACCES ( PXENV_STATUS_TFTP_ACCESS_VIOLATION | 0x0200 ) #define EACCES ( ERRFILE | PXENV_STATUS_TFTP_ACCESS_VIOLATION | 0x02000000 )
/** Address in use */ /** Address in use */
#define EADDRINUSE ( PXENV_STATUS_UDP_OPEN | 0x0300 ) #define EADDRINUSE ( ERRFILE | PXENV_STATUS_UDP_OPEN | 0x03000000 )
/** Address not available */ /** Address not available */
#define EADDRNOTAVAIL ( PXENV_STATUS_UDP_OPEN | 0x0400 ) #define EADDRNOTAVAIL ( ERRFILE | PXENV_STATUS_UDP_OPEN | 0x04000000 )
/** Address family not supported */ /** Address family not supported */
#define EAFNOSUPPORT ( PXENV_STATUS_UNSUPPORTED | 0x0500 ) #define EAFNOSUPPORT ( ERRFILE | PXENV_STATUS_UNSUPPORTED | 0x05000000 )
/** Resource temporarily unavailable */ /** Resource temporarily unavailable */
#define EAGAIN ( PXENV_STATUS_FAILURE | 0x0600 ) #define EAGAIN ( ERRFILE | PXENV_STATUS_FAILURE | 0x06000000 )
/** Connection already in progress */ /** Connection already in progress */
#define EALREADY ( PXENV_STATUS_UDP_OPEN | 0x0700 ) #define EALREADY ( ERRFILE | PXENV_STATUS_UDP_OPEN | 0x07000000 )
/** Bad file descriptor */ /** Bad file descriptor */
#define EBADF ( PXENV_STATUS_TFTP_CLOSED | 0x0800 ) #define EBADF ( ERRFILE | PXENV_STATUS_TFTP_CLOSED | 0x08000000 )
/** Bad message */ /** Bad message */
#define EBADMSG ( PXENV_STATUS_FAILURE | 0x0900 ) #define EBADMSG ( ERRFILE | PXENV_STATUS_FAILURE | 0x09000000 )
/** Resource busy */ /** Resource busy */
#define EBUSY ( PXENV_STATUS_OUT_OF_RESOURCES | 0x0a00 ) #define EBUSY ( ERRFILE | PXENV_STATUS_OUT_OF_RESOURCES | 0x0a000000 )
/** Operation canceled */ /** Operation canceled */
#define ECANCELED ( PXENV_STATUS_BINL_CANCELED_BY_KEYSTROKE | 0x0b00 ) #define ECANCELED \
( ERRFILE | PXENV_STATUS_BINL_CANCELED_BY_KEYSTROKE | 0x0b000000 )
/** No child processes */ /** No child processes */
#define ECHILD ( PXENV_STATUS_TFTP_FILE_NOT_FOUND | 0x0c00 ) #define ECHILD ( ERRFILE | PXENV_STATUS_TFTP_FILE_NOT_FOUND | 0x0c000000 )
/** Connection aborted */ /** Connection aborted */
#define ECONNABORTED ( PXENV_STATUS_TFTP_CANNOT_READ_FROM_CONNECTION | 0x0d00 ) #define ECONNABORTED \
( ERRFILE | PXENV_STATUS_TFTP_CANNOT_READ_FROM_CONNECTION | 0x0d000000 )
/** Connection refused */ /** Connection refused */
#define ECONNREFUSED ( PXENV_STATUS_TFTP_CANNOT_OPEN_CONNECTION | 0x0e00 ) #define ECONNREFUSED \
( ERRFILE | PXENV_STATUS_TFTP_CANNOT_OPEN_CONNECTION | 0x0e000000 )
/** Connection reset */ /** Connection reset */
#define ECONNRESET ( PXENV_STATUS_TFTP_CANNOT_READ_FROM_CONNECTION | 0x0f00 ) #define ECONNRESET \
( ERRFILE | PXENV_STATUS_TFTP_CANNOT_READ_FROM_CONNECTION | 0x0f000000 )
/** Resource deadlock avoided */ /** Resource deadlock avoided */
#define EDEADLK ( PXENV_STATUS_FAILURE | 0x1000 ) #define EDEADLK ( ERRFILE | PXENV_STATUS_FAILURE | 0x10000000 )
/** Destination address required */ /** Destination address required */
#define EDESTADDRREQ ( PXENV_STATUS_BAD_FUNC | 0x1100 ) #define EDESTADDRREQ ( ERRFILE | PXENV_STATUS_BAD_FUNC | 0x11000000 )
/** Domain error */ /** Domain error */
#define EDOM ( PXENV_STATUS_FAILURE | 0x1200 ) #define EDOM ( ERRFILE | PXENV_STATUS_FAILURE | 0x12000000 )
/** Reserved */ /** Reserved */
#define EDQUOT ( PXENV_STATUS_FAILURE | 0x1300 ) #define EDQUOT ( ERRFILE | PXENV_STATUS_FAILURE | 0x13000000 )
/** File exists */ /** File exists */
#define EEXIST ( PXENV_STATUS_FAILURE | 0x1400 ) #define EEXIST ( ERRFILE | PXENV_STATUS_FAILURE | 0x14000000 )
/** Bad address */ /** Bad address */
#define EFAULT ( PXENV_STATUS_MCOPY_PROBLEM | 0x1500 ) #define EFAULT ( ERRFILE | PXENV_STATUS_MCOPY_PROBLEM | 0x15000000 )
/** File too large */ /** File too large */
#define EFBIG ( PXENV_STATUS_MCOPY_PROBLEM | 0x1600 ) #define EFBIG ( ERRFILE | PXENV_STATUS_MCOPY_PROBLEM | 0x16000000 )
/** Host is unreachable */ /** Host is unreachable */
#define EHOSTUNREACH ( PXENV_STATUS_ARP_TIMEOUT | 0x1700 ) #define EHOSTUNREACH ( ERRFILE | PXENV_STATUS_ARP_TIMEOUT | 0x17000000 )
/** Identifier removed */ /** Identifier removed */
#define EIDRM ( PXENV_STATUS_FAILURE | 0x1800 ) #define EIDRM ( ERRFILE | PXENV_STATUS_FAILURE | 0x18000000 )
/** Illegal byte sequence */ /** Illegal byte sequence */
#define EILSEQ ( PXENV_STATUS_FAILURE | 0x1900 ) #define EILSEQ ( ERRFILE | PXENV_STATUS_FAILURE | 0x19000000 )
/** Operation in progress */ /** Operation in progress */
#define EINPROGRESS ( PXENV_STATUS_FAILURE | 0x1a00 ) #define EINPROGRESS ( ERRFILE | PXENV_STATUS_FAILURE | 0x1a000000 )
/** Interrupted function call */ /** Interrupted function call */
#define EINTR ( PXENV_STATUS_FAILURE | 0x1b00 ) #define EINTR ( ERRFILE | PXENV_STATUS_FAILURE | 0x1b000000 )
/** Invalid argument */ /** Invalid argument */
#define EINVAL ( PXENV_STATUS_BAD_FUNC | 0x1c00 ) #define EINVAL ( ERRFILE | PXENV_STATUS_BAD_FUNC | 0x1c000000 )
/** Input/output error */ /** Input/output error */
#define EIO ( PXENV_STATUS_TFTP_CANNOT_READ_FROM_CONNECTION | 0x1d00 ) #define EIO \
( ERRFILE | PXENV_STATUS_TFTP_CANNOT_READ_FROM_CONNECTION | 0x1d000000 )
/** Socket is connected */ /** Socket is connected */
#define EISCONN ( PXENV_STATUS_UDP_OPEN | 0x1e00 ) #define EISCONN ( ERRFILE | PXENV_STATUS_UDP_OPEN | 0x1e000000 )
/** Is a directory */ /** Is a directory */
#define EISDIR ( PXENV_STATUS_FAILURE | 0x1f00 ) #define EISDIR ( ERRFILE | PXENV_STATUS_FAILURE | 0x1f000000 )
/** Too many levels of symbolic links */ /** Too many levels of symbolic links */
#define ELOOP ( PXENV_STATUS_FAILURE | 0x2000 ) #define ELOOP ( ERRFILE | PXENV_STATUS_FAILURE | 0x20000000 )
/** Too many open files */ /** Too many open files */
#define EMFILE ( PXENV_STATUS_OUT_OF_RESOURCES | 0x2100 ) #define EMFILE ( ERRFILE | PXENV_STATUS_OUT_OF_RESOURCES | 0x21000000 )
/** Too many links */ /** Too many links */
#define EMLINK ( PXENV_STATUS_FAILURE | 0x2200 ) #define EMLINK ( ERRFILE | PXENV_STATUS_FAILURE | 0x22000000 )
/** Inappropriate message buffer length */ /** Inappropriate message buffer length */
#define EMSGSIZE ( PXENV_STATUS_BAD_FUNC | 0x2300 ) #define EMSGSIZE ( ERRFILE | PXENV_STATUS_BAD_FUNC | 0x23000000 )
/** Reserved */ /** Reserved */
#define EMULTIHOP ( PXENV_STATUS_FAILURE | 0x2400 ) #define EMULTIHOP ( ERRFILE | PXENV_STATUS_FAILURE | 0x24000000 )
/** Filename too long */ /** Filename too long */
#define ENAMETOOLONG ( PXENV_STATUS_FAILURE | 0x2500 ) #define ENAMETOOLONG ( ERRFILE | PXENV_STATUS_FAILURE | 0x25000000 )
/** Network is down */ /** Network is down */
#define ENETDOWN ( PXENV_STATUS_ARP_TIMEOUT | 0x2600 ) #define ENETDOWN ( ERRFILE | PXENV_STATUS_ARP_TIMEOUT | 0x26000000 )
/** Connection aborted by network */ /** Connection aborted by network */
#define ENETRESET ( PXENV_STATUS_FAILURE | 0x2700 ) #define ENETRESET ( ERRFILE | PXENV_STATUS_FAILURE | 0x27000000 )
/** Network unreachable */ /** Network unreachable */
#define ENETUNREACH ( PXENV_STATUS_ARP_TIMEOUT | 0x2800 ) #define ENETUNREACH ( ERRFILE | PXENV_STATUS_ARP_TIMEOUT | 0x28000000 )
/** Too many open files in system */ /** Too many open files in system */
#define ENFILE ( PXENV_STATUS_OUT_OF_RESOURCES | 0x2900 ) #define ENFILE ( ERRFILE | PXENV_STATUS_OUT_OF_RESOURCES | 0x29000000 )
/** No buffer space available */ /** No buffer space available */
#define ENOBUFS ( PXENV_STATUS_OUT_OF_RESOURCES | 0x2a00 ) #define ENOBUFS ( ERRFILE | PXENV_STATUS_OUT_OF_RESOURCES | 0x2a000000 )
/** No message is available on the STREAM head read queue */ /** No message is available on the STREAM head read queue */
#define ENODATA ( PXENV_STATUS_FAILURE | 0x2b00 ) #define ENODATA ( ERRFILE | PXENV_STATUS_FAILURE | 0x2b000000 )
/** No such device */ /** No such device */
#define ENODEV ( PXENV_STATUS_TFTP_FILE_NOT_FOUND | 0x2c00 ) #define ENODEV ( ERRFILE | PXENV_STATUS_TFTP_FILE_NOT_FOUND | 0x2c000000 )
/** No such file or directory */ /** No such file or directory */
#define ENOENT ( PXENV_STATUS_TFTP_FILE_NOT_FOUND | 0x2d00 ) #define ENOENT ( ERRFILE | PXENV_STATUS_TFTP_FILE_NOT_FOUND | 0x2d000000 )
/** Exec format error */ /** Exec format error */
#define ENOEXEC ( PXENV_STATUS_FAILURE | 0x2e00 ) #define ENOEXEC ( ERRFILE | PXENV_STATUS_FAILURE | 0x2e000000 )
/** No locks available */ /** No locks available */
#define ENOLCK ( PXENV_STATUS_FAILURE | 0x2f00 ) #define ENOLCK ( ERRFILE | PXENV_STATUS_FAILURE | 0x2f000000 )
/** Reserved */ /** Reserved */
#define ENOLINK ( PXENV_STATUS_FAILURE | 0x3000 ) #define ENOLINK ( ERRFILE | PXENV_STATUS_FAILURE | 0x30000000 )
/** Not enough space */ /** Not enough space */
#define ENOMEM ( PXENV_STATUS_OUT_OF_RESOURCES | 0x3100 ) #define ENOMEM ( ERRFILE | PXENV_STATUS_OUT_OF_RESOURCES | 0x31000000 )
/** No message of the desired type */ /** No message of the desired type */
#define ENOMSG ( PXENV_STATUS_FAILURE | 0x3200 ) #define ENOMSG ( ERRFILE | PXENV_STATUS_FAILURE | 0x32000000 )
/** Protocol not available */ /** Protocol not available */
#define ENOPROTOOPT ( PXENV_STATUS_UNSUPPORTED | 0x3300 ) #define ENOPROTOOPT ( ERRFILE | PXENV_STATUS_UNSUPPORTED | 0x33000000 )
/** No space left on device */ /** No space left on device */
#define ENOSPC ( PXENV_STATUS_OUT_OF_RESOURCES | 0x3400 ) #define ENOSPC ( ERRFILE | PXENV_STATUS_OUT_OF_RESOURCES | 0x34000000 )
/** No STREAM resources */ /** No STREAM resources */
#define ENOSR ( PXENV_STATUS_OUT_OF_RESOURCES | 0x3500 ) #define ENOSR ( ERRFILE | PXENV_STATUS_OUT_OF_RESOURCES | 0x35000000 )
/** Not a STREAM */ /** Not a STREAM */
#define ENOSTR ( PXENV_STATUS_FAILURE | 0x3600 ) #define ENOSTR ( ERRFILE | PXENV_STATUS_FAILURE | 0x36000000 )
/** Function not implemented */ /** Function not implemented */
#define ENOSYS ( PXENV_STATUS_UNSUPPORTED | 0x3700 ) #define ENOSYS ( ERRFILE | PXENV_STATUS_UNSUPPORTED | 0x37000000 )
/** The socket is not connected */ /** The socket is not connected */
#define ENOTCONN ( PXENV_STATUS_FAILURE | 0x3800 ) #define ENOTCONN ( ERRFILE | PXENV_STATUS_FAILURE | 0x38000000 )
/** Not a directory */ /** Not a directory */
#define ENOTDIR ( PXENV_STATUS_FAILURE | 0x3900 ) #define ENOTDIR ( ERRFILE | PXENV_STATUS_FAILURE | 0x39000000 )
/** Directory not empty */ /** Directory not empty */
#define ENOTEMPTY ( PXENV_STATUS_FAILURE | 0x3a00 ) #define ENOTEMPTY ( ERRFILE | PXENV_STATUS_FAILURE | 0x3a000000 )
/** Not a socket */ /** Not a socket */
#define ENOTSOCK ( PXENV_STATUS_FAILURE | 0x3b00 ) #define ENOTSOCK ( ERRFILE | PXENV_STATUS_FAILURE | 0x3b000000 )
/** Not supported */ /** Not supported */
#define ENOTSUP ( PXENV_STATUS_UNSUPPORTED | 0x3c00 ) #define ENOTSUP ( ERRFILE | PXENV_STATUS_UNSUPPORTED | 0x3c000000 )
/** Inappropriate I/O control operation */ /** Inappropriate I/O control operation */
#define ENOTTY ( PXENV_STATUS_FAILURE | 0x3d00 ) #define ENOTTY ( ERRFILE | PXENV_STATUS_FAILURE | 0x3d000000 )
/** No such device or address */ /** No such device or address */
#define ENXIO ( PXENV_STATUS_TFTP_FILE_NOT_FOUND | 0x3e00 ) #define ENXIO ( ERRFILE | PXENV_STATUS_TFTP_FILE_NOT_FOUND | 0x3e000000 )
/** Operation not supported on socket */ /** Operation not supported on socket */
#define EOPNOTSUPP ( PXENV_STATUS_UNSUPPORTED | 0x3f00 ) #define EOPNOTSUPP ( ERRFILE | PXENV_STATUS_UNSUPPORTED | 0x3f000000 )
/** Value too large to be stored in data type */ /** Value too large to be stored in data type */
#define EOVERFLOW ( PXENV_STATUS_FAILURE | 0x4000 ) #define EOVERFLOW ( ERRFILE | PXENV_STATUS_FAILURE | 0x40000000 )
/** Operation not permitted */ /** Operation not permitted */
#define EPERM ( PXENV_STATUS_TFTP_ACCESS_VIOLATION | 0x4100 ) #define EPERM ( ERRFILE | PXENV_STATUS_TFTP_ACCESS_VIOLATION | 0x41000000 )
/** Broken pipe */ /** Broken pipe */
#define EPIPE ( PXENV_STATUS_FAILURE | 0x4200 ) #define EPIPE ( ERRFILE | PXENV_STATUS_FAILURE | 0x42000000 )
/** Protocol error */ /** Protocol error */
#define EPROTO ( PXENV_STATUS_FAILURE | 0x4300 ) #define EPROTO ( ERRFILE | PXENV_STATUS_FAILURE | 0x43000000 )
/** Protocol not supported */ /** Protocol not supported */
#define EPROTONOSUPPORT ( PXENV_STATUS_UNSUPPORTED | 0x4400 ) #define EPROTONOSUPPORT ( ERRFILE | PXENV_STATUS_UNSUPPORTED | 0x44000000 )
/** Protocol wrong type for socket */ /** Protocol wrong type for socket */
#define EPROTOTYPE ( PXENV_STATUS_FAILURE | 0x4500 ) #define EPROTOTYPE ( ERRFILE | PXENV_STATUS_FAILURE | 0x45000000 )
/** Result too large */ /** Result too large */
#define ERANGE ( PXENV_STATUS_FAILURE | 0x4600 ) #define ERANGE ( ERRFILE | PXENV_STATUS_FAILURE | 0x46000000 )
/** Read-only file system */ /** Read-only file system */
#define EROFS ( PXENV_STATUS_FAILURE | 0x4700 ) #define EROFS ( ERRFILE | PXENV_STATUS_FAILURE | 0x47000000 )
/** Invalid seek */ /** Invalid seek */
#define ESPIPE ( PXENV_STATUS_FAILURE | 0x4800 ) #define ESPIPE ( ERRFILE | PXENV_STATUS_FAILURE | 0x48000000 )
/** No such process */ /** No such process */
#define ESRCH ( PXENV_STATUS_TFTP_FILE_NOT_FOUND | 0x4900 ) #define ESRCH ( ERRFILE | PXENV_STATUS_TFTP_FILE_NOT_FOUND | 0x49000000 )
/** Stale file handle */ /** Stale file handle */
#define ESTALE ( PXENV_STATUS_FAILURE | 0x4a00 ) #define ESTALE ( ERRFILE | PXENV_STATUS_FAILURE | 0x4a000000 )
/** STREAM ioctl() timeout */ /** STREAM ioctl() timeout */
#define ETIME ( PXENV_STATUS_FAILURE | 0x4b00 ) #define ETIME ( ERRFILE | PXENV_STATUS_FAILURE | 0x4b000000 )
/** Operation timed out */ /** Operation timed out */
#define ETIMEDOUT ( PXENV_STATUS_TFTP_READ_TIMEOUT | 0x4c00 ) #define ETIMEDOUT ( ERRFILE | PXENV_STATUS_TFTP_READ_TIMEOUT | 0x4c000000 )
/** Text file busy */ /** Text file busy */
#define ETXTBSY ( PXENV_STATUS_FAILURE | 0x4d00 ) #define ETXTBSY ( ERRFILE | PXENV_STATUS_FAILURE | 0x4d000000 )
/** Operation would block */ /** Operation would block */
#define EWOULDBLOCK ( PXENV_STATUS_FAILURE | 0x4e00 ) #define EWOULDBLOCK ( ERRFILE | PXENV_STATUS_FAILURE | 0x4e000000 )
/** Improper link */ /** Improper link */
#define EXDEV ( PXENV_STATUS_FAILURE | 0x4f00 ) #define EXDEV ( ERRFILE | PXENV_STATUS_FAILURE | 0x4f000000 )
/** @} */ /** @} */
/** /**
* @defgroup gpxeerrors gPXE-specific error codes * @defgroup euniq Per-file error disambiguators
* *
* The names, meanings, and values of these error codes are defined by * Files which use the same error number multiple times should
* this file. A gPXE-specific error code should be defined only where * probably define their own error subspace using these
* the POSIX error code does not identify the error with sufficient * disambiguators. For example:
* specificity. For example, ENOMEM probably encapsulates everything *
* that needs to be known about the error (we've run out of heap * #define ETCP_HEADER_TOO_SHORT EUNIQ_01
* space), while EACCES does not (did the server refuse the * #define ETCP_BAD_CHECKSUM EUNIQ_02
* connection, or did we decide that the server failed to provide a
* valid SSL/TLS certificate?).
* *
* @{ * @{
*/ */
#define EUNIQ_01 0x00000100
#define EUNIQ_02 0x00000200
#define EUNIQ_03 0x00000300
#define EUNIQ_04 0x00000400
#define EUNIQ_05 0x00000500
#define EUNIQ_06 0x00000600
#define EUNIQ_07 0x00000700
#define EUNIQ_08 0x00000800
#define EUNIQ_09 0x00000900
#define EUNIQ_0A 0x00000a00
#define EUNIQ_0B 0x00000b00
#define EUNIQ_0C 0x00000c00
#define EUNIQ_0D 0x00000d00
#define EUNIQ_0E 0x00000e00
#define EUNIQ_0F 0x00000f00
#define EUNIQ_10 0x00001000
#define EUNIQ_11 0x00001100
#define EUNIQ_12 0x00001200
#define EUNIQ_13 0x00001300
#define EUNIQ_14 0x00001400
#define EUNIQ_15 0x00001500
#define EUNIQ_16 0x00001600
#define EUNIQ_17 0x00001700
#define EUNIQ_18 0x00001800
#define EUNIQ_19 0x00001900
#define EUNIQ_1A 0x00001a00
#define EUNIQ_1B 0x00001b00
#define EUNIQ_1C 0x00001c00
#define EUNIQ_1D 0x00001d00
#define EUNIQ_1E 0x00001e00
#define EUNIQ_1F 0x00001f00
/** @} */ /** @} */
extern int errno; extern int errno;

28
src/include/gpxe/crypto.h
View File

@ -9,7 +9,6 @@
#include <stdint.h> #include <stdint.h>
#include <stddef.h> #include <stddef.h>
#include <errno.h>
/** A cryptographic algorithm */ /** A cryptographic algorithm */
struct crypto_algorithm { struct crypto_algorithm {
@ -101,30 +100,17 @@ static inline int cipher_setkey ( struct crypto_algorithm *crypto,
return crypto->setkey ( ctx, key, keylen ); return crypto->setkey ( ctx, key, keylen );
} }
static inline int cipher_encrypt ( struct crypto_algorithm *crypto,
void *ctx, const void *src, void *dst,
size_t len ) {
if ( ( len & ( crypto->blocksize - 1 ) ) ) {
return -EINVAL;
}
crypto->encode ( ctx, src, dst, len );
return 0;
}
static inline int cipher_decrypt ( struct crypto_algorithm *crypto,
void *ctx, const void *src, void *dst,
size_t len ) {
if ( ( len & ( crypto->blocksize - 1 ) ) ) {
return -EINVAL;
}
crypto->decode ( ctx, src, dst, len );
return 0;
}
static inline int is_stream_cipher ( struct crypto_algorithm *crypto ) { static inline int is_stream_cipher ( struct crypto_algorithm *crypto ) {
return ( crypto->blocksize == 1 ); return ( crypto->blocksize == 1 );
} }
extern struct crypto_algorithm crypto_null; extern struct crypto_algorithm crypto_null;
extern int cipher_encrypt ( struct crypto_algorithm *crypto,
void *ctx, const void *src, void *dst,
size_t len );
extern int cipher_decrypt ( struct crypto_algorithm *crypto,
void *ctx, const void *src, void *dst,
size_t len );
#endif /* _GPXE_CRYPTO_H */ #endif /* _GPXE_CRYPTO_H */

121
src/include/gpxe/errfile.h Normal file
View File

@ -0,0 +1,121 @@
#ifndef _GPXE_ERRFILE_H
#define _GPXE_ERRFILE_H
/** @file
*
* Error file identifiers
*
*/
#include <bits/errfile.h>
/**
* @defgroup errfilecat Error file identifier categories
*
* @{
*/
#define ERRFILE_CORE 0x00002000 /**< Core code */
#define ERRFILE_DRIVER 0x00004000 /**< Driver code */
#define ERRFILE_NET 0x00006000 /**< Networking code */
#define ERRFILE_IMAGE 0x00008000 /**< Image code */
#define ERRFILE_OTHER 0x0000e000 /**< Any other code */
/** @} */
/** Flag for architecture-dependent error files */
#define ERRFILE_ARCH 0x00800000
/**
* @defgroup errfile Error file identifiers
*
* These values are automatically incorporated into the definitions
* for error numbers such as EINVAL.
*
* @{
*/
#define ERRFILE_asprintf ( ERRFILE_CORE | 0x00000000 )
#define ERRFILE_downloader ( ERRFILE_CORE | 0x00010000 )
#define ERRFILE_exec ( ERRFILE_CORE | 0x00020000 )
#define ERRFILE_hw ( ERRFILE_CORE | 0x00030000 )
#define ERRFILE_iobuf ( ERRFILE_CORE | 0x00040000 )
#define ERRFILE_job ( ERRFILE_CORE | 0x00050000 )
#define ERRFILE_linebuf ( ERRFILE_CORE | 0x00060000 )
#define ERRFILE_monojob ( ERRFILE_CORE | 0x00070000 )
#define ERRFILE_nvo ( ERRFILE_CORE | 0x00080000 )
#define ERRFILE_open ( ERRFILE_CORE | 0x00090000 )
#define ERRFILE_posix_io ( ERRFILE_CORE | 0x000a0000 )
#define ERRFILE_resolv ( ERRFILE_CORE | 0x000b0000 )
#define ERRFILE_settings ( ERRFILE_CORE | 0x000c0000 )
#define ERRFILE_vsprintf ( ERRFILE_CORE | 0x000d0000 )
#define ERRFILE_xfer ( ERRFILE_CORE | 0x000e0000 )
#define ERRFILE_eisa ( ERRFILE_DRIVER | 0x00000000 )
#define ERRFILE_isa ( ERRFILE_DRIVER | 0x00010000 )
#define ERRFILE_isapnp ( ERRFILE_DRIVER | 0x00020000 )
#define ERRFILE_mca ( ERRFILE_DRIVER | 0x00030000 )
#define ERRFILE_pci ( ERRFILE_DRIVER | 0x00040000 )
#define ERRFILE_nvs ( ERRFILE_DRIVER | 0x00100000 )
#define ERRFILE_spi ( ERRFILE_DRIVER | 0x00110000 )
#define ERRFILE_i2c_bit ( ERRFILE_DRIVER | 0x00120000 )
#define ERRFILE_spi_bit ( ERRFILE_DRIVER | 0x00130000 )
#define ERRFILE_3c509 ( ERRFILE_DRIVER | 0x00200000 )
#define ERRFILE_bnx2 ( ERRFILE_DRIVER | 0x00210000 )
#define ERRFILE_cs89x0 ( ERRFILE_DRIVER | 0x00220000 )
#define ERRFILE_eepro ( ERRFILE_DRIVER | 0x00230000 )
#define ERRFILE_etherfabric ( ERRFILE_DRIVER | 0x00240000 )
#define ERRFILE_legacy ( ERRFILE_DRIVER | 0x00250000 )
#define ERRFILE_natsemi ( ERRFILE_DRIVER | 0x00260000 )
#define ERRFILE_pnic ( ERRFILE_DRIVER | 0x00270000 )
#define ERRFILE_prism2_pci ( ERRFILE_DRIVER | 0x00280000 )
#define ERRFILE_prism2_plx ( ERRFILE_DRIVER | 0x00290000 )
#define ERRFILE_rtl8139 ( ERRFILE_DRIVER | 0x002a0000 )
#define ERRFILE_smc9000 ( ERRFILE_DRIVER | 0x002b0000 )
#define ERRFILE_tg3 ( ERRFILE_DRIVER | 0x002c0000 )
#define ERRFILE_scsi ( ERRFILE_DRIVER | 0x00700000 )
#define ERRFILE_aoe ( ERRFILE_NET | 0x00000000 )
#define ERRFILE_arp ( ERRFILE_NET | 0x00010000 )
#define ERRFILE_dhcpopts ( ERRFILE_NET | 0x00020000 )
#define ERRFILE_ethernet ( ERRFILE_NET | 0x00030000 )
#define ERRFILE_icmpv6 ( ERRFILE_NET | 0x00040000 )
#define ERRFILE_ipv4 ( ERRFILE_NET | 0x00050000 )
#define ERRFILE_ipv6 ( ERRFILE_NET | 0x00060000 )
#define ERRFILE_ndp ( ERRFILE_NET | 0x00070000 )
#define ERRFILE_netdevice ( ERRFILE_NET | 0x00080000 )
#define ERRFILE_nullnet ( ERRFILE_NET | 0x00090000 )
#define ERRFILE_tcp ( ERRFILE_NET | 0x000a0000 )
#define ERRFILE_ftp ( ERRFILE_NET | 0x000b0000 )
#define ERRFILE_http ( ERRFILE_NET | 0x000c0000 )
#define ERRFILE_iscsi ( ERRFILE_NET | 0x000d0000 )
#define ERRFILE_tcpip ( ERRFILE_NET | 0x000e0000 )
#define ERRFILE_udp ( ERRFILE_NET | 0x000f0000 )
#define ERRFILE_dhcp ( ERRFILE_NET | 0x00100000 )
#define ERRFILE_dns ( ERRFILE_NET | 0x00110000 )
#define ERRFILE_tftp ( ERRFILE_NET | 0x00120000 )
#define ERRFILE_image ( ERRFILE_IMAGE | 0x00000000 )
#define ERRFILE_elf ( ERRFILE_IMAGE | 0x00010000 )
#define ERRFILE_script ( ERRFILE_IMAGE | 0x00020000 )
#define ERRFILE_segment ( ERRFILE_IMAGE | 0x00030000 )
#define ERRFILE_asn1 ( ERRFILE_OTHER | 0x00000000 )
#define ERRFILE_chap ( ERRFILE_OTHER | 0x00010000 )
#define ERRFILE_aoeboot ( ERRFILE_OTHER | 0x00020000 )
#define ERRFILE_autoboot ( ERRFILE_OTHER | 0x00030000 )
#define ERRFILE_dhcpmgmt ( ERRFILE_OTHER | 0x00040000 )
#define ERRFILE_imgmgmt ( ERRFILE_OTHER | 0x00050000 )
#define ERRFILE_pxe_tftp ( ERRFILE_OTHER | 0x00060000 )
#define ERRFILE_pxe_udp ( ERRFILE_OTHER | 0x00070000 )
#define ERRFILE_axtls_aes ( ERRFILE_OTHER | 0x00080000 )
#define ERRFILE_cipher ( ERRFILE_OTHER | 0x00090000 )
#define ERRFILE_image_cmd ( ERRFILE_OTHER | 0x000a0000 )
#define ERRFILE_uri_test ( ERRFILE_OTHER | 0x000b0000 )
/** @} */
#endif /* _GPXE_ERRFILE_H */

1
src/include/gpxe/errortab.h
View File

@ -7,7 +7,6 @@
* *
*/ */
#include <errno.h>
#include <gpxe/tables.h> #include <gpxe/tables.h>
struct errortab { struct errortab {

20
src/include/gpxe/iobuf.h
View File

@ -9,7 +9,6 @@
#include <stdint.h> #include <stdint.h>
#include <assert.h> #include <assert.h>
#include <errno.h>
#include <gpxe/list.h> #include <gpxe/list.h>
/** /**
@ -162,26 +161,9 @@ static inline size_t iob_tailroom ( struct io_buffer *iobuf ) {
return ( iobuf->end - iobuf->tail ); return ( iobuf->end - iobuf->tail );
} }
/**
* Ensure I/O buffer has sufficient headroom
*
* @v iobuf I/O buffer
* @v len Required headroom
*
* This function currently only checks for the required headroom; it
* does not reallocate the I/O buffer if required. If we ever have a
* code path that requires this functionality, it's a fairly trivial
* change to make.
*/
static inline __attribute__ (( always_inline )) int
iob_ensure_headroom ( struct io_buffer *iobuf, size_t len ) {
if ( iob_headroom ( iobuf ) >= len )
return 0;
return -ENOBUFS;
}
extern struct io_buffer * alloc_iob ( size_t len ); extern struct io_buffer * alloc_iob ( size_t len );
extern void free_iob ( struct io_buffer *iobuf ); extern void free_iob ( struct io_buffer *iobuf );
extern void iob_pad ( struct io_buffer *iobuf, size_t min_len ); extern void iob_pad ( struct io_buffer *iobuf, size_t min_len );
extern int iob_ensure_headroom ( struct io_buffer *iobuf, size_t len );
#endif /* _GPXE_IOBUF_H */ #endif /* _GPXE_IOBUF_H */

1
src/include/gpxe/ndp.h
View File

@ -1,6 +1,5 @@
#include <stdint.h> #include <stdint.h>
#include <byteswap.h> #include <byteswap.h>
#include <errno.h>
#include <string.h> #include <string.h>
#include <gpxe/icmp6.h> #include <gpxe/icmp6.h>
#include <gpxe/ip6.h> #include <gpxe/ip6.h>

1
src/interface/pxe/pxe_errors.c
View File

@ -1,3 +1,4 @@
#include <errno.h>
#include <gpxe/errortab.h> #include <gpxe/errortab.h>
/* /*

1
src/interface/pxe/pxe_tftp.c
View File

@ -24,6 +24,7 @@
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>
#include <errno.h>
#include <byteswap.h> #include <byteswap.h>
#include <gpxe/uaccess.h> #include <gpxe/uaccess.h>
#include <gpxe/in.h> #include <gpxe/in.h>

1
src/net/nullnet.c
View File

@ -17,6 +17,7 @@
*/ */
#include <stdint.h> #include <stdint.h>
#include <errno.h>
#include <gpxe/iobuf.h> #include <gpxe/iobuf.h>
#include <gpxe/netdevice.h> #include <gpxe/netdevice.h>

22
src/net/tcp.c
View File

@ -395,7 +395,6 @@ static int tcp_xmit ( struct tcp_connection *tcp, int force_send ) {
size_t seq_len; size_t seq_len;
size_t app_win; size_t app_win;
size_t rcv_win; size_t rcv_win;
int rc;
/* If retransmission timer is already running, do nothing */ /* If retransmission timer is already running, do nothing */
if ( timer_running ( &tcp->timer ) ) if ( timer_running ( &tcp->timer ) )
@ -485,25 +484,8 @@ static int tcp_xmit ( struct tcp_connection *tcp, int force_send ) {
DBGC ( tcp, "\n" ); DBGC ( tcp, "\n" );
/* Transmit packet */ /* Transmit packet */
rc = tcpip_tx ( iobuf, &tcp_protocol, &tcp->peer, NULL, &tcphdr->csum ); return tcpip_tx ( iobuf, &tcp_protocol, &tcp->peer, NULL,
&tcphdr->csum );
/* If we got -ENETUNREACH, kill the connection immediately
* because there is no point retrying. This isn't strictly
* necessary (since we will eventually time out anyway), but
* it avoids irritating needless delays. Don't do this for
* RST packets transmitted on connection abort, to avoid a
* potential infinite loop.
*/
if ( ( ! ( tcp->tcp_state & TCP_STATE_SENT ( TCP_RST ) ) ) &&
( rc == -ENETUNREACH ) ) {
DBGC ( tcp, "TCP %p aborting after TX failed: %s\n",
tcp, strerror ( rc ) );
tcp->tcp_state = TCP_CLOSED;
tcp_dump_state ( tcp );
tcp_close ( tcp, rc );
}
return rc;
} }
/** /**