mirror of https://github.com/ipxe/ipxe.git
321 lines
8.0 KiB
C
321 lines
8.0 KiB
C
/*
|
|
* Copyright (C) 2008 Daniel Verkamp <daniel@drv.nu>.
|
|
*
|
|
* 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., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
*/
|
|
|
|
/**
|
|
* @file
|
|
*
|
|
* SYSLINUX COMBOOT (16-bit) image format
|
|
*
|
|
*/
|
|
|
|
#include <stdint.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <strings.h>
|
|
#include <errno.h>
|
|
#include <assert.h>
|
|
#include <realmode.h>
|
|
#include <basemem.h>
|
|
#include <comboot.h>
|
|
#include <gpxe/uaccess.h>
|
|
#include <gpxe/image.h>
|
|
#include <gpxe/segment.h>
|
|
#include <gpxe/init.h>
|
|
#include <gpxe/features.h>
|
|
|
|
FEATURE ( FEATURE_IMAGE, "COMBOOT", DHCP_EB_FEATURE_COMBOOT, 1 );
|
|
|
|
struct image_type comboot_image_type __image_type ( PROBE_NORMAL );
|
|
|
|
/**
|
|
* COMBOOT PSP, copied to offset 0 of code segment
|
|
*/
|
|
struct comboot_psp {
|
|
/** INT 20 instruction, executed if COMBOOT image returns with RET */
|
|
uint16_t int20;
|
|
/** Segment of first non-free paragraph of memory */
|
|
uint16_t first_non_free_para;
|
|
};
|
|
|
|
/** Offset in PSP of command line */
|
|
#define COMBOOT_PSP_CMDLINE_OFFSET 0x81
|
|
|
|
/** Maximum length of command line in PSP
|
|
* (127 bytes minus space and CR) */
|
|
#define COMBOOT_MAX_CMDLINE_LEN 125
|
|
|
|
|
|
/**
|
|
* Copy command line to PSP
|
|
*
|
|
* @v image COMBOOT image
|
|
*/
|
|
static void comboot_copy_cmdline ( struct image * image, userptr_t seg_userptr ) {
|
|
const char *cmdline = ( image->cmdline ? image->cmdline : "" );
|
|
int cmdline_len = strlen ( cmdline );
|
|
if( cmdline_len > COMBOOT_MAX_CMDLINE_LEN )
|
|
cmdline_len = COMBOOT_MAX_CMDLINE_LEN;
|
|
uint8_t len_byte = cmdline_len;
|
|
char spc = ' ', cr = '\r';
|
|
|
|
/* Copy length to byte before command line */
|
|
copy_to_user ( seg_userptr, COMBOOT_PSP_CMDLINE_OFFSET - 1,
|
|
&len_byte, 1 );
|
|
|
|
/* Command line starts with space */
|
|
copy_to_user ( seg_userptr,
|
|
COMBOOT_PSP_CMDLINE_OFFSET,
|
|
&spc, 1 );
|
|
|
|
/* Copy command line */
|
|
copy_to_user ( seg_userptr,
|
|
COMBOOT_PSP_CMDLINE_OFFSET + 1,
|
|
cmdline, cmdline_len );
|
|
|
|
/* Command line ends with CR */
|
|
copy_to_user ( seg_userptr,
|
|
COMBOOT_PSP_CMDLINE_OFFSET + cmdline_len + 1,
|
|
&cr, 1 );
|
|
}
|
|
|
|
/**
|
|
* Initialize PSP
|
|
*
|
|
* @v image COMBOOT image
|
|
* @v seg_userptr segment to initialize
|
|
*/
|
|
static void comboot_init_psp ( struct image * image, userptr_t seg_userptr ) {
|
|
struct comboot_psp psp;
|
|
|
|
/* Fill PSP */
|
|
|
|
/* INT 20h instruction, byte order reversed */
|
|
psp.int20 = 0x20CD;
|
|
|
|
/* get_fbms() returns BIOS free base memory counter, which is in
|
|
* kilobytes; x * 1024 / 16 == x * 64 == x << 6 */
|
|
psp.first_non_free_para = get_fbms() << 6;
|
|
|
|
DBGC ( image, "COMBOOT %p: first non-free paragraph = 0x%x\n",
|
|
image, psp.first_non_free_para );
|
|
|
|
/* Copy the PSP to offset 0 of segment.
|
|
* The rest of the PSP was already zeroed by
|
|
* comboot_prepare_segment. */
|
|
copy_to_user ( seg_userptr, 0, &psp, sizeof( psp ) );
|
|
|
|
/* Copy the command line to the PSP */
|
|
comboot_copy_cmdline ( image, seg_userptr );
|
|
}
|
|
|
|
/**
|
|
* Execute COMBOOT image
|
|
*
|
|
* @v image COMBOOT image
|
|
* @ret rc Return status code
|
|
*/
|
|
static int comboot_exec ( struct image *image ) {
|
|
userptr_t seg_userptr = real_to_user ( COMBOOT_PSP_SEG, 0 );
|
|
int state;
|
|
|
|
state = rmsetjmp ( comboot_return );
|
|
|
|
switch ( state ) {
|
|
case 0: /* First time through; invoke COMBOOT program */
|
|
|
|
/* Initialize PSP */
|
|
comboot_init_psp ( image, seg_userptr );
|
|
|
|
/* Hook COMBOOT API interrupts */
|
|
hook_comboot_interrupts();
|
|
|
|
DBGC ( image, "executing 16-bit COMBOOT image at %4x:0100\n",
|
|
COMBOOT_PSP_SEG );
|
|
|
|
/* Unregister image, so that a "boot" command doesn't
|
|
* throw us into an execution loop. We never
|
|
* reregister ourselves; COMBOOT images expect to be
|
|
* removed on exit.
|
|
*/
|
|
unregister_image ( image );
|
|
|
|
/* Store stack segment at 0x38 and stack pointer at 0x3A
|
|
* in the PSP and jump to the image */
|
|
__asm__ __volatile__ (
|
|
REAL_CODE ( /* Save return address with segment on old stack */
|
|
"popw %%ax\n\t"
|
|
"pushw %%cs\n\t"
|
|
"pushw %%ax\n\t"
|
|
/* Set DS=ES=segment with image */
|
|
"movw %w0, %%ds\n\t"
|
|
"movw %w0, %%es\n\t"
|
|
/* Set SS:SP to new stack (end of image segment) */
|
|
"movw %w0, %%ss\n\t"
|
|
"xor %%sp, %%sp\n\t"
|
|
"pushw $0\n\t"
|
|
"pushw %w0\n\t"
|
|
"pushw $0x100\n\t"
|
|
/* Zero registers (some COM files assume GP regs are 0) */
|
|
"xorw %%ax, %%ax\n\t"
|
|
"xorw %%bx, %%bx\n\t"
|
|
"xorw %%cx, %%cx\n\t"
|
|
"xorw %%dx, %%dx\n\t"
|
|
"xorw %%si, %%si\n\t"
|
|
"xorw %%di, %%di\n\t"
|
|
"xorw %%bp, %%bp\n\t"
|
|
"lret\n\t" )
|
|
: : "r" ( COMBOOT_PSP_SEG ) : "eax" );
|
|
DBGC ( image, "COMBOOT %p: returned\n", image );
|
|
break;
|
|
|
|
case COMBOOT_EXIT:
|
|
DBGC ( image, "COMBOOT %p: exited\n", image );
|
|
break;
|
|
|
|
case COMBOOT_EXIT_RUN_KERNEL:
|
|
DBGC ( image, "COMBOOT %p: exited to run kernel %p\n",
|
|
image, comboot_replacement_image );
|
|
image->replacement = comboot_replacement_image;
|
|
comboot_replacement_image = NULL;
|
|
image_autoload ( image->replacement );
|
|
break;
|
|
|
|
case COMBOOT_EXIT_COMMAND:
|
|
DBGC ( image, "COMBOOT %p: exited after executing command\n",
|
|
image );
|
|
break;
|
|
|
|
default:
|
|
assert ( 0 );
|
|
break;
|
|
}
|
|
|
|
unhook_comboot_interrupts();
|
|
comboot_force_text_mode();
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Check image name extension
|
|
*
|
|
* @v image COMBOOT image
|
|
* @ret rc Return status code
|
|
*/
|
|
static int comboot_identify ( struct image *image ) {
|
|
const char *ext;
|
|
|
|
ext = strrchr( image->name, '.' );
|
|
|
|
if ( ! ext ) {
|
|
DBGC ( image, "COMBOOT %p: no extension\n",
|
|
image );
|
|
return -ENOEXEC;
|
|
}
|
|
|
|
++ext;
|
|
|
|
if ( strcasecmp( ext, "com" ) && strcasecmp( ext, "cbt" ) ) {
|
|
DBGC ( image, "COMBOOT %p: unrecognized extension %s\n",
|
|
image, ext );
|
|
return -ENOEXEC;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Load COMBOOT image into memory, preparing a segment and returning it
|
|
* @v image COMBOOT image
|
|
* @ret rc Return status code
|
|
*/
|
|
static int comboot_prepare_segment ( struct image *image )
|
|
{
|
|
userptr_t seg_userptr;
|
|
size_t filesz, memsz;
|
|
int rc;
|
|
|
|
/* Load image in segment */
|
|
seg_userptr = real_to_user ( COMBOOT_PSP_SEG, 0 );
|
|
|
|
/* Allow etra 0x100 bytes before image for PSP */
|
|
filesz = image->len + 0x100;
|
|
|
|
/* Ensure the entire 64k segment is free */
|
|
memsz = 0xFFFF;
|
|
|
|
/* Prepare, verify, and load the real-mode segment */
|
|
if ( ( rc = prep_segment ( seg_userptr, filesz, memsz ) ) != 0 ) {
|
|
DBGC ( image, "COMBOOT %p: could not prepare segment: %s\n",
|
|
image, strerror ( rc ) );
|
|
return rc;
|
|
}
|
|
|
|
/* Zero PSP */
|
|
memset_user ( seg_userptr, 0, 0, 0x100 );
|
|
|
|
/* Copy image to segment:0100 */
|
|
memcpy_user ( seg_userptr, 0x100, image->data, 0, image->len );
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Load COMBOOT image into memory
|
|
*
|
|
* @v image COMBOOT image
|
|
* @ret rc Return status code
|
|
*/
|
|
static int comboot_load ( struct image *image ) {
|
|
int rc;
|
|
|
|
DBGC ( image, "COMBOOT %p: name '%s'\n",
|
|
image, image->name );
|
|
|
|
/* Check if this is a COMBOOT image */
|
|
if ( ( rc = comboot_identify ( image ) ) != 0 ) {
|
|
|
|
return rc;
|
|
}
|
|
|
|
/* This is a 16-bit COMBOOT image, valid or otherwise */
|
|
if ( ! image->type )
|
|
image->type = &comboot_image_type;
|
|
|
|
/* Sanity check for filesize */
|
|
if( image->len >= 0xFF00 ) {
|
|
DBGC( image, "COMBOOT %p: image too large\n",
|
|
image );
|
|
return -ENOEXEC;
|
|
}
|
|
|
|
/* Prepare segment and load image */
|
|
if ( ( rc = comboot_prepare_segment ( image ) ) != 0 ) {
|
|
return rc;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/** SYSLINUX COMBOOT (16-bit) image type */
|
|
struct image_type comboot_image_type __image_type ( PROBE_NORMAL ) = {
|
|
.name = "COMBOOT",
|
|
.load = comboot_load,
|
|
.exec = comboot_exec,
|
|
};
|