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