/* * Copyright (C) 2008 Daniel Verkamp . * * 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 * */ FILE_LICENCE ( GPL2_OR_LATER ); #include #include #include #include #include #include #include #include #include #include #include #include #include #include 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, };