| /* |
| * Copyright (C) 2008 Daniel Verkamp <daniel@drv.nu>. |
| * |
| * This program is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU General Public License as |
| * published by the Free Software Foundation; either version 2 of the |
| * License, or any later version. |
| * |
| * This program is distributed in the hope that it will be useful, but |
| * WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA |
| * 02110-1301, USA. |
| */ |
| |
| /** |
| * @file SYSLINUX COMBOOT API |
| * |
| */ |
| |
| FILE_LICENCE ( GPL2_OR_LATER ); |
| |
| #include <errno.h> |
| #include <realmode.h> |
| #include <biosint.h> |
| #include <ipxe/console.h> |
| #include <stdlib.h> |
| #include <comboot.h> |
| #include <bzimage.h> |
| #include <pxe_call.h> |
| #include <rmsetjmp.h> |
| #include <string.h> |
| #include <ipxe/posix_io.h> |
| #include <ipxe/process.h> |
| #include <ipxe/serial.h> |
| #include <ipxe/init.h> |
| #include <ipxe/image.h> |
| #include <ipxe/version.h> |
| #include <usr/imgmgmt.h> |
| |
| /** The "SYSLINUX" version string */ |
| static char __bss16_array ( syslinux_version, [32] ); |
| #define syslinux_version __use_data16 ( syslinux_version ) |
| |
| /** The "SYSLINUX" copyright string */ |
| static char __data16_array ( syslinux_copyright, [] ) = " http://ipxe.org"; |
| #define syslinux_copyright __use_data16 ( syslinux_copyright ) |
| |
| static char __data16_array ( syslinux_configuration_file, [] ) = ""; |
| #define syslinux_configuration_file __use_data16 ( syslinux_configuration_file ) |
| |
| /** Feature flags */ |
| static uint8_t __data16 ( comboot_feature_flags ) = COMBOOT_FEATURE_IDLE_LOOP; |
| #define comboot_feature_flags __use_data16 ( comboot_feature_flags ) |
| |
| typedef union { |
| syslinux_pm_regs pm; syslinux_rm_regs rm; |
| } syslinux_regs; |
| |
| /** Initial register values for INT 22h AX=1Ah and 1Bh */ |
| static syslinux_regs __text16 ( comboot_initial_regs ); |
| #define comboot_initial_regs __use_text16 ( comboot_initial_regs ) |
| |
| static struct segoff __text16 ( int20_vector ); |
| #define int20_vector __use_text16 ( int20_vector ) |
| |
| static struct segoff __text16 ( int21_vector ); |
| #define int21_vector __use_text16 ( int21_vector ) |
| |
| static struct segoff __text16 ( int22_vector ); |
| #define int22_vector __use_text16 ( int22_vector ) |
| |
| extern void int20_wrapper ( void ); |
| extern void int21_wrapper ( void ); |
| extern void int22_wrapper ( void ); |
| |
| /* setjmp/longjmp context buffer used to return after loading an image */ |
| rmjmp_buf comboot_return; |
| |
| /* Mode flags set by INT 22h AX=0017h */ |
| static uint16_t comboot_graphics_mode = 0; |
| |
| /** |
| * Print a string with a particular terminator |
| */ |
| static void print_user_string ( unsigned int segment, unsigned int offset, char terminator ) { |
| int i = 0; |
| char c; |
| userptr_t str = real_to_user ( segment, offset ); |
| for ( ; ; ) { |
| copy_from_user ( &c, str, i, 1 ); |
| if ( c == terminator ) break; |
| putchar ( c ); |
| i++; |
| } |
| } |
| |
| |
| /** |
| * Perform a series of memory copies from a list in low memory |
| */ |
| static void shuffle ( unsigned int list_segment, unsigned int list_offset, unsigned int count ) |
| { |
| comboot_shuffle_descriptor shuf[COMBOOT_MAX_SHUFFLE_DESCRIPTORS]; |
| unsigned int i; |
| |
| /* Copy shuffle descriptor list so it doesn't get overwritten */ |
| copy_from_user ( shuf, real_to_user ( list_segment, list_offset ), 0, |
| count * sizeof( comboot_shuffle_descriptor ) ); |
| |
| /* Do the copies */ |
| for ( i = 0; i < count; i++ ) { |
| userptr_t src_u = phys_to_user ( shuf[ i ].src ); |
| userptr_t dest_u = phys_to_user ( shuf[ i ].dest ); |
| |
| if ( shuf[ i ].src == 0xFFFFFFFF ) { |
| /* Fill with 0 instead of copying */ |
| memset_user ( dest_u, 0, 0, shuf[ i ].len ); |
| } else if ( shuf[ i ].dest == 0xFFFFFFFF ) { |
| /* Copy new list of descriptors */ |
| count = shuf[ i ].len / sizeof( comboot_shuffle_descriptor ); |
| assert ( count <= COMBOOT_MAX_SHUFFLE_DESCRIPTORS ); |
| copy_from_user ( shuf, src_u, 0, shuf[ i ].len ); |
| i = -1; |
| } else { |
| /* Regular copy */ |
| memmove_user ( dest_u, 0, src_u, 0, shuf[ i ].len ); |
| } |
| } |
| } |
| |
| |
| /** |
| * Set default text mode |
| */ |
| void comboot_force_text_mode ( void ) { |
| if ( comboot_graphics_mode & COMBOOT_VIDEO_VESA ) { |
| /* Set VGA mode 3 via VESA VBE mode set */ |
| __asm__ __volatile__ ( |
| REAL_CODE ( |
| "mov $0x4F02, %%ax\n\t" |
| "mov $0x03, %%bx\n\t" |
| "int $0x10\n\t" |
| ) |
| : : ); |
| } else if ( comboot_graphics_mode & COMBOOT_VIDEO_GRAPHICS ) { |
| /* Set VGA mode 3 via standard VGA mode set */ |
| __asm__ __volatile__ ( |
| REAL_CODE ( |
| "mov $0x03, %%ax\n\t" |
| "int $0x10\n\t" |
| ) |
| : : ); |
| } |
| |
| comboot_graphics_mode = 0; |
| } |
| |
| |
| /** |
| * Fetch kernel and optional initrd |
| */ |
| static int comboot_fetch_kernel ( char *kernel_file, char *cmdline ) { |
| struct image *kernel; |
| struct image *initrd; |
| char *initrd_file; |
| int rc; |
| |
| /* Find initrd= parameter, if any */ |
| if ( ( initrd_file = strstr ( cmdline, "initrd=" ) ) != NULL ) { |
| char *initrd_end; |
| |
| /* skip "initrd=" */ |
| initrd_file += 7; |
| |
| /* Find terminating space, if any, and replace with NUL */ |
| initrd_end = strchr ( initrd_file, ' ' ); |
| if ( initrd_end ) |
| *initrd_end = '\0'; |
| |
| DBG ( "COMBOOT: fetching initrd '%s'\n", initrd_file ); |
| |
| /* Fetch initrd */ |
| if ( ( rc = imgdownload_string ( initrd_file, 0, |
| &initrd ) ) != 0 ) { |
| DBG ( "COMBOOT: could not fetch initrd: %s\n", |
| strerror ( rc ) ); |
| return rc; |
| } |
| |
| /* Restore space after initrd name, if applicable */ |
| if ( initrd_end ) |
| *initrd_end = ' '; |
| } |
| |
| DBG ( "COMBOOT: fetching kernel '%s'\n", kernel_file ); |
| |
| /* Fetch kernel */ |
| if ( ( rc = imgdownload_string ( kernel_file, 0, &kernel ) ) != 0 ) { |
| DBG ( "COMBOOT: could not fetch kernel: %s\n", |
| strerror ( rc ) ); |
| return rc; |
| } |
| |
| /* Replace comboot image with kernel */ |
| if ( ( rc = image_replace ( kernel ) ) != 0 ) { |
| DBG ( "COMBOOT: could not replace with kernel: %s\n", |
| strerror ( rc ) ); |
| return rc; |
| } |
| |
| return 0; |
| } |
| |
| |
| /** |
| * Terminate program interrupt handler |
| */ |
| static __asmcall __used void int20 ( struct i386_all_regs *ix86 __unused ) { |
| rmlongjmp ( comboot_return, COMBOOT_EXIT ); |
| } |
| |
| |
| /** |
| * DOS-compatible API |
| */ |
| static __asmcall __used void int21 ( struct i386_all_regs *ix86 ) { |
| ix86->flags |= CF; |
| |
| switch ( ix86->regs.ah ) { |
| case 0x00: |
| case 0x4C: /* Terminate program */ |
| rmlongjmp ( comboot_return, COMBOOT_EXIT ); |
| break; |
| |
| case 0x01: /* Get Key with Echo */ |
| case 0x08: /* Get Key without Echo */ |
| /* TODO: handle extended characters? */ |
| ix86->regs.al = getchar( ); |
| |
| /* Enter */ |
| if ( ix86->regs.al == 0x0A ) |
| ix86->regs.al = 0x0D; |
| |
| if ( ix86->regs.ah == 0x01 ) |
| putchar ( ix86->regs.al ); |
| |
| ix86->flags &= ~CF; |
| break; |
| |
| case 0x02: /* Write Character */ |
| putchar ( ix86->regs.dl ); |
| ix86->flags &= ~CF; |
| break; |
| |
| case 0x04: /* Write Character to Serial Port */ |
| if ( serial_console.base ) { |
| uart_transmit ( &serial_console, ix86->regs.dl ); |
| ix86->flags &= ~CF; |
| } |
| break; |
| |
| case 0x09: /* Write DOS String to Console */ |
| print_user_string ( ix86->segs.ds, ix86->regs.dx, '$' ); |
| ix86->flags &= ~CF; |
| break; |
| |
| case 0x0B: /* Check Keyboard */ |
| if ( iskey() ) |
| ix86->regs.al = 0xFF; |
| else |
| ix86->regs.al = 0x00; |
| |
| ix86->flags &= ~CF; |
| break; |
| |
| case 0x30: /* Check DOS Version */ |
| /* Bottom halves all 0; top halves spell "SYSLINUX" */ |
| ix86->regs.eax = 0x59530000; |
| ix86->regs.ebx = 0x4C530000; |
| ix86->regs.ecx = 0x4E490000; |
| ix86->regs.edx = 0x58550000; |
| ix86->flags &= ~CF; |
| break; |
| |
| default: |
| DBG ( "COMBOOT unknown int21 function %02x\n", ix86->regs.ah ); |
| break; |
| } |
| } |
| |
| |
| /** |
| * Dispatch PXE API call weakly |
| * |
| * @v ix86 Registers for PXE call |
| * @ret present Zero if the PXE stack is present, nonzero if not |
| * |
| * A successful return only indicates that the PXE stack was available |
| * for dispatching the call; it says nothing about the success of |
| * whatever the call asked for. |
| */ |
| __weak int pxe_api_call_weak ( struct i386_all_regs *ix86 __unused ) { |
| return -1; |
| } |
| |
| /** |
| * SYSLINUX API |
| */ |
| static __asmcall __used void int22 ( struct i386_all_regs *ix86 ) { |
| ix86->flags |= CF; |
| |
| switch ( ix86->regs.ax ) { |
| case 0x0001: /* Get Version */ |
| |
| /* Number of INT 22h API functions available */ |
| ix86->regs.ax = 0x001D; |
| |
| /* SYSLINUX version number */ |
| ix86->regs.ch = 0; /* major */ |
| ix86->regs.cl = 0; /* minor */ |
| |
| /* SYSLINUX derivative ID */ |
| ix86->regs.dl = BZI_LOADER_TYPE_IPXE; |
| |
| /* SYSLINUX version */ |
| snprintf ( syslinux_version, sizeof ( syslinux_version ), |
| "\r\niPXE %s", product_version ); |
| |
| /* SYSLINUX version and copyright strings */ |
| ix86->segs.es = rm_ds; |
| ix86->regs.si = ( ( unsigned ) __from_data16 ( syslinux_version ) ); |
| ix86->regs.di = ( ( unsigned ) __from_data16 ( syslinux_copyright ) ); |
| |
| ix86->flags &= ~CF; |
| break; |
| |
| case 0x0002: /* Write String */ |
| print_user_string ( ix86->segs.es, ix86->regs.bx, '\0' ); |
| ix86->flags &= ~CF; |
| break; |
| |
| case 0x0003: /* Run command */ |
| { |
| userptr_t cmd_u = real_to_user ( ix86->segs.es, ix86->regs.bx ); |
| int len = strlen_user ( cmd_u, 0 ); |
| char cmd[len + 1]; |
| copy_from_user ( cmd, cmd_u, 0, len + 1 ); |
| DBG ( "COMBOOT: executing command '%s'\n", cmd ); |
| system ( cmd ); |
| DBG ( "COMBOOT: exiting after executing command...\n" ); |
| rmlongjmp ( comboot_return, COMBOOT_EXIT_COMMAND ); |
| } |
| break; |
| |
| case 0x0004: /* Run default command */ |
| /* FIXME: just exit for now */ |
| rmlongjmp ( comboot_return, COMBOOT_EXIT_COMMAND ); |
| break; |
| |
| case 0x0005: /* Force text mode */ |
| comboot_force_text_mode ( ); |
| ix86->flags &= ~CF; |
| break; |
| |
| case 0x0006: /* Open file */ |
| { |
| int fd; |
| userptr_t file_u = real_to_user ( ix86->segs.es, ix86->regs.si ); |
| int len = strlen_user ( file_u, 0 ); |
| char file[len + 1]; |
| |
| copy_from_user ( file, file_u, 0, len + 1 ); |
| |
| if ( file[0] == '\0' ) { |
| DBG ( "COMBOOT: attempted open with empty file name\n" ); |
| break; |
| } |
| |
| DBG ( "COMBOOT: opening file '%s'\n", file ); |
| |
| fd = open ( file ); |
| |
| if ( fd < 0 ) { |
| DBG ( "COMBOOT: error opening file %s\n", file ); |
| break; |
| } |
| |
| /* This relies on the fact that a iPXE POSIX fd will |
| * always fit in 16 bits. |
| */ |
| #if (POSIX_FD_MAX > 65535) |
| #error POSIX_FD_MAX too large |
| #endif |
| ix86->regs.si = (uint16_t) fd; |
| |
| ix86->regs.cx = COMBOOT_FILE_BLOCKSZ; |
| ix86->regs.eax = fsize ( fd ); |
| ix86->flags &= ~CF; |
| } |
| break; |
| |
| case 0x0007: /* Read file */ |
| { |
| int fd = ix86->regs.si; |
| int len = ix86->regs.cx * COMBOOT_FILE_BLOCKSZ; |
| int rc; |
| fd_set fds; |
| userptr_t buf = real_to_user ( ix86->segs.es, ix86->regs.bx ); |
| |
| /* Wait for data ready to read */ |
| FD_ZERO ( &fds ); |
| FD_SET ( fd, &fds ); |
| |
| select ( &fds, 1 ); |
| |
| rc = read_user ( fd, buf, 0, len ); |
| if ( rc < 0 ) { |
| DBG ( "COMBOOT: read failed\n" ); |
| ix86->regs.si = 0; |
| break; |
| } |
| |
| ix86->regs.ecx = rc; |
| ix86->flags &= ~CF; |
| } |
| break; |
| |
| case 0x0008: /* Close file */ |
| { |
| int fd = ix86->regs.si; |
| close ( fd ); |
| ix86->flags &= ~CF; |
| } |
| break; |
| |
| case 0x0009: /* Call PXE Stack */ |
| if ( pxe_api_call_weak ( ix86 ) != 0 ) |
| ix86->flags |= CF; |
| else |
| ix86->flags &= ~CF; |
| break; |
| |
| case 0x000A: /* Get Derivative-Specific Information */ |
| |
| /* iPXE has its own derivative ID, so there is no defined |
| * output here; just return AL for now */ |
| ix86->regs.al = BZI_LOADER_TYPE_IPXE; |
| ix86->flags &= ~CF; |
| break; |
| |
| case 0x000B: /* Get Serial Console Configuration */ |
| if ( serial_console.base ) { |
| ix86->regs.dx = ( ( intptr_t ) serial_console.base ); |
| ix86->regs.cx = serial_console.divisor; |
| ix86->regs.bx = 0; |
| ix86->flags &= ~CF; |
| } |
| break; |
| |
| case 0x000C: /* Perform final cleanup */ |
| shutdown_boot(); |
| break; |
| |
| case 0x000E: /* Get configuration file name */ |
| /* FIXME: stub */ |
| ix86->segs.es = rm_ds; |
| ix86->regs.bx = ( ( unsigned ) __from_data16 ( syslinux_configuration_file ) ); |
| ix86->flags &= ~CF; |
| break; |
| |
| case 0x000F: /* Get IPAPPEND strings */ |
| /* FIXME: stub */ |
| ix86->regs.cx = 0; |
| ix86->segs.es = 0; |
| ix86->regs.bx = 0; |
| ix86->flags &= ~CF; |
| break; |
| |
| case 0x0010: /* Resolve hostname */ |
| { |
| userptr_t hostname_u = real_to_user ( ix86->segs.es, ix86->regs.bx ); |
| int len = strlen_user ( hostname_u, 0 ); |
| char hostname[len]; |
| struct in_addr addr; |
| |
| copy_from_user ( hostname, hostname_u, 0, len + 1 ); |
| |
| /* TODO: |
| * "If the hostname does not contain a dot (.), the |
| * local domain name is automatically appended." |
| */ |
| |
| comboot_resolv ( hostname, &addr ); |
| |
| ix86->regs.eax = addr.s_addr; |
| ix86->flags &= ~CF; |
| } |
| break; |
| |
| case 0x0011: /* Maximum number of shuffle descriptors */ |
| ix86->regs.cx = COMBOOT_MAX_SHUFFLE_DESCRIPTORS; |
| ix86->flags &= ~CF; |
| break; |
| |
| case 0x0012: /* Cleanup, shuffle and boot */ |
| if ( ix86->regs.cx > COMBOOT_MAX_SHUFFLE_DESCRIPTORS ) |
| break; |
| |
| /* Perform final cleanup */ |
| shutdown_boot(); |
| |
| /* Perform sequence of copies */ |
| shuffle ( ix86->segs.es, ix86->regs.di, ix86->regs.cx ); |
| |
| /* Jump to real-mode entry point */ |
| __asm__ __volatile__ ( |
| REAL_CODE ( |
| "pushw %0\n\t" |
| "popw %%ds\n\t" |
| "pushl %1\n\t" |
| "lret\n\t" |
| ) |
| : |
| : "r" ( ix86->segs.ds ), |
| "r" ( ix86->regs.ebp ), |
| "d" ( ix86->regs.ebx ), |
| "S" ( ix86->regs.esi ) ); |
| |
| assert ( 0 ); /* Execution should never reach this point */ |
| |
| break; |
| |
| case 0x0013: /* Idle loop call */ |
| step ( ); |
| ix86->flags &= ~CF; |
| break; |
| |
| case 0x0015: /* Get feature flags */ |
| ix86->segs.es = rm_ds; |
| ix86->regs.bx = ( ( unsigned ) __from_data16 ( &comboot_feature_flags ) ); |
| ix86->regs.cx = 1; /* Number of feature flag bytes */ |
| ix86->flags &= ~CF; |
| break; |
| |
| case 0x0016: /* Run kernel image */ |
| { |
| userptr_t file_u = real_to_user ( ix86->segs.ds, ix86->regs.si ); |
| userptr_t cmd_u = real_to_user ( ix86->segs.es, ix86->regs.bx ); |
| int file_len = strlen_user ( file_u, 0 ); |
| int cmd_len = strlen_user ( cmd_u, 0 ); |
| char file[file_len + 1]; |
| char cmd[cmd_len + 1]; |
| |
| copy_from_user ( file, file_u, 0, file_len + 1 ); |
| copy_from_user ( cmd, cmd_u, 0, cmd_len + 1 ); |
| |
| DBG ( "COMBOOT: run kernel %s %s\n", file, cmd ); |
| comboot_fetch_kernel ( file, cmd ); |
| /* Technically, we should return if we |
| * couldn't load the kernel, but it's not safe |
| * to do that since we have just overwritten |
| * part of the COMBOOT program's memory space. |
| */ |
| DBG ( "COMBOOT: exiting to run kernel...\n" ); |
| rmlongjmp ( comboot_return, COMBOOT_EXIT_RUN_KERNEL ); |
| } |
| break; |
| |
| case 0x0017: /* Report video mode change */ |
| comboot_graphics_mode = ix86->regs.bx; |
| ix86->flags &= ~CF; |
| break; |
| |
| case 0x0018: /* Query custom font */ |
| /* FIXME: stub */ |
| ix86->regs.al = 0; |
| ix86->segs.es = 0; |
| ix86->regs.bx = 0; |
| ix86->flags &= ~CF; |
| break; |
| |
| case 0x001B: /* Cleanup, shuffle and boot to real mode */ |
| if ( ix86->regs.cx > COMBOOT_MAX_SHUFFLE_DESCRIPTORS ) |
| break; |
| |
| /* Perform final cleanup */ |
| shutdown_boot(); |
| |
| /* Perform sequence of copies */ |
| shuffle ( ix86->segs.es, ix86->regs.di, ix86->regs.cx ); |
| |
| /* Copy initial register values to .text16 */ |
| memcpy_user ( real_to_user ( rm_cs, (unsigned) __from_text16 ( &comboot_initial_regs ) ), 0, |
| real_to_user ( ix86->segs.ds, ix86->regs.si ), 0, |
| sizeof(syslinux_rm_regs) ); |
| |
| /* Load initial register values */ |
| __asm__ __volatile__ ( |
| REAL_CODE ( |
| /* Point SS:SP at the register value structure */ |
| "pushw %%cs\n\t" |
| "popw %%ss\n\t" |
| "movw $comboot_initial_regs, %%sp\n\t" |
| |
| /* Segment registers */ |
| "popw %%es\n\t" |
| "popw %%ax\n\t" /* Skip CS */ |
| "popw %%ds\n\t" |
| "popw %%ax\n\t" /* Skip SS for now */ |
| "popw %%fs\n\t" |
| "popw %%gs\n\t" |
| |
| /* GP registers */ |
| "popl %%eax\n\t" |
| "popl %%ecx\n\t" |
| "popl %%edx\n\t" |
| "popl %%ebx\n\t" |
| "popl %%ebp\n\t" /* Skip ESP for now */ |
| "popl %%ebp\n\t" |
| "popl %%esi\n\t" |
| "popl %%edi\n\t" |
| |
| /* Load correct SS:ESP */ |
| "movw $(comboot_initial_regs + 6), %%sp\n\t" |
| "popw %%ss\n\t" |
| "movl %%cs:(comboot_initial_regs + 28), %%esp\n\t" |
| |
| "ljmp *%%cs:(comboot_initial_regs + 44)\n\t" |
| ) |
| : : ); |
| |
| break; |
| |
| case 0x001C: /* Get pointer to auxilliary data vector */ |
| /* FIXME: stub */ |
| ix86->regs.cx = 0; /* Size of the ADV */ |
| ix86->flags &= ~CF; |
| break; |
| |
| case 0x001D: /* Write auxilliary data vector */ |
| /* FIXME: stub */ |
| ix86->flags &= ~CF; |
| break; |
| |
| default: |
| DBG ( "COMBOOT unknown int22 function %04x\n", ix86->regs.ax ); |
| break; |
| } |
| } |
| |
| /** |
| * Hook BIOS interrupts related to COMBOOT API (INT 20h, 21h, 22h) |
| */ |
| void hook_comboot_interrupts ( ) { |
| |
| __asm__ __volatile__ ( |
| TEXT16_CODE ( "\nint20_wrapper:\n\t" |
| VIRT_CALL ( int20 ) |
| "clc\n\t" |
| "call patch_cf\n\t" |
| "iret\n\t" ) : ); |
| |
| hook_bios_interrupt ( 0x20, ( intptr_t ) int20_wrapper, &int20_vector ); |
| |
| __asm__ __volatile__ ( |
| TEXT16_CODE ( "\nint21_wrapper:\n\t" |
| VIRT_CALL ( int21 ) |
| "clc\n\t" |
| "call patch_cf\n\t" |
| "iret\n\t" ) : ); |
| |
| hook_bios_interrupt ( 0x21, ( intptr_t ) int21_wrapper, &int21_vector ); |
| |
| __asm__ __volatile__ ( |
| TEXT16_CODE ( "\nint22_wrapper:\n\t" |
| VIRT_CALL ( int22 ) |
| "clc\n\t" |
| "call patch_cf\n\t" |
| "iret\n\t" ) : ); |
| |
| hook_bios_interrupt ( 0x22, ( intptr_t ) int22_wrapper, &int22_vector ); |
| } |
| |
| /** |
| * Unhook BIOS interrupts related to COMBOOT API (INT 20h, 21h, 22h) |
| */ |
| void unhook_comboot_interrupts ( ) { |
| |
| unhook_bios_interrupt ( 0x20, ( intptr_t ) int20_wrapper, |
| &int20_vector ); |
| |
| unhook_bios_interrupt ( 0x21, ( intptr_t ) int21_wrapper, |
| &int21_vector ); |
| |
| unhook_bios_interrupt ( 0x22, ( intptr_t ) int22_wrapper, |
| &int22_vector ); |
| } |
| |
| /* Avoid dragging in serial console support unconditionally */ |
| struct uart serial_console __attribute__ (( weak )); |