pxe_call.c

Go to the documentation of this file.

/*
 * Copyright (C) 2006 Michael Brown <mbrown@fensystems.co.uk>.
 *
 * 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.
 *
 * You can also choose to distribute this program under the terms of
 * the Unmodified Binary Distribution Licence (as given in the file
 * COPYING.UBDL), provided that you have satisfied its requirements.
 */

FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );

#include <ipxe/uaccess.h>
#include <ipxe/init.h>
#include <ipxe/profile.h>
#include <ipxe/netdevice.h>
#include <rmsetjmp.h>
#include <registers.h>
#include <biosint.h>
#include <pxe.h>
#include <pxe_call.h>

/** @file
 *
 * PXE API entry point
 */

/* Disambiguate the various error causes */
#define EINFO_EPXENBP                                                   \
        __einfo_uniqify ( EINFO_EPLATFORM, 0x01,                        \
                          "External PXE NBP error" )
#define EPXENBP( status ) EPLATFORM ( EINFO_EPXENBP, status )

/** Vector for chaining INT 1A */
extern struct segoff __text16 ( pxe_int_1a_vector );
#define pxe_int_1a_vector __use_text16 ( pxe_int_1a_vector )

/** INT 1A handler */
extern void pxe_int_1a ( void );

/** INT 1A hooked flag */
static int int_1a_hooked = 0;

/** Real-mode code segment size */
extern char _text16_memsz[];
#define _text16_memsz ( ( size_t ) _text16_memsz )

/** Real-mode data segment size */
extern char _data16_memsz[];
#define _data16_memsz ( ( size_t ) _data16_memsz )

/** PXENV_UNDI_TRANSMIT API call profiler */
static struct profiler pxe_api_tx_profiler __profiler =
        { .name = "pxeapi.tx" };

/** PXENV_UNDI_ISR API call profiler */
static struct profiler pxe_api_isr_profiler __profiler =
        { .name = "pxeapi.isr" };

/** PXE unknown API call profiler
 *
 * This profiler can be used to measure the overhead of a dummy PXE
 * API call.
 */
static struct profiler pxe_api_unknown_profiler __profiler =
        { .name = "pxeapi.unknown" };

/** Miscellaneous PXE API call profiler */
static struct profiler pxe_api_misc_profiler __profiler =
        { .name = "pxeapi.misc" };

/**
 * Handle an unknown PXE API call
 *
 * @v pxenv_unknown                     Pointer to a struct s_PXENV_UNKNOWN
 * @ret #PXENV_EXIT_FAILURE             Always
 * @err #PXENV_STATUS_UNSUPPORTED       Always
 */
static PXENV_EXIT_t pxenv_unknown ( struct s_PXENV_UNKNOWN *pxenv_unknown ) {
        pxenv_unknown->Status = PXENV_STATUS_UNSUPPORTED;
        return PXENV_EXIT_FAILURE;
}

/** Unknown PXE API call list */
struct pxe_api_call pxenv_unknown_api __pxe_api_call =
        PXE_API_CALL ( PXENV_UNKNOWN, pxenv_unknown, struct s_PXENV_UNKNOWN );

/**
 * Locate PXE API call
 *
 * @v opcode            Opcode
 * @ret call            PXE API call, or NULL
 */
static struct pxe_api_call * find_pxe_api_call ( uint16_t opcode ) {
        struct pxe_api_call *call;

        for_each_table_entry ( call, PXE_API_CALLS ) {
                if ( call->opcode == opcode )
                        return call;
        }
        return NULL;
}

/**
 * Determine applicable profiler (for debugging)
 *
 * @v opcode            PXE opcode
 * @ret profiler        Profiler
 */
static struct profiler * pxe_api_profiler ( unsigned int opcode ) {

        /* Determine applicable profiler */
        switch ( opcode ) {
        case PXENV_UNDI_TRANSMIT:
                return &pxe_api_tx_profiler;
        case PXENV_UNDI_ISR:
                return &pxe_api_isr_profiler;
        case PXENV_UNKNOWN:
                return &pxe_api_unknown_profiler;
        default:
                return &pxe_api_misc_profiler;
        }
}

/**
 * Dispatch PXE API call
 *
 * @v bx                PXE opcode
 * @v es:di             Address of PXE parameter block
 * @ret ax              PXE exit code
 */
__asmcall void pxe_api_call ( struct i386_all_regs *ix86 ) {
        uint16_t opcode = ix86->regs.bx;
        userptr_t uparams = real_to_user ( ix86->segs.es, ix86->regs.di );
        struct profiler *profiler = pxe_api_profiler ( opcode );
        struct pxe_api_call *call;
        union u_PXENV_ANY params;
        PXENV_EXIT_t ret;

        /* Start profiling */
        profile_start ( profiler );

        /* Locate API call */
        call = find_pxe_api_call ( opcode );
        if ( ! call ) {
                DBGC ( &pxe_netdev, "PXENV_UNKNOWN_%04x\n", opcode );
                call = &pxenv_unknown_api;
        }

        /* Copy parameter block from caller */
        copy_from_user ( &params, uparams, 0, call->params_len );

        /* Set default status in case child routine fails to do so */
        params.Status = PXENV_STATUS_FAILURE;

        /* Hand off to relevant API routine */
        ret = call->entry ( &params );

        /* Copy modified parameter block back to caller and return */
        copy_to_user ( uparams, 0, &params, call->params_len );
        ix86->regs.ax = ret;

        /* Stop profiling, if applicable */
        profile_stop ( profiler );
}

/**
 * Dispatch weak PXE API call with PXE stack available
 *
 * @v ix86              Registers for PXE call
 * @ret present         Zero (PXE stack present)
 */
int pxe_api_call_weak ( struct i386_all_regs *ix86 ) {
        pxe_api_call ( ix86 );
        return 0;
}

/**
 * Dispatch PXE loader call
 *
 * @v es:di             Address of PXE parameter block
 * @ret ax              PXE exit code
 */
__asmcall void pxe_loader_call ( struct i386_all_regs *ix86 ) {
        userptr_t uparams = real_to_user ( ix86->segs.es, ix86->regs.di );
        struct s_UNDI_LOADER params;
        PXENV_EXIT_t ret;

        /* Copy parameter block from caller */
        copy_from_user ( &params, uparams, 0, sizeof ( params ) );

        /* Fill in ROM segment address */
        ppxe.UNDIROMID.segment = ix86->segs.ds;

        /* Set default status in case child routine fails to do so */
        params.Status = PXENV_STATUS_FAILURE;

        /* Call UNDI loader */
        ret = undi_loader ( &params );

        /* Copy modified parameter block back to caller and return */
        copy_to_user ( uparams, 0, &params, sizeof ( params ) );
        ix86->regs.ax = ret;
}

/**
 * Calculate byte checksum as used by PXE
 *
 * @v data              Data
 * @v size              Length of data
 * @ret sum             Checksum
 */
static uint8_t pxe_checksum ( void *data, size_t size ) {
        uint8_t *bytes = data;
        uint8_t sum = 0;

        while ( size-- ) {
                sum += *bytes++;
        }
        return sum;
}

/**
 * Initialise !PXE and PXENV+ structures
 *
 */
static void pxe_init_structures ( void ) {
        uint32_t rm_cs_phys = ( rm_cs << 4 );
        uint32_t rm_ds_phys = ( rm_ds << 4 );

        /* Fill in missing segment fields */
        ppxe.EntryPointSP.segment = rm_cs;
        ppxe.EntryPointESP.segment = rm_cs;
        ppxe.Stack.segment_address = rm_ds;
        ppxe.Stack.Physical_address = rm_ds_phys;
        ppxe.UNDIData.segment_address = rm_ds;
        ppxe.UNDIData.Physical_address = rm_ds_phys;
        ppxe.UNDICode.segment_address = rm_cs;
        ppxe.UNDICode.Physical_address = rm_cs_phys;
        ppxe.UNDICodeWrite.segment_address = rm_cs;
        ppxe.UNDICodeWrite.Physical_address = rm_cs_phys;
        pxenv.RMEntry.segment = rm_cs;
        pxenv.StackSeg = rm_ds;
        pxenv.UNDIDataSeg = rm_ds;
        pxenv.UNDICodeSeg = rm_cs;
        pxenv.PXEPtr.segment = rm_cs;

        /* Update checksums */
        ppxe.StructCksum -= pxe_checksum ( &ppxe, sizeof ( ppxe ) );
        pxenv.Checksum -= pxe_checksum ( &pxenv, sizeof ( pxenv ) );
}

/** PXE structure initialiser */
struct init_fn pxe_init_fn __init_fn ( INIT_NORMAL ) = {
        .initialise = pxe_init_structures,
};

/**
 * Activate PXE stack
 *
 * @v netdev            Net device to use as PXE net device
 */
void pxe_activate ( struct net_device *netdev ) {
        uint32_t discard_a;
        uint32_t discard_b;
        uint32_t discard_d;

        /* Ensure INT 1A is hooked */
        if ( ! int_1a_hooked ) {
                hook_bios_interrupt ( 0x1a, ( intptr_t ) pxe_int_1a,
                                      &pxe_int_1a_vector );
                devices_get();
                int_1a_hooked = 1;
        }

        /* Set PXE network device */
        pxe_set_netdev ( netdev );

        /* Notify BIOS of installation */
        __asm__ __volatile__ ( REAL_CODE ( "pushw %%cs\n\t"
                                           "popw %%es\n\t"
                                           "int $0x1a\n\t" )
                               : "=a" ( discard_a ), "=b" ( discard_b ),
                                 "=d" ( discard_d )
                               : "0" ( 0x564e ),
                                 "1" ( __from_text16 ( &pxenv ) ) );
}

/**
 * Deactivate PXE stack
 *
 * @ret rc              Return status code
 */
int pxe_deactivate ( void ) {
        int rc;

        /* Clear PXE network device */
        pxe_set_netdev ( NULL );

        /* Ensure INT 1A is unhooked, if possible */
        if ( int_1a_hooked ) {
                if ( ( rc = unhook_bios_interrupt ( 0x1a,
                                                    ( intptr_t ) pxe_int_1a,
                                                    &pxe_int_1a_vector ))!= 0){
                        DBGC ( &pxe_netdev, "PXE could not unhook INT 1A: %s\n",
                               strerror ( rc ) );
                        return rc;
                }
                devices_put();
                int_1a_hooked = 0;
        }

        return 0;
}

/** Jump buffer for PXENV_RESTART_TFTP */
rmjmp_buf pxe_restart_nbp;

/**
 * Start PXE NBP at 0000:7c00
 *
 * @ret rc              Return status code
 */
int pxe_start_nbp ( void ) {
        int jmp;
        int discard_b, discard_c, discard_d, discard_D;
        uint16_t status;

        DBGC ( &pxe_netdev, "PXE NBP starting with netdev %s, code %04x:%04zx, "
               "data %04x:%04zx\n", ( pxe_netdev ? pxe_netdev->name : "<none>"),
               rm_cs, _text16_memsz, rm_ds, _data16_memsz );

        /* Allow restarting NBP via PXENV_RESTART_TFTP */
        jmp = rmsetjmp ( pxe_restart_nbp );
        if ( jmp )
                DBGC ( &pxe_netdev, "PXE NBP restarting (%x)\n", jmp );

        /* Far call to PXE NBP */
        __asm__ __volatile__ ( REAL_CODE ( "pushl %%ebp\n\t" /* gcc bug */
                                           "movw %%cx, %%es\n\t"
                                           "pushw %%es\n\t"
                                           "pushw %%di\n\t"
                                           "sti\n\t"
                                           "lcall $0, $0x7c00\n\t"
                                           "popl %%ebp\n\t" /* discard */
                                           "popl %%ebp\n\t" /* gcc bug */ )
                               : "=a" ( status ), "=b" ( discard_b ),
                                 "=c" ( discard_c ), "=d" ( discard_d ),
                                 "=D" ( discard_D )
                               : "a" ( 0 ), "b" ( __from_text16 ( &pxenv ) ),
                                 "c" ( rm_cs ),
                                 "d" ( virt_to_phys ( &pxenv ) ),
                                 "D" ( __from_text16 ( &ppxe ) )
                               : "esi", "memory" );
        if ( status )
                return -EPXENBP ( status );

        return 0;
}

/**
 * Notify BIOS of existence of network device
 *
 * @v netdev            Network device
 * @v priv              Private data
 * @ret rc              Return status code
 */
static int pxe_notify ( struct net_device *netdev, void *priv __unused ) {

        /* Do nothing if we already have a network device */
        if ( pxe_netdev )
                return 0;

        /* Activate (and deactivate) PXE stack to notify BIOS */
        pxe_activate ( netdev );
        pxe_deactivate();

        return 0;
}

/** PXE BIOS notification driver */
struct net_driver pxe_driver __net_driver = {
        .name = "PXE",
        .probe = pxe_notify,
};

REQUIRING_SYMBOL ( pxe_api_call );
REQUIRE_OBJECT ( pxe_preboot );
REQUIRE_OBJECT ( pxe_undi );
REQUIRE_OBJECT ( pxe_udp );
REQUIRE_OBJECT ( pxe_tftp );
REQUIRE_OBJECT ( pxe_file );