[comboot] Unhook interrupt vectors after returning from a COMBOOT image
[people/lynusvaz/gpxe.git] / 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 }