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