2007-08-10 02:44:20 +02:00
|
|
|
/*
|
|
|
|
|
* Copyright Fen Systems Ltd. 2007. Portions of this code are derived
|
|
|
|
|
* from IBM Corporation Sample Programs. Copyright IBM Corporation
|
|
|
|
|
* 2004, 2007. All rights reserved.
|
|
|
|
|
*
|
|
|
|
|
* Permission is hereby granted, free of charge, to any person
|
|
|
|
|
* obtaining a copy of this software and associated documentation
|
|
|
|
|
* files (the "Software"), to deal in the Software without
|
|
|
|
|
* restriction, including without limitation the rights to use, copy,
|
|
|
|
|
* modify, merge, publish, distribute, sublicense, and/or sell copies
|
|
|
|
|
* of the Software, and to permit persons to whom the Software is
|
|
|
|
|
* furnished to do so, subject to the following conditions:
|
|
|
|
|
*
|
|
|
|
|
* The above copyright notice and this permission notice shall be
|
|
|
|
|
* included in all copies or substantial portions of the Software.
|
|
|
|
|
*
|
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
|
|
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
|
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
|
|
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
|
|
|
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
|
|
|
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
|
|
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
|
|
|
* SOFTWARE.
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
|
2009-05-01 16:41:06 +02:00
|
|
|
FILE_LICENCE ( BSD2 );
|
|
|
|
|
|
2007-08-10 02:44:20 +02:00
|
|
|
#include <stdint.h>
|
|
|
|
|
#include <stdio.h>
|
|
|
|
|
#include <string.h>
|
|
|
|
|
#include <errno.h>
|
|
|
|
|
#include <byteswap.h>
|
2010-04-19 21:16:01 +02:00
|
|
|
#include <ipxe/pci.h>
|
|
|
|
|
#include <ipxe/acpi.h>
|
|
|
|
|
#include <ipxe/in.h>
|
|
|
|
|
#include <ipxe/netdevice.h>
|
|
|
|
|
#include <ipxe/ethernet.h>
|
2013-03-01 16:32:16 +01:00
|
|
|
#include <ipxe/vlan.h>
|
2010-04-19 21:16:01 +02:00
|
|
|
#include <ipxe/dhcp.h>
|
|
|
|
|
#include <ipxe/iscsi.h>
|
|
|
|
|
#include <ipxe/ibft.h>
|
2007-08-10 02:44:20 +02:00
|
|
|
|
|
|
|
|
/** @file
|
|
|
|
|
*
|
|
|
|
|
* iSCSI boot firmware table
|
|
|
|
|
*
|
|
|
|
|
* The information in this file is derived from the document "iSCSI
|
|
|
|
|
* Boot Firmware Table (iBFT)" as published by IBM at
|
|
|
|
|
*
|
|
|
|
|
* ftp://ftp.software.ibm.com/systems/support/system_x_pdf/ibm_iscsi_boot_firmware_table_v1.02.pdf
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
|
[block] Replace gPXE block-device API with an iPXE asynchronous interface
The block device interface used in gPXE predates the invention of even
the old gPXE data-transfer interface, let alone the current iPXE
generic asynchronous interface mechanism. Bring this old code up to
date, with the following benefits:
o Block device commands can be cancelled by the requestor. The INT 13
layer uses this to provide a global timeout on all INT 13 calls,
with the result that an unexpected passive failure mode (such as
an iSCSI target ACKing the request but never sending a response)
will lead to a timeout that gets reported back to the INT 13 user,
rather than simply freezing the system.
o INT 13,00 (reset drive) is now able to reset the underlying block
device. INT 13 users, such as DOS, that use INT 13,00 as a method
for error recovery now have a chance of recovering.
o All block device commands are tagged, with a numerical tag that
will show up in debugging output and in packet captures; this will
allow easier interpretation of bug reports that include both
sources of information.
o The extremely ugly hacks used to generate the boot firmware tables
have been eradicated and replaced with a generic acpi_describe()
method (exploiting the ability of iPXE interfaces to pass through
methods to an underlying interface). The ACPI tables are now
built in a shared data block within .bss16, rather than each
requiring dedicated space in .data16.
o The architecture-independent concept of a SAN device has been
exposed to the iPXE core through the sanboot API, which provides
calls to hook, unhook, boot, and describe SAN devices. This
allows for much more flexible usage patterns (such as hooking an
empty SAN device and then running an OS installer via TFTP).
Signed-off-by: Michael Brown <mcb30@ipxe.org>
2010-09-03 17:11:51 +02:00
|
|
|
/**
|
|
|
|
|
* An iBFT created by iPXE
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
struct ipxe_ibft {
|
|
|
|
|
/** The fixed section */
|
|
|
|
|
struct ibft_table table;
|
|
|
|
|
/** The Initiator section */
|
|
|
|
|
struct ibft_initiator initiator __attribute__ (( aligned ( 16 ) ));
|
|
|
|
|
/** The NIC section */
|
|
|
|
|
struct ibft_nic nic __attribute__ (( aligned ( 16 ) ));
|
|
|
|
|
/** The Target section */
|
|
|
|
|
struct ibft_target target __attribute__ (( aligned ( 16 ) ));
|
|
|
|
|
/** Strings block */
|
|
|
|
|
char strings[0];
|
|
|
|
|
} __attribute__ (( packed, aligned ( 16 ) ));
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* iSCSI string block descriptor
|
|
|
|
|
*
|
|
|
|
|
* This is an internal structure that we use to keep track of the
|
|
|
|
|
* allocation of string data.
|
|
|
|
|
*/
|
|
|
|
|
struct ibft_strings {
|
|
|
|
|
/** The iBFT containing these strings */
|
|
|
|
|
struct ibft_table *table;
|
|
|
|
|
/** Offset of first free byte within iBFT */
|
|
|
|
|
size_t offset;
|
|
|
|
|
/** Total length of the iBFT */
|
|
|
|
|
size_t len;
|
2007-08-10 02:44:20 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Fill in an IP address field within iBFT
|
|
|
|
|
*
|
|
|
|
|
* @v ipaddr IP address field
|
|
|
|
|
* @v in IPv4 address
|
|
|
|
|
*/
|
|
|
|
|
static void ibft_set_ipaddr ( struct ibft_ipaddr *ipaddr, struct in_addr in ) {
|
2011-02-25 00:39:38 +01:00
|
|
|
memset ( ipaddr, 0, sizeof ( *ipaddr ) );
|
2007-08-10 02:44:20 +02:00
|
|
|
if ( in.s_addr ) {
|
|
|
|
|
ipaddr->in = in;
|
|
|
|
|
ipaddr->ones = 0xffff;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
2008-03-25 21:46:16 +01:00
|
|
|
* Fill in an IP address within iBFT from configuration setting
|
2007-08-10 02:44:20 +02:00
|
|
|
*
|
|
|
|
|
* @v ipaddr IP address field
|
2008-03-25 21:46:16 +01:00
|
|
|
* @v setting Configuration setting
|
2010-12-09 16:35:02 +01:00
|
|
|
* @v count Maximum number of IP addresses
|
2007-08-10 02:44:20 +02:00
|
|
|
*/
|
[block] Replace gPXE block-device API with an iPXE asynchronous interface
The block device interface used in gPXE predates the invention of even
the old gPXE data-transfer interface, let alone the current iPXE
generic asynchronous interface mechanism. Bring this old code up to
date, with the following benefits:
o Block device commands can be cancelled by the requestor. The INT 13
layer uses this to provide a global timeout on all INT 13 calls,
with the result that an unexpected passive failure mode (such as
an iSCSI target ACKing the request but never sending a response)
will lead to a timeout that gets reported back to the INT 13 user,
rather than simply freezing the system.
o INT 13,00 (reset drive) is now able to reset the underlying block
device. INT 13 users, such as DOS, that use INT 13,00 as a method
for error recovery now have a chance of recovering.
o All block device commands are tagged, with a numerical tag that
will show up in debugging output and in packet captures; this will
allow easier interpretation of bug reports that include both
sources of information.
o The extremely ugly hacks used to generate the boot firmware tables
have been eradicated and replaced with a generic acpi_describe()
method (exploiting the ability of iPXE interfaces to pass through
methods to an underlying interface). The ACPI tables are now
built in a shared data block within .bss16, rather than each
requiring dedicated space in .data16.
o The architecture-independent concept of a SAN device has been
exposed to the iPXE core through the sanboot API, which provides
calls to hook, unhook, boot, and describe SAN devices. This
allows for much more flexible usage patterns (such as hooking an
empty SAN device and then running an OS installer via TFTP).
Signed-off-by: Michael Brown <mcb30@ipxe.org>
2010-09-03 17:11:51 +02:00
|
|
|
static void ibft_set_ipaddr_setting ( struct ibft_ipaddr *ipaddr,
|
2013-12-03 17:48:56 +01:00
|
|
|
const struct setting *setting,
|
2010-12-09 16:35:02 +01:00
|
|
|
unsigned int count ) {
|
|
|
|
|
struct in_addr in[count];
|
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
|
|
fetch_ipv4_array_setting ( NULL, setting, in, count );
|
|
|
|
|
for ( i = 0 ; i < count ; i++ ) {
|
|
|
|
|
ibft_set_ipaddr ( &ipaddr[i], in[i] );
|
|
|
|
|
}
|
2007-08-10 02:44:20 +02:00
|
|
|
}
|
|
|
|
|
|
2009-02-20 22:41:00 +01:00
|
|
|
/**
|
|
|
|
|
* Read IP address from iBFT (for debugging)
|
|
|
|
|
*
|
|
|
|
|
* @v strings iBFT string block descriptor
|
|
|
|
|
* @v string String field
|
|
|
|
|
* @ret ipaddr IP address string
|
|
|
|
|
*/
|
|
|
|
|
static const char * ibft_ipaddr ( struct ibft_ipaddr *ipaddr ) {
|
|
|
|
|
return inet_ntoa ( ipaddr->in );
|
|
|
|
|
}
|
|
|
|
|
|
2007-08-10 02:44:20 +02:00
|
|
|
/**
|
2008-03-21 01:49:44 +01:00
|
|
|
* Allocate a string within iBFT
|
2007-08-10 02:44:20 +02:00
|
|
|
*
|
|
|
|
|
* @v strings iBFT string block descriptor
|
2008-03-21 01:49:44 +01:00
|
|
|
* @v string String field to fill in
|
|
|
|
|
* @v len Length of string to allocate (excluding NUL)
|
[block] Replace gPXE block-device API with an iPXE asynchronous interface
The block device interface used in gPXE predates the invention of even
the old gPXE data-transfer interface, let alone the current iPXE
generic asynchronous interface mechanism. Bring this old code up to
date, with the following benefits:
o Block device commands can be cancelled by the requestor. The INT 13
layer uses this to provide a global timeout on all INT 13 calls,
with the result that an unexpected passive failure mode (such as
an iSCSI target ACKing the request but never sending a response)
will lead to a timeout that gets reported back to the INT 13 user,
rather than simply freezing the system.
o INT 13,00 (reset drive) is now able to reset the underlying block
device. INT 13 users, such as DOS, that use INT 13,00 as a method
for error recovery now have a chance of recovering.
o All block device commands are tagged, with a numerical tag that
will show up in debugging output and in packet captures; this will
allow easier interpretation of bug reports that include both
sources of information.
o The extremely ugly hacks used to generate the boot firmware tables
have been eradicated and replaced with a generic acpi_describe()
method (exploiting the ability of iPXE interfaces to pass through
methods to an underlying interface). The ACPI tables are now
built in a shared data block within .bss16, rather than each
requiring dedicated space in .data16.
o The architecture-independent concept of a SAN device has been
exposed to the iPXE core through the sanboot API, which provides
calls to hook, unhook, boot, and describe SAN devices. This
allows for much more flexible usage patterns (such as hooking an
empty SAN device and then running an OS installer via TFTP).
Signed-off-by: Michael Brown <mcb30@ipxe.org>
2010-09-03 17:11:51 +02:00
|
|
|
* @ret dest String destination, or NULL
|
2007-08-10 02:44:20 +02:00
|
|
|
*/
|
[block] Replace gPXE block-device API with an iPXE asynchronous interface
The block device interface used in gPXE predates the invention of even
the old gPXE data-transfer interface, let alone the current iPXE
generic asynchronous interface mechanism. Bring this old code up to
date, with the following benefits:
o Block device commands can be cancelled by the requestor. The INT 13
layer uses this to provide a global timeout on all INT 13 calls,
with the result that an unexpected passive failure mode (such as
an iSCSI target ACKing the request but never sending a response)
will lead to a timeout that gets reported back to the INT 13 user,
rather than simply freezing the system.
o INT 13,00 (reset drive) is now able to reset the underlying block
device. INT 13 users, such as DOS, that use INT 13,00 as a method
for error recovery now have a chance of recovering.
o All block device commands are tagged, with a numerical tag that
will show up in debugging output and in packet captures; this will
allow easier interpretation of bug reports that include both
sources of information.
o The extremely ugly hacks used to generate the boot firmware tables
have been eradicated and replaced with a generic acpi_describe()
method (exploiting the ability of iPXE interfaces to pass through
methods to an underlying interface). The ACPI tables are now
built in a shared data block within .bss16, rather than each
requiring dedicated space in .data16.
o The architecture-independent concept of a SAN device has been
exposed to the iPXE core through the sanboot API, which provides
calls to hook, unhook, boot, and describe SAN devices. This
allows for much more flexible usage patterns (such as hooking an
empty SAN device and then running an OS installer via TFTP).
Signed-off-by: Michael Brown <mcb30@ipxe.org>
2010-09-03 17:11:51 +02:00
|
|
|
static char * ibft_alloc_string ( struct ibft_strings *strings,
|
|
|
|
|
struct ibft_string *string, size_t len ) {
|
2007-08-10 02:44:20 +02:00
|
|
|
|
[block] Replace gPXE block-device API with an iPXE asynchronous interface
The block device interface used in gPXE predates the invention of even
the old gPXE data-transfer interface, let alone the current iPXE
generic asynchronous interface mechanism. Bring this old code up to
date, with the following benefits:
o Block device commands can be cancelled by the requestor. The INT 13
layer uses this to provide a global timeout on all INT 13 calls,
with the result that an unexpected passive failure mode (such as
an iSCSI target ACKing the request but never sending a response)
will lead to a timeout that gets reported back to the INT 13 user,
rather than simply freezing the system.
o INT 13,00 (reset drive) is now able to reset the underlying block
device. INT 13 users, such as DOS, that use INT 13,00 as a method
for error recovery now have a chance of recovering.
o All block device commands are tagged, with a numerical tag that
will show up in debugging output and in packet captures; this will
allow easier interpretation of bug reports that include both
sources of information.
o The extremely ugly hacks used to generate the boot firmware tables
have been eradicated and replaced with a generic acpi_describe()
method (exploiting the ability of iPXE interfaces to pass through
methods to an underlying interface). The ACPI tables are now
built in a shared data block within .bss16, rather than each
requiring dedicated space in .data16.
o The architecture-independent concept of a SAN device has been
exposed to the iPXE core through the sanboot API, which provides
calls to hook, unhook, boot, and describe SAN devices. This
allows for much more flexible usage patterns (such as hooking an
empty SAN device and then running an OS installer via TFTP).
Signed-off-by: Michael Brown <mcb30@ipxe.org>
2010-09-03 17:11:51 +02:00
|
|
|
if ( ( strings->offset + len ) >= strings->len )
|
|
|
|
|
return NULL;
|
2007-08-10 02:44:20 +02:00
|
|
|
|
[block] Replace gPXE block-device API with an iPXE asynchronous interface
The block device interface used in gPXE predates the invention of even
the old gPXE data-transfer interface, let alone the current iPXE
generic asynchronous interface mechanism. Bring this old code up to
date, with the following benefits:
o Block device commands can be cancelled by the requestor. The INT 13
layer uses this to provide a global timeout on all INT 13 calls,
with the result that an unexpected passive failure mode (such as
an iSCSI target ACKing the request but never sending a response)
will lead to a timeout that gets reported back to the INT 13 user,
rather than simply freezing the system.
o INT 13,00 (reset drive) is now able to reset the underlying block
device. INT 13 users, such as DOS, that use INT 13,00 as a method
for error recovery now have a chance of recovering.
o All block device commands are tagged, with a numerical tag that
will show up in debugging output and in packet captures; this will
allow easier interpretation of bug reports that include both
sources of information.
o The extremely ugly hacks used to generate the boot firmware tables
have been eradicated and replaced with a generic acpi_describe()
method (exploiting the ability of iPXE interfaces to pass through
methods to an underlying interface). The ACPI tables are now
built in a shared data block within .bss16, rather than each
requiring dedicated space in .data16.
o The architecture-independent concept of a SAN device has been
exposed to the iPXE core through the sanboot API, which provides
calls to hook, unhook, boot, and describe SAN devices. This
allows for much more flexible usage patterns (such as hooking an
empty SAN device and then running an OS installer via TFTP).
Signed-off-by: Michael Brown <mcb30@ipxe.org>
2010-09-03 17:11:51 +02:00
|
|
|
string->offset = cpu_to_le16 ( strings->offset );
|
|
|
|
|
string->len = cpu_to_le16 ( len );
|
2007-08-10 02:44:20 +02:00
|
|
|
strings->offset += ( len + 1 );
|
[block] Replace gPXE block-device API with an iPXE asynchronous interface
The block device interface used in gPXE predates the invention of even
the old gPXE data-transfer interface, let alone the current iPXE
generic asynchronous interface mechanism. Bring this old code up to
date, with the following benefits:
o Block device commands can be cancelled by the requestor. The INT 13
layer uses this to provide a global timeout on all INT 13 calls,
with the result that an unexpected passive failure mode (such as
an iSCSI target ACKing the request but never sending a response)
will lead to a timeout that gets reported back to the INT 13 user,
rather than simply freezing the system.
o INT 13,00 (reset drive) is now able to reset the underlying block
device. INT 13 users, such as DOS, that use INT 13,00 as a method
for error recovery now have a chance of recovering.
o All block device commands are tagged, with a numerical tag that
will show up in debugging output and in packet captures; this will
allow easier interpretation of bug reports that include both
sources of information.
o The extremely ugly hacks used to generate the boot firmware tables
have been eradicated and replaced with a generic acpi_describe()
method (exploiting the ability of iPXE interfaces to pass through
methods to an underlying interface). The ACPI tables are now
built in a shared data block within .bss16, rather than each
requiring dedicated space in .data16.
o The architecture-independent concept of a SAN device has been
exposed to the iPXE core through the sanboot API, which provides
calls to hook, unhook, boot, and describe SAN devices. This
allows for much more flexible usage patterns (such as hooking an
empty SAN device and then running an OS installer via TFTP).
Signed-off-by: Michael Brown <mcb30@ipxe.org>
2010-09-03 17:11:51 +02:00
|
|
|
|
|
|
|
|
return ( ( ( char * ) strings->table ) + string->offset );
|
2007-08-10 02:44:20 +02:00
|
|
|
}
|
|
|
|
|
|
2008-03-21 01:49:44 +01:00
|
|
|
/**
|
|
|
|
|
* Fill in a string field within iBFT
|
|
|
|
|
*
|
|
|
|
|
* @v strings iBFT string block descriptor
|
|
|
|
|
* @v string String field
|
2008-08-11 04:12:38 +02:00
|
|
|
* @v data String to fill in, or NULL
|
2008-03-21 01:49:44 +01:00
|
|
|
* @ret rc Return status code
|
|
|
|
|
*/
|
[block] Replace gPXE block-device API with an iPXE asynchronous interface
The block device interface used in gPXE predates the invention of even
the old gPXE data-transfer interface, let alone the current iPXE
generic asynchronous interface mechanism. Bring this old code up to
date, with the following benefits:
o Block device commands can be cancelled by the requestor. The INT 13
layer uses this to provide a global timeout on all INT 13 calls,
with the result that an unexpected passive failure mode (such as
an iSCSI target ACKing the request but never sending a response)
will lead to a timeout that gets reported back to the INT 13 user,
rather than simply freezing the system.
o INT 13,00 (reset drive) is now able to reset the underlying block
device. INT 13 users, such as DOS, that use INT 13,00 as a method
for error recovery now have a chance of recovering.
o All block device commands are tagged, with a numerical tag that
will show up in debugging output and in packet captures; this will
allow easier interpretation of bug reports that include both
sources of information.
o The extremely ugly hacks used to generate the boot firmware tables
have been eradicated and replaced with a generic acpi_describe()
method (exploiting the ability of iPXE interfaces to pass through
methods to an underlying interface). The ACPI tables are now
built in a shared data block within .bss16, rather than each
requiring dedicated space in .data16.
o The architecture-independent concept of a SAN device has been
exposed to the iPXE core through the sanboot API, which provides
calls to hook, unhook, boot, and describe SAN devices. This
allows for much more flexible usage patterns (such as hooking an
empty SAN device and then running an OS installer via TFTP).
Signed-off-by: Michael Brown <mcb30@ipxe.org>
2010-09-03 17:11:51 +02:00
|
|
|
static int ibft_set_string ( struct ibft_strings *strings,
|
2008-03-21 01:49:44 +01:00
|
|
|
struct ibft_string *string, const char *data ) {
|
|
|
|
|
char *dest;
|
|
|
|
|
|
2008-08-11 04:12:38 +02:00
|
|
|
if ( ! data )
|
|
|
|
|
return 0;
|
|
|
|
|
|
[block] Replace gPXE block-device API with an iPXE asynchronous interface
The block device interface used in gPXE predates the invention of even
the old gPXE data-transfer interface, let alone the current iPXE
generic asynchronous interface mechanism. Bring this old code up to
date, with the following benefits:
o Block device commands can be cancelled by the requestor. The INT 13
layer uses this to provide a global timeout on all INT 13 calls,
with the result that an unexpected passive failure mode (such as
an iSCSI target ACKing the request but never sending a response)
will lead to a timeout that gets reported back to the INT 13 user,
rather than simply freezing the system.
o INT 13,00 (reset drive) is now able to reset the underlying block
device. INT 13 users, such as DOS, that use INT 13,00 as a method
for error recovery now have a chance of recovering.
o All block device commands are tagged, with a numerical tag that
will show up in debugging output and in packet captures; this will
allow easier interpretation of bug reports that include both
sources of information.
o The extremely ugly hacks used to generate the boot firmware tables
have been eradicated and replaced with a generic acpi_describe()
method (exploiting the ability of iPXE interfaces to pass through
methods to an underlying interface). The ACPI tables are now
built in a shared data block within .bss16, rather than each
requiring dedicated space in .data16.
o The architecture-independent concept of a SAN device has been
exposed to the iPXE core through the sanboot API, which provides
calls to hook, unhook, boot, and describe SAN devices. This
allows for much more flexible usage patterns (such as hooking an
empty SAN device and then running an OS installer via TFTP).
Signed-off-by: Michael Brown <mcb30@ipxe.org>
2010-09-03 17:11:51 +02:00
|
|
|
dest = ibft_alloc_string ( strings, string, strlen ( data ) );
|
|
|
|
|
if ( ! dest )
|
|
|
|
|
return -ENOBUFS;
|
2008-03-21 01:49:44 +01:00
|
|
|
strcpy ( dest, data );
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2007-08-10 02:44:20 +02:00
|
|
|
/**
|
2008-03-25 21:46:16 +01:00
|
|
|
* Fill in a string field within iBFT from configuration setting
|
2007-08-10 02:44:20 +02:00
|
|
|
*
|
|
|
|
|
* @v strings iBFT string block descriptor
|
|
|
|
|
* @v string String field
|
2008-03-25 21:46:16 +01:00
|
|
|
* @v setting Configuration setting
|
2007-08-10 02:44:20 +02:00
|
|
|
* @ret rc Return status code
|
|
|
|
|
*/
|
[block] Replace gPXE block-device API with an iPXE asynchronous interface
The block device interface used in gPXE predates the invention of even
the old gPXE data-transfer interface, let alone the current iPXE
generic asynchronous interface mechanism. Bring this old code up to
date, with the following benefits:
o Block device commands can be cancelled by the requestor. The INT 13
layer uses this to provide a global timeout on all INT 13 calls,
with the result that an unexpected passive failure mode (such as
an iSCSI target ACKing the request but never sending a response)
will lead to a timeout that gets reported back to the INT 13 user,
rather than simply freezing the system.
o INT 13,00 (reset drive) is now able to reset the underlying block
device. INT 13 users, such as DOS, that use INT 13,00 as a method
for error recovery now have a chance of recovering.
o All block device commands are tagged, with a numerical tag that
will show up in debugging output and in packet captures; this will
allow easier interpretation of bug reports that include both
sources of information.
o The extremely ugly hacks used to generate the boot firmware tables
have been eradicated and replaced with a generic acpi_describe()
method (exploiting the ability of iPXE interfaces to pass through
methods to an underlying interface). The ACPI tables are now
built in a shared data block within .bss16, rather than each
requiring dedicated space in .data16.
o The architecture-independent concept of a SAN device has been
exposed to the iPXE core through the sanboot API, which provides
calls to hook, unhook, boot, and describe SAN devices. This
allows for much more flexible usage patterns (such as hooking an
empty SAN device and then running an OS installer via TFTP).
Signed-off-by: Michael Brown <mcb30@ipxe.org>
2010-09-03 17:11:51 +02:00
|
|
|
static int ibft_set_string_setting ( struct ibft_strings *strings,
|
|
|
|
|
struct ibft_string *string,
|
2013-12-03 17:48:56 +01:00
|
|
|
const struct setting *setting ) {
|
|
|
|
|
struct settings *origin;
|
|
|
|
|
struct setting fetched;
|
2008-03-21 01:49:44 +01:00
|
|
|
int len;
|
|
|
|
|
char *dest;
|
2007-08-10 02:44:20 +02:00
|
|
|
|
2013-12-03 17:48:56 +01:00
|
|
|
len = fetch_setting ( NULL, setting, &origin, &fetched, NULL, 0 );
|
2008-03-21 01:49:44 +01:00
|
|
|
if ( len < 0 ) {
|
2007-08-10 02:44:20 +02:00
|
|
|
string->offset = 0;
|
[block] Replace gPXE block-device API with an iPXE asynchronous interface
The block device interface used in gPXE predates the invention of even
the old gPXE data-transfer interface, let alone the current iPXE
generic asynchronous interface mechanism. Bring this old code up to
date, with the following benefits:
o Block device commands can be cancelled by the requestor. The INT 13
layer uses this to provide a global timeout on all INT 13 calls,
with the result that an unexpected passive failure mode (such as
an iSCSI target ACKing the request but never sending a response)
will lead to a timeout that gets reported back to the INT 13 user,
rather than simply freezing the system.
o INT 13,00 (reset drive) is now able to reset the underlying block
device. INT 13 users, such as DOS, that use INT 13,00 as a method
for error recovery now have a chance of recovering.
o All block device commands are tagged, with a numerical tag that
will show up in debugging output and in packet captures; this will
allow easier interpretation of bug reports that include both
sources of information.
o The extremely ugly hacks used to generate the boot firmware tables
have been eradicated and replaced with a generic acpi_describe()
method (exploiting the ability of iPXE interfaces to pass through
methods to an underlying interface). The ACPI tables are now
built in a shared data block within .bss16, rather than each
requiring dedicated space in .data16.
o The architecture-independent concept of a SAN device has been
exposed to the iPXE core through the sanboot API, which provides
calls to hook, unhook, boot, and describe SAN devices. This
allows for much more flexible usage patterns (such as hooking an
empty SAN device and then running an OS installer via TFTP).
Signed-off-by: Michael Brown <mcb30@ipxe.org>
2010-09-03 17:11:51 +02:00
|
|
|
string->len = 0;
|
2007-08-10 02:44:20 +02:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
[block] Replace gPXE block-device API with an iPXE asynchronous interface
The block device interface used in gPXE predates the invention of even
the old gPXE data-transfer interface, let alone the current iPXE
generic asynchronous interface mechanism. Bring this old code up to
date, with the following benefits:
o Block device commands can be cancelled by the requestor. The INT 13
layer uses this to provide a global timeout on all INT 13 calls,
with the result that an unexpected passive failure mode (such as
an iSCSI target ACKing the request but never sending a response)
will lead to a timeout that gets reported back to the INT 13 user,
rather than simply freezing the system.
o INT 13,00 (reset drive) is now able to reset the underlying block
device. INT 13 users, such as DOS, that use INT 13,00 as a method
for error recovery now have a chance of recovering.
o All block device commands are tagged, with a numerical tag that
will show up in debugging output and in packet captures; this will
allow easier interpretation of bug reports that include both
sources of information.
o The extremely ugly hacks used to generate the boot firmware tables
have been eradicated and replaced with a generic acpi_describe()
method (exploiting the ability of iPXE interfaces to pass through
methods to an underlying interface). The ACPI tables are now
built in a shared data block within .bss16, rather than each
requiring dedicated space in .data16.
o The architecture-independent concept of a SAN device has been
exposed to the iPXE core through the sanboot API, which provides
calls to hook, unhook, boot, and describe SAN devices. This
allows for much more flexible usage patterns (such as hooking an
empty SAN device and then running an OS installer via TFTP).
Signed-off-by: Michael Brown <mcb30@ipxe.org>
2010-09-03 17:11:51 +02:00
|
|
|
dest = ibft_alloc_string ( strings, string, len );
|
|
|
|
|
if ( ! dest )
|
|
|
|
|
return -ENOBUFS;
|
2013-12-03 17:48:56 +01:00
|
|
|
fetch_string_setting ( origin, &fetched, dest, ( len + 1 ));
|
[block] Replace gPXE block-device API with an iPXE asynchronous interface
The block device interface used in gPXE predates the invention of even
the old gPXE data-transfer interface, let alone the current iPXE
generic asynchronous interface mechanism. Bring this old code up to
date, with the following benefits:
o Block device commands can be cancelled by the requestor. The INT 13
layer uses this to provide a global timeout on all INT 13 calls,
with the result that an unexpected passive failure mode (such as
an iSCSI target ACKing the request but never sending a response)
will lead to a timeout that gets reported back to the INT 13 user,
rather than simply freezing the system.
o INT 13,00 (reset drive) is now able to reset the underlying block
device. INT 13 users, such as DOS, that use INT 13,00 as a method
for error recovery now have a chance of recovering.
o All block device commands are tagged, with a numerical tag that
will show up in debugging output and in packet captures; this will
allow easier interpretation of bug reports that include both
sources of information.
o The extremely ugly hacks used to generate the boot firmware tables
have been eradicated and replaced with a generic acpi_describe()
method (exploiting the ability of iPXE interfaces to pass through
methods to an underlying interface). The ACPI tables are now
built in a shared data block within .bss16, rather than each
requiring dedicated space in .data16.
o The architecture-independent concept of a SAN device has been
exposed to the iPXE core through the sanboot API, which provides
calls to hook, unhook, boot, and describe SAN devices. This
allows for much more flexible usage patterns (such as hooking an
empty SAN device and then running an OS installer via TFTP).
Signed-off-by: Michael Brown <mcb30@ipxe.org>
2010-09-03 17:11:51 +02:00
|
|
|
|
2008-03-21 01:49:44 +01:00
|
|
|
return 0;
|
2007-08-10 02:44:20 +02:00
|
|
|
}
|
|
|
|
|
|
2009-02-20 22:41:00 +01:00
|
|
|
/**
|
|
|
|
|
* Read string from iBFT (for debugging)
|
|
|
|
|
*
|
|
|
|
|
* @v strings iBFT string block descriptor
|
|
|
|
|
* @v string String field
|
|
|
|
|
* @ret data String content (or "<empty>")
|
|
|
|
|
*/
|
[block] Replace gPXE block-device API with an iPXE asynchronous interface
The block device interface used in gPXE predates the invention of even
the old gPXE data-transfer interface, let alone the current iPXE
generic asynchronous interface mechanism. Bring this old code up to
date, with the following benefits:
o Block device commands can be cancelled by the requestor. The INT 13
layer uses this to provide a global timeout on all INT 13 calls,
with the result that an unexpected passive failure mode (such as
an iSCSI target ACKing the request but never sending a response)
will lead to a timeout that gets reported back to the INT 13 user,
rather than simply freezing the system.
o INT 13,00 (reset drive) is now able to reset the underlying block
device. INT 13 users, such as DOS, that use INT 13,00 as a method
for error recovery now have a chance of recovering.
o All block device commands are tagged, with a numerical tag that
will show up in debugging output and in packet captures; this will
allow easier interpretation of bug reports that include both
sources of information.
o The extremely ugly hacks used to generate the boot firmware tables
have been eradicated and replaced with a generic acpi_describe()
method (exploiting the ability of iPXE interfaces to pass through
methods to an underlying interface). The ACPI tables are now
built in a shared data block within .bss16, rather than each
requiring dedicated space in .data16.
o The architecture-independent concept of a SAN device has been
exposed to the iPXE core through the sanboot API, which provides
calls to hook, unhook, boot, and describe SAN devices. This
allows for much more flexible usage patterns (such as hooking an
empty SAN device and then running an OS installer via TFTP).
Signed-off-by: Michael Brown <mcb30@ipxe.org>
2010-09-03 17:11:51 +02:00
|
|
|
static const char * ibft_string ( struct ibft_strings *strings,
|
2009-02-20 22:41:00 +01:00
|
|
|
struct ibft_string *string ) {
|
2009-10-23 22:33:48 +02:00
|
|
|
return ( string->offset ?
|
|
|
|
|
( ( ( char * ) strings->table ) + string->offset ) : NULL );
|
2009-02-20 22:41:00 +01:00
|
|
|
}
|
|
|
|
|
|
2007-08-10 02:44:20 +02:00
|
|
|
/**
|
|
|
|
|
* Fill in NIC portion of iBFT
|
|
|
|
|
*
|
|
|
|
|
* @v nic NIC portion of iBFT
|
|
|
|
|
* @v strings iBFT string block descriptor
|
|
|
|
|
* @v netdev Network device
|
|
|
|
|
* @ret rc Return status code
|
|
|
|
|
*/
|
|
|
|
|
static int ibft_fill_nic ( struct ibft_nic *nic,
|
[block] Replace gPXE block-device API with an iPXE asynchronous interface
The block device interface used in gPXE predates the invention of even
the old gPXE data-transfer interface, let alone the current iPXE
generic asynchronous interface mechanism. Bring this old code up to
date, with the following benefits:
o Block device commands can be cancelled by the requestor. The INT 13
layer uses this to provide a global timeout on all INT 13 calls,
with the result that an unexpected passive failure mode (such as
an iSCSI target ACKing the request but never sending a response)
will lead to a timeout that gets reported back to the INT 13 user,
rather than simply freezing the system.
o INT 13,00 (reset drive) is now able to reset the underlying block
device. INT 13 users, such as DOS, that use INT 13,00 as a method
for error recovery now have a chance of recovering.
o All block device commands are tagged, with a numerical tag that
will show up in debugging output and in packet captures; this will
allow easier interpretation of bug reports that include both
sources of information.
o The extremely ugly hacks used to generate the boot firmware tables
have been eradicated and replaced with a generic acpi_describe()
method (exploiting the ability of iPXE interfaces to pass through
methods to an underlying interface). The ACPI tables are now
built in a shared data block within .bss16, rather than each
requiring dedicated space in .data16.
o The architecture-independent concept of a SAN device has been
exposed to the iPXE core through the sanboot API, which provides
calls to hook, unhook, boot, and describe SAN devices. This
allows for much more flexible usage patterns (such as hooking an
empty SAN device and then running an OS installer via TFTP).
Signed-off-by: Michael Brown <mcb30@ipxe.org>
2010-09-03 17:11:51 +02:00
|
|
|
struct ibft_strings *strings,
|
2007-08-10 02:44:20 +02:00
|
|
|
struct net_device *netdev ) {
|
2009-10-23 23:18:04 +02:00
|
|
|
struct ll_protocol *ll_protocol = netdev->ll_protocol;
|
2008-03-21 01:49:44 +01:00
|
|
|
struct in_addr netmask_addr = { 0 };
|
2007-08-10 02:44:20 +02:00
|
|
|
unsigned int netmask_count = 0;
|
|
|
|
|
int rc;
|
|
|
|
|
|
[block] Replace gPXE block-device API with an iPXE asynchronous interface
The block device interface used in gPXE predates the invention of even
the old gPXE data-transfer interface, let alone the current iPXE
generic asynchronous interface mechanism. Bring this old code up to
date, with the following benefits:
o Block device commands can be cancelled by the requestor. The INT 13
layer uses this to provide a global timeout on all INT 13 calls,
with the result that an unexpected passive failure mode (such as
an iSCSI target ACKing the request but never sending a response)
will lead to a timeout that gets reported back to the INT 13 user,
rather than simply freezing the system.
o INT 13,00 (reset drive) is now able to reset the underlying block
device. INT 13 users, such as DOS, that use INT 13,00 as a method
for error recovery now have a chance of recovering.
o All block device commands are tagged, with a numerical tag that
will show up in debugging output and in packet captures; this will
allow easier interpretation of bug reports that include both
sources of information.
o The extremely ugly hacks used to generate the boot firmware tables
have been eradicated and replaced with a generic acpi_describe()
method (exploiting the ability of iPXE interfaces to pass through
methods to an underlying interface). The ACPI tables are now
built in a shared data block within .bss16, rather than each
requiring dedicated space in .data16.
o The architecture-independent concept of a SAN device has been
exposed to the iPXE core through the sanboot API, which provides
calls to hook, unhook, boot, and describe SAN devices. This
allows for much more flexible usage patterns (such as hooking an
empty SAN device and then running an OS installer via TFTP).
Signed-off-by: Michael Brown <mcb30@ipxe.org>
2010-09-03 17:11:51 +02:00
|
|
|
/* Fill in common header */
|
|
|
|
|
nic->header.structure_id = IBFT_STRUCTURE_ID_NIC;
|
|
|
|
|
nic->header.version = 1;
|
|
|
|
|
nic->header.length = cpu_to_le16 ( sizeof ( *nic ) );
|
|
|
|
|
nic->header.flags = ( IBFT_FL_NIC_BLOCK_VALID |
|
|
|
|
|
IBFT_FL_NIC_FIRMWARE_BOOT_SELECTED );
|
|
|
|
|
|
|
|
|
|
/* Extract values from configuration settings */
|
2010-12-09 16:35:02 +01:00
|
|
|
ibft_set_ipaddr_setting ( &nic->ip_address, &ip_setting, 1 );
|
2009-02-20 22:41:00 +01:00
|
|
|
DBG ( "iBFT NIC IP = %s\n", ibft_ipaddr ( &nic->ip_address ) );
|
2010-12-09 16:35:02 +01:00
|
|
|
ibft_set_ipaddr_setting ( &nic->gateway, &gateway_setting, 1 );
|
2009-02-20 22:41:00 +01:00
|
|
|
DBG ( "iBFT NIC gateway = %s\n", ibft_ipaddr ( &nic->gateway ) );
|
2010-12-09 16:35:02 +01:00
|
|
|
ibft_set_ipaddr_setting ( &nic->dns[0], &dns_setting,
|
|
|
|
|
( sizeof ( nic->dns ) /
|
|
|
|
|
sizeof ( nic->dns[0] ) ) );
|
|
|
|
|
DBG ( "iBFT NIC DNS = %s", ibft_ipaddr ( &nic->dns[0] ) );
|
|
|
|
|
DBG ( ", %s\n", ibft_ipaddr ( &nic->dns[1] ) );
|
[block] Replace gPXE block-device API with an iPXE asynchronous interface
The block device interface used in gPXE predates the invention of even
the old gPXE data-transfer interface, let alone the current iPXE
generic asynchronous interface mechanism. Bring this old code up to
date, with the following benefits:
o Block device commands can be cancelled by the requestor. The INT 13
layer uses this to provide a global timeout on all INT 13 calls,
with the result that an unexpected passive failure mode (such as
an iSCSI target ACKing the request but never sending a response)
will lead to a timeout that gets reported back to the INT 13 user,
rather than simply freezing the system.
o INT 13,00 (reset drive) is now able to reset the underlying block
device. INT 13 users, such as DOS, that use INT 13,00 as a method
for error recovery now have a chance of recovering.
o All block device commands are tagged, with a numerical tag that
will show up in debugging output and in packet captures; this will
allow easier interpretation of bug reports that include both
sources of information.
o The extremely ugly hacks used to generate the boot firmware tables
have been eradicated and replaced with a generic acpi_describe()
method (exploiting the ability of iPXE interfaces to pass through
methods to an underlying interface). The ACPI tables are now
built in a shared data block within .bss16, rather than each
requiring dedicated space in .data16.
o The architecture-independent concept of a SAN device has been
exposed to the iPXE core through the sanboot API, which provides
calls to hook, unhook, boot, and describe SAN devices. This
allows for much more flexible usage patterns (such as hooking an
empty SAN device and then running an OS installer via TFTP).
Signed-off-by: Michael Brown <mcb30@ipxe.org>
2010-09-03 17:11:51 +02:00
|
|
|
if ( ( rc = ibft_set_string_setting ( strings, &nic->hostname,
|
|
|
|
|
&hostname_setting ) ) != 0 )
|
2007-08-10 02:44:20 +02:00
|
|
|
return rc;
|
2009-02-20 22:41:00 +01:00
|
|
|
DBG ( "iBFT NIC hostname = %s\n",
|
|
|
|
|
ibft_string ( strings, &nic->hostname ) );
|
2007-08-10 02:44:20 +02:00
|
|
|
|
|
|
|
|
/* Derive subnet mask prefix from subnet mask */
|
2008-03-25 21:46:16 +01:00
|
|
|
fetch_ipv4_setting ( NULL, &netmask_setting, &netmask_addr );
|
2007-08-10 02:44:20 +02:00
|
|
|
while ( netmask_addr.s_addr ) {
|
|
|
|
|
if ( netmask_addr.s_addr & 0x1 )
|
|
|
|
|
netmask_count++;
|
|
|
|
|
netmask_addr.s_addr >>= 1;
|
|
|
|
|
}
|
|
|
|
|
nic->subnet_mask_prefix = netmask_count;
|
2009-02-20 22:41:00 +01:00
|
|
|
DBG ( "iBFT NIC subnet = /%d\n", nic->subnet_mask_prefix );
|
2007-08-10 02:44:20 +02:00
|
|
|
|
|
|
|
|
/* Extract values from net-device configuration */
|
2013-03-01 16:32:16 +01:00
|
|
|
nic->vlan = cpu_to_le16 ( vlan_tag ( netdev ) );
|
|
|
|
|
DBG ( "iBFT NIC VLAN = %02x\n", le16_to_cpu ( nic->vlan ) );
|
2009-10-23 23:18:04 +02:00
|
|
|
if ( ( rc = ll_protocol->eth_addr ( netdev->ll_addr,
|
|
|
|
|
nic->mac_address ) ) != 0 ) {
|
|
|
|
|
DBG ( "Could not determine iBFT MAC: %s\n", strerror ( rc ) );
|
|
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
DBG ( "iBFT NIC MAC = %s\n", eth_ntoa ( nic->mac_address ) );
|
[block] Replace gPXE block-device API with an iPXE asynchronous interface
The block device interface used in gPXE predates the invention of even
the old gPXE data-transfer interface, let alone the current iPXE
generic asynchronous interface mechanism. Bring this old code up to
date, with the following benefits:
o Block device commands can be cancelled by the requestor. The INT 13
layer uses this to provide a global timeout on all INT 13 calls,
with the result that an unexpected passive failure mode (such as
an iSCSI target ACKing the request but never sending a response)
will lead to a timeout that gets reported back to the INT 13 user,
rather than simply freezing the system.
o INT 13,00 (reset drive) is now able to reset the underlying block
device. INT 13 users, such as DOS, that use INT 13,00 as a method
for error recovery now have a chance of recovering.
o All block device commands are tagged, with a numerical tag that
will show up in debugging output and in packet captures; this will
allow easier interpretation of bug reports that include both
sources of information.
o The extremely ugly hacks used to generate the boot firmware tables
have been eradicated and replaced with a generic acpi_describe()
method (exploiting the ability of iPXE interfaces to pass through
methods to an underlying interface). The ACPI tables are now
built in a shared data block within .bss16, rather than each
requiring dedicated space in .data16.
o The architecture-independent concept of a SAN device has been
exposed to the iPXE core through the sanboot API, which provides
calls to hook, unhook, boot, and describe SAN devices. This
allows for much more flexible usage patterns (such as hooking an
empty SAN device and then running an OS installer via TFTP).
Signed-off-by: Michael Brown <mcb30@ipxe.org>
2010-09-03 17:11:51 +02:00
|
|
|
nic->pci_bus_dev_func = cpu_to_le16 ( netdev->dev->desc.location );
|
|
|
|
|
DBG ( "iBFT NIC PCI = %04x\n", le16_to_cpu ( nic->pci_bus_dev_func ) );
|
2007-08-10 02:44:20 +02:00
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Fill in Initiator portion of iBFT
|
|
|
|
|
*
|
|
|
|
|
* @v initiator Initiator portion of iBFT
|
|
|
|
|
* @v strings iBFT string block descriptor
|
2011-03-03 23:08:50 +01:00
|
|
|
* @v iscsi iSCSI session
|
2007-08-10 02:44:20 +02:00
|
|
|
* @ret rc Return status code
|
|
|
|
|
*/
|
|
|
|
|
static int ibft_fill_initiator ( struct ibft_initiator *initiator,
|
2011-03-03 23:08:50 +01:00
|
|
|
struct ibft_strings *strings,
|
|
|
|
|
struct iscsi_session *iscsi ) {
|
2007-08-10 02:44:20 +02:00
|
|
|
int rc;
|
|
|
|
|
|
[block] Replace gPXE block-device API with an iPXE asynchronous interface
The block device interface used in gPXE predates the invention of even
the old gPXE data-transfer interface, let alone the current iPXE
generic asynchronous interface mechanism. Bring this old code up to
date, with the following benefits:
o Block device commands can be cancelled by the requestor. The INT 13
layer uses this to provide a global timeout on all INT 13 calls,
with the result that an unexpected passive failure mode (such as
an iSCSI target ACKing the request but never sending a response)
will lead to a timeout that gets reported back to the INT 13 user,
rather than simply freezing the system.
o INT 13,00 (reset drive) is now able to reset the underlying block
device. INT 13 users, such as DOS, that use INT 13,00 as a method
for error recovery now have a chance of recovering.
o All block device commands are tagged, with a numerical tag that
will show up in debugging output and in packet captures; this will
allow easier interpretation of bug reports that include both
sources of information.
o The extremely ugly hacks used to generate the boot firmware tables
have been eradicated and replaced with a generic acpi_describe()
method (exploiting the ability of iPXE interfaces to pass through
methods to an underlying interface). The ACPI tables are now
built in a shared data block within .bss16, rather than each
requiring dedicated space in .data16.
o The architecture-independent concept of a SAN device has been
exposed to the iPXE core through the sanboot API, which provides
calls to hook, unhook, boot, and describe SAN devices. This
allows for much more flexible usage patterns (such as hooking an
empty SAN device and then running an OS installer via TFTP).
Signed-off-by: Michael Brown <mcb30@ipxe.org>
2010-09-03 17:11:51 +02:00
|
|
|
/* Fill in common header */
|
|
|
|
|
initiator->header.structure_id = IBFT_STRUCTURE_ID_INITIATOR;
|
|
|
|
|
initiator->header.version = 1;
|
|
|
|
|
initiator->header.length = cpu_to_le16 ( sizeof ( *initiator ) );
|
|
|
|
|
initiator->header.flags = ( IBFT_FL_INITIATOR_BLOCK_VALID |
|
|
|
|
|
IBFT_FL_INITIATOR_FIRMWARE_BOOT_SELECTED );
|
|
|
|
|
|
|
|
|
|
/* Fill in hostname */
|
2007-08-10 02:44:20 +02:00
|
|
|
if ( ( rc = ibft_set_string ( strings, &initiator->initiator_name,
|
2011-03-03 23:08:50 +01:00
|
|
|
iscsi->initiator_iqn ) ) != 0 )
|
2007-08-10 02:44:20 +02:00
|
|
|
return rc;
|
2009-02-20 22:41:00 +01:00
|
|
|
DBG ( "iBFT initiator hostname = %s\n",
|
|
|
|
|
ibft_string ( strings, &initiator->initiator_name ) );
|
2007-08-10 02:44:20 +02:00
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2008-08-11 04:12:38 +02:00
|
|
|
/**
|
|
|
|
|
* Fill in Target CHAP portion of iBFT
|
|
|
|
|
*
|
|
|
|
|
* @v target Target portion of iBFT
|
|
|
|
|
* @v strings iBFT string block descriptor
|
|
|
|
|
* @v iscsi iSCSI session
|
|
|
|
|
* @ret rc Return status code
|
|
|
|
|
*/
|
|
|
|
|
static int ibft_fill_target_chap ( struct ibft_target *target,
|
[block] Replace gPXE block-device API with an iPXE asynchronous interface
The block device interface used in gPXE predates the invention of even
the old gPXE data-transfer interface, let alone the current iPXE
generic asynchronous interface mechanism. Bring this old code up to
date, with the following benefits:
o Block device commands can be cancelled by the requestor. The INT 13
layer uses this to provide a global timeout on all INT 13 calls,
with the result that an unexpected passive failure mode (such as
an iSCSI target ACKing the request but never sending a response)
will lead to a timeout that gets reported back to the INT 13 user,
rather than simply freezing the system.
o INT 13,00 (reset drive) is now able to reset the underlying block
device. INT 13 users, such as DOS, that use INT 13,00 as a method
for error recovery now have a chance of recovering.
o All block device commands are tagged, with a numerical tag that
will show up in debugging output and in packet captures; this will
allow easier interpretation of bug reports that include both
sources of information.
o The extremely ugly hacks used to generate the boot firmware tables
have been eradicated and replaced with a generic acpi_describe()
method (exploiting the ability of iPXE interfaces to pass through
methods to an underlying interface). The ACPI tables are now
built in a shared data block within .bss16, rather than each
requiring dedicated space in .data16.
o The architecture-independent concept of a SAN device has been
exposed to the iPXE core through the sanboot API, which provides
calls to hook, unhook, boot, and describe SAN devices. This
allows for much more flexible usage patterns (such as hooking an
empty SAN device and then running an OS installer via TFTP).
Signed-off-by: Michael Brown <mcb30@ipxe.org>
2010-09-03 17:11:51 +02:00
|
|
|
struct ibft_strings *strings,
|
2008-08-11 04:12:38 +02:00
|
|
|
struct iscsi_session *iscsi ) {
|
|
|
|
|
int rc;
|
|
|
|
|
|
2009-02-20 22:41:00 +01:00
|
|
|
if ( ! ( iscsi->status & ISCSI_STATUS_AUTH_FORWARD_REQUIRED ) )
|
2008-08-11 04:12:38 +02:00
|
|
|
return 0;
|
2009-02-20 22:41:00 +01:00
|
|
|
|
|
|
|
|
assert ( iscsi->initiator_username );
|
2008-08-11 04:12:38 +02:00
|
|
|
assert ( iscsi->initiator_password );
|
|
|
|
|
|
|
|
|
|
target->chap_type = IBFT_CHAP_ONE_WAY;
|
|
|
|
|
if ( ( rc = ibft_set_string ( strings, &target->chap_name,
|
|
|
|
|
iscsi->initiator_username ) ) != 0 )
|
|
|
|
|
return rc;
|
2009-02-20 22:41:00 +01:00
|
|
|
DBG ( "iBFT target username = %s\n",
|
|
|
|
|
ibft_string ( strings, &target->chap_name ) );
|
2008-08-11 04:12:38 +02:00
|
|
|
if ( ( rc = ibft_set_string ( strings, &target->chap_secret,
|
|
|
|
|
iscsi->initiator_password ) ) != 0 )
|
|
|
|
|
return rc;
|
2009-02-20 22:41:00 +01:00
|
|
|
DBG ( "iBFT target password = <redacted>\n" );
|
|
|
|
|
|
2008-08-11 04:12:38 +02:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Fill in Target Reverse CHAP portion of iBFT
|
|
|
|
|
*
|
|
|
|
|
* @v target Target portion of iBFT
|
|
|
|
|
* @v strings iBFT string block descriptor
|
|
|
|
|
* @v iscsi iSCSI session
|
|
|
|
|
* @ret rc Return status code
|
|
|
|
|
*/
|
|
|
|
|
static int ibft_fill_target_reverse_chap ( struct ibft_target *target,
|
[block] Replace gPXE block-device API with an iPXE asynchronous interface
The block device interface used in gPXE predates the invention of even
the old gPXE data-transfer interface, let alone the current iPXE
generic asynchronous interface mechanism. Bring this old code up to
date, with the following benefits:
o Block device commands can be cancelled by the requestor. The INT 13
layer uses this to provide a global timeout on all INT 13 calls,
with the result that an unexpected passive failure mode (such as
an iSCSI target ACKing the request but never sending a response)
will lead to a timeout that gets reported back to the INT 13 user,
rather than simply freezing the system.
o INT 13,00 (reset drive) is now able to reset the underlying block
device. INT 13 users, such as DOS, that use INT 13,00 as a method
for error recovery now have a chance of recovering.
o All block device commands are tagged, with a numerical tag that
will show up in debugging output and in packet captures; this will
allow easier interpretation of bug reports that include both
sources of information.
o The extremely ugly hacks used to generate the boot firmware tables
have been eradicated and replaced with a generic acpi_describe()
method (exploiting the ability of iPXE interfaces to pass through
methods to an underlying interface). The ACPI tables are now
built in a shared data block within .bss16, rather than each
requiring dedicated space in .data16.
o The architecture-independent concept of a SAN device has been
exposed to the iPXE core through the sanboot API, which provides
calls to hook, unhook, boot, and describe SAN devices. This
allows for much more flexible usage patterns (such as hooking an
empty SAN device and then running an OS installer via TFTP).
Signed-off-by: Michael Brown <mcb30@ipxe.org>
2010-09-03 17:11:51 +02:00
|
|
|
struct ibft_strings *strings,
|
2008-08-11 04:12:38 +02:00
|
|
|
struct iscsi_session *iscsi ) {
|
|
|
|
|
int rc;
|
|
|
|
|
|
2009-02-20 22:41:00 +01:00
|
|
|
if ( ! ( iscsi->status & ISCSI_STATUS_AUTH_REVERSE_REQUIRED ) )
|
2008-08-11 04:12:38 +02:00
|
|
|
return 0;
|
2009-02-20 22:41:00 +01:00
|
|
|
|
2008-08-11 04:12:38 +02:00
|
|
|
assert ( iscsi->initiator_username );
|
|
|
|
|
assert ( iscsi->initiator_password );
|
2009-02-20 22:41:00 +01:00
|
|
|
assert ( iscsi->target_username );
|
|
|
|
|
assert ( iscsi->target_password );
|
2008-08-11 04:12:38 +02:00
|
|
|
|
|
|
|
|
target->chap_type = IBFT_CHAP_MUTUAL;
|
|
|
|
|
if ( ( rc = ibft_set_string ( strings, &target->reverse_chap_name,
|
|
|
|
|
iscsi->target_username ) ) != 0 )
|
|
|
|
|
return rc;
|
2009-02-20 22:41:00 +01:00
|
|
|
DBG ( "iBFT target reverse username = %s\n",
|
|
|
|
|
ibft_string ( strings, &target->chap_name ) );
|
2008-08-11 04:12:38 +02:00
|
|
|
if ( ( rc = ibft_set_string ( strings, &target->reverse_chap_secret,
|
|
|
|
|
iscsi->target_password ) ) != 0 )
|
|
|
|
|
return rc;
|
2009-02-20 22:41:00 +01:00
|
|
|
DBG ( "iBFT target reverse password = <redacted>\n" );
|
|
|
|
|
|
2008-08-11 04:12:38 +02:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2007-08-10 02:44:20 +02:00
|
|
|
/**
|
|
|
|
|
* Fill in Target portion of iBFT
|
|
|
|
|
*
|
|
|
|
|
* @v target Target portion of iBFT
|
|
|
|
|
* @v strings iBFT string block descriptor
|
|
|
|
|
* @v iscsi iSCSI session
|
|
|
|
|
* @ret rc Return status code
|
|
|
|
|
*/
|
|
|
|
|
static int ibft_fill_target ( struct ibft_target *target,
|
[block] Replace gPXE block-device API with an iPXE asynchronous interface
The block device interface used in gPXE predates the invention of even
the old gPXE data-transfer interface, let alone the current iPXE
generic asynchronous interface mechanism. Bring this old code up to
date, with the following benefits:
o Block device commands can be cancelled by the requestor. The INT 13
layer uses this to provide a global timeout on all INT 13 calls,
with the result that an unexpected passive failure mode (such as
an iSCSI target ACKing the request but never sending a response)
will lead to a timeout that gets reported back to the INT 13 user,
rather than simply freezing the system.
o INT 13,00 (reset drive) is now able to reset the underlying block
device. INT 13 users, such as DOS, that use INT 13,00 as a method
for error recovery now have a chance of recovering.
o All block device commands are tagged, with a numerical tag that
will show up in debugging output and in packet captures; this will
allow easier interpretation of bug reports that include both
sources of information.
o The extremely ugly hacks used to generate the boot firmware tables
have been eradicated and replaced with a generic acpi_describe()
method (exploiting the ability of iPXE interfaces to pass through
methods to an underlying interface). The ACPI tables are now
built in a shared data block within .bss16, rather than each
requiring dedicated space in .data16.
o The architecture-independent concept of a SAN device has been
exposed to the iPXE core through the sanboot API, which provides
calls to hook, unhook, boot, and describe SAN devices. This
allows for much more flexible usage patterns (such as hooking an
empty SAN device and then running an OS installer via TFTP).
Signed-off-by: Michael Brown <mcb30@ipxe.org>
2010-09-03 17:11:51 +02:00
|
|
|
struct ibft_strings *strings,
|
2007-08-10 02:44:20 +02:00
|
|
|
struct iscsi_session *iscsi ) {
|
|
|
|
|
struct sockaddr_in *sin_target =
|
|
|
|
|
( struct sockaddr_in * ) &iscsi->target_sockaddr;
|
|
|
|
|
int rc;
|
|
|
|
|
|
[block] Replace gPXE block-device API with an iPXE asynchronous interface
The block device interface used in gPXE predates the invention of even
the old gPXE data-transfer interface, let alone the current iPXE
generic asynchronous interface mechanism. Bring this old code up to
date, with the following benefits:
o Block device commands can be cancelled by the requestor. The INT 13
layer uses this to provide a global timeout on all INT 13 calls,
with the result that an unexpected passive failure mode (such as
an iSCSI target ACKing the request but never sending a response)
will lead to a timeout that gets reported back to the INT 13 user,
rather than simply freezing the system.
o INT 13,00 (reset drive) is now able to reset the underlying block
device. INT 13 users, such as DOS, that use INT 13,00 as a method
for error recovery now have a chance of recovering.
o All block device commands are tagged, with a numerical tag that
will show up in debugging output and in packet captures; this will
allow easier interpretation of bug reports that include both
sources of information.
o The extremely ugly hacks used to generate the boot firmware tables
have been eradicated and replaced with a generic acpi_describe()
method (exploiting the ability of iPXE interfaces to pass through
methods to an underlying interface). The ACPI tables are now
built in a shared data block within .bss16, rather than each
requiring dedicated space in .data16.
o The architecture-independent concept of a SAN device has been
exposed to the iPXE core through the sanboot API, which provides
calls to hook, unhook, boot, and describe SAN devices. This
allows for much more flexible usage patterns (such as hooking an
empty SAN device and then running an OS installer via TFTP).
Signed-off-by: Michael Brown <mcb30@ipxe.org>
2010-09-03 17:11:51 +02:00
|
|
|
/* Fill in common header */
|
|
|
|
|
target->header.structure_id = IBFT_STRUCTURE_ID_TARGET;
|
|
|
|
|
target->header.version = 1;
|
|
|
|
|
target->header.length = cpu_to_le16 ( sizeof ( *target ) );
|
|
|
|
|
target->header.flags = ( IBFT_FL_TARGET_BLOCK_VALID |
|
|
|
|
|
IBFT_FL_TARGET_FIRMWARE_BOOT_SELECTED );
|
|
|
|
|
|
2007-08-10 02:44:20 +02:00
|
|
|
/* Fill in Target values */
|
|
|
|
|
ibft_set_ipaddr ( &target->ip_address, sin_target->sin_addr );
|
2009-02-20 22:41:00 +01:00
|
|
|
DBG ( "iBFT target IP = %s\n", ibft_ipaddr ( &target->ip_address ) );
|
[block] Replace gPXE block-device API with an iPXE asynchronous interface
The block device interface used in gPXE predates the invention of even
the old gPXE data-transfer interface, let alone the current iPXE
generic asynchronous interface mechanism. Bring this old code up to
date, with the following benefits:
o Block device commands can be cancelled by the requestor. The INT 13
layer uses this to provide a global timeout on all INT 13 calls,
with the result that an unexpected passive failure mode (such as
an iSCSI target ACKing the request but never sending a response)
will lead to a timeout that gets reported back to the INT 13 user,
rather than simply freezing the system.
o INT 13,00 (reset drive) is now able to reset the underlying block
device. INT 13 users, such as DOS, that use INT 13,00 as a method
for error recovery now have a chance of recovering.
o All block device commands are tagged, with a numerical tag that
will show up in debugging output and in packet captures; this will
allow easier interpretation of bug reports that include both
sources of information.
o The extremely ugly hacks used to generate the boot firmware tables
have been eradicated and replaced with a generic acpi_describe()
method (exploiting the ability of iPXE interfaces to pass through
methods to an underlying interface). The ACPI tables are now
built in a shared data block within .bss16, rather than each
requiring dedicated space in .data16.
o The architecture-independent concept of a SAN device has been
exposed to the iPXE core through the sanboot API, which provides
calls to hook, unhook, boot, and describe SAN devices. This
allows for much more flexible usage patterns (such as hooking an
empty SAN device and then running an OS installer via TFTP).
Signed-off-by: Michael Brown <mcb30@ipxe.org>
2010-09-03 17:11:51 +02:00
|
|
|
target->socket = cpu_to_le16 ( ntohs ( sin_target->sin_port ) );
|
2009-02-20 22:41:00 +01:00
|
|
|
DBG ( "iBFT target port = %d\n", target->socket );
|
[block] Replace gPXE block-device API with an iPXE asynchronous interface
The block device interface used in gPXE predates the invention of even
the old gPXE data-transfer interface, let alone the current iPXE
generic asynchronous interface mechanism. Bring this old code up to
date, with the following benefits:
o Block device commands can be cancelled by the requestor. The INT 13
layer uses this to provide a global timeout on all INT 13 calls,
with the result that an unexpected passive failure mode (such as
an iSCSI target ACKing the request but never sending a response)
will lead to a timeout that gets reported back to the INT 13 user,
rather than simply freezing the system.
o INT 13,00 (reset drive) is now able to reset the underlying block
device. INT 13 users, such as DOS, that use INT 13,00 as a method
for error recovery now have a chance of recovering.
o All block device commands are tagged, with a numerical tag that
will show up in debugging output and in packet captures; this will
allow easier interpretation of bug reports that include both
sources of information.
o The extremely ugly hacks used to generate the boot firmware tables
have been eradicated and replaced with a generic acpi_describe()
method (exploiting the ability of iPXE interfaces to pass through
methods to an underlying interface). The ACPI tables are now
built in a shared data block within .bss16, rather than each
requiring dedicated space in .data16.
o The architecture-independent concept of a SAN device has been
exposed to the iPXE core through the sanboot API, which provides
calls to hook, unhook, boot, and describe SAN devices. This
allows for much more flexible usage patterns (such as hooking an
empty SAN device and then running an OS installer via TFTP).
Signed-off-by: Michael Brown <mcb30@ipxe.org>
2010-09-03 17:11:51 +02:00
|
|
|
memcpy ( &target->boot_lun, &iscsi->lun, sizeof ( target->boot_lun ) );
|
|
|
|
|
DBG ( "iBFT target boot LUN = " SCSI_LUN_FORMAT "\n",
|
|
|
|
|
SCSI_LUN_DATA ( target->boot_lun ) );
|
2007-08-10 02:44:20 +02:00
|
|
|
if ( ( rc = ibft_set_string ( strings, &target->target_name,
|
2008-03-21 01:49:44 +01:00
|
|
|
iscsi->target_iqn ) ) != 0 )
|
2007-08-10 02:44:20 +02:00
|
|
|
return rc;
|
2009-02-20 22:41:00 +01:00
|
|
|
DBG ( "iBFT target name = %s\n",
|
|
|
|
|
ibft_string ( strings, &target->target_name ) );
|
2008-08-11 04:12:38 +02:00
|
|
|
if ( ( rc = ibft_fill_target_chap ( target, strings, iscsi ) ) != 0 )
|
|
|
|
|
return rc;
|
|
|
|
|
if ( ( rc = ibft_fill_target_reverse_chap ( target, strings,
|
|
|
|
|
iscsi ) ) != 0 )
|
|
|
|
|
return rc;
|
2007-08-10 02:44:20 +02:00
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
[block] Replace gPXE block-device API with an iPXE asynchronous interface
The block device interface used in gPXE predates the invention of even
the old gPXE data-transfer interface, let alone the current iPXE
generic asynchronous interface mechanism. Bring this old code up to
date, with the following benefits:
o Block device commands can be cancelled by the requestor. The INT 13
layer uses this to provide a global timeout on all INT 13 calls,
with the result that an unexpected passive failure mode (such as
an iSCSI target ACKing the request but never sending a response)
will lead to a timeout that gets reported back to the INT 13 user,
rather than simply freezing the system.
o INT 13,00 (reset drive) is now able to reset the underlying block
device. INT 13 users, such as DOS, that use INT 13,00 as a method
for error recovery now have a chance of recovering.
o All block device commands are tagged, with a numerical tag that
will show up in debugging output and in packet captures; this will
allow easier interpretation of bug reports that include both
sources of information.
o The extremely ugly hacks used to generate the boot firmware tables
have been eradicated and replaced with a generic acpi_describe()
method (exploiting the ability of iPXE interfaces to pass through
methods to an underlying interface). The ACPI tables are now
built in a shared data block within .bss16, rather than each
requiring dedicated space in .data16.
o The architecture-independent concept of a SAN device has been
exposed to the iPXE core through the sanboot API, which provides
calls to hook, unhook, boot, and describe SAN devices. This
allows for much more flexible usage patterns (such as hooking an
empty SAN device and then running an OS installer via TFTP).
Signed-off-by: Michael Brown <mcb30@ipxe.org>
2010-09-03 17:11:51 +02:00
|
|
|
* Fill in iBFT
|
2007-08-10 02:44:20 +02:00
|
|
|
*
|
[block] Replace gPXE block-device API with an iPXE asynchronous interface
The block device interface used in gPXE predates the invention of even
the old gPXE data-transfer interface, let alone the current iPXE
generic asynchronous interface mechanism. Bring this old code up to
date, with the following benefits:
o Block device commands can be cancelled by the requestor. The INT 13
layer uses this to provide a global timeout on all INT 13 calls,
with the result that an unexpected passive failure mode (such as
an iSCSI target ACKing the request but never sending a response)
will lead to a timeout that gets reported back to the INT 13 user,
rather than simply freezing the system.
o INT 13,00 (reset drive) is now able to reset the underlying block
device. INT 13 users, such as DOS, that use INT 13,00 as a method
for error recovery now have a chance of recovering.
o All block device commands are tagged, with a numerical tag that
will show up in debugging output and in packet captures; this will
allow easier interpretation of bug reports that include both
sources of information.
o The extremely ugly hacks used to generate the boot firmware tables
have been eradicated and replaced with a generic acpi_describe()
method (exploiting the ability of iPXE interfaces to pass through
methods to an underlying interface). The ACPI tables are now
built in a shared data block within .bss16, rather than each
requiring dedicated space in .data16.
o The architecture-independent concept of a SAN device has been
exposed to the iPXE core through the sanboot API, which provides
calls to hook, unhook, boot, and describe SAN devices. This
allows for much more flexible usage patterns (such as hooking an
empty SAN device and then running an OS installer via TFTP).
Signed-off-by: Michael Brown <mcb30@ipxe.org>
2010-09-03 17:11:51 +02:00
|
|
|
* @v iscsi iSCSI session
|
|
|
|
|
* @v acpi ACPI table
|
|
|
|
|
* @v len Length of ACPI table
|
2007-08-10 02:44:20 +02:00
|
|
|
* @ret rc Return status code
|
|
|
|
|
*/
|
[block] Replace gPXE block-device API with an iPXE asynchronous interface
The block device interface used in gPXE predates the invention of even
the old gPXE data-transfer interface, let alone the current iPXE
generic asynchronous interface mechanism. Bring this old code up to
date, with the following benefits:
o Block device commands can be cancelled by the requestor. The INT 13
layer uses this to provide a global timeout on all INT 13 calls,
with the result that an unexpected passive failure mode (such as
an iSCSI target ACKing the request but never sending a response)
will lead to a timeout that gets reported back to the INT 13 user,
rather than simply freezing the system.
o INT 13,00 (reset drive) is now able to reset the underlying block
device. INT 13 users, such as DOS, that use INT 13,00 as a method
for error recovery now have a chance of recovering.
o All block device commands are tagged, with a numerical tag that
will show up in debugging output and in packet captures; this will
allow easier interpretation of bug reports that include both
sources of information.
o The extremely ugly hacks used to generate the boot firmware tables
have been eradicated and replaced with a generic acpi_describe()
method (exploiting the ability of iPXE interfaces to pass through
methods to an underlying interface). The ACPI tables are now
built in a shared data block within .bss16, rather than each
requiring dedicated space in .data16.
o The architecture-independent concept of a SAN device has been
exposed to the iPXE core through the sanboot API, which provides
calls to hook, unhook, boot, and describe SAN devices. This
allows for much more flexible usage patterns (such as hooking an
empty SAN device and then running an OS installer via TFTP).
Signed-off-by: Michael Brown <mcb30@ipxe.org>
2010-09-03 17:11:51 +02:00
|
|
|
int ibft_describe ( struct iscsi_session *iscsi,
|
|
|
|
|
struct acpi_description_header *acpi,
|
|
|
|
|
size_t len ) {
|
|
|
|
|
struct ipxe_ibft *ibft =
|
|
|
|
|
container_of ( acpi, struct ipxe_ibft, table.acpi );
|
|
|
|
|
struct ibft_strings strings = {
|
|
|
|
|
.table = &ibft->table,
|
|
|
|
|
.offset = offsetof ( typeof ( *ibft ), strings ),
|
|
|
|
|
.len = len,
|
2007-08-10 02:44:20 +02:00
|
|
|
};
|
[block] Replace gPXE block-device API with an iPXE asynchronous interface
The block device interface used in gPXE predates the invention of even
the old gPXE data-transfer interface, let alone the current iPXE
generic asynchronous interface mechanism. Bring this old code up to
date, with the following benefits:
o Block device commands can be cancelled by the requestor. The INT 13
layer uses this to provide a global timeout on all INT 13 calls,
with the result that an unexpected passive failure mode (such as
an iSCSI target ACKing the request but never sending a response)
will lead to a timeout that gets reported back to the INT 13 user,
rather than simply freezing the system.
o INT 13,00 (reset drive) is now able to reset the underlying block
device. INT 13 users, such as DOS, that use INT 13,00 as a method
for error recovery now have a chance of recovering.
o All block device commands are tagged, with a numerical tag that
will show up in debugging output and in packet captures; this will
allow easier interpretation of bug reports that include both
sources of information.
o The extremely ugly hacks used to generate the boot firmware tables
have been eradicated and replaced with a generic acpi_describe()
method (exploiting the ability of iPXE interfaces to pass through
methods to an underlying interface). The ACPI tables are now
built in a shared data block within .bss16, rather than each
requiring dedicated space in .data16.
o The architecture-independent concept of a SAN device has been
exposed to the iPXE core through the sanboot API, which provides
calls to hook, unhook, boot, and describe SAN devices. This
allows for much more flexible usage patterns (such as hooking an
empty SAN device and then running an OS installer via TFTP).
Signed-off-by: Michael Brown <mcb30@ipxe.org>
2010-09-03 17:11:51 +02:00
|
|
|
struct net_device *netdev;
|
2007-08-10 02:44:20 +02:00
|
|
|
int rc;
|
|
|
|
|
|
[block] Replace gPXE block-device API with an iPXE asynchronous interface
The block device interface used in gPXE predates the invention of even
the old gPXE data-transfer interface, let alone the current iPXE
generic asynchronous interface mechanism. Bring this old code up to
date, with the following benefits:
o Block device commands can be cancelled by the requestor. The INT 13
layer uses this to provide a global timeout on all INT 13 calls,
with the result that an unexpected passive failure mode (such as
an iSCSI target ACKing the request but never sending a response)
will lead to a timeout that gets reported back to the INT 13 user,
rather than simply freezing the system.
o INT 13,00 (reset drive) is now able to reset the underlying block
device. INT 13 users, such as DOS, that use INT 13,00 as a method
for error recovery now have a chance of recovering.
o All block device commands are tagged, with a numerical tag that
will show up in debugging output and in packet captures; this will
allow easier interpretation of bug reports that include both
sources of information.
o The extremely ugly hacks used to generate the boot firmware tables
have been eradicated and replaced with a generic acpi_describe()
method (exploiting the ability of iPXE interfaces to pass through
methods to an underlying interface). The ACPI tables are now
built in a shared data block within .bss16, rather than each
requiring dedicated space in .data16.
o The architecture-independent concept of a SAN device has been
exposed to the iPXE core through the sanboot API, which provides
calls to hook, unhook, boot, and describe SAN devices. This
allows for much more flexible usage patterns (such as hooking an
empty SAN device and then running an OS installer via TFTP).
Signed-off-by: Michael Brown <mcb30@ipxe.org>
2010-09-03 17:11:51 +02:00
|
|
|
/* Ugly hack. Now that we have a generic interface mechanism
|
|
|
|
|
* that can support ioctls, we can potentially eliminate this.
|
|
|
|
|
*/
|
|
|
|
|
netdev = last_opened_netdev();
|
|
|
|
|
if ( ! netdev ) {
|
|
|
|
|
DBGC ( iscsi, "iSCSI %p cannot guess network device\n",
|
|
|
|
|
iscsi );
|
|
|
|
|
return -ENODEV;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Fill in ACPI header */
|
|
|
|
|
ibft->table.acpi.signature = cpu_to_le32 ( IBFT_SIG );
|
|
|
|
|
ibft->table.acpi.length = cpu_to_le32 ( len );
|
|
|
|
|
ibft->table.acpi.revision = 1;
|
|
|
|
|
|
|
|
|
|
/* Fill in Control block */
|
|
|
|
|
ibft->table.control.header.structure_id = IBFT_STRUCTURE_ID_CONTROL;
|
|
|
|
|
ibft->table.control.header.version = 1;
|
|
|
|
|
ibft->table.control.header.length =
|
|
|
|
|
cpu_to_le16 ( sizeof ( ibft->table.control ) );
|
|
|
|
|
ibft->table.control.initiator =
|
|
|
|
|
cpu_to_le16 ( offsetof ( typeof ( *ibft ), initiator ) );
|
|
|
|
|
ibft->table.control.nic_0 =
|
|
|
|
|
cpu_to_le16 ( offsetof ( typeof ( *ibft ), nic ) );
|
|
|
|
|
ibft->table.control.target_0 =
|
|
|
|
|
cpu_to_le16 ( offsetof ( typeof ( *ibft ), target ) );
|
|
|
|
|
|
|
|
|
|
/* Fill in NIC, Initiator and Target blocks */
|
|
|
|
|
if ( ( rc = ibft_fill_nic ( &ibft->nic, &strings, netdev ) ) != 0 )
|
2007-08-10 02:44:20 +02:00
|
|
|
return rc;
|
2011-03-03 23:08:50 +01:00
|
|
|
if ( ( rc = ibft_fill_initiator ( &ibft->initiator, &strings,
|
|
|
|
|
iscsi ) ) != 0 )
|
2007-08-10 02:44:20 +02:00
|
|
|
return rc;
|
[block] Replace gPXE block-device API with an iPXE asynchronous interface
The block device interface used in gPXE predates the invention of even
the old gPXE data-transfer interface, let alone the current iPXE
generic asynchronous interface mechanism. Bring this old code up to
date, with the following benefits:
o Block device commands can be cancelled by the requestor. The INT 13
layer uses this to provide a global timeout on all INT 13 calls,
with the result that an unexpected passive failure mode (such as
an iSCSI target ACKing the request but never sending a response)
will lead to a timeout that gets reported back to the INT 13 user,
rather than simply freezing the system.
o INT 13,00 (reset drive) is now able to reset the underlying block
device. INT 13 users, such as DOS, that use INT 13,00 as a method
for error recovery now have a chance of recovering.
o All block device commands are tagged, with a numerical tag that
will show up in debugging output and in packet captures; this will
allow easier interpretation of bug reports that include both
sources of information.
o The extremely ugly hacks used to generate the boot firmware tables
have been eradicated and replaced with a generic acpi_describe()
method (exploiting the ability of iPXE interfaces to pass through
methods to an underlying interface). The ACPI tables are now
built in a shared data block within .bss16, rather than each
requiring dedicated space in .data16.
o The architecture-independent concept of a SAN device has been
exposed to the iPXE core through the sanboot API, which provides
calls to hook, unhook, boot, and describe SAN devices. This
allows for much more flexible usage patterns (such as hooking an
empty SAN device and then running an OS installer via TFTP).
Signed-off-by: Michael Brown <mcb30@ipxe.org>
2010-09-03 17:11:51 +02:00
|
|
|
if ( ( rc = ibft_fill_target ( &ibft->target, &strings,
|
2007-08-10 02:44:20 +02:00
|
|
|
iscsi ) ) != 0 )
|
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|