src/arch/i386/image/com32.c

   1 /*
   2  * Copyright (C) 2008 Daniel Verkamp <daniel@drv.nu>.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License as
   6  * published by the Free Software Foundation; either version 2 of the
   7  * License, or any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17  */
  18
  19 /**
  20  * @file
  21  *
  22  * SYSLINUX COM32 image format
  23  *
  24  */
  25
  26 #include <stdint.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include <strings.h>
  30 #include <errno.h>
  31 #include <assert.h>
  32 #include <realmode.h>
  33 #include <basemem.h>
  34 #include <comboot.h>
  35 #include <gpxe/uaccess.h>
  36 #include <gpxe/image.h>
  37 #include <gpxe/segment.h>
  38 #include <gpxe/init.h>
  39 #include <gpxe/memmap.h>
  40
  41 struct image_type com32_image_type __image_type ( PROBE_NORMAL );
  42
  43 /**
  44  * Execute COMBOOT image
  45  *
  46  * @v image             COM32 image
  47  * @ret rc              Return status code
  48  */
  49 static int com32_exec ( struct image *image ) {
  50         struct memory_map memmap;
  51         unsigned int i;
  52         int state;
  53         uint32_t avail_mem_top;
  54
  55         state = setjmp ( comboot_return );
  56
  57         switch ( state ) {
  58         case 0: /* First time through; invoke COM32 program */
  59
  60                 /* Get memory map */
  61                 get_memmap ( &memmap );
  62
  63                 /* Find end of block covering COM32 image loading area */
  64                 for ( i = 0, avail_mem_top = 0 ; i < memmap.count ; i++ ) {
  65                         if ( (memmap.regions[i].start <= COM32_START_PHYS) &&
  66                              (memmap.regions[i].end > COM32_START_PHYS + image->len) ) {
  67                                 avail_mem_top = memmap.regions[i].end;
  68                                 break;
  69                         }
  70                 }
  71
  72                 DBGC ( image, "COM32 %p: available memory top = 0x%x\n",
  73                        image, avail_mem_top );
  74
  75                 assert ( avail_mem_top != 0 );
  76
  77                 com32_external_esp = phys_to_virt ( avail_mem_top );
  78
  79                 /* Hook COMBOOT API interrupts */
  80                 hook_comboot_interrupts();
  81
  82                 /* Unregister image, so that a "boot" command doesn't
  83                  * throw us into an execution loop.  We never
  84                  * reregister ourselves; COMBOOT images expect to be
  85                  * removed on exit.
  86                  */
  87                 unregister_image ( image );
  88
  89                 __asm__ __volatile__ (
  90                         "movl %%esp, (com32_internal_esp)\n\t" /* Save internal virtual address space ESP */
  91                         "movl (com32_external_esp), %%esp\n\t" /* Switch to COM32 ESP (top of available memory) */
  92                         "call _virt_to_phys\n\t"               /* Switch to flat physical address space */
  93                         "pushl %0\n\t"                         /* Pointer to CDECL helper function */
  94                         "pushl %1\n\t"                         /* Pointer to FAR call helper function */
  95                         "pushl %2\n\t"                         /* Size of low memory bounce buffer */
  96                         "pushl %3\n\t"                         /* Pointer to low memory bounce buffer */
  97                         "pushl %4\n\t"                         /* Pointer to INT call helper function */
  98                         "pushl %5\n\t"                         /* Pointer to the command line arguments */
  99                         "pushl $6\n\t"                         /* Number of additional arguments */
 100                         "call *%6\n\t"                         /* Execute image */
 101                         "call _phys_to_virt\n\t"               /* Switch back to internal virtual address space */
 102                         "movl (com32_internal_esp), %%esp\n\t" /* Switch back to internal stack */
 103                 :
 104                 :
 105                         /* %0 */ "r" ( virt_to_phys ( com32_cfarcall_wrapper ) ),
 106                         /* %1 */ "r" ( virt_to_phys ( com32_farcall_wrapper ) ),
 107                         /* %2 */ "r" ( get_fbms() * 1024 - (COM32_BOUNCE_SEG << 4) ),
 108                         /* %3 */ "i" ( COM32_BOUNCE_SEG << 4 ),
 109                         /* %4 */ "r" ( virt_to_phys ( com32_intcall_wrapper ) ),
 110                         /* %5 */ "r" ( virt_to_phys ( image->cmdline ) ),
 111                         /* %6 */ "r" ( COM32_START_PHYS )
 112                 :
 113                         "memory" );
 114                 DBGC ( image, "COM32 %p: returned\n", image );
 115                 break;
 116
 117         case COMBOOT_EXIT:
 118                 DBGC ( image, "COM32 %p: exited\n", image );
 119                 break;
 120
 121         case COMBOOT_EXIT_RUN_KERNEL:
 122                 DBGC ( image, "COM32 %p: exited to run kernel %p\n",
 123                        image, comboot_replacement_image );
 124                 image->replacement = comboot_replacement_image;
 125                 comboot_replacement_image = NULL;
 126                 image_autoload ( image->replacement );
 127                 break;
 128
 129         case COMBOOT_EXIT_COMMAND:
 130                 DBGC ( image, "COM32 %p: exited after executing command\n",
 131                        image );
 132                 break;
 133
 134         default:
 135                 assert ( 0 );
 136                 break;
 137         }
 138
 139         unhook_comboot_interrupts();
 140         comboot_force_text_mode();
 141
 142         return 0;
 143 }
 144
 145 /**
 146  * Check image name extension
 147  *
 148  * @v image             COM32 image
 149  * @ret rc              Return status code
 150  */
 151 static int com32_identify ( struct image *image ) {
 152         const char *ext;
 153         static const uint8_t magic[] = { 0xB8, 0xFF, 0x4C, 0xCD, 0x21 };
 154         uint8_t buf[5];
 155
 156         if ( image->len >= 5 ) {
 157                 /* Check for magic number
 158                  * mov eax,21cd4cffh
 159                  * B8 FF 4C CD 21
 160                  */
 161                 copy_from_user ( buf, image->data, 0, sizeof(buf) );
 162                 if ( ! memcmp ( buf, magic, sizeof(buf) ) ) {
 163                         DBGC ( image, "COM32 %p: found magic number\n",
 164                                image );
 165                         return 0;
 166                 }
 167         }
 168
 169         /* Magic number not found; check filename extension */
 170
 171         ext = strrchr( image->name, '.' );
 172
 173         if ( ! ext ) {
 174                 DBGC ( image, "COM32 %p: no extension\n",
 175                        image );
 176                 return -ENOEXEC;
 177         }
 178
 179         ++ext;
 180
 181         if ( strcasecmp( ext, "c32" ) ) {
 182                 DBGC ( image, "COM32 %p: unrecognized extension %s\n",
 183                        image, ext );
 184                 return -ENOEXEC;
 185         }
 186
 187         return 0;
 188 }
 189
 190
 191 /**
 192  * Load COM32 image into memory
 193  * @v image             COM32 image
 194  * @ret rc              Return status code
 195  */
 196 static int comboot_load_image ( struct image *image ) {
 197         size_t filesz, memsz;
 198         userptr_t buffer;
 199         int rc;
 200
 201         filesz = image->len;
 202         memsz = filesz;
 203         buffer = phys_to_user ( COM32_START_PHYS );
 204         if ( ( rc = prep_segment ( buffer, filesz, memsz ) ) != 0 ) {
 205                 DBGC ( image, "COM32 %p: could not prepare segment: %s\n",
 206                        image, strerror ( rc ) );
 207                 return rc;
 208         }
 209
 210         /* Copy image to segment */
 211         memcpy_user ( buffer, 0, image->data, 0, filesz );
 212
 213         return 0;
 214 }
 215
 216 /**
 217  * Prepare COM32 low memory bounce buffer
 218  * @v image             COM32 image
 219  * @ret rc              Return status code
 220  */
 221 static int comboot_prepare_bounce_buffer ( struct image * image ) {
 222         unsigned int seg;
 223         userptr_t seg_userptr;
 224         size_t filesz, memsz;
 225         int rc;
 226
 227         seg = COM32_BOUNCE_SEG;
 228         seg_userptr = real_to_user ( seg, 0 );
 229
 230         /* Ensure the entire 64k segment is free */
 231         memsz = 0xFFFF;
 232         filesz = 0;
 233
 234         /* Prepare, verify, and load the real-mode segment */
 235         if ( ( rc = prep_segment ( seg_userptr, filesz, memsz ) ) != 0 ) {
 236                 DBGC ( image, "COM32 %p: could not prepare bounce buffer segment: %s\n",
 237                        image, strerror ( rc ) );
 238                 return rc;
 239         }
 240
 241         return 0;
 242 }
 243
 244 /**
 245  * Load COM32 image into memory
 246  *
 247  * @v image             COM32 image
 248  * @ret rc              Return status code
 249  */
 250 static int com32_load ( struct image *image ) {
 251         int rc;
 252
 253         DBGC ( image, "COM32 %p: name '%s', cmdline '%s'\n",
 254                image, image->name, image->cmdline );
 255
 256         /* Check if this is a COMBOOT image */
 257         if ( ( rc = com32_identify ( image ) ) != 0 ) {
 258                 return rc;
 259         }
 260
 261         /* This is a COM32 image, valid or otherwise */
 262         if ( ! image->type )
 263                 image->type = &com32_image_type;
 264
 265         /* Load image */
 266         if ( ( rc = comboot_load_image ( image ) ) != 0 ) {
 267                 return rc;
 268         }
 269
 270         /* Prepare bounce buffer segment */
 271         if ( ( rc = comboot_prepare_bounce_buffer ( image ) ) != 0 ) {
 272                 return rc;
 273         }
 274
 275         return 0;
 276 }
 277
 278 /** SYSLINUX COM32 image type */
 279 struct image_type com32_image_type __image_type ( PROBE_NORMAL ) = {
 280         .name = "COM32",
 281         .load = com32_load,
 282         .exec = com32_exec,
 283 };