src/arch/x86/image/com32.c - ipxe - Git at Google

 /*
  * 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>
 #include <ipxe/console.h>

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

 		/* 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__ ( PHYS_CODE (
 			/* Preserve registers */
 			"pushal\n\t"
 			/* Preserve stack pointer */
 			"subl $4, %k0\n\t"
 			"movl %%esp, (%k0)\n\t"
 			/* Switch to COM32 stack */
 			"movl %k0, %%esp\n\t"
 			/* Enable interrupts */
 			"sti\n\t"
 			/* Construct stack frame */
 			"pushl %k1\n\t"
 			"pushl %k2\n\t"
 			"pushl %k3\n\t"
 			"pushl %k4\n\t"
 			"pushl %k5\n\t"
 			"pushl %k6\n\t"
 			"pushl $6\n\t"
 			/* Call COM32 entry point */
 			"movl %k7, %k0\n\t"
 			"call *%k0\n\t"
 			/* Disable interrupts */
 			"cli\n\t"
 			/* Restore stack pointer */
 			"movl 28(%%esp), %%esp\n\t"
 			/* Restore registers */
 			"popal\n\t" )
 			:
 			: "r" ( avail_mem_top ),
 			  "r" ( virt_to_phys ( com32_cfarcall_wrapper ) ),
 			  "r" ( virt_to_phys ( com32_farcall_wrapper ) ),
 			  "r" ( get_fbms() * 1024 - ( COM32_BOUNCE_SEG << 4 ) ),
 			  "i" ( COM32_BOUNCE_SEG << 4 ),
 			  "r" ( virt_to_phys ( com32_intcall_wrapper ) ),
 			  "r" ( virt_to_phys ( image->cmdline ?
 					       image->cmdline : "" ) ),
 			  "i" ( 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
  * @v image		COM32 image
  * @ret rc		Return status code
  */
 static int com32_load_image ( struct image *image ) {
 	size_t filesz, memsz;
 	userptr_t buffer;
 	int rc;

 	filesz = image->len;
 	memsz = filesz;
 	buffer = phys_to_user ( COM32_START_PHYS );
 	if ( ( rc = prep_segment ( buffer, filesz, memsz ) ) != 0 ) {
 		DBGC ( image, "COM32 %p: could not prepare segment: %s\n",
 		       image, strerror ( rc ) );
 		return rc;
 	}

 	/* Copy image to segment */
 	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;
 	}

 	/* Reset console */
 	console_reset();

 	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,
 };
	/*
	* 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>
	#include <ipxe/console.h>

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

	/* 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__ ( PHYS_CODE (
	/* Preserve registers */
	"pushal\n\t"
	/* Preserve stack pointer */
	"subl $4, %k0\n\t"
	"movl %%esp, (%k0)\n\t"
	/* Switch to COM32 stack */
	"movl %k0, %%esp\n\t"
	/* Enable interrupts */
	"sti\n\t"
	/* Construct stack frame */
	"pushl %k1\n\t"
	"pushl %k2\n\t"
	"pushl %k3\n\t"
	"pushl %k4\n\t"
	"pushl %k5\n\t"
	"pushl %k6\n\t"
	"pushl $6\n\t"
	/* Call COM32 entry point */
	"movl %k7, %k0\n\t"
	"call *%k0\n\t"
	/* Disable interrupts */
	"cli\n\t"
	/* Restore stack pointer */
	"movl 28(%%esp), %%esp\n\t"
	/* Restore registers */
	"popal\n\t" )
	:
	: "r" ( avail_mem_top ),
	"r" ( virt_to_phys ( com32_cfarcall_wrapper ) ),
	"r" ( virt_to_phys ( com32_farcall_wrapper ) ),
	"r" ( get_fbms() * 1024 - ( COM32_BOUNCE_SEG << 4 ) ),
	"i" ( COM32_BOUNCE_SEG << 4 ),
	"r" ( virt_to_phys ( com32_intcall_wrapper ) ),
	"r" ( virt_to_phys ( image->cmdline ?
	image->cmdline : "" ) ),
	"i" ( 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
	* @v image COM32 image
	* @ret rc Return status code
	*/
	static int com32_load_image ( struct image *image ) {
	size_t filesz, memsz;
	userptr_t buffer;
	int rc;

	filesz = image->len;
	memsz = filesz;
	buffer = phys_to_user ( COM32_START_PHYS );
	if ( ( rc = prep_segment ( buffer, filesz, memsz ) ) != 0 ) {
	DBGC ( image, "COM32 %p: could not prepare segment: %s\n",
	image, strerror ( rc ) );
	return rc;
	}

	/* Copy image to segment */
	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;
	}

	/* Reset console */
	console_reset();

	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,
	};