src/arch/i386/image/comboot.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 COMBOOT (16-bit) 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/features.h>
  40
  41 FEATURE ( FEATURE_IMAGE, "COMBOOT", DHCP_EB_FEATURE_COMBOOT, 1 );
  42
  43 struct image_type comboot_image_type __image_type ( PROBE_NORMAL );
  44
  45 /**
  46  * COMBOOT PSP, copied to offset 0 of code segment
  47  */
  48 struct comboot_psp {
  49         /** INT 20 instruction, executed if COMBOOT image returns with RET */
  50         uint16_t int20;
  51         /** Segment of first non-free paragraph of memory */
  52         uint16_t first_non_free_para;
  53 };
  54
  55 /** Offset in PSP of command line */
  56 #define COMBOOT_PSP_CMDLINE_OFFSET 0x81
  57
  58 /** Maximum length of command line in PSP
  59  * (127 bytes minus space and CR) */
  60 #define COMBOOT_MAX_CMDLINE_LEN    125
  61
  62
  63 /**
  64  * Copy command line to PSP
  65  *
  66  * @v image             COMBOOT image
  67  */
  68 static void comboot_copy_cmdline ( struct image * image, userptr_t seg_userptr ) {
  69         const char *cmdline = ( image->cmdline ? image->cmdline : "" );
  70         int cmdline_len = strlen ( cmdline );
  71         if( cmdline_len > COMBOOT_MAX_CMDLINE_LEN )
  72                 cmdline_len = COMBOOT_MAX_CMDLINE_LEN;
  73         uint8_t len_byte = cmdline_len;
  74         char spc = ' ', cr = '\r';
  75
  76         /* Copy length to byte before command line */
  77         copy_to_user ( seg_userptr, COMBOOT_PSP_CMDLINE_OFFSET - 1,
  78                        &len_byte, 1 );
  79
  80         /* Command line starts with space */
  81         copy_to_user ( seg_userptr,
  82                        COMBOOT_PSP_CMDLINE_OFFSET,
  83                        &spc, 1 );
  84
  85         /* Copy command line */
  86         copy_to_user ( seg_userptr,
  87                        COMBOOT_PSP_CMDLINE_OFFSET + 1,
  88                        cmdline, cmdline_len );
  89
  90         /* Command line ends with CR */
  91         copy_to_user ( seg_userptr,
  92                        COMBOOT_PSP_CMDLINE_OFFSET + cmdline_len + 1,
  93                        &cr, 1 );
  94 }
  95
  96 /**
  97  * Initialize PSP
  98  *
  99  * @v image             COMBOOT image
 100  * @v seg_userptr       segment to initialize
 101  */
 102 static void comboot_init_psp ( struct image * image, userptr_t seg_userptr ) {
 103         struct comboot_psp psp;
 104
 105         /* Fill PSP */
 106
 107         /* INT 20h instruction, byte order reversed */
 108         psp.int20 = 0x20CD;
 109
 110         /* get_fbms() returns BIOS free base memory counter, which is in
 111          * kilobytes; x * 1024 / 16 == x * 64 == x << 6 */
 112         psp.first_non_free_para = get_fbms() << 6;
 113
 114         DBGC ( image, "COMBOOT %p: first non-free paragraph = 0x%x\n",
 115                image, psp.first_non_free_para );
 116
 117         /* Copy the PSP to offset 0 of segment.
 118          * The rest of the PSP was already zeroed by
 119          * comboot_prepare_segment. */
 120         copy_to_user ( seg_userptr, 0, &psp, sizeof( psp ) );
 121
 122         /* Copy the command line to the PSP */
 123         comboot_copy_cmdline ( image, seg_userptr );
 124 }
 125
 126 /**
 127  * Execute COMBOOT image
 128  *
 129  * @v image             COMBOOT image
 130  * @ret rc              Return status code
 131  */
 132 static int comboot_exec ( struct image *image ) {
 133         userptr_t seg_userptr = real_to_user ( COMBOOT_PSP_SEG, 0 );
 134         int state;
 135
 136         state = rmsetjmp ( comboot_return );
 137
 138         switch ( state ) {
 139         case 0: /* First time through; invoke COMBOOT program */
 140
 141                 /* Initialize PSP */
 142                 comboot_init_psp ( image, seg_userptr );
 143
 144                 /* Hook COMBOOT API interrupts */
 145                 hook_comboot_interrupts();
 146
 147                 DBGC ( image, "executing 16-bit COMBOOT image at %4x:0100\n",
 148                        COMBOOT_PSP_SEG );
 149
 150                 /* Unregister image, so that a "boot" command doesn't
 151                  * throw us into an execution loop.  We never
 152                  * reregister ourselves; COMBOOT images expect to be
 153                  * removed on exit.
 154                  */
 155                 unregister_image ( image );
 156
 157                 /* Store stack segment at 0x38 and stack pointer at 0x3A
 158                  * in the PSP and jump to the image */
 159                 __asm__ __volatile__ (
 160                     REAL_CODE ( /* Save return address with segment on old stack */
 161                                     "popw %%ax\n\t"
 162                                     "pushw %%cs\n\t"
 163                                     "pushw %%ax\n\t"
 164                                     /* Set DS=ES=segment with image */
 165                                     "movw %w0, %%ds\n\t"
 166                                     "movw %w0, %%es\n\t"
 167                                     /* Set SS:SP to new stack (end of image segment) */
 168                                     "movw %w0, %%ss\n\t"
 169                                     "xor %%sp, %%sp\n\t"
 170                                     "pushw $0\n\t"
 171                                     "pushw %w0\n\t"
 172                                     "pushw $0x100\n\t"
 173                                     /* Zero registers (some COM files assume GP regs are 0) */
 174                                     "xorw %%ax, %%ax\n\t"
 175                                     "xorw %%bx, %%bx\n\t"
 176                                     "xorw %%cx, %%cx\n\t"
 177                                     "xorw %%dx, %%dx\n\t"
 178                                     "xorw %%si, %%si\n\t"
 179                                     "xorw %%di, %%di\n\t"
 180                                     "xorw %%bp, %%bp\n\t"
 181                                     "lret\n\t" )
 182                                          : : "r" ( COMBOOT_PSP_SEG ) : "eax" );
 183                 DBGC ( image, "COMBOOT %p: returned\n", image );
 184                 break;
 185
 186         case COMBOOT_EXIT:
 187                 DBGC ( image, "COMBOOT %p: exited\n", image );
 188                 break;
 189
 190         case COMBOOT_EXIT_RUN_KERNEL:
 191                 DBGC ( image, "COMBOOT %p: exited to run kernel %p\n",
 192                        image, comboot_replacement_image );
 193                 image->replacement = comboot_replacement_image;
 194                 comboot_replacement_image = NULL;
 195                 image_autoload ( image->replacement );
 196                 break;
 197
 198         case COMBOOT_EXIT_COMMAND:
 199                 DBGC ( image, "COMBOOT %p: exited after executing command\n",
 200                        image );
 201                 break;
 202
 203         default:
 204                 assert ( 0 );
 205                 break;
 206         }
 207
 208         unhook_comboot_interrupts();
 209         comboot_force_text_mode();
 210
 211         return 0;
 212 }
 213
 214 /**
 215  * Check image name extension
 216  *
 217  * @v image             COMBOOT image
 218  * @ret rc              Return status code
 219  */
 220 static int comboot_identify ( struct image *image ) {
 221         const char *ext;
 222
 223         ext = strrchr( image->name, '.' );
 224
 225         if ( ! ext ) {
 226                 DBGC ( image, "COMBOOT %p: no extension\n",
 227                        image );
 228                 return -ENOEXEC;
 229         }
 230
 231         ++ext;
 232
 233         if ( strcasecmp( ext, "com" ) && strcasecmp( ext, "cbt" ) ) {
 234                 DBGC ( image, "COMBOOT %p: unrecognized extension %s\n",
 235                        image, ext );
 236                 return -ENOEXEC;
 237         }
 238
 239         return 0;
 240 }
 241
 242 /**
 243  * Load COMBOOT image into memory, preparing a segment and returning it
 244  * @v image             COMBOOT image
 245  * @ret rc              Return status code
 246  */
 247 static int comboot_prepare_segment ( struct image *image )
 248 {
 249         userptr_t seg_userptr;
 250         size_t filesz, memsz;
 251         int rc;
 252
 253         /* Load image in segment */
 254         seg_userptr = real_to_user ( COMBOOT_PSP_SEG, 0 );
 255
 256         /* Allow etra 0x100 bytes before image for PSP */
 257         filesz = image->len + 0x100;
 258
 259         /* Ensure the entire 64k segment is free */
 260         memsz = 0xFFFF;
 261
 262         /* Prepare, verify, and load the real-mode segment */
 263         if ( ( rc = prep_segment ( seg_userptr, filesz, memsz ) ) != 0 ) {
 264                 DBGC ( image, "COMBOOT %p: could not prepare segment: %s\n",
 265                        image, strerror ( rc ) );
 266                 return rc;
 267         }
 268
 269         /* Zero PSP */
 270         memset_user ( seg_userptr, 0, 0, 0x100 );
 271
 272         /* Copy image to segment:0100 */
 273         memcpy_user ( seg_userptr, 0x100, image->data, 0, image->len );
 274
 275         return 0;
 276 }
 277
 278 /**
 279  * Load COMBOOT image into memory
 280  *
 281  * @v image             COMBOOT image
 282  * @ret rc              Return status code
 283  */
 284 static int comboot_load ( struct image *image ) {
 285         int rc;
 286
 287         DBGC ( image, "COMBOOT %p: name '%s'\n",
 288                image, image->name );
 289
 290         /* Check if this is a COMBOOT image */
 291         if ( ( rc = comboot_identify ( image ) ) != 0 ) {
 292
 293                 return rc;
 294         }
 295
 296         /* This is a 16-bit COMBOOT image, valid or otherwise */
 297         if ( ! image->type )
 298                 image->type = &comboot_image_type;
 299
 300         /* Sanity check for filesize */
 301         if( image->len >= 0xFF00 ) {
 302                 DBGC( image, "COMBOOT %p: image too large\n",
 303                       image );
 304                 return -ENOEXEC;
 305         }
 306
 307         /* Prepare segment and load image */
 308         if ( ( rc = comboot_prepare_segment ( image ) ) != 0 ) {
 309                 return rc;
 310         }
 311
 312         return 0;
 313 }
 314
 315 /** SYSLINUX COMBOOT (16-bit) image type */
 316 struct image_type comboot_image_type __image_type ( PROBE_NORMAL ) = {
 317         .name = "COMBOOT",
 318         .load = comboot_load,
 319         .exec = comboot_exec,
 320 };