src/arch/i386/interface/syslinux/comboot_call.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 SYSLINUX COMBOOT API
  21  *
  22  */
  23
  24 #include <errno.h>
  25 #include <realmode.h>
  26 #include <biosint.h>
  27 #include <console.h>
  28 #include <stdlib.h>
  29 #include <comboot.h>
  30 #include <bzimage.h>
  31 #include <pxe_call.h>
  32 #include <setjmp.h>
  33 #include <string.h>
  34 #include <gpxe/posix_io.h>
  35 #include <gpxe/process.h>
  36 #include <gpxe/serial.h>
  37 #include <gpxe/init.h>
  38 #include <gpxe/image.h>
  39 #include <usr/imgmgmt.h>
  40
  41 /** The "SYSLINUX" version string */
  42 static char __data16_array ( syslinux_version, [] ) = "gPXE " VERSION;
  43 #define syslinux_version __use_data16 ( syslinux_version )
  44
  45 /** The "SYSLINUX" copyright string */
  46 static char __data16_array ( syslinux_copyright, [] ) = "http://etherboot.org";
  47 #define syslinux_copyright __use_data16 ( syslinux_copyright )
  48
  49 static char __data16_array ( syslinux_configuration_file, [] ) = "";
  50 #define syslinux_configuration_file __use_data16 ( syslinux_configuration_file )
  51
  52 /** Feature flags */
  53 static uint8_t __data16 ( comboot_feature_flags ) = COMBOOT_FEATURE_IDLE_LOOP;
  54 #define comboot_feature_flags __use_data16 ( comboot_feature_flags )
  55
  56 static struct segoff __text16 ( int20_vector );
  57 #define int20_vector __use_text16 ( int20_vector )
  58
  59 static struct segoff __text16 ( int21_vector );
  60 #define int21_vector __use_text16 ( int21_vector )
  61
  62 static struct segoff __text16 ( int22_vector );
  63 #define int22_vector __use_text16 ( int22_vector )
  64
  65 extern void int20_wrapper ( void );
  66 extern void int21_wrapper ( void );
  67 extern void int22_wrapper ( void );
  68
  69 /* setjmp/longjmp context buffer used to return after loading an image */
  70 jmp_buf comboot_return;
  71
  72 /* Replacement image when exiting with COMBOOT_EXIT_RUN_KERNEL */
  73 struct image *comboot_replacement_image;
  74
  75 /* Mode flags set by INT 22h AX=0017h */
  76 static uint16_t comboot_graphics_mode = 0;
  77
  78
  79 /**
  80  * Print a string with a particular terminator
  81  */
  82 static void print_user_string ( unsigned int segment, unsigned int offset, char terminator ) {
  83         int i = 0;
  84         char c;
  85         userptr_t str = real_to_user ( segment, offset );
  86         for ( ; ; ) {
  87                 copy_from_user ( &c, str, i, 1 );
  88                 if ( c == terminator ) break;
  89                 putchar ( c );
  90                 i++;
  91         }
  92 }
  93
  94
  95 /**
  96  * Perform a series of memory copies from a list in low memory
  97  */
  98 static void shuffle ( unsigned int list_segment, unsigned int list_offset, unsigned int count )
  99 {
 100         comboot_shuffle_descriptor shuf[COMBOOT_MAX_SHUFFLE_DESCRIPTORS];
 101         unsigned int i;
 102
 103         /* Copy shuffle descriptor list so it doesn't get overwritten */
 104         copy_from_user ( shuf, real_to_user ( list_segment, list_offset ), 0,
 105                          count * sizeof( comboot_shuffle_descriptor ) );
 106
 107         /* Do the copies */
 108         for ( i = 0; i < count; i++ ) {
 109                 userptr_t src_u = phys_to_user ( shuf[ i ].src );
 110                 userptr_t dest_u = phys_to_user ( shuf[ i ].dest );
 111
 112                 if ( shuf[ i ].src == 0xFFFFFFFF ) {
 113                         /* Fill with 0 instead of copying */
 114                         memset_user ( dest_u, 0, 0, shuf[ i ].len );
 115                 } else if ( shuf[ i ].dest == 0xFFFFFFFF ) {
 116                         /* Copy new list of descriptors */
 117                         count = shuf[ i ].len / sizeof( comboot_shuffle_descriptor );
 118                         assert ( count <= COMBOOT_MAX_SHUFFLE_DESCRIPTORS );
 119                         copy_from_user ( shuf, src_u, 0, shuf[ i ].len );
 120                         i = -1;
 121                 } else {
 122                         /* Regular copy */
 123                         memmove_user ( dest_u, 0, src_u, 0, shuf[ i ].len );
 124                 }
 125         }
 126 }
 127
 128
 129 /**
 130  * Set default text mode
 131  */
 132 void comboot_force_text_mode ( void ) {
 133         if ( comboot_graphics_mode & COMBOOT_VIDEO_VESA ) {
 134                 /* Set VGA mode 3 via VESA VBE mode set */
 135                 __asm__ __volatile__ (
 136                         REAL_CODE (
 137                                 "mov $0x4F02, %%ax\n\t"
 138                                 "mov $0x03, %%bx\n\t"
 139                                 "int $0x10\n\t"
 140                         )
 141                 : : );
 142         } else if ( comboot_graphics_mode & COMBOOT_VIDEO_GRAPHICS ) {
 143                 /* Set VGA mode 3 via standard VGA mode set */
 144                 __asm__ __volatile__ (
 145                         REAL_CODE (
 146                                 "mov $0x03, %%ax\n\t"
 147                                 "int $0x10\n\t"
 148                         )
 149                 : : );
 150         }
 151
 152         comboot_graphics_mode = 0;
 153 }
 154
 155
 156 /**
 157  * Fetch kernel and optional initrd
 158  */
 159 static int comboot_fetch_kernel ( char *kernel_file, char *cmdline ) {
 160         struct image *kernel = NULL;
 161         struct image *initrd = NULL;
 162         char *initrd_file;
 163         int rc;
 164
 165         /* Find initrd= parameter, if any */
 166         if ( ( initrd_file = strstr ( cmdline, "initrd=" ) ) != NULL ) {
 167                 char *initrd_end;
 168
 169                 /* skip "initrd=" */
 170                 initrd_file += 7;
 171
 172                 /* Find terminating space, if any, and replace with NUL */
 173                 initrd_end = strchr ( initrd_file, ' ' );
 174                 if ( initrd_end )
 175                         *initrd_end = '\0';
 176
 177                 DBG ( "COMBOOT: fetching initrd '%s'\n", initrd_file );
 178
 179                 /* Allocate and fetch initrd */
 180                 initrd = alloc_image();
 181                 if ( ! initrd ) {
 182                         DBG ( "COMBOOT: could not allocate initrd\n" );
 183                         rc = -ENOMEM;
 184                         goto out;
 185                 }
 186                 if ( ( rc = imgfetch ( initrd, initrd_file,
 187                                        register_image ) ) != 0 ) {
 188                         DBG ( "COMBOOT: could not fetch initrd: %s\n",
 189                               strerror ( rc ) );
 190                         goto out;
 191                 }
 192
 193                 /* Restore space after initrd name, if applicable */
 194                 if ( initrd_end )
 195                         *initrd_end = ' ';
 196         }
 197
 198         DBG ( "COMBOOT: fetching kernel '%s'\n", kernel_file );
 199
 200         /* Allocate and fetch kernel */
 201         kernel = alloc_image();
 202         if ( ! kernel ) {
 203                 DBG ( "COMBOOT: could not allocate kernel\n" );
 204                 rc = -ENOMEM;
 205                 goto out;
 206         }
 207         if ( ( rc = imgfetch ( kernel, kernel_file,
 208                                register_image ) ) != 0 ) {
 209                 DBG ( "COMBOOT: could not fetch kernel: %s\n",
 210                       strerror ( rc ) );
 211                 goto out;
 212         }
 213         if ( ( rc = image_set_cmdline ( kernel, cmdline ) ) != 0 ) {
 214                 DBG ( "COMBOOT: could not set kernel command line: %s\n",
 215                       strerror ( rc ) );
 216                 goto out;
 217         }
 218
 219         /* Store kernel as replacement image */
 220         assert ( comboot_replacement_image == NULL );
 221         comboot_replacement_image = image_get ( kernel );
 222
 223  out:
 224         /* Drop image references unconditionally; either we want to
 225          * discard them, or they have been registered and we should
 226          * drop out local reference.
 227          */
 228         image_put ( kernel );
 229         image_put ( initrd );
 230         return rc;
 231 }
 232
 233
 234 /**
 235  * Terminate program interrupt handler
 236  */
 237 static __asmcall void int20 ( struct i386_all_regs *ix86 __unused ) {
 238         longjmp ( comboot_return, COMBOOT_EXIT );
 239 }
 240
 241
 242 /**
 243  * DOS-compatible API
 244  */
 245 static __asmcall void int21 ( struct i386_all_regs *ix86 ) {
 246         ix86->flags |= CF;
 247
 248         switch ( ix86->regs.ah ) {
 249         case 0x00:
 250         case 0x4C: /* Terminate program */
 251                 longjmp ( comboot_return, COMBOOT_EXIT );
 252                 break;
 253
 254         case 0x01: /* Get Key with Echo */
 255         case 0x08: /* Get Key without Echo */
 256                 /* TODO: handle extended characters? */
 257                 ix86->regs.al = getchar( );
 258
 259                 /* Enter */
 260                 if ( ix86->regs.al == 0x0A )
 261                         ix86->regs.al = 0x0D;
 262
 263                 if ( ix86->regs.ah == 0x01 )
 264                         putchar ( ix86->regs.al );
 265
 266                 ix86->flags &= ~CF;
 267                 break;
 268
 269         case 0x02: /* Write Character */
 270                 putchar ( ix86->regs.dl );
 271                 ix86->flags &= ~CF;
 272                 break;
 273
 274         case 0x04: /* Write Character to Serial Port */
 275                 serial_putc ( ix86->regs.dl );
 276                 ix86->flags &= ~CF;
 277                 break;
 278
 279         case 0x09: /* Write DOS String to Console */
 280                 print_user_string ( ix86->segs.ds, ix86->regs.dx, '$' );
 281                 ix86->flags &= ~CF;
 282                 break;
 283
 284         case 0x0B: /* Check Keyboard */
 285                 if ( iskey() )
 286                         ix86->regs.al = 0xFF;
 287                 else
 288                         ix86->regs.al = 0x00;
 289
 290                 ix86->flags &= ~CF;
 291                 break;
 292
 293         case 0x30: /* Check DOS Version */
 294                 /* Bottom halves all 0; top halves spell "SYSLINUX" */
 295                 ix86->regs.eax = 0x59530000;
 296                 ix86->regs.ebx = 0x4C530000;
 297                 ix86->regs.ecx = 0x4E490000;
 298                 ix86->regs.edx = 0x58550000;
 299                 ix86->flags &= ~CF;
 300                 break;
 301
 302         default:
 303                 DBG ( "COMBOOT unknown int21 function %02x\n", ix86->regs.ah );
 304                 break;
 305         }
 306 }
 307
 308
 309 /**
 310  * SYSLINUX API
 311  */
 312 static __asmcall void int22 ( struct i386_all_regs *ix86 ) {
 313         ix86->flags |= CF;
 314
 315         switch ( ix86->regs.ax ) {
 316         case 0x0001: /* Get Version */
 317
 318                 /* Number of INT 22h API functions available */
 319                 ix86->regs.ax = 0x0018;
 320
 321                 /* SYSLINUX version number */
 322                 ix86->regs.ch = 0; /* major */
 323                 ix86->regs.cl = 0; /* minor */
 324
 325                 /* SYSLINUX derivative ID */
 326                 ix86->regs.dl = BZI_LOADER_TYPE_GPXE;
 327
 328                 /* SYSLINUX version and copyright strings */
 329                 ix86->segs.es = rm_ds;
 330                 ix86->regs.si = ( ( unsigned ) __from_data16 ( syslinux_version ) );
 331                 ix86->regs.di = ( ( unsigned ) __from_data16 ( syslinux_copyright ) );
 332
 333                 ix86->flags &= ~CF;
 334                 break;
 335
 336         case 0x0002: /* Write String */
 337                 print_user_string ( ix86->segs.es, ix86->regs.bx, '\0' );
 338                 ix86->flags &= ~CF;
 339                 break;
 340
 341         case 0x0003: /* Run command */
 342                 {
 343                         userptr_t cmd_u = real_to_user ( ix86->segs.es, ix86->regs.bx );
 344                         int len = strlen_user ( cmd_u, 0 );
 345                         char cmd[len + 1];
 346                         copy_from_user ( cmd, cmd_u, 0, len + 1 );
 347                         DBG ( "COMBOOT: executing command '%s'\n", cmd );
 348                         system ( cmd );
 349                         DBG ( "COMBOOT: exiting after executing command...\n" );
 350                         longjmp ( comboot_return, COMBOOT_EXIT_COMMAND );
 351                 }
 352                 break;
 353
 354         case 0x0004: /* Run default command */
 355                 /* FIXME: just exit for now */
 356                 longjmp ( comboot_return, COMBOOT_EXIT_COMMAND );
 357                 break;
 358
 359         case 0x0005: /* Force text mode */
 360                 comboot_force_text_mode ( );
 361                 ix86->flags &= ~CF;
 362                 break;
 363
 364         case 0x0006: /* Open file */
 365                 {
 366                         int fd;
 367                         userptr_t file_u = real_to_user ( ix86->segs.es, ix86->regs.si );
 368                         int len = strlen_user ( file_u, 0 );
 369                         char file[len + 1];
 370
 371                         copy_from_user ( file, file_u, 0, len + 1 );
 372
 373                         if ( file[0] == '\0' ) {
 374                                 DBG ( "COMBOOT: attempted open with empty file name\n" );
 375                                 break;
 376                         }
 377
 378                         DBG ( "COMBOOT: opening file '%s'\n", file );
 379
 380                         fd = open ( file );
 381
 382                         if ( fd < 0 ) {
 383                                 DBG ( "COMBOOT: error opening file %s\n", file );
 384                                 break;
 385                         }
 386
 387                         /* This relies on the fact that a gPXE POSIX fd will
 388                          * always fit in 16 bits.
 389                          */
 390 #if (POSIX_FD_MAX > 65535)
 391 #error POSIX_FD_MAX too large
 392 #endif
 393                         ix86->regs.si = (uint16_t) fd;
 394
 395                         ix86->regs.cx = COMBOOT_FILE_BLOCKSZ;
 396                         ix86->regs.eax = fsize ( fd );
 397                         ix86->flags &= ~CF;
 398                 }
 399                 break;
 400
 401         case 0x0007: /* Read file */
 402                 {
 403                         int fd = ix86->regs.si;
 404                         int len = ix86->regs.cx * COMBOOT_FILE_BLOCKSZ;
 405                         int rc;
 406                         fd_set fds;
 407                         userptr_t buf = real_to_user ( ix86->segs.es, ix86->regs.bx );
 408
 409                         /* Wait for data ready to read */
 410                         FD_ZERO ( &fds );
 411                         FD_SET ( fd, &fds );
 412
 413                         select ( &fds, 1 );
 414
 415                         rc = read_user ( fd, buf, 0, len );
 416                         if ( rc < 0 ) {
 417                                 DBG ( "COMBOOT: read failed\n" );
 418                                 ix86->regs.si = 0;
 419                                 break;
 420                         }
 421
 422                         ix86->regs.ecx = rc;
 423                         ix86->flags &= ~CF;
 424                 }
 425                 break;
 426
 427         case 0x0008: /* Close file */
 428                 {
 429                         int fd = ix86->regs.si;
 430                         close ( fd );
 431                         ix86->flags &= ~CF;
 432                 }
 433                 break;
 434
 435         case 0x0009: /* Call PXE Stack */
 436                 pxe_api_call ( ix86 );
 437                 ix86->flags &= ~CF;
 438                 break;
 439
 440         case 0x000A: /* Get Derivative-Specific Information */
 441
 442                 /* gPXE has its own derivative ID, so there is no defined
 443                  * output here; just return AL for now */
 444                 ix86->regs.al = BZI_LOADER_TYPE_GPXE;
 445                 ix86->flags &= ~CF;
 446                 break;
 447
 448         case 0x000B: /* Get Serial Console Configuration */
 449                 /* FIXME: stub */
 450                 ix86->regs.dx = 0;
 451                 ix86->flags &= ~CF;
 452                 break;
 453
 454         case 0x000E: /* Get configuration file name */
 455                 /* FIXME: stub */
 456                 ix86->segs.es = rm_ds;
 457                 ix86->regs.bx = ( ( unsigned ) __from_data16 ( syslinux_configuration_file ) );
 458                 ix86->flags &= ~CF;
 459                 break;
 460
 461         case 0x000F: /* Get IPAPPEND strings */
 462                 /* FIXME: stub */
 463                 ix86->regs.cx = 0;
 464                 ix86->segs.es = 0;
 465                 ix86->regs.bx = 0;
 466                 ix86->flags &= ~CF;
 467                 break;
 468
 469         case 0x0010: /* Resolve hostname */
 470                 {
 471                         userptr_t hostname_u = real_to_user ( ix86->segs.es, ix86->regs.bx );
 472                         int len = strlen_user ( hostname_u, 0 );
 473                         char hostname[len];
 474                         struct in_addr addr;
 475
 476                         copy_from_user ( hostname, hostname_u, 0, len + 1 );
 477
 478                         /* TODO:
 479                          * "If the hostname does not contain a dot (.), the
 480                          * local domain name is automatically appended."
 481                          */
 482
 483                         comboot_resolv ( hostname, &addr );
 484
 485                         ix86->regs.eax = addr.s_addr;
 486                         ix86->flags &= ~CF;
 487                 }
 488                 break;
 489
 490         case 0x0011: /* Maximum number of shuffle descriptors */
 491                 ix86->regs.cx = COMBOOT_MAX_SHUFFLE_DESCRIPTORS;
 492                 ix86->flags &= ~CF;
 493                 break;
 494
 495         case 0x0012: /* Cleanup, shuffle and boot */
 496                 if ( ix86->regs.cx > COMBOOT_MAX_SHUFFLE_DESCRIPTORS )
 497                         break;
 498
 499                 /* Perform final cleanup */
 500                 shutdown ( SHUTDOWN_BOOT );
 501
 502                 /* Perform sequence of copies */
 503                 shuffle ( ix86->segs.es, ix86->regs.di, ix86->regs.cx );
 504
 505                 /* Jump to real-mode entry point */
 506                 __asm__ __volatile__ (
 507                         REAL_CODE (
 508                                 "pushw %0\n\t"
 509                                 "popw %%ds\n\t"
 510                                 "pushl %1\n\t"
 511                                 "lret\n\t"
 512                         )
 513                         :
 514                         : "r" ( ix86->segs.ds ),
 515                           "r" ( ix86->regs.ebp ),
 516                           "d" ( ix86->regs.ebx ),
 517                           "S" ( ix86->regs.esi ) );
 518
 519                 assert ( 0 ); /* Execution should never reach this point */
 520
 521                 break;
 522
 523         case 0x0013: /* Idle loop call */
 524                 step ( );
 525                 ix86->flags &= ~CF;
 526                 break;
 527
 528         case 0x0015: /* Get feature flags */
 529                 ix86->segs.es = rm_ds;
 530                 ix86->regs.bx = ( ( unsigned ) __from_data16 ( &comboot_feature_flags ) );
 531                 ix86->regs.cx = 1; /* Number of feature flag bytes */
 532                 ix86->flags &= ~CF;
 533                 break;
 534
 535         case 0x0016: /* Run kernel image */
 536                 {
 537                         userptr_t file_u = real_to_user ( ix86->segs.ds, ix86->regs.si );
 538                         userptr_t cmd_u = real_to_user ( ix86->segs.es, ix86->regs.bx );
 539                         int file_len = strlen_user ( file_u, 0 );
 540                         int cmd_len = strlen_user ( cmd_u, 0 );
 541                         char file[file_len + 1];
 542                         char cmd[cmd_len + 1];
 543
 544                         copy_from_user ( file, file_u, 0, file_len + 1 );
 545                         copy_from_user ( cmd, cmd_u, 0, cmd_len + 1 );
 546
 547                         DBG ( "COMBOOT: run kernel %s %s\n", file, cmd );
 548                         comboot_fetch_kernel ( file, cmd );
 549                         /* Technically, we should return if we
 550                          * couldn't load the kernel, but it's not safe
 551                          * to do that since we have just overwritten
 552                          * part of the COMBOOT program's memory space.
 553                          */
 554                         DBG ( "COMBOOT: exiting to run kernel...\n" );
 555                         longjmp ( comboot_return, COMBOOT_EXIT_RUN_KERNEL );
 556                 }
 557                 break;
 558
 559         case 0x0017: /* Report video mode change */
 560                 comboot_graphics_mode = ix86->regs.bx;
 561                 ix86->flags &= ~CF;
 562                 break;
 563
 564         case 0x0018: /* Query custom font */
 565                 /* FIXME: stub */
 566                 ix86->regs.al = 0;
 567                 ix86->segs.es = 0;
 568                 ix86->regs.bx = 0;
 569                 ix86->flags &= ~CF;
 570                 break;
 571
 572         default:
 573                 DBG ( "COMBOOT unknown int22 function %04x\n", ix86->regs.ax );
 574                 break;
 575         }
 576 }
 577
 578 /**
 579  * Hook BIOS interrupts related to COMBOOT API (INT 20h, 21h, 22h)
 580  */
 581 void hook_comboot_interrupts ( ) {
 582
 583         __asm__ __volatile__ (
 584                 TEXT16_CODE ( "\nint20_wrapper:\n\t"
 585                               "pushl %0\n\t"
 586                               "pushw %%cs\n\t"
 587                               "call prot_call\n\t"
 588                               "addw $4, %%sp\n\t"
 589                               "iret\n\t" )
 590                           : : "i" ( int20 ) );
 591
 592         hook_bios_interrupt ( 0x20, ( unsigned int ) int20_wrapper,
 593                                       &int20_vector );
 594
 595         __asm__ __volatile__ (
 596                 TEXT16_CODE ( "\nint21_wrapper:\n\t"
 597                               "pushl %0\n\t"
 598                               "pushw %%cs\n\t"
 599                               "call prot_call\n\t"
 600                               "addw $4, %%sp\n\t"
 601                               "iret\n\t" )
 602                           : : "i" ( int21 ) );
 603
 604         hook_bios_interrupt ( 0x21, ( unsigned int ) int21_wrapper,
 605                               &int21_vector );
 606
 607         __asm__  __volatile__ (
 608                 TEXT16_CODE ( "\nint22_wrapper:\n\t"
 609                               "pushl %0\n\t"
 610                               "pushw %%cs\n\t"
 611                               "call prot_call\n\t"
 612                               "addw $4, %%sp\n\t"
 613                               "iret\n\t" )
 614                           : : "i" ( int22) );
 615
 616         hook_bios_interrupt ( 0x22, ( unsigned int ) int22_wrapper,
 617                               &int22_vector );
 618 }
 619
 620 /**
 621  * Unhook BIOS interrupts related to COMBOOT API (INT 20h, 21h, 22h)
 622  */
 623 void unhook_comboot_interrupts ( ) {
 624
 625         unhook_bios_interrupt ( 0x20, ( unsigned int ) int20_wrapper,
 626                                 &int20_vector );
 627
 628         unhook_bios_interrupt ( 0x21, ( unsigned int ) int21_wrapper,
 629                                 &int21_vector );
 630
 631         unhook_bios_interrupt ( 0x22, ( unsigned int ) int22_wrapper,
 632                                 &int22_vector );
 633 }