comboot.c File Reference

SYSLINUX COMBOOT (16-bit) image format. More...

#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 <ipxe/image.h>
#include <ipxe/segment.h>
#include <ipxe/init.h>
#include <ipxe/features.h>
#include <ipxe/console.h>

Go to the source code of this file.

Data Structures
struct	comboot_psp
	COMBOOT PSP, copied to offset 0 of code segment. More...

Macros
#define	COMBOOT_PSP_CMDLINE_OFFSET   0x81
	Offset in PSP of command line.
#define	COMBOOT_MAX_CMDLINE_LEN   125
	Maximum length of command line in PSP (127 bytes minus space and CR)

Functions
	FILE_LICENCE (GPL2_OR_LATER)
	FEATURE (FEATURE_IMAGE, "COMBOOT", DHCP_EB_FEATURE_COMBOOT, 1)
static void	comboot_copy_cmdline (struct image *image, void *seg)
	Copy command line to PSP.
static void	comboot_init_psp (struct image *image, void *seg)
	Initialize PSP.
static int	comboot_exec_loop (struct image *image)
	Execute COMBOOT image.
static int	comboot_identify (struct image *image)
	Check image name extension.
static int	comboot_prepare_segment (struct image *image)
	Load COMBOOT image into memory, preparing a segment and returning it.
static int	comboot_probe (struct image *image)
	Probe COMBOOT image.
static int	comboot_exec (struct image *image)
	Execute COMBOOT image.
struct image_type comboot_image_type	__image_type (PROBE_NORMAL)
	SYSLINUX COMBOOT (16-bit) image type.

Detailed Description

SYSLINUX COMBOOT (16-bit) image format.

Definition in file comboot.c.

Macro Definition Documentation

COMBOOT_PSP_CMDLINE_OFFSET

#define COMBOOT_PSP_CMDLINE_OFFSET   0x81

Offset in PSP of command line.

Definition at line 57 of file comboot.c.

Referenced by comboot_copy_cmdline().

COMBOOT_MAX_CMDLINE_LEN

#define COMBOOT_MAX_CMDLINE_LEN   125

Maximum length of command line in PSP (127 bytes minus space and CR)

Definition at line 61 of file comboot.c.

Referenced by comboot_copy_cmdline().

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER

)

FEATURE()

FEATURE	(	FEATURE_IMAGE	,
		"COMBOOT"	,
		DHCP_EB_FEATURE_COMBOOT	,
		1	)

References DHCP_EB_FEATURE_COMBOOT, and FEATURE_IMAGE.

comboot_copy_cmdline()

void comboot_copy_cmdline ( struct image * image, void * seg )

static

Copy command line to PSP.

Parameters

image

COMBOOT image

Definition at line 69 of file comboot.c.

                                                                     {
        const char *cmdline = ( image->cmdline ? image->cmdline : "" );
        int cmdline_len = strlen ( cmdline );
        uint8_t *psp_cmdline;
 
        /* Limit length of command line */
        if( cmdline_len > COMBOOT_MAX_CMDLINE_LEN )
                cmdline_len = COMBOOT_MAX_CMDLINE_LEN;
 
        /* Copy length to byte before command line */
        psp_cmdline = ( seg + COMBOOT_PSP_CMDLINE_OFFSET );
        psp_cmdline[-1] = cmdline_len;
 
        /* Command line starts with space */
        psp_cmdline[0] = ' ';
 
        /* Copy command line */
        memcpy ( &psp_cmdline[1], cmdline, cmdline_len );
 
        /* Command line ends with CR */
        psp_cmdline[ 1 + cmdline_len ] = '\r';
}

References cmdline, image::cmdline, COMBOOT_MAX_CMDLINE_LEN, COMBOOT_PSP_CMDLINE_OFFSET, memcpy(), seg, and strlen().

Referenced by comboot_init_psp().

comboot_init_psp()

void comboot_init_psp ( struct image * image, void * seg )

static

Initialize PSP.

Parameters

image	COMBOOT image
seg	segment to initialize

Definition at line 98 of file comboot.c.

                                                                 {
        struct comboot_psp *psp;
 
        /* Fill PSP */
        psp = seg;
 
        /* 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 %s: first non-free paragraph = 0x%x\n",
               image->name, psp->first_non_free_para );
 
        /* Copy the command line to the PSP */
        comboot_copy_cmdline ( image, seg );
}

References comboot_copy_cmdline(), DBGC, comboot_psp::first_non_free_para, get_fbms(), comboot_psp::int20, image::name, and seg.

Referenced by comboot_exec_loop().

comboot_exec_loop()

int comboot_exec_loop ( struct image * image )

static

Execute COMBOOT image.

Parameters

image

COMBOOT image

Return values

rc	Return status code

Definition at line 124 of file comboot.c.

                                                     {
        void *seg = real_to_virt ( 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 );
 
                /* 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 %s: returned\n", image->name );
                break;
 
        case COMBOOT_EXIT:
                DBGC ( image, "COMBOOT %s: exited\n", image->name );
                break;
 
        case COMBOOT_EXIT_RUN_KERNEL:
                assert ( image->replacement );
                DBGC ( image, "COMBOOT %s: exited to run kernel %s\n",
                       image->name, image->replacement->name );
                break;
 
        case COMBOOT_EXIT_COMMAND:
                DBGC ( image, "COMBOOT %s: exited after executing command\n",
                       image->name );
                break;
 
        default:
                assert ( 0 );
                break;
        }
 
        unhook_comboot_interrupts();
        comboot_force_text_mode();
 
        return 0;
}

References __asm__(), __volatile__(), assert, COMBOOT_EXIT, COMBOOT_EXIT_COMMAND, COMBOOT_EXIT_RUN_KERNEL, comboot_force_text_mode(), comboot_init_psp(), COMBOOT_PSP_SEG, comboot_return, DBGC, hook_comboot_interrupts(), image::name, REAL_CODE, real_to_virt(), image::replacement, rmsetjmp, seg, state, unhook_comboot_interrupts(), and unregister_image().

Referenced by comboot_exec().

comboot_identify()

int comboot_identify ( struct image * image )

static

Check image name extension.

Parameters

image

COMBOOT image

Return values

rc	Return status code

Definition at line 210 of file comboot.c.

                                                    {
        const char *ext;
 
        ext = strrchr( image->name, '.' );
 
        if ( ! ext ) {
                DBGC ( image, "COMBOOT %s: no extension\n",
                       image->name );
                return -ENOEXEC;
        }
 
        ++ext;
 
        if ( strcasecmp( ext, "cbt" ) ) {
                DBGC ( image, "COMBOOT %s: unrecognized extension %s\n",
                       image->name, ext );
                return -ENOEXEC;
        }
 
        return 0;
}

References DBGC, ENOEXEC, ext, image::name, strcasecmp(), and strrchr().

Referenced by comboot_probe().

comboot_prepare_segment()

int comboot_prepare_segment ( struct image * image )

static

Load COMBOOT image into memory, preparing a segment and returning it.

Parameters

image

COMBOOT image

Return values

rc	Return status code

Definition at line 237 of file comboot.c.

{
        void *seg;
        size_t filesz, memsz;
        int rc;
 
        /* Load image in segment */
        seg = real_to_virt ( 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, filesz, memsz ) ) != 0 ) {
                DBGC ( image, "COMBOOT %s: could not prepare segment: %s\n",
                       image->name, strerror ( rc ) );
                return rc;
        }
 
        /* Zero PSP */
        memset ( seg, 0, 0x100 );
 
        /* Copy image to segment:0100 */
        memcpy ( ( seg + 0x100 ), image->data, image->len );
 
        return 0;
}

References COMBOOT_PSP_SEG, image::data, DBGC, image::len, memcpy(), memset(), memsz, image::name, prep_segment(), rc, real_to_virt(), seg, and strerror().

Referenced by comboot_exec().

comboot_probe()

int comboot_probe ( struct image * image )

static

Probe COMBOOT image.

Parameters

image

COMBOOT image

Return values

rc	Return status code

Definition at line 274 of file comboot.c.

                                                 {
        int rc;
 
        /* Check if this is a COMBOOT image */
        if ( ( rc = comboot_identify ( image ) ) != 0 ) {
 
                return rc;
        }
 
        return 0;
}

References comboot_identify(), and rc.

Referenced by __image_type().

comboot_exec()

int comboot_exec ( struct image * image )

static

Execute COMBOOT image.

Parameters

image

COMBOOT image

Return values

rc	Return status code

Definition at line 292 of file comboot.c.

                                                {
        int rc;
 
        /* Sanity check for filesize */
        if( image->len >= 0xFF00 ) {
                DBGC( image, "COMBOOT %s: image too large\n",
                      image->name );
                return -ENOEXEC;
        }
 
        /* Prepare segment and load image */
        if ( ( rc = comboot_prepare_segment ( image ) ) != 0 ) {
                return rc;
        }
 
        /* Reset console */
        console_reset();
 
        return comboot_exec_loop ( image );
}

References comboot_exec_loop(), comboot_prepare_segment(), console_reset(), DBGC, ENOEXEC, image::len, image::name, and rc.

Referenced by __image_type().

__image_type()

struct image_type comboot_image_type __image_type

(

PROBE_NORMAL

)

SYSLINUX COMBOOT (16-bit) image type.

References __image_type, comboot_exec(), comboot_probe(), and PROBE_NORMAL.