pxeparent.h File Reference

#include <pxe_types.h>

Go to the source code of this file.

Functions
	FILE_LICENCE (GPL2_OR_LATER)
int	pxeparent_call (SEGOFF16_t entry, unsigned int function, void *params, size_t params_len)
	Issue parent PXE API call.

---

Function Documentation

FILE_LICENCE

(

GPL2_OR_LATER

)

int pxeparent_call	(	SEGOFF16_t	entry,
		unsigned int	function,
		void *	params,
		size_t	params_len
	)

Issue parent PXE API call.

Parameters:

	entry	Parent PXE stack entry point
	function	API call number
	params	PXE parameter block
	params_len	Length of PXE parameter block

Return values:

rc

Return status code

Definition at line 125 of file pxeparent.c.

References __asm__(), __from_data16, assert, DBG, DBG_HDA, EIO, gateA20_set(), memcpy, s_SEGOFF16::offset, PXENV_EXIT_SUCCESS, pxeparent_entry_point, pxeparent_function_name(), pxeparent_params, REAL_CODE, rm_ds, s_SEGOFF16::segment, and strerror().

Referenced by get_cached_dhcpack(), undinet_close(), undinet_open(), undinet_poll(), undinet_probe(), undinet_remove(), and undinet_transmit().

                                                       {
        PXENV_EXIT_t exit;
        int discard_b, discard_D;
        int rc;

        /* Copy parameter block and entry point */
        assert ( params_len <= sizeof ( pxeparent_params ) );
        memcpy ( &pxeparent_params, params, params_len );
        memcpy ( &pxeparent_entry_point, &entry, sizeof ( entry ) );

        /* Call real-mode entry point.  This calling convention will
         * work with both the !PXE and the PXENV+ entry points.
         */
        __asm__ __volatile__ ( REAL_CODE ( "pushw %%es\n\t"
                                           "pushw %%di\n\t"
                                           "pushw %%bx\n\t"
                                           "lcall *pxeparent_entry_point\n\t"
                                           "addw $6, %%sp\n\t" )
                               : "=a" ( exit ), "=b" ( discard_b ),
                                 "=D" ( discard_D )
                               : "b" ( function ),
                                 "D" ( __from_data16 ( &pxeparent_params ) )
                               : "ecx", "edx", "esi", "ebp" );

        /* PXE API calls may rudely change the status of A20 and not
         * bother to restore it afterwards.  Intel is known to be
         * guilty of this.
         *
         * Note that we will return to this point even if A20 gets
         * screwed up by the parent PXE stack, because Etherboot always
         * resides in an even megabyte of RAM.
         */
        gateA20_set();

        /* Determine return status code based on PXENV_EXIT and
         * PXENV_STATUS
         */
        if ( exit == PXENV_EXIT_SUCCESS ) {
                rc = 0;
        } else {
                rc = -pxeparent_params.Status;
                /* Paranoia; don't return success for the combination
                 * of PXENV_EXIT_FAILURE but PXENV_STATUS_SUCCESS
                 */
                if ( rc == 0 )
                        rc = -EIO;
        }

        /* If anything goes wrong, print as much debug information as
         * it's possible to give.
         */
        if ( rc != 0 ) {
                SEGOFF16_t rm_params = {
                        .segment = rm_ds,
                        .offset = __from_data16 ( &pxeparent_params ),
                };

                DBG ( "PXEPARENT %s failed: %s\n",
                       pxeparent_function_name ( function ), strerror ( rc ) );
                DBG ( "PXEPARENT parameters at %04x:%04x length "
                       "%#02zx, entry point at %04x:%04x\n",
                       rm_params.segment, rm_params.offset, params_len,
                       pxeparent_entry_point.segment,
                       pxeparent_entry_point.offset );
                DBG ( "PXEPARENT parameters provided:\n" );
                DBG_HDA ( rm_params, params, params_len );
                DBG ( "PXEPARENT parameters returned:\n" );
                DBG_HDA ( rm_params, &pxeparent_params, params_len );
        }

        /* Copy parameter block back */
        memcpy ( params, &pxeparent_params, params_len );

        return rc;
}