sysadmin/ipxe
1
0
Fork 0
mirror of https://github.com/ipxe/ipxe synced 2025-12-23 13:30:57 +03:00
Code Issues Packages Projects Releases Wiki Activity

[bios] Add bin-x86_64-pcbios build platform

Browse Source 
Move most arch/i386 files to arch/x86, and adjust the contents of the
Makefiles and the include/bits/*.h headers to reflect the new
locations.

This patch makes no substantive code changes, as can be seen using a
rename-aware diff (e.g. "git show -M5").

This patch does not make the pcbios platform functional for x86_64; it
merely allows it to compile without errors.

Signed-off-by: Michael Brown <mcb30@ipxe.org>
This commit is contained in:
Michael Brown
2016-02-16 15:19:01 +00:00
parent 43515f9f1a
commit f468f12b1e
155 changed files with 198 additions and 240 deletions
Download Patch File Download Diff File Expand all files Collapse all files

404
src/arch/x86/interface/pxe/pxe_call.c Normal file
View File

@@ -0,0 +1,404 @@
/*
* Copyright (C) 2006 Michael Brown <mbrown@fensystems.co.uk>.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
* 02110-1301, USA.
*
* You can also choose to distribute this program under the terms of
* the Unmodified Binary Distribution Licence (as given in the file
* COPYING.UBDL), provided that you have satisfied its requirements.
*/
FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
#include <ipxe/uaccess.h>
#include <ipxe/init.h>
#include <ipxe/profile.h>
#include <ipxe/netdevice.h>
#include <rmsetjmp.h>
#include <registers.h>
#include <biosint.h>
#include <pxe.h>
#include <pxe_call.h>
/** @file
*
* PXE API entry point
*/
/* Disambiguate the various error causes */
#define EINFO_EPXENBP \
__einfo_uniqify ( EINFO_EPLATFORM, 0x01, \
"External PXE NBP error" )
#define EPXENBP( status ) EPLATFORM ( EINFO_EPXENBP, status )
/** Vector for chaining INT 1A */
extern struct segoff __text16 ( pxe_int_1a_vector );
#define pxe_int_1a_vector __use_text16 ( pxe_int_1a_vector )
/** INT 1A handler */
extern void pxe_int_1a ( void );
/** INT 1A hooked flag */
static int int_1a_hooked = 0;
/** Real-mode code segment size */
extern char _text16_memsz[];
#define _text16_memsz ( ( size_t ) _text16_memsz )
/** Real-mode data segment size */
extern char _data16_memsz[];
#define _data16_memsz ( ( size_t ) _data16_memsz )
/** PXENV_UNDI_TRANSMIT API call profiler */
static struct profiler pxe_api_tx_profiler __profiler =
{ .name = "pxeapi.tx" };
/** PXENV_UNDI_ISR API call profiler */
static struct profiler pxe_api_isr_profiler __profiler =
{ .name = "pxeapi.isr" };
/** PXE unknown API call profiler
*
* This profiler can be used to measure the overhead of a dummy PXE
* API call.
*/
static struct profiler pxe_api_unknown_profiler __profiler =
{ .name = "pxeapi.unknown" };
/** Miscellaneous PXE API call profiler */
static struct profiler pxe_api_misc_profiler __profiler =
{ .name = "pxeapi.misc" };
/**
* Handle an unknown PXE API call
*
* @v pxenv_unknown Pointer to a struct s_PXENV_UNKNOWN
* @ret #PXENV_EXIT_FAILURE Always
* @err #PXENV_STATUS_UNSUPPORTED Always
*/
static PXENV_EXIT_t pxenv_unknown ( struct s_PXENV_UNKNOWN *pxenv_unknown ) {
pxenv_unknown->Status = PXENV_STATUS_UNSUPPORTED;
return PXENV_EXIT_FAILURE;
}
/** Unknown PXE API call list */
struct pxe_api_call pxenv_unknown_api __pxe_api_call =
PXE_API_CALL ( PXENV_UNKNOWN, pxenv_unknown, struct s_PXENV_UNKNOWN );
/**
* Locate PXE API call
*
* @v opcode Opcode
* @ret call PXE API call, or NULL
*/
static struct pxe_api_call * find_pxe_api_call ( uint16_t opcode ) {
struct pxe_api_call *call;
for_each_table_entry ( call, PXE_API_CALLS ) {
if ( call->opcode == opcode )
return call;
}
return NULL;
}
/**
* Determine applicable profiler (for debugging)
*
* @v opcode PXE opcode
* @ret profiler Profiler
*/
static struct profiler * pxe_api_profiler ( unsigned int opcode ) {
/* Determine applicable profiler */
switch ( opcode ) {
case PXENV_UNDI_TRANSMIT:
return &pxe_api_tx_profiler;
case PXENV_UNDI_ISR:
return &pxe_api_isr_profiler;
case PXENV_UNKNOWN:
return &pxe_api_unknown_profiler;
default:
return &pxe_api_misc_profiler;
}
}
/**
* Dispatch PXE API call
*
* @v bx PXE opcode
* @v es:di Address of PXE parameter block
* @ret ax PXE exit code
*/
__asmcall void pxe_api_call ( struct i386_all_regs *ix86 ) {
uint16_t opcode = ix86->regs.bx;
userptr_t uparams = real_to_user ( ix86->segs.es, ix86->regs.di );
struct profiler *profiler = pxe_api_profiler ( opcode );
struct pxe_api_call *call;
union u_PXENV_ANY params;
PXENV_EXIT_t ret;
/* Start profiling */
profile_start ( profiler );
/* Locate API call */
call = find_pxe_api_call ( opcode );
if ( ! call ) {
DBGC ( &pxe_netdev, "PXENV_UNKNOWN_%04x\n", opcode );
call = &pxenv_unknown_api;
}
/* Copy parameter block from caller */
copy_from_user ( &params, uparams, 0, call->params_len );
/* Set default status in case child routine fails to do so */
params.Status = PXENV_STATUS_FAILURE;
/* Hand off to relevant API routine */
ret = call->entry ( &params );
/* Copy modified parameter block back to caller and return */
copy_to_user ( uparams, 0, &params, call->params_len );
ix86->regs.ax = ret;
/* Stop profiling, if applicable */
profile_stop ( profiler );
}
/**
* Dispatch weak PXE API call with PXE stack available
*
* @v ix86 Registers for PXE call
* @ret present Zero (PXE stack present)
*/
int pxe_api_call_weak ( struct i386_all_regs *ix86 ) {
pxe_api_call ( ix86 );
return 0;
}
/**
* Dispatch PXE loader call
*
* @v es:di Address of PXE parameter block
* @ret ax PXE exit code
*/
__asmcall void pxe_loader_call ( struct i386_all_regs *ix86 ) {
userptr_t uparams = real_to_user ( ix86->segs.es, ix86->regs.di );
struct s_UNDI_LOADER params;
PXENV_EXIT_t ret;
/* Copy parameter block from caller */
copy_from_user ( &params, uparams, 0, sizeof ( params ) );
/* Fill in ROM segment address */
ppxe.UNDIROMID.segment = ix86->segs.ds;
/* Set default status in case child routine fails to do so */
params.Status = PXENV_STATUS_FAILURE;
/* Call UNDI loader */
ret = undi_loader ( &params );
/* Copy modified parameter block back to caller and return */
copy_to_user ( uparams, 0, &params, sizeof ( params ) );
ix86->regs.ax = ret;
}
/**
* Calculate byte checksum as used by PXE
*
* @v data Data
* @v size Length of data
* @ret sum Checksum
*/
static uint8_t pxe_checksum ( void *data, size_t size ) {
uint8_t *bytes = data;
uint8_t sum = 0;
while ( size-- ) {
sum += *bytes++;
}
return sum;
}
/**
* Initialise !PXE and PXENV+ structures
*
*/
static void pxe_init_structures ( void ) {
uint32_t rm_cs_phys = ( rm_cs << 4 );
uint32_t rm_ds_phys = ( rm_ds << 4 );
/* Fill in missing segment fields */
ppxe.EntryPointSP.segment = rm_cs;
ppxe.EntryPointESP.segment = rm_cs;
ppxe.Stack.segment_address = rm_ds;
ppxe.Stack.Physical_address = rm_ds_phys;
ppxe.UNDIData.segment_address = rm_ds;
ppxe.UNDIData.Physical_address = rm_ds_phys;
ppxe.UNDICode.segment_address = rm_cs;
ppxe.UNDICode.Physical_address = rm_cs_phys;
ppxe.UNDICodeWrite.segment_address = rm_cs;
ppxe.UNDICodeWrite.Physical_address = rm_cs_phys;
pxenv.RMEntry.segment = rm_cs;
pxenv.StackSeg = rm_ds;
pxenv.UNDIDataSeg = rm_ds;
pxenv.UNDICodeSeg = rm_cs;
pxenv.PXEPtr.segment = rm_cs;
/* Update checksums */
ppxe.StructCksum -= pxe_checksum ( &ppxe, sizeof ( ppxe ) );
pxenv.Checksum -= pxe_checksum ( &pxenv, sizeof ( pxenv ) );
}
/** PXE structure initialiser */
struct init_fn pxe_init_fn __init_fn ( INIT_NORMAL ) = {
.initialise = pxe_init_structures,
};
/**
* Activate PXE stack
*
* @v netdev Net device to use as PXE net device
*/
void pxe_activate ( struct net_device *netdev ) {
uint32_t discard_a;
uint32_t discard_b;
uint32_t discard_d;
/* Ensure INT 1A is hooked */
if ( ! int_1a_hooked ) {
hook_bios_interrupt ( 0x1a, ( intptr_t ) pxe_int_1a,
&pxe_int_1a_vector );
devices_get();
int_1a_hooked = 1;
}
/* Set PXE network device */
pxe_set_netdev ( netdev );
/* Notify BIOS of installation */
__asm__ __volatile__ ( REAL_CODE ( "pushw %%cs\n\t"
"popw %%es\n\t"
"int $0x1a\n\t" )
: "=a" ( discard_a ), "=b" ( discard_b ),
"=d" ( discard_d )
: "0" ( 0x564e ),
"1" ( __from_text16 ( &pxenv ) ) );
}
/**
* Deactivate PXE stack
*
* @ret rc Return status code
*/
int pxe_deactivate ( void ) {
int rc;
/* Clear PXE network device */
pxe_set_netdev ( NULL );
/* Ensure INT 1A is unhooked, if possible */
if ( int_1a_hooked ) {
if ( ( rc = unhook_bios_interrupt ( 0x1a,
( intptr_t ) pxe_int_1a,
&pxe_int_1a_vector ))!= 0){
DBGC ( &pxe_netdev, "PXE could not unhook INT 1A: %s\n",
strerror ( rc ) );
return rc;
}
devices_put();
int_1a_hooked = 0;
}
return 0;
}
/** Jump buffer for PXENV_RESTART_TFTP */
rmjmp_buf pxe_restart_nbp;
/**
* Start PXE NBP at 0000:7c00
*
* @ret rc Return status code
*/
int pxe_start_nbp ( void ) {
int jmp;
int discard_b, discard_c, discard_d, discard_D;
uint16_t status;
DBGC ( &pxe_netdev, "PXE NBP starting with netdev %s, code %04x:%04zx, "
"data %04x:%04zx\n", ( pxe_netdev ? pxe_netdev->name : "<none>"),
rm_cs, _text16_memsz, rm_ds, _data16_memsz );
/* Allow restarting NBP via PXENV_RESTART_TFTP */
jmp = rmsetjmp ( pxe_restart_nbp );
if ( jmp )
DBGC ( &pxe_netdev, "PXE NBP restarting (%x)\n", jmp );
/* Far call to PXE NBP */
__asm__ __volatile__ ( REAL_CODE ( "pushl %%ebp\n\t" /* gcc bug */
"movw %%cx, %%es\n\t"
"pushw %%es\n\t"
"pushw %%di\n\t"
"sti\n\t"
"lcall $0, $0x7c00\n\t"
"popl %%ebp\n\t" /* discard */
"popl %%ebp\n\t" /* gcc bug */ )
: "=a" ( status ), "=b" ( discard_b ),
"=c" ( discard_c ), "=d" ( discard_d ),
"=D" ( discard_D )
: "a" ( 0 ), "b" ( __from_text16 ( &pxenv ) ),
"c" ( rm_cs ),
"d" ( virt_to_phys ( &pxenv ) ),
"D" ( __from_text16 ( &ppxe ) )
: "esi", "memory" );
if ( status )
return -EPXENBP ( status );
return 0;
}
/**
* Notify BIOS of existence of network device
*
* @v netdev Network device
* @ret rc Return status code
*/
static int pxe_notify ( struct net_device *netdev ) {
/* Do nothing if we already have a network device */
if ( pxe_netdev )
return 0;
/* Activate (and deactivate) PXE stack to notify BIOS */
pxe_activate ( netdev );
pxe_deactivate();
return 0;
}
/** PXE BIOS notification driver */
struct net_driver pxe_driver __net_driver = {
.name = "PXE",
.probe = pxe_notify,
};
REQUIRING_SYMBOL ( pxe_api_call );
REQUIRE_OBJECT ( pxe_preboot );
REQUIRE_OBJECT ( pxe_undi );
REQUIRE_OBJECT ( pxe_udp );
REQUIRE_OBJECT ( pxe_tftp );
REQUIRE_OBJECT ( pxe_file );

221
src/arch/x86/interface/pxe/pxe_entry.S Normal file
View File

@@ -0,0 +1,221 @@
/*
* Copyright (C) 2006 Michael Brown <mbrown@fensystems.co.uk>.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
* 02110-1301, USA.
*
* You can also choose to distribute this program under the terms of
* the Unmodified Binary Distribution Licence (as given in the file
* COPYING.UBDL), provided that you have satisfied its requirements.
*
*/
FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL )
.arch i386
/****************************************************************************
* !PXE structure
****************************************************************************
*/
.section ".text16.data", "aw", @progbits
.globl ppxe
.align 16
ppxe:
.ascii "!PXE" /* Signature */
.byte pxe_length /* StructLength */
.byte 0 /* StructCksum */
.byte 0 /* StructRev */
.byte 0 /* reserved_1 */
.word undiheader, 0 /* UNDIROMID */
.word 0, 0 /* BaseROMID */
.word pxe_entry_sp, 0 /* EntryPointSP */
.word pxe_entry_esp, 0 /* EntryPointESP */
.word -1, -1 /* StatusCallout */
.byte 0 /* reserved_2 */
.byte SegDescCnt /* SegDescCnt */
.word 0 /* FirstSelector */
pxe_segments:
.word 0, 0, 0, _data16_memsz /* Stack */
.word 0, 0, 0, _data16_memsz /* UNDIData */
.word 0, 0, 0, _text16_memsz /* UNDICode */
.word 0, 0, 0, _text16_memsz /* UNDICodeWrite */
.word 0, 0, 0, 0 /* BC_Data */
.word 0, 0, 0, 0 /* BC_Code */
.word 0, 0, 0, 0 /* BC_CodeWrite */
.equ SegDescCnt, ( ( . - pxe_segments ) / 8 )
.equ pxe_length, . - ppxe
.size ppxe, . - ppxe
/* Define undiheader=0 as a weak symbol for non-ROM builds */
.section ".weak", "a", @nobits
.weak undiheader
undiheader:
/****************************************************************************
* PXENV+ structure
****************************************************************************
*/
.section ".text16.data", "aw", @progbits
.globl pxenv
.align 16
pxenv:
.ascii "PXENV+" /* Signature */
.word 0x0201 /* Version */
.byte pxenv_length /* Length */
.byte 0 /* Checksum */
.word pxenv_entry, 0 /* RMEntry */
.long 0 /* PMEntry */
.word 0 /* PMSelector */
.word 0 /* StackSeg */
.word _data16_memsz /* StackSize */
.word 0 /* BC_CodeSeg */
.word 0 /* BC_CodeSize */
.word 0 /* BC_DataSeg */
.word 0 /* BC_DataSize */
.word 0 /* UNDIDataSeg */
.word _data16_memsz /* UNDIDataSize */
.word 0 /* UNDICodeSeg */
.word _text16_memsz /* UNDICodeSize */
.word ppxe, 0 /* PXEPtr */
.equ pxenv_length, . - pxenv
.size pxenv, . - pxenv
/****************************************************************************
* pxenv_entry (16-bit far call)
*
* PXE API call PXENV+ entry point
*
* Parameters:
* %es:di : Far pointer to PXE parameter structure
* %bx : PXE API call
* Returns:
* %ax : PXE exit status
* Corrupts:
* none
****************************************************************************
*/
/* Wyse Streaming Manager server (WLDRM13.BIN) assumes that
* the PXENV+ entry point is at UNDI_CS:0000; apparently,
* somebody at Wyse has difficulty distinguishing between the
* words "may" and "must"...
*/
.section ".text16.null", "ax", @progbits
.code16
pxenv_null_entry:
jmp pxenv_entry
.section ".text16", "ax", @progbits
.code16
pxenv_entry:
pushl $pxe_api_call
pushw %cs
call prot_call
addl $4, %esp
lret
.size pxenv_entry, . - pxenv_entry
/****************************************************************************
* pxe_entry
*
* PXE API call !PXE entry point
*
* Parameters:
* stack : Far pointer to PXE parameter structure
* stack : PXE API call
* Returns:
* %ax : PXE exit status
* Corrupts:
* none
****************************************************************************
*/
.section ".text16", "ax", @progbits
.code16
pxe_entry:
pxe_entry_sp:
/* Preserve original %esp */
pushl %esp
/* Zero high word of %esp to allow use of common code */
movzwl %sp, %esp
jmp pxe_entry_common
pxe_entry_esp:
/* Preserve %esp to match behaviour of pxe_entry_sp */
pushl %esp
pxe_entry_common:
/* Save PXENV+ API call registers */
pushw %es
pushw %di
pushw %bx
/* Load !PXE parameters from stack into PXENV+ registers */
addr32 movw 18(%esp), %bx
movw %bx, %es
addr32 movw 16(%esp), %di
addr32 movw 14(%esp), %bx
/* Make call as for PXENV+ */
pushw %cs
call pxenv_entry
/* Restore PXENV+ registers */
popw %bx
popw %di
popw %es
/* Restore original %esp and return */
popl %esp
lret
.size pxe_entry, . - pxe_entry
/****************************************************************************
* pxe_int_1a
*
* PXE INT 1A handler
*
* Parameters:
* %ax : 0x5650
* Returns:
* %ax : 0x564e
* %es:bx : Far pointer to the PXENV+ structure
* %edx : Physical address of the PXENV+ structure
* CF cleared
* Corrupts:
* none
****************************************************************************
*/
.section ".text16", "ax", @progbits
.code16
.globl pxe_int_1a
pxe_int_1a:
pushfw
cmpw $0x5650, %ax
jne 1f
/* INT 1A,5650 - PXE installation check */
xorl %edx, %edx
movw %cs, %dx
movw %dx, %es
movw $pxenv, %bx
shll $4, %edx
addl $pxenv, %edx
movw $0x564e, %ax
pushw %bp
movw %sp, %bp
andb $~0x01, 8(%bp) /* Clear CF on return */
popw %bp
popfw
iret
1: /* INT 1A,other - pass through */
popfw
ljmp *%cs:pxe_int_1a_vector
.section ".text16.data", "aw", @progbits
.globl pxe_int_1a_vector
pxe_int_1a_vector: .long 0

65
src/arch/x86/interface/pxe/pxe_exit_hook.c Normal file
View File

@@ -0,0 +1,65 @@
/** @file
*
* PXE exit hook
*
*/
/*
* Copyright (C) 2010 Shao Miller <shao.miller@yrdsb.edu.on.ca>.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
* 02110-1301, USA.
*
* You can also choose to distribute this program under the terms of
* the Unmodified Binary Distribution Licence (as given in the file
* COPYING.UBDL), provided that you have satisfied its requirements.
*/
FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
#include <stdint.h>
#include <realmode.h>
#include <pxe.h>
/** PXE exit hook */
extern segoff_t __data16 ( pxe_exit_hook );
#define pxe_exit_hook __use_data16 ( pxe_exit_hook )
/**
* FILE EXIT HOOK
*
* @v file_exit_hook Pointer to a struct
* s_PXENV_FILE_EXIT_HOOK
* @v s_PXENV_FILE_EXIT_HOOK::Hook SEG16:OFF16 to jump to
* @ret #PXENV_EXIT_SUCCESS Successfully set hook
* @ret #PXENV_EXIT_FAILURE We're not an NBP build
* @ret s_PXENV_FILE_EXIT_HOOK::Status PXE status code
*
*/
static PXENV_EXIT_t
pxenv_file_exit_hook ( struct s_PXENV_FILE_EXIT_HOOK *file_exit_hook ) {
DBG ( "PXENV_FILE_EXIT_HOOK" );
/* We'll jump to the specified SEG16:OFF16 during exit */
pxe_exit_hook.segment = file_exit_hook->Hook.segment;
pxe_exit_hook.offset = file_exit_hook->Hook.offset;
file_exit_hook->Status = PXENV_STATUS_SUCCESS;
return PXENV_EXIT_SUCCESS;
}
/** PXE file API */
struct pxe_api_call pxe_file_api_exit_hook __pxe_api_call =
PXE_API_CALL ( PXENV_FILE_EXIT_HOOK, pxenv_file_exit_hook,
struct s_PXENV_FILE_EXIT_HOOK );

346
src/arch/x86/interface/pxe/pxe_file.c Normal file
View File

@@ -0,0 +1,346 @@
/** @file
*
* PXE FILE API
*
*/
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <byteswap.h>
#include <ipxe/uaccess.h>
#include <ipxe/posix_io.h>
#include <ipxe/features.h>
#include <pxe.h>
#include <realmode.h>
/*
* Copyright (C) 2007 Michael Brown <mbrown@fensystems.co.uk>.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
* 02110-1301, USA.
*
* You can also choose to distribute this program under the terms of
* the Unmodified Binary Distribution Licence (as given in the file
* COPYING.UBDL), provided that you have satisfied its requirements.
*/
FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
FEATURE ( FEATURE_MISC, "PXEXT", DHCP_EB_FEATURE_PXE_EXT, 2 );
/**
* FILE OPEN
*
* @v file_open Pointer to a struct s_PXENV_FILE_OPEN
* @v s_PXENV_FILE_OPEN::FileName URL of file to open
* @ret #PXENV_EXIT_SUCCESS File was opened
* @ret #PXENV_EXIT_FAILURE File was not opened
* @ret s_PXENV_FILE_OPEN::Status PXE status code
* @ret s_PXENV_FILE_OPEN::FileHandle Handle of opened file
*
*/
static PXENV_EXIT_t pxenv_file_open ( struct s_PXENV_FILE_OPEN *file_open ) {
userptr_t filename;
size_t filename_len;
int fd;
DBG ( "PXENV_FILE_OPEN" );
/* Copy name from external program, and open it */
filename = real_to_user ( file_open->FileName.segment,
file_open->FileName.offset );
filename_len = strlen_user ( filename, 0 );
{
char uri_string[ filename_len + 1 ];
copy_from_user ( uri_string, filename, 0,
sizeof ( uri_string ) );
DBG ( " %s", uri_string );
fd = open ( uri_string );
}
if ( fd < 0 ) {
file_open->Status = PXENV_STATUS ( fd );
return PXENV_EXIT_FAILURE;
}
DBG ( " as file %d", fd );
file_open->FileHandle = fd;
file_open->Status = PXENV_STATUS_SUCCESS;
return PXENV_EXIT_SUCCESS;
}
/**
* FILE CLOSE
*
* @v file_close Pointer to a struct s_PXENV_FILE_CLOSE
* @v s_PXENV_FILE_CLOSE::FileHandle File handle
* @ret #PXENV_EXIT_SUCCESS File was closed
* @ret #PXENV_EXIT_FAILURE File was not closed
* @ret s_PXENV_FILE_CLOSE::Status PXE status code
*
*/
static PXENV_EXIT_t pxenv_file_close ( struct s_PXENV_FILE_CLOSE *file_close ) {
DBG ( "PXENV_FILE_CLOSE %d", file_close->FileHandle );
close ( file_close->FileHandle );
file_close->Status = PXENV_STATUS_SUCCESS;
return PXENV_EXIT_SUCCESS;
}
/**
* FILE SELECT
*
* @v file_select Pointer to a struct s_PXENV_FILE_SELECT
* @v s_PXENV_FILE_SELECT::FileHandle File handle
* @ret #PXENV_EXIT_SUCCESS File has been checked for readiness
* @ret #PXENV_EXIT_FAILURE File has not been checked for readiness
* @ret s_PXENV_FILE_SELECT::Status PXE status code
* @ret s_PXENV_FILE_SELECT::Ready Indication of readiness
*
*/
static PXENV_EXIT_t
pxenv_file_select ( struct s_PXENV_FILE_SELECT *file_select ) {
fd_set fdset;
int ready;
DBG ( "PXENV_FILE_SELECT %d", file_select->FileHandle );
FD_ZERO ( &fdset );
FD_SET ( file_select->FileHandle, &fdset );
if ( ( ready = select ( &fdset, 0 ) ) < 0 ) {
file_select->Status = PXENV_STATUS ( ready );
return PXENV_EXIT_FAILURE;
}
file_select->Ready = ( ready ? RDY_READ : 0 );
file_select->Status = PXENV_STATUS_SUCCESS;
return PXENV_EXIT_SUCCESS;
}
/**
* FILE READ
*
* @v file_read Pointer to a struct s_PXENV_FILE_READ
* @v s_PXENV_FILE_READ::FileHandle File handle
* @v s_PXENV_FILE_READ::BufferSize Size of data buffer
* @v s_PXENV_FILE_READ::Buffer Data buffer
* @ret #PXENV_EXIT_SUCCESS Data has been read from file
* @ret #PXENV_EXIT_FAILURE Data has not been read from file
* @ret s_PXENV_FILE_READ::Status PXE status code
* @ret s_PXENV_FILE_READ::Ready Indication of readiness
* @ret s_PXENV_FILE_READ::BufferSize Length of data read
*
*/
static PXENV_EXIT_t pxenv_file_read ( struct s_PXENV_FILE_READ *file_read ) {
userptr_t buffer;
ssize_t len;
DBG ( "PXENV_FILE_READ %d to %04x:%04x+%04x", file_read->FileHandle,
file_read->Buffer.segment, file_read->Buffer.offset,
file_read->BufferSize );
buffer = real_to_user ( file_read->Buffer.segment,
file_read->Buffer.offset );
if ( ( len = read_user ( file_read->FileHandle, buffer, 0,
file_read->BufferSize ) ) < 0 ) {
file_read->Status = PXENV_STATUS ( len );
return PXENV_EXIT_FAILURE;
}
DBG ( " read %04zx", ( ( size_t ) len ) );
file_read->BufferSize = len;
file_read->Status = PXENV_STATUS_SUCCESS;
return PXENV_EXIT_SUCCESS;
}
/**
* GET FILE SIZE
*
* @v get_file_size Pointer to a struct s_PXENV_GET_FILE_SIZE
* @v s_PXENV_GET_FILE_SIZE::FileHandle File handle
* @ret #PXENV_EXIT_SUCCESS File size has been determined
* @ret #PXENV_EXIT_FAILURE File size has not been determined
* @ret s_PXENV_GET_FILE_SIZE::Status PXE status code
* @ret s_PXENV_GET_FILE_SIZE::FileSize Size of file
*/
static PXENV_EXIT_t
pxenv_get_file_size ( struct s_PXENV_GET_FILE_SIZE *get_file_size ) {
ssize_t filesize;
DBG ( "PXENV_GET_FILE_SIZE %d", get_file_size->FileHandle );
filesize = fsize ( get_file_size->FileHandle );
if ( filesize < 0 ) {
get_file_size->Status = PXENV_STATUS ( filesize );
return PXENV_EXIT_FAILURE;
}
DBG ( " is %zd", ( ( size_t ) filesize ) );
get_file_size->FileSize = filesize;
get_file_size->Status = PXENV_STATUS_SUCCESS;
return PXENV_EXIT_SUCCESS;
}
/**
* FILE EXEC
*
* @v file_exec Pointer to a struct s_PXENV_FILE_EXEC
* @v s_PXENV_FILE_EXEC::Command Command to execute
* @ret #PXENV_EXIT_SUCCESS Command was executed successfully
* @ret #PXENV_EXIT_FAILURE Command was not executed successfully
* @ret s_PXENV_FILE_EXEC::Status PXE status code
*
*/
static PXENV_EXIT_t pxenv_file_exec ( struct s_PXENV_FILE_EXEC *file_exec ) {
userptr_t command;
size_t command_len;
int rc;
DBG ( "PXENV_FILE_EXEC" );
/* Copy name from external program, and exec it */
command = real_to_user ( file_exec->Command.segment,
file_exec->Command.offset );
command_len = strlen_user ( command, 0 );
{
char command_string[ command_len + 1 ];
copy_from_user ( command_string, command, 0,
sizeof ( command_string ) );
DBG ( " %s", command_string );
if ( ( rc = system ( command_string ) ) != 0 ) {
file_exec->Status = PXENV_STATUS ( rc );
return PXENV_EXIT_FAILURE;
}
}
file_exec->Status = PXENV_STATUS_SUCCESS;
return PXENV_EXIT_SUCCESS;
}
/**
* FILE CMDLINE
*
* @v file_cmdline Pointer to a struct s_PXENV_FILE_CMDLINE
* @v s_PXENV_FILE_CMDLINE::Buffer Buffer to contain command line
* @v s_PXENV_FILE_CMDLINE::BufferSize Size of buffer
* @ret #PXENV_EXIT_SUCCESS Command was executed successfully
* @ret #PXENV_EXIT_FAILURE Command was not executed successfully
* @ret s_PXENV_FILE_EXEC::Status PXE status code
* @ret s_PXENV_FILE_EXEC::BufferSize Length of command line (including NUL)
*
*/
static PXENV_EXIT_t
pxenv_file_cmdline ( struct s_PXENV_FILE_CMDLINE *file_cmdline ) {
userptr_t buffer;
size_t max_len;
size_t len;
DBG ( "PXENV_FILE_CMDLINE to %04x:%04x+%04x \"%s\"\n",
file_cmdline->Buffer.segment, file_cmdline->Buffer.offset,
file_cmdline->BufferSize, pxe_cmdline );
buffer = real_to_user ( file_cmdline->Buffer.segment,
file_cmdline->Buffer.offset );
len = file_cmdline->BufferSize;
max_len = ( pxe_cmdline ?
( strlen ( pxe_cmdline ) + 1 /* NUL */ ) : 0 );
if ( len > max_len )
len = max_len;
copy_to_user ( buffer, 0, pxe_cmdline, len );
file_cmdline->BufferSize = max_len;
file_cmdline->Status = PXENV_STATUS_SUCCESS;
return PXENV_EXIT_SUCCESS;
}
/**
* FILE API CHECK
*
* @v file_exec Pointer to a struct s_PXENV_FILE_API_CHECK
* @v s_PXENV_FILE_API_CHECK::Magic Inbound magic number (0x91d447b2)
* @ret #PXENV_EXIT_SUCCESS Command was executed successfully
* @ret #PXENV_EXIT_FAILURE Command was not executed successfully
* @ret s_PXENV_FILE_API_CHECK::Status PXE status code
* @ret s_PXENV_FILE_API_CHECK::Magic Outbound magic number (0xe9c17b20)
* @ret s_PXENV_FILE_API_CHECK::Provider "iPXE" (0x45585067)
* @ret s_PXENV_FILE_API_CHECK::APIMask API function bitmask
* @ret s_PXENV_FILE_API_CHECK::Flags Reserved
*
*/
static PXENV_EXIT_t
pxenv_file_api_check ( struct s_PXENV_FILE_API_CHECK *file_api_check ) {
struct pxe_api_call *call;
unsigned int mask = 0;
unsigned int offset;
DBG ( "PXENV_FILE_API_CHECK" );
/* Check for magic value */
if ( file_api_check->Magic != 0x91d447b2 ) {
file_api_check->Status = PXENV_STATUS_BAD_FUNC;
return PXENV_EXIT_FAILURE;
}
/* Check for required parameter size */
if ( file_api_check->Size < sizeof ( *file_api_check ) ) {
file_api_check->Status = PXENV_STATUS_OUT_OF_RESOURCES;
return PXENV_EXIT_FAILURE;
}
/* Determine supported calls */
for_each_table_entry ( call, PXE_API_CALLS ) {
offset = ( call->opcode - PXENV_FILE_MIN );
if ( offset <= ( PXENV_FILE_MAX - PXENV_FILE_MIN ) )
mask |= ( 1 << offset );
}
/* Fill in parameters */
file_api_check->Size = sizeof ( *file_api_check );
file_api_check->Magic = 0xe9c17b20;
file_api_check->Provider = 0x45585067; /* "iPXE" */
file_api_check->APIMask = mask;
file_api_check->Flags = 0; /* None defined */
file_api_check->Status = PXENV_STATUS_SUCCESS;
return PXENV_EXIT_SUCCESS;
}
/** PXE file API */
struct pxe_api_call pxe_file_api[] __pxe_api_call = {
PXE_API_CALL ( PXENV_FILE_OPEN, pxenv_file_open,
struct s_PXENV_FILE_OPEN ),
PXE_API_CALL ( PXENV_FILE_CLOSE, pxenv_file_close,
struct s_PXENV_FILE_CLOSE ),
PXE_API_CALL ( PXENV_FILE_SELECT, pxenv_file_select,
struct s_PXENV_FILE_SELECT ),
PXE_API_CALL ( PXENV_FILE_READ, pxenv_file_read,
struct s_PXENV_FILE_READ ),
PXE_API_CALL ( PXENV_GET_FILE_SIZE, pxenv_get_file_size,
struct s_PXENV_GET_FILE_SIZE ),
PXE_API_CALL ( PXENV_FILE_EXEC, pxenv_file_exec,
struct s_PXENV_FILE_EXEC ),
PXE_API_CALL ( PXENV_FILE_CMDLINE, pxenv_file_cmdline,
struct s_PXENV_FILE_CMDLINE ),
PXE_API_CALL ( PXENV_FILE_API_CHECK, pxenv_file_api_check,
struct s_PXENV_FILE_API_CHECK ),
};

55
src/arch/x86/interface/pxe/pxe_loader.c Normal file
View File

@@ -0,0 +1,55 @@
/*
* Copyright (C) 2007 Michael Brown <mbrown@fensystems.co.uk>.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
* 02110-1301, USA.
*
* You can also choose to distribute this program under the terms of
* the Unmodified Binary Distribution Licence (as given in the file
* COPYING.UBDL), provided that you have satisfied its requirements.
*/
FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
#include <ipxe/init.h>
#include "pxe.h"
#include "pxe_call.h"
/** @file
*
* PXE UNDI loader
*
*/
/* PXENV_UNDI_LOADER
*
*/
PXENV_EXIT_t undi_loader ( struct s_UNDI_LOADER *undi_loader ) {
/* Perform one-time initialisation (e.g. heap) */
initialise();
DBG ( "[PXENV_UNDI_LOADER to CS %04x DS %04x]",
undi_loader->UNDI_CS, undi_loader->UNDI_DS );
/* Fill in UNDI loader structure */
undi_loader->PXEptr.segment = rm_cs;
undi_loader->PXEptr.offset = __from_text16 ( &ppxe );
undi_loader->PXENVptr.segment = rm_cs;
undi_loader->PXENVptr.offset = __from_text16 ( &pxenv );
undi_loader->Status = PXENV_STATUS_SUCCESS;
return PXENV_EXIT_SUCCESS;
}

397
src/arch/x86/interface/pxe/pxe_preboot.c Normal file
View File

@@ -0,0 +1,397 @@
/** @file
*
* PXE Preboot API
*
*/
/* PXE API interface for Etherboot.
*
* Copyright (C) 2004 Michael Brown <mbrown@fensystems.co.uk>.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
* 02110-1301, USA.
*
* You can also choose to distribute this program under the terms of
* the Unmodified Binary Distribution Licence (as given in the file
* COPYING.UBDL), provided that you have satisfied its requirements.
*/
FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include <ipxe/uaccess.h>
#include <ipxe/dhcp.h>
#include <ipxe/fakedhcp.h>
#include <ipxe/device.h>
#include <ipxe/netdevice.h>
#include <ipxe/isapnp.h>
#include <ipxe/init.h>
#include <ipxe/if_ether.h>
#include <basemem_packet.h>
#include <biosint.h>
#include <rmsetjmp.h>
#include "pxe.h"
#include "pxe_call.h"
/* Avoid dragging in isapnp.o unnecessarily */
uint16_t isapnp_read_port;
/** Zero-based versions of PXENV_GET_CACHED_INFO::PacketType */
enum pxe_cached_info_indices {
CACHED_INFO_DHCPDISCOVER = ( PXENV_PACKET_TYPE_DHCP_DISCOVER - 1 ),
CACHED_INFO_DHCPACK = ( PXENV_PACKET_TYPE_DHCP_ACK - 1 ),
CACHED_INFO_BINL = ( PXENV_PACKET_TYPE_CACHED_REPLY - 1 ),
NUM_CACHED_INFOS
};
/** A cached DHCP packet */
union pxe_cached_info {
struct dhcphdr dhcphdr;
/* This buffer must be *exactly* the size of a BOOTPLAYER_t
* structure, otherwise WinPE will die horribly. It takes the
* size of *our* buffer and feeds it in to us as the size of
* one of *its* buffers. If our buffer is larger than it
* expects, we therefore end up overwriting part of its data
* segment, since it tells us to do so. (D'oh!)
*
* Note that a BOOTPLAYER_t is not necessarily large enough to
* hold a DHCP packet; this is a flaw in the PXE spec.
*/
BOOTPLAYER_t packet;
} __attribute__ (( packed ));
/** A PXE DHCP packet creator */
struct pxe_dhcp_packet_creator {
/** Create DHCP packet
*
* @v netdev Network device
* @v data Buffer for DHCP packet
* @v max_len Size of DHCP packet buffer
* @ret rc Return status code
*/
int ( * create ) ( struct net_device *netdev, void *data,
size_t max_len );
};
/** PXE DHCP packet creators */
static struct pxe_dhcp_packet_creator pxe_dhcp_packet_creators[] = {
[CACHED_INFO_DHCPDISCOVER] = { create_fakedhcpdiscover },
[CACHED_INFO_DHCPACK] = { create_fakedhcpack },
[CACHED_INFO_BINL] = { create_fakepxebsack },
};
/**
* Name PXENV_GET_CACHED_INFO packet type
*
* @v packet_type Packet type
* @ret name Name of packet type
*/
static inline __attribute__ (( always_inline )) const char *
pxenv_get_cached_info_name ( int packet_type ) {
switch ( packet_type ) {
case PXENV_PACKET_TYPE_DHCP_DISCOVER:
return "DHCPDISCOVER";
case PXENV_PACKET_TYPE_DHCP_ACK:
return "DHCPACK";
case PXENV_PACKET_TYPE_CACHED_REPLY:
return "BINL";
default:
return "<INVALID>";
}
}
/* The case in which the caller doesn't supply a buffer is really
* awkward to support given that we have multiple sources of options,
* and that we don't actually store the DHCP packets. (We may not
* even have performed DHCP; we may have obtained all configuration
* from non-volatile stored options or from the command line.)
*
* Some NBPs rely on the buffers we provide being persistent, so we
* can't just use the temporary packet buffer. 4.5kB of base memory
* always wasted just because some clients are too lazy to provide
* their own buffers...
*/
static union pxe_cached_info __bss16_array ( cached_info, [NUM_CACHED_INFOS] );
#define cached_info __use_data16 ( cached_info )
/**
* Construct cached DHCP packets
*
*/
void pxe_fake_cached_info ( void ) {
struct pxe_dhcp_packet_creator *creator;
union pxe_cached_info *info;
unsigned int i;
int rc;
/* Sanity check */
assert ( pxe_netdev != NULL );
/* Erase any stale packets */
memset ( cached_info, 0, sizeof ( cached_info ) );
/* Construct all DHCP packets */
for ( i = 0 ; i < ( sizeof ( pxe_dhcp_packet_creators ) /
sizeof ( pxe_dhcp_packet_creators[0] ) ) ; i++ ) {
/* Construct DHCP packet */
creator = &pxe_dhcp_packet_creators[i];
info = &cached_info[i];
if ( ( rc = creator->create ( pxe_netdev, info,
sizeof ( *info ) ) ) != 0 ) {
DBGC ( &pxe_netdev, " failed to build packet: %s\n",
strerror ( rc ) );
/* Continue constructing remaining packets */
}
}
}
/**
* UNLOAD BASE CODE STACK
*
* @v None -
* @ret ...
*
*/
static PXENV_EXIT_t
pxenv_unload_stack ( struct s_PXENV_UNLOAD_STACK *unload_stack ) {
DBGC ( &pxe_netdev, "PXENV_UNLOAD_STACK\n" );
unload_stack->Status = PXENV_STATUS_SUCCESS;
return PXENV_EXIT_SUCCESS;
}
/* PXENV_GET_CACHED_INFO
*
* Status: working
*/
static PXENV_EXIT_t
pxenv_get_cached_info ( struct s_PXENV_GET_CACHED_INFO *get_cached_info ) {
union pxe_cached_info *info;
unsigned int idx;
size_t len;
userptr_t buffer;
DBGC ( &pxe_netdev, "PXENV_GET_CACHED_INFO %s to %04x:%04x+%x",
pxenv_get_cached_info_name ( get_cached_info->PacketType ),
get_cached_info->Buffer.segment,
get_cached_info->Buffer.offset, get_cached_info->BufferSize );
/* Sanity check */
idx = ( get_cached_info->PacketType - 1 );
if ( idx >= NUM_CACHED_INFOS ) {
DBGC ( &pxe_netdev, " bad PacketType %d\n",
get_cached_info->PacketType );
get_cached_info->Status = PXENV_STATUS_UNSUPPORTED;
return PXENV_EXIT_FAILURE;
}
info = &cached_info[idx];
/* Copy packet (if applicable) */
len = get_cached_info->BufferSize;
if ( len == 0 ) {
/* Point client at our cached buffer.
*
* To add to the fun, Intel decided at some point in
* the evolution of the PXE specification to add the
* BufferLimit field, which we are meant to fill in
* with the length of our packet buffer, so that the
* caller can safely modify the boot server reply
* packet stored therein. However, this field was not
* present in earlier versions of the PXE spec, and
* there is at least one PXE NBP (Altiris) which
* allocates only exactly enough space for this
* earlier, shorter version of the structure. If we
* actually fill in the BufferLimit field, we
* therefore risk trashing random areas of the
* caller's memory. If we *don't* fill it in, then
* the caller is at liberty to assume that whatever
* random value happened to be in that location
* represents the length of the buffer we've just
* passed back to it.
*
* Since older PXE stacks won't fill this field in
* anyway, it's probably safe to assume that no
* callers actually rely on it, so we choose to not
* fill it in.
*/
get_cached_info->Buffer.segment = rm_ds;
get_cached_info->Buffer.offset = __from_data16 ( info );
get_cached_info->BufferSize = sizeof ( *info );
DBGC ( &pxe_netdev, " using %04x:%04x+%04x['%x']",
get_cached_info->Buffer.segment,
get_cached_info->Buffer.offset,
get_cached_info->BufferSize,
get_cached_info->BufferLimit );
} else {
/* Copy packet to client buffer */
if ( len > sizeof ( *info ) )
len = sizeof ( *info );
if ( len < sizeof ( *info ) )
DBGC ( &pxe_netdev, " buffer may be too short" );
buffer = real_to_user ( get_cached_info->Buffer.segment,
get_cached_info->Buffer.offset );
copy_to_user ( buffer, 0, info, len );
get_cached_info->BufferSize = len;
}
DBGC ( &pxe_netdev, "\n" );
get_cached_info->Status = PXENV_STATUS_SUCCESS;
return PXENV_EXIT_SUCCESS;
}
/* PXENV_RESTART_TFTP
*
* Status: working
*/
static PXENV_EXIT_t
pxenv_restart_tftp ( struct s_PXENV_TFTP_READ_FILE *restart_tftp ) {
PXENV_EXIT_t tftp_exit;
DBGC ( &pxe_netdev, "PXENV_RESTART_TFTP\n" );
/* Words cannot describe the complete mismatch between the PXE
* specification and any possible version of reality...
*/
restart_tftp->Buffer = PXE_LOAD_PHYS; /* Fixed by spec, apparently */
restart_tftp->BufferSize = ( 0xa0000 - PXE_LOAD_PHYS ); /* Near enough */
tftp_exit = pxenv_tftp_read_file ( restart_tftp );
if ( tftp_exit != PXENV_EXIT_SUCCESS )
return tftp_exit;
/* Restart NBP */
rmlongjmp ( pxe_restart_nbp, PXENV_RESTART_TFTP );
}
/* PXENV_START_UNDI
*
* Status: working
*/
static PXENV_EXIT_t pxenv_start_undi ( struct s_PXENV_START_UNDI *start_undi ) {
unsigned int bus_type;
unsigned int location;
struct net_device *netdev;
DBGC ( &pxe_netdev, "PXENV_START_UNDI %04x:%04x:%04x\n",
start_undi->AX, start_undi->BX, start_undi->DX );
/* Determine bus type and location. Use a heuristic to decide
* whether we are PCI or ISAPnP
*/
if ( ( start_undi->DX >= ISAPNP_READ_PORT_MIN ) &&
( start_undi->DX <= ISAPNP_READ_PORT_MAX ) &&
( start_undi->BX >= ISAPNP_CSN_MIN ) &&
( start_undi->BX <= ISAPNP_CSN_MAX ) ) {
bus_type = BUS_TYPE_ISAPNP;
location = start_undi->BX;
/* Record ISAPnP read port for use by isapnp.c */
isapnp_read_port = start_undi->DX;
} else {
bus_type = BUS_TYPE_PCI;
location = start_undi->AX;
}
/* Probe for devices, etc. */
startup();
/* Look for a matching net device */
netdev = find_netdev_by_location ( bus_type, location );
if ( ! netdev ) {
DBGC ( &pxe_netdev, "PXENV_START_UNDI could not find matching "
"net device\n" );
start_undi->Status = PXENV_STATUS_UNDI_CANNOT_INITIALIZE_NIC;
return PXENV_EXIT_FAILURE;
}
DBGC ( &pxe_netdev, "PXENV_START_UNDI found net device %s\n",
netdev->name );
/* Activate PXE */
pxe_activate ( netdev );
start_undi->Status = PXENV_STATUS_SUCCESS;
return PXENV_EXIT_SUCCESS;
}
/* PXENV_STOP_UNDI
*
* Status: working
*/
static PXENV_EXIT_t pxenv_stop_undi ( struct s_PXENV_STOP_UNDI *stop_undi ) {
DBGC ( &pxe_netdev, "PXENV_STOP_UNDI\n" );
/* Deactivate PXE */
pxe_deactivate();
/* Prepare for unload */
shutdown_boot();
/* Check to see if we still have any hooked interrupts */
if ( hooked_bios_interrupts != 0 ) {
DBGC ( &pxe_netdev, "PXENV_STOP_UNDI failed: %d interrupts "
"still hooked\n", hooked_bios_interrupts );
stop_undi->Status = PXENV_STATUS_KEEP_UNDI;
return PXENV_EXIT_FAILURE;
}
stop_undi->Status = PXENV_STATUS_SUCCESS;
return PXENV_EXIT_SUCCESS;
}
/* PXENV_START_BASE
*
* Status: won't implement (requires major structural changes)
*/
static PXENV_EXIT_t pxenv_start_base ( struct s_PXENV_START_BASE *start_base ) {
DBGC ( &pxe_netdev, "PXENV_START_BASE\n" );
start_base->Status = PXENV_STATUS_UNSUPPORTED;
return PXENV_EXIT_FAILURE;
}
/* PXENV_STOP_BASE
*
* Status: working
*/
static PXENV_EXIT_t pxenv_stop_base ( struct s_PXENV_STOP_BASE *stop_base ) {
DBGC ( &pxe_netdev, "PXENV_STOP_BASE\n" );
/* The only time we will be called is when the NBP is trying
* to shut down the PXE stack. There's nothing we need to do
* in this call.
*/
stop_base->Status = PXENV_STATUS_SUCCESS;
return PXENV_EXIT_SUCCESS;
}
/** PXE preboot API */
struct pxe_api_call pxe_preboot_api[] __pxe_api_call = {
PXE_API_CALL ( PXENV_UNLOAD_STACK, pxenv_unload_stack,
struct s_PXENV_UNLOAD_STACK ),
PXE_API_CALL ( PXENV_GET_CACHED_INFO, pxenv_get_cached_info,
struct s_PXENV_GET_CACHED_INFO ),
PXE_API_CALL ( PXENV_RESTART_TFTP, pxenv_restart_tftp,
struct s_PXENV_TFTP_READ_FILE ),
PXE_API_CALL ( PXENV_START_UNDI, pxenv_start_undi,
struct s_PXENV_START_UNDI ),
PXE_API_CALL ( PXENV_STOP_UNDI, pxenv_stop_undi,
struct s_PXENV_STOP_UNDI ),
PXE_API_CALL ( PXENV_START_BASE, pxenv_start_base,
struct s_PXENV_START_BASE ),
PXE_API_CALL ( PXENV_STOP_BASE, pxenv_stop_base,
struct s_PXENV_STOP_BASE ),
};

595
src/arch/x86/interface/pxe/pxe_tftp.c Normal file
View File

@@ -0,0 +1,595 @@
/** @file
*
* PXE TFTP API
*
*/
/*
* Copyright (C) 2004 Michael Brown <mbrown@fensystems.co.uk>.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
* 02110-1301, USA.
*
* You can also choose to distribute this program under the terms of
* the Unmodified Binary Distribution Licence (as given in the file
* COPYING.UBDL), provided that you have satisfied its requirements.
*/
FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <byteswap.h>
#include <ipxe/uaccess.h>
#include <ipxe/in.h>
#include <ipxe/tftp.h>
#include <ipxe/iobuf.h>
#include <ipxe/xfer.h>
#include <ipxe/open.h>
#include <ipxe/process.h>
#include <ipxe/uri.h>
#include <realmode.h>
#include <pxe.h>
/** A PXE TFTP connection */
struct pxe_tftp_connection {
/** Data transfer interface */
struct interface xfer;
/** Data buffer */
userptr_t buffer;
/** Size of data buffer */
size_t size;
/** Starting offset of data buffer */
size_t start;
/** File position */
size_t offset;
/** Maximum file position */
size_t max_offset;
/** Block size */
size_t blksize;
/** Block index */
unsigned int blkidx;
/** Overall return status code */
int rc;
};
/**
* Close PXE TFTP connection
*
* @v pxe_tftp PXE TFTP connection
* @v rc Final status code
*/
static void pxe_tftp_close ( struct pxe_tftp_connection *pxe_tftp, int rc ) {
intf_shutdown ( &pxe_tftp->xfer, rc );
pxe_tftp->rc = rc;
}
/**
* Check flow control window
*
* @v pxe_tftp PXE TFTP connection
* @ret len Length of window
*/
static size_t pxe_tftp_xfer_window ( struct pxe_tftp_connection *pxe_tftp ) {
return pxe_tftp->blksize;
}
/**
* Receive new data
*
* @v pxe_tftp PXE TFTP connection
* @v iobuf I/O buffer
* @v meta Transfer metadata
* @ret rc Return status code
*/
static int pxe_tftp_xfer_deliver ( struct pxe_tftp_connection *pxe_tftp,
struct io_buffer *iobuf,
struct xfer_metadata *meta ) {
size_t len = iob_len ( iobuf );
int rc = 0;
/* Calculate new buffer position */
if ( meta->flags & XFER_FL_ABS_OFFSET )
pxe_tftp->offset = 0;
pxe_tftp->offset += meta->offset;
/* Copy data block to buffer */
if ( len == 0 ) {
/* No data (pure seek); treat as success */
} else if ( pxe_tftp->offset < pxe_tftp->start ) {
DBG ( " buffer underrun at %zx (min %zx)",
pxe_tftp->offset, pxe_tftp->start );
rc = -ENOBUFS;
} else if ( ( pxe_tftp->offset + len ) >
( pxe_tftp->start + pxe_tftp->size ) ) {
DBG ( " buffer overrun at %zx (max %zx)",
( pxe_tftp->offset + len ),
( pxe_tftp->start + pxe_tftp->size ) );
rc = -ENOBUFS;
} else {
copy_to_user ( pxe_tftp->buffer,
( pxe_tftp->offset - pxe_tftp->start ),
iobuf->data, len );
}
/* Calculate new buffer position */
pxe_tftp->offset += len;
/* Record maximum offset as the file size */
if ( pxe_tftp->max_offset < pxe_tftp->offset )
pxe_tftp->max_offset = pxe_tftp->offset;
/* Terminate transfer on error */
if ( rc != 0 )
pxe_tftp_close ( pxe_tftp, rc );
free_iob ( iobuf );
return rc;
}
/** PXE TFTP connection interface operations */
static struct interface_operation pxe_tftp_xfer_ops[] = {
INTF_OP ( xfer_deliver, struct pxe_tftp_connection *,
pxe_tftp_xfer_deliver ),
INTF_OP ( xfer_window, struct pxe_tftp_connection *,
pxe_tftp_xfer_window ),
INTF_OP ( intf_close, struct pxe_tftp_connection *, pxe_tftp_close ),
};
/** PXE TFTP connection interface descriptor */
static struct interface_descriptor pxe_tftp_xfer_desc =
INTF_DESC ( struct pxe_tftp_connection, xfer, pxe_tftp_xfer_ops );
/** The PXE TFTP connection */
static struct pxe_tftp_connection pxe_tftp = {
.xfer = INTF_INIT ( pxe_tftp_xfer_desc ),
};
/**
* Open PXE TFTP connection
*
* @v ipaddress IP address
* @v port TFTP server port (in network byte order)
* @v filename File name
* @v blksize Requested block size
* @ret rc Return status code
*/
static int pxe_tftp_open ( IP4_t ipaddress, UDP_PORT_t port,
UINT8_t *filename, UINT16_t blksize ) {
union {
struct sockaddr sa;
struct sockaddr_in sin;
} server;
struct uri *uri;
int rc;
/* Reset PXE TFTP connection structure */
memset ( &pxe_tftp, 0, sizeof ( pxe_tftp ) );
intf_init ( &pxe_tftp.xfer, &pxe_tftp_xfer_desc, NULL );
if ( blksize < TFTP_DEFAULT_BLKSIZE )
blksize = TFTP_DEFAULT_BLKSIZE;
pxe_tftp.blksize = blksize;
pxe_tftp.rc = -EINPROGRESS;
/* Construct URI */
memset ( &server, 0, sizeof ( server ) );
server.sin.sin_family = AF_INET;
server.sin.sin_addr.s_addr = ipaddress;
server.sin.sin_port = port;
DBG ( " %s", sock_ntoa ( &server.sa ) );
if ( port )
DBG ( ":%d", ntohs ( port ) );
DBG ( ":%s", filename );
uri = pxe_uri ( &server.sa, ( ( char * ) filename ) );
if ( ! uri ) {
DBG ( " could not create URI\n" );
return -ENOMEM;
}
/* Open PXE TFTP connection */
if ( ( rc = xfer_open_uri ( &pxe_tftp.xfer, uri ) ) != 0 ) {
DBG ( " could not open (%s)\n", strerror ( rc ) );
return rc;
}
return 0;
}
/**
* TFTP OPEN
*
* @v tftp_open Pointer to a struct s_PXENV_TFTP_OPEN
* @v s_PXENV_TFTP_OPEN::ServerIPAddress TFTP server IP address
* @v s_PXENV_TFTP_OPEN::GatewayIPAddress Relay agent IP address, or 0.0.0.0
* @v s_PXENV_TFTP_OPEN::FileName Name of file to open
* @v s_PXENV_TFTP_OPEN::TFTPPort TFTP server UDP port
* @v s_PXENV_TFTP_OPEN::PacketSize TFTP blksize option to request
* @ret #PXENV_EXIT_SUCCESS File was opened
* @ret #PXENV_EXIT_FAILURE File was not opened
* @ret s_PXENV_TFTP_OPEN::Status PXE status code
* @ret s_PXENV_TFTP_OPEN::PacketSize Negotiated blksize
* @err #PXENV_STATUS_TFTP_INVALID_PACKET_SIZE Requested blksize too small
*
* Opens a TFTP connection for downloading a file a block at a time
* using pxenv_tftp_read().
*
* If s_PXENV_TFTP_OPEN::GatewayIPAddress is 0.0.0.0, normal IP
* routing will take place. See the relevant
* @ref pxe_routing "implementation note" for more details.
*
* On x86, you must set the s_PXE::StatusCallout field to a nonzero
* value before calling this function in protected mode. You cannot
* call this function with a 32-bit stack segment. (See the relevant
* @ref pxe_x86_pmode16 "implementation note" for more details.)
*
* @note According to the PXE specification version 2.1, this call
* "opens a file for reading/writing", though how writing is to be
* achieved without the existence of an API call %pxenv_tftp_write()
* is not made clear.
*
* @note Despite the existence of the numerous statements within the
* PXE specification of the form "...if a TFTP/MTFTP or UDP connection
* is active...", you cannot use pxenv_tftp_open() and
* pxenv_tftp_read() to read a file via MTFTP; only via plain old
* TFTP. If you want to use MTFTP, use pxenv_tftp_read_file()
* instead. Astute readers will note that, since
* pxenv_tftp_read_file() is an atomic operation from the point of
* view of the PXE API, it is conceptually impossible to issue any
* other PXE API call "if an MTFTP connection is active".
*/
static PXENV_EXIT_t pxenv_tftp_open ( struct s_PXENV_TFTP_OPEN *tftp_open ) {
int rc;
DBG ( "PXENV_TFTP_OPEN" );
/* Guard against callers that fail to close before re-opening */
pxe_tftp_close ( &pxe_tftp, 0 );
/* Open connection */
if ( ( rc = pxe_tftp_open ( tftp_open->ServerIPAddress,
tftp_open->TFTPPort,
tftp_open->FileName,
tftp_open->PacketSize ) ) != 0 ) {
tftp_open->Status = PXENV_STATUS ( rc );
return PXENV_EXIT_FAILURE;
}
/* Wait for OACK to arrive so that we have the block size */
while ( ( ( rc = pxe_tftp.rc ) == -EINPROGRESS ) &&
( pxe_tftp.max_offset == 0 ) ) {
step();
}
pxe_tftp.blksize = xfer_window ( &pxe_tftp.xfer );
tftp_open->PacketSize = pxe_tftp.blksize;
DBG ( " blksize=%d", tftp_open->PacketSize );
/* EINPROGRESS is normal; we don't wait for the whole transfer */
if ( rc == -EINPROGRESS )
rc = 0;
tftp_open->Status = PXENV_STATUS ( rc );
return ( rc ? PXENV_EXIT_FAILURE : PXENV_EXIT_SUCCESS );
}
/**
* TFTP CLOSE
*
* @v tftp_close Pointer to a struct s_PXENV_TFTP_CLOSE
* @ret #PXENV_EXIT_SUCCESS File was closed successfully
* @ret #PXENV_EXIT_FAILURE File was not closed
* @ret s_PXENV_TFTP_CLOSE::Status PXE status code
* @err None -
*
* Close a connection previously opened with pxenv_tftp_open(). You
* must have previously opened a connection with pxenv_tftp_open().
*
* On x86, you must set the s_PXE::StatusCallout field to a nonzero
* value before calling this function in protected mode. You cannot
* call this function with a 32-bit stack segment. (See the relevant
* @ref pxe_x86_pmode16 "implementation note" for more details.)
*/
static PXENV_EXIT_t pxenv_tftp_close ( struct s_PXENV_TFTP_CLOSE *tftp_close ) {
DBG ( "PXENV_TFTP_CLOSE" );
pxe_tftp_close ( &pxe_tftp, 0 );
tftp_close->Status = PXENV_STATUS_SUCCESS;
return PXENV_EXIT_SUCCESS;
}
/**
* TFTP READ
*
* @v tftp_read Pointer to a struct s_PXENV_TFTP_READ
* @v s_PXENV_TFTP_READ::Buffer Address of data buffer
* @ret #PXENV_EXIT_SUCCESS Data was read successfully
* @ret #PXENV_EXIT_FAILURE Data was not read
* @ret s_PXENV_TFTP_READ::Status PXE status code
* @ret s_PXENV_TFTP_READ::PacketNumber TFTP packet number
* @ret s_PXENV_TFTP_READ::BufferSize Length of data written into buffer
*
* Reads a single packet from a connection previously opened with
* pxenv_tftp_open() into the data buffer pointed to by
* s_PXENV_TFTP_READ::Buffer. You must have previously opened a
* connection with pxenv_tftp_open(). The data written into
* s_PXENV_TFTP_READ::Buffer is just the file data; the various
* network headers have already been removed.
*
* The buffer must be large enough to contain a packet of the size
* negotiated via the s_PXENV_TFTP_OPEN::PacketSize field in the
* pxenv_tftp_open() call. It is worth noting that the PXE
* specification does @b not require the caller to fill in
* s_PXENV_TFTP_READ::BufferSize before calling pxenv_tftp_read(), so
* the PXE stack is free to ignore whatever value the caller might
* place there and just assume that the buffer is large enough. That
* said, it may be worth the caller always filling in
* s_PXENV_TFTP_READ::BufferSize to guard against PXE stacks that
* mistake it for an input parameter.
*
* The length of the TFTP data packet will be returned via
* s_PXENV_TFTP_READ::BufferSize. If this length is less than the
* blksize negotiated via s_PXENV_TFTP_OPEN::PacketSize in the call to
* pxenv_tftp_open(), this indicates that the block is the last block
* in the file. Note that zero is a valid length for
* s_PXENV_TFTP_READ::BufferSize, and will occur when the length of
* the file is a multiple of the blksize.
*
* The PXE specification doesn't actually state that calls to
* pxenv_tftp_read() will return the data packets in strict sequential
* order, though most PXE stacks will probably do so. The sequence
* number of the packet will be returned in
* s_PXENV_TFTP_READ::PacketNumber. The first packet in the file has
* a sequence number of one, not zero.
*
* To guard against flawed PXE stacks, the caller should probably set
* s_PXENV_TFTP_READ::PacketNumber to one less than the expected
* returned value (i.e. set it to zero for the first call to
* pxenv_tftp_read() and then re-use the returned s_PXENV_TFTP_READ
* parameter block for subsequent calls without modifying
* s_PXENV_TFTP_READ::PacketNumber between calls). The caller should
* also guard against potential problems caused by flawed
* implementations returning the occasional duplicate packet, by
* checking that the value returned in s_PXENV_TFTP_READ::PacketNumber
* is as expected (i.e. one greater than that returned from the
* previous call to pxenv_tftp_read()).
*
* On x86, you must set the s_PXE::StatusCallout field to a nonzero
* value before calling this function in protected mode. You cannot
* call this function with a 32-bit stack segment. (See the relevant
* @ref pxe_x86_pmode16 "implementation note" for more details.)
*/
static PXENV_EXIT_t pxenv_tftp_read ( struct s_PXENV_TFTP_READ *tftp_read ) {
int rc;
DBG ( "PXENV_TFTP_READ to %04x:%04x",
tftp_read->Buffer.segment, tftp_read->Buffer.offset );
/* Read single block into buffer */
pxe_tftp.buffer = real_to_user ( tftp_read->Buffer.segment,
tftp_read->Buffer.offset );
pxe_tftp.size = pxe_tftp.blksize;
pxe_tftp.start = pxe_tftp.offset;
while ( ( ( rc = pxe_tftp.rc ) == -EINPROGRESS ) &&
( pxe_tftp.offset == pxe_tftp.start ) )
step();
pxe_tftp.buffer = UNULL;
tftp_read->BufferSize = ( pxe_tftp.offset - pxe_tftp.start );
tftp_read->PacketNumber = ++pxe_tftp.blkidx;
/* EINPROGRESS is normal if we haven't reached EOF yet */
if ( rc == -EINPROGRESS )
rc = 0;
tftp_read->Status = PXENV_STATUS ( rc );
return ( rc ? PXENV_EXIT_FAILURE : PXENV_EXIT_SUCCESS );
}
/**
* TFTP/MTFTP read file
*
* @v tftp_read_file Pointer to a struct s_PXENV_TFTP_READ_FILE
* @v s_PXENV_TFTP_READ_FILE::FileName File name
* @v s_PXENV_TFTP_READ_FILE::BufferSize Size of the receive buffer
* @v s_PXENV_TFTP_READ_FILE::Buffer Address of the receive buffer
* @v s_PXENV_TFTP_READ_FILE::ServerIPAddress TFTP server IP address
* @v s_PXENV_TFTP_READ_FILE::GatewayIPAddress Relay agent IP address
* @v s_PXENV_TFTP_READ_FILE::McastIPAddress File's multicast IP address
* @v s_PXENV_TFTP_READ_FILE::TFTPClntPort Client multicast UDP port
* @v s_PXENV_TFTP_READ_FILE::TFTPSrvPort Server multicast UDP port
* @v s_PXENV_TFTP_READ_FILE::TFTPOpenTimeOut Time to wait for first packet
* @v s_PXENV_TFTP_READ_FILE::TFTPReopenDelay MTFTP inactivity timeout
* @ret #PXENV_EXIT_SUCCESS File downloaded successfully
* @ret #PXENV_EXIT_FAILURE File not downloaded
* @ret s_PXENV_TFTP_READ_FILE::Status PXE status code
* @ret s_PXENV_TFTP_READ_FILE::BufferSize Length of downloaded file
*
* Downloads an entire file via either TFTP or MTFTP into the buffer
* pointed to by s_PXENV_TFTP_READ_FILE::Buffer.
*
* The PXE specification does not make it clear how the caller
* requests that MTFTP be used rather than TFTP (or vice versa). One
* reasonable guess is that setting
* s_PXENV_TFTP_READ_FILE::McastIPAddress to 0.0.0.0 would cause TFTP
* to be used instead of MTFTP, though it is conceivable that some PXE
* stacks would interpret that as "use the DHCP-provided multicast IP
* address" instead. Some PXE stacks will not implement MTFTP at all,
* and will always use TFTP.
*
* It is not specified whether or not
* s_PXENV_TFTP_READ_FILE::TFTPSrvPort will be used as the TFTP server
* port for TFTP (rather than MTFTP) downloads. Callers should assume
* that the only way to access a TFTP server on a non-standard port is
* to use pxenv_tftp_open() and pxenv_tftp_read().
*
* If s_PXENV_TFTP_READ_FILE::GatewayIPAddress is 0.0.0.0, normal IP
* routing will take place. See the relevant
* @ref pxe_routing "implementation note" for more details.
*
* It is interesting to note that s_PXENV_TFTP_READ_FILE::Buffer is an
* #ADDR32_t type, i.e. nominally a flat physical address. Some PXE
* NBPs (e.g. NTLDR) are known to call pxenv_tftp_read_file() in real
* mode with s_PXENV_TFTP_READ_FILE::Buffer set to an address above
* 1MB. This means that PXE stacks must be prepared to write to areas
* outside base memory. Exactly how this is to be achieved is not
* specified, though using INT 15,87 is as close to a standard method
* as any, and should probably be used. Switching to protected-mode
* in order to access high memory will fail if pxenv_tftp_read_file()
* is called in V86 mode; it is reasonably to expect that a V86
* monitor would intercept the relatively well-defined INT 15,87 if it
* wants the PXE stack to be able to write to high memory.
*
* Things get even more interesting if pxenv_tftp_read_file() is
* called in protected mode, because there is then absolutely no way
* for the PXE stack to write to an absolute physical address. You
* can't even get around the problem by creating a special "access
* everything" segment in the s_PXE data structure, because the
* #SEGDESC_t descriptors are limited to 64kB in size.
*
* Previous versions of the PXE specification (e.g. WfM 1.1a) provide
* a separate API call, %pxenv_tftp_read_file_pmode(), specifically to
* work around this problem. The s_PXENV_TFTP_READ_FILE_PMODE
* parameter block splits s_PXENV_TFTP_READ_FILE::Buffer into
* s_PXENV_TFTP_READ_FILE_PMODE::BufferSelector and
* s_PXENV_TFTP_READ_FILE_PMODE::BufferOffset, i.e. it provides a
* protected-mode segment:offset address for the data buffer. This
* API call is no longer present in version 2.1 of the PXE
* specification.
*
* Etherboot makes the assumption that s_PXENV_TFTP_READ_FILE::Buffer
* is an offset relative to the caller's data segment, when
* pxenv_tftp_read_file() is called in protected mode.
*
* On x86, you must set the s_PXE::StatusCallout field to a nonzero
* value before calling this function in protected mode. You cannot
* call this function with a 32-bit stack segment. (See the relevant
* @ref pxe_x86_pmode16 "implementation note" for more details.)
*/
PXENV_EXIT_t pxenv_tftp_read_file ( struct s_PXENV_TFTP_READ_FILE
*tftp_read_file ) {
int rc;
DBG ( "PXENV_TFTP_READ_FILE to %08x+%x", tftp_read_file->Buffer,
tftp_read_file->BufferSize );
/* Open TFTP file */
if ( ( rc = pxe_tftp_open ( tftp_read_file->ServerIPAddress, 0,
tftp_read_file->FileName, 0 ) ) != 0 ) {
tftp_read_file->Status = PXENV_STATUS ( rc );
return PXENV_EXIT_FAILURE;
}
/* Read entire file */
pxe_tftp.buffer = phys_to_user ( tftp_read_file->Buffer );
pxe_tftp.size = tftp_read_file->BufferSize;
while ( ( rc = pxe_tftp.rc ) == -EINPROGRESS )
step();
pxe_tftp.buffer = UNULL;
tftp_read_file->BufferSize = pxe_tftp.max_offset;
/* Close TFTP file */
pxe_tftp_close ( &pxe_tftp, rc );
tftp_read_file->Status = PXENV_STATUS ( rc );
return ( rc ? PXENV_EXIT_FAILURE : PXENV_EXIT_SUCCESS );
}
/**
* TFTP GET FILE SIZE
*
* @v tftp_get_fsize Pointer to a struct s_PXENV_TFTP_GET_FSIZE
* @v s_PXENV_TFTP_GET_FSIZE::ServerIPAddress TFTP server IP address
* @v s_PXENV_TFTP_GET_FSIZE::GatewayIPAddress Relay agent IP address
* @v s_PXENV_TFTP_GET_FSIZE::FileName File name
* @ret #PXENV_EXIT_SUCCESS File size was determined successfully
* @ret #PXENV_EXIT_FAILURE File size was not determined
* @ret s_PXENV_TFTP_GET_FSIZE::Status PXE status code
* @ret s_PXENV_TFTP_GET_FSIZE::FileSize File size
*
* Determine the size of a file on a TFTP server. This uses the
* "tsize" TFTP option, and so will not work with a TFTP server that
* does not support TFTP options, or that does not support the "tsize"
* option.
*
* The PXE specification states that this API call will @b not open a
* TFTP connection for subsequent use with pxenv_tftp_read(). (This
* is somewhat daft, since the only way to obtain the file size via
* the "tsize" option involves issuing a TFTP open request, but that's
* life.)
*
* You cannot call pxenv_tftp_get_fsize() while a TFTP or UDP
* connection is open.
*
* If s_PXENV_TFTP_GET_FSIZE::GatewayIPAddress is 0.0.0.0, normal IP
* routing will take place. See the relevant
* @ref pxe_routing "implementation note" for more details.
*
* On x86, you must set the s_PXE::StatusCallout field to a nonzero
* value before calling this function in protected mode. You cannot
* call this function with a 32-bit stack segment. (See the relevant
* @ref pxe_x86_pmode16 "implementation note" for more details.)
*
* @note There is no way to specify the TFTP server port with this API
* call. Though you can open a file using a non-standard TFTP server
* port (via s_PXENV_TFTP_OPEN::TFTPPort or, potentially,
* s_PXENV_TFTP_READ_FILE::TFTPSrvPort), you can only get the size of
* a file from a TFTP server listening on the standard TFTP port.
* "Consistency" is not a word in Intel's vocabulary.
*/
static PXENV_EXIT_t pxenv_tftp_get_fsize ( struct s_PXENV_TFTP_GET_FSIZE
*tftp_get_fsize ) {
int rc;
DBG ( "PXENV_TFTP_GET_FSIZE" );
/* Open TFTP file */
if ( ( rc = pxe_tftp_open ( tftp_get_fsize->ServerIPAddress, 0,
tftp_get_fsize->FileName, 0 ) ) != 0 ) {
tftp_get_fsize->Status = PXENV_STATUS ( rc );
return PXENV_EXIT_FAILURE;
}
/* Wait for initial seek to arrive, and record size */
while ( ( ( rc = pxe_tftp.rc ) == -EINPROGRESS ) &&
( pxe_tftp.max_offset == 0 ) ) {
step();
}
tftp_get_fsize->FileSize = pxe_tftp.max_offset;
DBG ( " fsize=%d", tftp_get_fsize->FileSize );
/* EINPROGRESS is normal; we don't wait for the whole transfer */
if ( rc == -EINPROGRESS )
rc = 0;
/* Close TFTP file */
pxe_tftp_close ( &pxe_tftp, rc );
tftp_get_fsize->Status = PXENV_STATUS ( rc );
return ( rc ? PXENV_EXIT_FAILURE : PXENV_EXIT_SUCCESS );
}
/** PXE TFTP API */
struct pxe_api_call pxe_tftp_api[] __pxe_api_call = {
PXE_API_CALL ( PXENV_TFTP_OPEN, pxenv_tftp_open,
struct s_PXENV_TFTP_OPEN ),
PXE_API_CALL ( PXENV_TFTP_CLOSE, pxenv_tftp_close,
struct s_PXENV_TFTP_CLOSE ),
PXE_API_CALL ( PXENV_TFTP_READ, pxenv_tftp_read,
struct s_PXENV_TFTP_READ ),
PXE_API_CALL ( PXENV_TFTP_READ_FILE, pxenv_tftp_read_file,
struct s_PXENV_TFTP_READ_FILE ),
PXE_API_CALL ( PXENV_TFTP_GET_FSIZE, pxenv_tftp_get_fsize,
struct s_PXENV_TFTP_GET_FSIZE ),
};

474
src/arch/x86/interface/pxe/pxe_udp.c Normal file
View File

@@ -0,0 +1,474 @@
/** @file
*
* PXE UDP API
*
*/
#include <string.h>
#include <byteswap.h>
#include <ipxe/iobuf.h>
#include <ipxe/xfer.h>
#include <ipxe/udp.h>
#include <ipxe/uaccess.h>
#include <ipxe/process.h>
#include <realmode.h>
#include <pxe.h>
/*
* Copyright (C) 2004 Michael Brown <mbrown@fensystems.co.uk>.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
* 02110-1301, USA.
*
* You can also choose to distribute this program under the terms of
* the Unmodified Binary Distribution Licence (as given in the file
* COPYING.UBDL), provided that you have satisfied its requirements.
*/
FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
/** A PXE UDP pseudo-header */
struct pxe_udp_pseudo_header {
/** Source IP address */
IP4_t src_ip;
/** Source port */
UDP_PORT_t s_port;
/** Destination IP address */
IP4_t dest_ip;
/** Destination port */
UDP_PORT_t d_port;
} __attribute__ (( packed ));
/** A PXE UDP connection */
struct pxe_udp_connection {
/** Data transfer interface to UDP stack */
struct interface xfer;
/** Local address */
struct sockaddr_in local;
/** List of received packets */
struct list_head list;
};
/**
* Receive PXE UDP data
*
* @v pxe_udp PXE UDP connection
* @v iobuf I/O buffer
* @v meta Data transfer metadata
* @ret rc Return status code
*
* Receives a packet as part of the current pxenv_udp_read()
* operation.
*/
static int pxe_udp_deliver ( struct pxe_udp_connection *pxe_udp,
struct io_buffer *iobuf,
struct xfer_metadata *meta ) {
struct pxe_udp_pseudo_header *pshdr;
struct sockaddr_in *sin_src;
struct sockaddr_in *sin_dest;
int rc;
/* Extract metadata */
assert ( meta );
sin_src = ( struct sockaddr_in * ) meta->src;
assert ( sin_src );
assert ( sin_src->sin_family == AF_INET );
sin_dest = ( struct sockaddr_in * ) meta->dest;
assert ( sin_dest );
assert ( sin_dest->sin_family == AF_INET );
/* Construct pseudo-header */
if ( ( rc = iob_ensure_headroom ( iobuf, sizeof ( *pshdr ) ) ) != 0 ) {
DBG ( "PXE could not prepend pseudo-header\n" );
rc = -ENOMEM;
goto drop;
}
pshdr = iob_push ( iobuf, sizeof ( *pshdr ) );
pshdr->src_ip = sin_src->sin_addr.s_addr;
pshdr->s_port = sin_src->sin_port;
pshdr->dest_ip = sin_dest->sin_addr.s_addr;
pshdr->d_port = sin_dest->sin_port;
/* Add to queue */
list_add_tail ( &iobuf->list, &pxe_udp->list );
return 0;
drop:
free_iob ( iobuf );
return rc;
}
/** PXE UDP data transfer interface operations */
static struct interface_operation pxe_udp_xfer_operations[] = {
INTF_OP ( xfer_deliver, struct pxe_udp_connection *, pxe_udp_deliver ),
};
/** PXE UDP data transfer interface descriptor */
static struct interface_descriptor pxe_udp_xfer_desc =
INTF_DESC ( struct pxe_udp_connection, xfer, pxe_udp_xfer_operations );
/** The PXE UDP connection */
static struct pxe_udp_connection pxe_udp = {
.xfer = INTF_INIT ( pxe_udp_xfer_desc ),
.local = {
.sin_family = AF_INET,
},
.list = LIST_HEAD_INIT ( pxe_udp.list ),
};
/**
* UDP OPEN
*
* @v pxenv_udp_open Pointer to a struct s_PXENV_UDP_OPEN
* @v s_PXENV_UDP_OPEN::src_ip IP address of this station, or 0.0.0.0
* @ret #PXENV_EXIT_SUCCESS Always
* @ret s_PXENV_UDP_OPEN::Status PXE status code
* @err #PXENV_STATUS_UDP_OPEN UDP connection already open
* @err #PXENV_STATUS_OUT_OF_RESOURCES Could not open connection
*
* Prepares the PXE stack for communication using pxenv_udp_write()
* and pxenv_udp_read().
*
* The IP address supplied in s_PXENV_UDP_OPEN::src_ip will be
* recorded and used as the local station's IP address for all further
* communication, including communication by means other than
* pxenv_udp_write() and pxenv_udp_read(). (If
* s_PXENV_UDP_OPEN::src_ip is 0.0.0.0, the local station's IP address
* will remain unchanged.)
*
* You can only have one open UDP connection at a time. This is not a
* meaningful restriction, since pxenv_udp_write() and
* pxenv_udp_read() allow you to specify arbitrary local and remote
* ports and an arbitrary remote address for each packet. According
* to the PXE specifiation, you cannot have a UDP connection open at
* the same time as a TFTP connection; this restriction does not apply
* to Etherboot.
*
* On x86, you must set the s_PXE::StatusCallout field to a nonzero
* value before calling this function in protected mode. You cannot
* call this function with a 32-bit stack segment. (See the relevant
* @ref pxe_x86_pmode16 "implementation note" for more details.)
*
* @note The PXE specification does not make it clear whether the IP
* address supplied in s_PXENV_UDP_OPEN::src_ip should be used only
* for this UDP connection, or retained for all future communication.
* The latter seems more consistent with typical PXE stack behaviour.
*
* @note Etherboot currently ignores the s_PXENV_UDP_OPEN::src_ip
* parameter.
*
*/
static PXENV_EXIT_t pxenv_udp_open ( struct s_PXENV_UDP_OPEN *pxenv_udp_open ) {
int rc;
DBG ( "PXENV_UDP_OPEN" );
/* Record source IP address */
pxe_udp.local.sin_addr.s_addr = pxenv_udp_open->src_ip;
DBG ( " %s\n", inet_ntoa ( pxe_udp.local.sin_addr ) );
/* Open promiscuous UDP connection */
intf_restart ( &pxe_udp.xfer, 0 );
if ( ( rc = udp_open_promisc ( &pxe_udp.xfer ) ) != 0 ) {
DBG ( "PXENV_UDP_OPEN could not open promiscuous socket: %s\n",
strerror ( rc ) );
pxenv_udp_open->Status = PXENV_STATUS ( rc );
return PXENV_EXIT_FAILURE;
}
pxenv_udp_open->Status = PXENV_STATUS_SUCCESS;
return PXENV_EXIT_SUCCESS;
}
/**
* UDP CLOSE
*
* @v pxenv_udp_close Pointer to a struct s_PXENV_UDP_CLOSE
* @ret #PXENV_EXIT_SUCCESS Always
* @ret s_PXENV_UDP_CLOSE::Status PXE status code
* @err None -
*
* Closes a UDP connection opened with pxenv_udp_open().
*
* You can only have one open UDP connection at a time. You cannot
* have a UDP connection open at the same time as a TFTP connection.
* You cannot use pxenv_udp_close() to close a TFTP connection; use
* pxenv_tftp_close() instead.
*
* On x86, you must set the s_PXE::StatusCallout field to a nonzero
* value before calling this function in protected mode. You cannot
* call this function with a 32-bit stack segment. (See the relevant
* @ref pxe_x86_pmode16 "implementation note" for more details.)
*
*/
static PXENV_EXIT_t
pxenv_udp_close ( struct s_PXENV_UDP_CLOSE *pxenv_udp_close ) {
struct io_buffer *iobuf;
struct io_buffer *tmp;
DBG ( "PXENV_UDP_CLOSE\n" );
/* Close UDP connection */
intf_restart ( &pxe_udp.xfer, 0 );
/* Discard any received packets */
list_for_each_entry_safe ( iobuf, tmp, &pxe_udp.list, list ) {
list_del ( &iobuf->list );
free_iob ( iobuf );
}
pxenv_udp_close->Status = PXENV_STATUS_SUCCESS;
return PXENV_EXIT_SUCCESS;
}
/**
* UDP WRITE
*
* @v pxenv_udp_write Pointer to a struct s_PXENV_UDP_WRITE
* @v s_PXENV_UDP_WRITE::ip Destination IP address
* @v s_PXENV_UDP_WRITE::gw Relay agent IP address, or 0.0.0.0
* @v s_PXENV_UDP_WRITE::src_port Source UDP port, or 0
* @v s_PXENV_UDP_WRITE::dst_port Destination UDP port
* @v s_PXENV_UDP_WRITE::buffer_size Length of the UDP payload
* @v s_PXENV_UDP_WRITE::buffer Address of the UDP payload
* @ret #PXENV_EXIT_SUCCESS Packet was transmitted successfully
* @ret #PXENV_EXIT_FAILURE Packet could not be transmitted
* @ret s_PXENV_UDP_WRITE::Status PXE status code
* @err #PXENV_STATUS_UDP_CLOSED UDP connection is not open
* @err #PXENV_STATUS_UNDI_TRANSMIT_ERROR Could not transmit packet
*
* Transmits a single UDP packet. A valid IP and UDP header will be
* prepended to the payload in s_PXENV_UDP_WRITE::buffer; the buffer
* should not contain precomputed IP and UDP headers, nor should it
* contain space allocated for these headers. The first byte of the
* buffer will be transmitted as the first byte following the UDP
* header.
*
* If s_PXENV_UDP_WRITE::gw is 0.0.0.0, normal IP routing will take
* place. See the relevant @ref pxe_routing "implementation note" for
* more details.
*
* If s_PXENV_UDP_WRITE::src_port is 0, port 2069 will be used.
*
* You must have opened a UDP connection with pxenv_udp_open() before
* calling pxenv_udp_write().
*
* On x86, you must set the s_PXE::StatusCallout field to a nonzero
* value before calling this function in protected mode. You cannot
* call this function with a 32-bit stack segment. (See the relevant
* @ref pxe_x86_pmode16 "implementation note" for more details.)
*
* @note Etherboot currently ignores the s_PXENV_UDP_WRITE::gw
* parameter.
*
*/
static PXENV_EXIT_t
pxenv_udp_write ( struct s_PXENV_UDP_WRITE *pxenv_udp_write ) {
struct sockaddr_in dest;
struct xfer_metadata meta = {
.src = ( struct sockaddr * ) &pxe_udp.local,
.dest = ( struct sockaddr * ) &dest,
.netdev = pxe_netdev,
};
size_t len;
struct io_buffer *iobuf;
userptr_t buffer;
int rc;
DBG ( "PXENV_UDP_WRITE" );
/* Construct destination socket address */
memset ( &dest, 0, sizeof ( dest ) );
dest.sin_family = AF_INET;
dest.sin_addr.s_addr = pxenv_udp_write->ip;
dest.sin_port = pxenv_udp_write->dst_port;
/* Set local (source) port. PXE spec says source port is 2069
* if not specified. Really, this ought to be set at UDP open
* time but hey, we didn't design this API.
*/
pxe_udp.local.sin_port = pxenv_udp_write->src_port;
if ( ! pxe_udp.local.sin_port )
pxe_udp.local.sin_port = htons ( 2069 );
/* FIXME: we ignore the gateway specified, since we're
* confident of being able to do our own routing. We should
* probably allow for multiple gateways.
*/
/* Allocate and fill data buffer */
len = pxenv_udp_write->buffer_size;
iobuf = xfer_alloc_iob ( &pxe_udp.xfer, len );
if ( ! iobuf ) {
DBG ( " out of memory\n" );
pxenv_udp_write->Status = PXENV_STATUS_OUT_OF_RESOURCES;
return PXENV_EXIT_FAILURE;
}
buffer = real_to_user ( pxenv_udp_write->buffer.segment,
pxenv_udp_write->buffer.offset );
copy_from_user ( iob_put ( iobuf, len ), buffer, 0, len );
DBG ( " %04x:%04x+%x %d->%s:%d\n", pxenv_udp_write->buffer.segment,
pxenv_udp_write->buffer.offset, pxenv_udp_write->buffer_size,
ntohs ( pxenv_udp_write->src_port ),
inet_ntoa ( dest.sin_addr ),
ntohs ( pxenv_udp_write->dst_port ) );
/* Transmit packet */
if ( ( rc = xfer_deliver ( &pxe_udp.xfer, iobuf, &meta ) ) != 0 ) {
DBG ( "PXENV_UDP_WRITE could not transmit: %s\n",
strerror ( rc ) );
pxenv_udp_write->Status = PXENV_STATUS ( rc );
return PXENV_EXIT_FAILURE;
}
pxenv_udp_write->Status = PXENV_STATUS_SUCCESS;
return PXENV_EXIT_SUCCESS;
}
/**
* UDP READ
*
* @v pxenv_udp_read Pointer to a struct s_PXENV_UDP_READ
* @v s_PXENV_UDP_READ::dest_ip Destination IP address, or 0.0.0.0
* @v s_PXENV_UDP_READ::d_port Destination UDP port, or 0
* @v s_PXENV_UDP_READ::buffer_size Size of the UDP payload buffer
* @v s_PXENV_UDP_READ::buffer Address of the UDP payload buffer
* @ret #PXENV_EXIT_SUCCESS A packet has been received
* @ret #PXENV_EXIT_FAILURE No packet has been received
* @ret s_PXENV_UDP_READ::Status PXE status code
* @ret s_PXENV_UDP_READ::src_ip Source IP address
* @ret s_PXENV_UDP_READ::dest_ip Destination IP address
* @ret s_PXENV_UDP_READ::s_port Source UDP port
* @ret s_PXENV_UDP_READ::d_port Destination UDP port
* @ret s_PXENV_UDP_READ::buffer_size Length of UDP payload
* @err #PXENV_STATUS_UDP_CLOSED UDP connection is not open
* @err #PXENV_STATUS_FAILURE No packet was ready to read
*
* Receive a single UDP packet. This is a non-blocking call; if no
* packet is ready to read, the call will return instantly with
* s_PXENV_UDP_READ::Status==PXENV_STATUS_FAILURE.
*
* If s_PXENV_UDP_READ::dest_ip is 0.0.0.0, UDP packets addressed to
* any IP address will be accepted and may be returned to the caller.
*
* If s_PXENV_UDP_READ::d_port is 0, UDP packets addressed to any UDP
* port will be accepted and may be returned to the caller.
*
* You must have opened a UDP connection with pxenv_udp_open() before
* calling pxenv_udp_read().
*
* On x86, you must set the s_PXE::StatusCallout field to a nonzero
* value before calling this function in protected mode. You cannot
* call this function with a 32-bit stack segment. (See the relevant
* @ref pxe_x86_pmode16 "implementation note" for more details.)
*
* @note The PXE specification (version 2.1) does not state that we
* should fill in s_PXENV_UDP_READ::dest_ip and
* s_PXENV_UDP_READ::d_port, but Microsoft Windows' NTLDR program
* expects us to do so, and will fail if we don't.
*
*/
static PXENV_EXIT_t pxenv_udp_read ( struct s_PXENV_UDP_READ *pxenv_udp_read ) {
struct in_addr dest_ip_wanted = { .s_addr = pxenv_udp_read->dest_ip };
struct in_addr dest_ip;
struct io_buffer *iobuf;
struct pxe_udp_pseudo_header *pshdr;
uint16_t d_port_wanted = pxenv_udp_read->d_port;
uint16_t d_port;
userptr_t buffer;
size_t len;
/* Try receiving a packet, if the queue is empty */
if ( list_empty ( &pxe_udp.list ) )
step();
/* Remove first packet from the queue */
iobuf = list_first_entry ( &pxe_udp.list, struct io_buffer, list );
if ( ! iobuf ) {
/* No packet received */
DBG2 ( "PXENV_UDP_READ\n" );
goto no_packet;
}
list_del ( &iobuf->list );
/* Strip pseudo-header */
assert ( iob_len ( iobuf ) >= sizeof ( *pshdr ) );
pshdr = iobuf->data;
iob_pull ( iobuf, sizeof ( *pshdr ) );
dest_ip.s_addr = pshdr->dest_ip;
d_port = pshdr->d_port;
DBG ( "PXENV_UDP_READ" );
/* Filter on destination address and/or port */
if ( dest_ip_wanted.s_addr &&
( dest_ip_wanted.s_addr != dest_ip.s_addr ) ) {
DBG ( " wrong IP %s", inet_ntoa ( dest_ip ) );
DBG ( " (wanted %s)\n", inet_ntoa ( dest_ip_wanted ) );
goto drop;
}
if ( d_port_wanted && ( d_port_wanted != d_port ) ) {
DBG ( " wrong port %d", htons ( d_port ) );
DBG ( " (wanted %d)\n", htons ( d_port_wanted ) );
goto drop;
}
/* Copy packet to buffer and record length */
buffer = real_to_user ( pxenv_udp_read->buffer.segment,
pxenv_udp_read->buffer.offset );
len = iob_len ( iobuf );
if ( len > pxenv_udp_read->buffer_size )
len = pxenv_udp_read->buffer_size;
copy_to_user ( buffer, 0, iobuf->data, len );
pxenv_udp_read->buffer_size = len;
/* Fill in source/dest information */
pxenv_udp_read->src_ip = pshdr->src_ip;
pxenv_udp_read->s_port = pshdr->s_port;
pxenv_udp_read->dest_ip = pshdr->dest_ip;
pxenv_udp_read->d_port = pshdr->d_port;
DBG ( " %04x:%04x+%x %s:", pxenv_udp_read->buffer.segment,
pxenv_udp_read->buffer.offset, pxenv_udp_read->buffer_size,
inet_ntoa ( *( ( struct in_addr * ) &pxenv_udp_read->src_ip ) ));
DBG ( "%d<-%s:%d\n", ntohs ( pxenv_udp_read->s_port ),
inet_ntoa ( *( ( struct in_addr * ) &pxenv_udp_read->dest_ip ) ),
ntohs ( pxenv_udp_read->d_port ) );
/* Free I/O buffer */
free_iob ( iobuf );
pxenv_udp_read->Status = PXENV_STATUS_SUCCESS;
return PXENV_EXIT_SUCCESS;
drop:
free_iob ( iobuf );
no_packet:
pxenv_udp_read->Status = PXENV_STATUS_FAILURE;
return PXENV_EXIT_FAILURE;
}
/** PXE UDP API */
struct pxe_api_call pxe_udp_api[] __pxe_api_call = {
PXE_API_CALL ( PXENV_UDP_OPEN, pxenv_udp_open,
struct s_PXENV_UDP_OPEN ),
PXE_API_CALL ( PXENV_UDP_CLOSE, pxenv_udp_close,
struct s_PXENV_UDP_CLOSE ),
PXE_API_CALL ( PXENV_UDP_WRITE, pxenv_udp_write,
struct s_PXENV_UDP_WRITE ),
PXE_API_CALL ( PXENV_UDP_READ, pxenv_udp_read,
struct s_PXENV_UDP_READ ),
};

1084
src/arch/x86/interface/pxe/pxe_undi.c Normal file
View File

File diff suppressed because it is too large Load Diff