ipxe/src/arch/i386/image/com32.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., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA.
 */

/**
 * @file
 *
 * SYSLINUX COM32 image format
 *
 */

FILE_LICENCE ( GPL2_OR_LATER );

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

struct idt_register com32_external_idtr = {
	.limit = COM32_NUM_IDT_ENTRIES * sizeof ( struct idt_descriptor ) - 1,
	.base = COM32_IDT
};

struct idt_register com32_internal_idtr;

/**
 * Execute COMBOOT image
 *
 * @v image		COM32 image
 * @ret rc		Return status code
 */
static int com32_exec_loop ( struct image *image ) {
	struct memory_map memmap;
	unsigned int i;
	int state;
	uint32_t avail_mem_top;

	state = rmsetjmp ( comboot_return );

	switch ( state ) {
	case 0: /* First time through; invoke COM32 program */

		/* Get memory map */
		get_memmap ( &memmap );

		/* Find end of block covering COM32 image loading area */
		for ( i = 0, avail_mem_top = 0 ; i < memmap.count ; i++ ) {
			if ( (memmap.regions[i].start <= COM32_START_PHYS) &&
			     (memmap.regions[i].end > COM32_START_PHYS + image->len) ) {
				avail_mem_top = memmap.regions[i].end;
				break;
			}
		}

		DBGC ( image, "COM32 %p: available memory top = 0x%x\n",
		       image, avail_mem_top );

		assert ( avail_mem_top != 0 );

		com32_external_esp = phys_to_virt ( avail_mem_top );

		/* Hook COMBOOT API interrupts */
		hook_comboot_interrupts();

		/* 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 );

		__asm__ __volatile__ (
			"sidt com32_internal_idtr\n\t"
			"lidt com32_external_idtr\n\t"	       /* Set up IDT */
			"movl %%esp, (com32_internal_esp)\n\t" /* Save internal virtual address space ESP */
			"movl (com32_external_esp), %%esp\n\t" /* Switch to COM32 ESP (top of available memory) */
			"call _virt_to_phys\n\t"               /* Switch to flat physical address space */
			"sti\n\t"			       /* Enable interrupts */
			"pushl %0\n\t"                         /* Pointer to CDECL helper function */
			"pushl %1\n\t"                         /* Pointer to FAR call helper function */
			"pushl %2\n\t"                         /* Size of low memory bounce buffer */
			"pushl %3\n\t"                         /* Pointer to low memory bounce buffer */
			"pushl %4\n\t"                         /* Pointer to INT call helper function */
			"pushl %5\n\t"                         /* Pointer to the command line arguments */
			"pushl $6\n\t"                         /* Number of additional arguments */
			"call *%6\n\t"                         /* Execute image */
			"cli\n\t"			       /* Disable interrupts */
			"call _phys_to_virt\n\t"	       /* Switch back to internal virtual address space */
			"lidt com32_internal_idtr\n\t"	       /* Switch back to internal IDT (for debugging) */
			"movl (com32_internal_esp), %%esp\n\t" /* Switch back to internal stack */
		:
		:
			/* %0 */ "r" ( virt_to_phys ( com32_cfarcall_wrapper ) ),
			/* %1 */ "r" ( virt_to_phys ( com32_farcall_wrapper ) ),
			/* %2 */ "r" ( get_fbms() * 1024 - (COM32_BOUNCE_SEG << 4) ),
			/* %3 */ "i" ( COM32_BOUNCE_SEG << 4 ),
			/* %4 */ "r" ( virt_to_phys ( com32_intcall_wrapper ) ),
			/* %5 */ "r" ( virt_to_phys ( image->cmdline ?
						      image->cmdline : "" ) ),
			/* %6 */ "r" ( COM32_START_PHYS )
		:
			"memory" );
		DBGC ( image, "COM32 %p: returned\n", image );
		break;

	case COMBOOT_EXIT:
		DBGC ( image, "COM32 %p: exited\n", image );
		break;

	case COMBOOT_EXIT_RUN_KERNEL:
		assert ( image->replacement );
		DBGC ( image, "COM32 %p: exited to run kernel %s\n",
		       image, image->replacement->name );
		break;

	case COMBOOT_EXIT_COMMAND:
		DBGC ( image, "COM32 %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		COM32 image
 * @ret rc		Return status code
 */
static int com32_identify ( struct image *image ) {
	const char *ext;
	static const uint8_t magic[] = { 0xB8, 0xFF, 0x4C, 0xCD, 0x21 };
	uint8_t buf[5];
	
	if ( image->len >= 5 ) {
		/* Check for magic number
		 * mov eax,21cd4cffh
		 * B8 FF 4C CD 21
		 */
		copy_from_user ( buf, image->data, 0, sizeof(buf) );
		if ( ! memcmp ( buf, magic, sizeof(buf) ) ) {
			DBGC ( image, "COM32 %p: found magic number\n",
			       image );
			return 0;
		}
	}

	/* Magic number not found; check filename extension */

	ext = strrchr( image->name, '.' );

	if ( ! ext ) {
		DBGC ( image, "COM32 %p: no extension\n",
		       image );
		return -ENOEXEC;
	}

	++ext;

	if ( strcasecmp( ext, "c32" ) ) {
		DBGC ( image, "COM32 %p: unrecognized extension %s\n",
		       image, ext );
		return -ENOEXEC;
	}

	return 0;
}


/**
 * Load COM32 image into memory and set up the IDT
 * @v image		COM32 image
 * @ret rc		Return status code
 */
static int com32_load_image ( struct image *image ) {
	physaddr_t com32_irq_wrapper_phys;
	struct idt_descriptor *idt;
	struct ijb_entry *ijb;
	size_t filesz, memsz;
	userptr_t buffer;
	int rc, i;

	/* The interrupt descriptor table, interrupt jump buffer, and
	 * image data are all contiguous in memory. Prepare them all at once.
	 */
	filesz = image->len +
		COM32_NUM_IDT_ENTRIES * sizeof ( struct idt_descriptor ) +
		COM32_NUM_IDT_ENTRIES * sizeof ( struct ijb_entry );
	memsz = filesz;
	buffer = phys_to_user ( COM32_IDT );
	if ( ( rc = prep_segment ( buffer, filesz, memsz ) ) != 0 ) {
		DBGC ( image, "COM32 %p: could not prepare segment: %s\n",
		       image, strerror ( rc ) );
		return rc;
	}

	/* Write the IDT and IJB */
	idt = phys_to_virt ( COM32_IDT );
	ijb = phys_to_virt ( COM32_IJB );
	com32_irq_wrapper_phys = virt_to_phys ( com32_irq_wrapper );

	for ( i = 0; i < COM32_NUM_IDT_ENTRIES; i++ ) {
		uint32_t ijb_address = virt_to_phys ( &ijb[i] );

		idt[i].offset_low = ijb_address & 0xFFFF;
		idt[i].selector = PHYSICAL_CS;
		idt[i].flags = IDT_INTERRUPT_GATE_FLAGS;
		idt[i].offset_high = ijb_address >> 16;

		ijb[i].pusha_instruction = IJB_PUSHA;
		ijb[i].mov_instruction = IJB_MOV_AL_IMM8;
		ijb[i].mov_value = i;
		ijb[i].jump_instruction = IJB_JMP_REL32;
		ijb[i].jump_destination = com32_irq_wrapper_phys -
			virt_to_phys ( &ijb[i + 1] );
	}

	/* Copy image to segment */
	buffer = phys_to_user ( COM32_START_PHYS );
	memcpy_user ( buffer, 0, image->data, 0, filesz );

	return 0;
}

/**
 * Prepare COM32 low memory bounce buffer
 * @v image		COM32 image
 * @ret rc		Return status code
 */
static int com32_prepare_bounce_buffer ( struct image * image ) {
	unsigned int seg;
	userptr_t seg_userptr;
	size_t filesz, memsz;
	int rc;

	seg = COM32_BOUNCE_SEG;
	seg_userptr = real_to_user ( seg, 0 );

	/* Ensure the entire 64k segment is free */
	memsz = 0xFFFF;
	filesz = 0;

	/* Prepare, verify, and load the real-mode segment */
	if ( ( rc = prep_segment ( seg_userptr, filesz, memsz ) ) != 0 ) {
		DBGC ( image, "COM32 %p: could not prepare bounce buffer segment: %s\n",
		       image, strerror ( rc ) );
		return rc;
	}

	return 0;
}

/**
 * Probe COM32 image
 *
 * @v image		COM32 image
 * @ret rc		Return status code
 */
static int com32_probe ( struct image *image ) {
	int rc;

	DBGC ( image, "COM32 %p: name '%s'\n", image, image->name );

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

	return 0;
}

/**
 * Execute COMBOOT image
 *
 * @v image		COM32 image
 * @ret rc		Return status code
 */
static int com32_exec ( struct image *image ) {
	int rc;

	/* Load image */
	if ( ( rc = com32_load_image ( image ) ) != 0 ) {
		return rc;
	}

	/* Prepare bounce buffer segment */
	if ( ( rc = com32_prepare_bounce_buffer ( image ) ) != 0 ) {
		return rc;
	}

	return com32_exec_loop ( image );
}

/** SYSLINUX COM32 image type */
struct image_type com32_image_type __image_type ( PROBE_NORMAL ) = {
	.name = "COM32",
	.probe = com32_probe,
	.exec = com32_exec,
};