src/interface/pxe/pxe_preboot.c

   1 /** @file
   2  *
   3  * PXE Preboot API
   4  *
   5  */
   6
   7 /* PXE API interface for Etherboot.
   8  *
   9  * Copyright (C) 2004 Michael Brown <mbrown@fensystems.co.uk>.
  10  *
  11  * This program is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU General Public License as
  13  * published by the Free Software Foundation; either version 2 of the
  14  * License, or any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful, but
  17  * WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  * General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program; if not, write to the Free Software
  23  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  24  */
  25
  26 #include <stdint.h>
  27 #include <string.h>
  28 #include <malloc.h>
  29 #include <gpxe/uaccess.h>
  30 #include <gpxe/dhcp.h>
  31 #include "pxe.h"
  32 #include "pxe_callbacks.h"
  33
  34 /**
  35  * UNLOAD BASE CODE STACK
  36  *
  37  * @v None                              -
  38  * @ret ...
  39  *
  40  */
  41 PXENV_EXIT_t pxenv_unload_stack ( struct s_PXENV_UNLOAD_STACK *unload_stack ) {
  42         DBG ( "PXENV_UNLOAD_STACK" );
  43
  44 #if 0
  45         /* We need to call cleanup() at some point.  The network card
  46          * has already been disabled by ENSURE_CAN_UNLOAD(), but for
  47          * the sake of completeness we should call the console_fini()
  48          * etc. that are part of cleanup().
  49          *
  50          * There seems to be a lack of consensus on which is the final
  51          * PXE API call to make, but it's a fairly safe bet that all
  52          * the potential shutdown sequences will include a call to
  53          * PXENV_UNLOAD_STACK at some point, so we may as well do it
  54          * here.
  55          */
  56         cleanup();
  57
  58         if ( ! success ) {
  59                 unload_stack->Status = PXENV_STATUS_KEEP_ALL;
  60                 return PXENV_EXIT_FAILURE;
  61         }
  62 #endif
  63
  64         unload_stack->Status = PXENV_STATUS_SUCCESS;
  65         return PXENV_EXIT_SUCCESS;
  66 }
  67
  68 /* PXENV_GET_CACHED_INFO
  69  *
  70  * Status: working
  71  */
  72 PXENV_EXIT_t pxenv_get_cached_info ( struct s_PXENV_GET_CACHED_INFO
  73                                      *get_cached_info ) {
  74         struct dhcp_packet dhcppkt;
  75         void *data = NULL;
  76         size_t len;
  77         int msgtype;
  78         struct dhcp_option_block *options;
  79         userptr_t buffer;
  80         int rc;
  81
  82         DBG ( "PXENV_GET_CACHED_INFO %d", get_cached_info->PacketType );
  83
  84         /* This is really, really awkward to support with our multiple
  85          * sources of options.
  86          */
  87         if ( get_cached_info->BufferLimit == 0 ) {
  88                 DBG ( " without an external buffer.  Aargh." );
  89                 goto err;
  90         }
  91
  92         DBG ( " to %04x:%04x+%x\n", get_cached_info->Buffer.segment,
  93               get_cached_info->Buffer.offset, get_cached_info->BufferLimit );
  94
  95         /* Allocate space for temporary copy */
  96         len = get_cached_info->BufferLimit;
  97         data = malloc ( len );
  98         if ( ! data ) {
  99                 DBG ( " out of memory" );
 100                 goto err;
 101         }
 102
 103         /* Construct DHCP packet */
 104         if ( get_cached_info->PacketType == PXENV_PACKET_TYPE_DHCP_DISCOVER ) {
 105                 msgtype = DHCPDISCOVER;
 106                 options = &dhcp_request_options;
 107         } else {
 108                 msgtype = DHCPACK;
 109                 options = NULL;
 110         }
 111         if ( ( rc = create_dhcp_packet ( pxe_netdev, msgtype, data, len,
 112                                          &dhcppkt ) ) != 0 ) {
 113                 DBG ( " failed to build packet" );
 114                 goto err;
 115         }
 116         if ( ( rc = copy_dhcp_packet_options ( &dhcppkt, options ) ) != 0 ) {
 117                 DBG ( " failed to copy options" );
 118                 goto err;
 119         }
 120
 121         /* Copy packet to client buffer */
 122         buffer = real_to_user ( get_cached_info->Buffer.segment,
 123                                 get_cached_info->Buffer.offset );
 124         copy_to_user ( buffer, 0, data, len );
 125
 126         free ( data );
 127         get_cached_info->Status = PXENV_STATUS_SUCCESS;
 128         return PXENV_EXIT_SUCCESS;
 129
 130  err:
 131         if ( data )
 132                 free ( data );
 133         get_cached_info->Status = PXENV_STATUS_OUT_OF_RESOURCES;
 134         return PXENV_EXIT_FAILURE;
 135 }
 136
 137 /* PXENV_RESTART_TFTP
 138  *
 139  * Status: working
 140  */
 141 PXENV_EXIT_t pxenv_restart_tftp ( struct s_PXENV_TFTP_READ_FILE
 142                                   *restart_tftp ) {
 143         DBG ( "PXENV_RESTART_TFTP" );
 144
 145 #if 0
 146         /* Words cannot describe the complete mismatch between the PXE
 147          * specification and any possible version of reality...
 148          */
 149         restart_tftp->Buffer = PXE_LOAD_ADDRESS; /* Fixed by spec, apparently */
 150         restart_tftp->BufferSize = get_free_base_memory() - PXE_LOAD_ADDRESS; /* Near enough */
 151         DBG ( "(" );
 152         tftp_exit = pxe_api_call ( PXENV_TFTP_READ_FILE, (union u_PXENV_ANY*)restart_tftp );
 153         DBG ( ")" );
 154         if ( tftp_exit != PXENV_EXIT_SUCCESS ) return tftp_exit;
 155
 156         /* Fire up the new NBP */
 157         restart_tftp->Status = xstartpxe();
 158 #endif
 159
 160         /* Not sure what "SUCCESS" actually means, since we can only
 161          * return if the new NBP failed to boot...
 162          */
 163         return PXENV_EXIT_SUCCESS;
 164 }
 165
 166 /* PXENV_START_UNDI
 167  *
 168  * Status: working
 169  */
 170 PXENV_EXIT_t pxenv_start_undi ( struct s_PXENV_START_UNDI *start_undi ) {
 171
 172         DBG ( "PXENV_START_UNDI" );
 173
 174 #if 0
 175         /* Record PCI bus & devfn passed by caller, so we know which
 176          * NIC they want to use.
 177          *
 178          * If they don't match our already-existing NIC structure, set
 179          * values to ensure that the specified NIC is used at the next
 180          * call to pxe_intialise_nic().
 181          */
 182         bus = ( start_undi->AX >> 8 ) & 0xff;
 183         devfn = start_undi->AX & 0xff;
 184
 185 #warning "device probing mechanism has completely changed"
 186 #if 0
 187         if ( ( pci->dev.driver == NULL ) ||
 188              ( pci->dev.bus != bus ) || ( pci->dev.devfn != devfn ) ) {
 189                 /* This is quite a bit of a hack and relies on
 190                  * knowledge of the internal operation of Etherboot's
 191                  * probe mechanism.
 192                  */
 193                 DBG ( " set PCI %hhx:%hhx.%hhx",
 194                       bus, PCI_SLOT(devfn), PCI_FUNC(devfn) );
 195                 dev->type = BOOT_NIC;
 196                 dev->to_probe = PROBE_PCI;
 197                 memset ( &dev->state, 0, sizeof(dev->state) );
 198                 pci->advance = 1;
 199                 pci->dev.use_specified = 1;
 200                 pci->dev.bus = bus;
 201                 pci->dev.devfn = devfn;
 202         }
 203 #endif
 204
 205 #endif
 206
 207         start_undi->Status = PXENV_STATUS_SUCCESS;
 208         return PXENV_EXIT_SUCCESS;
 209 }
 210
 211 /* PXENV_STOP_UNDI
 212  *
 213  * Status: working
 214  */
 215 PXENV_EXIT_t pxenv_stop_undi ( struct s_PXENV_STOP_UNDI *stop_undi ) {
 216         DBG ( "PXENV_STOP_UNDI" );
 217
 218 #if 0
 219         if ( ! ensure_pxe_state(CAN_UNLOAD) ) {
 220                 stop_undi->Status = PXENV_STATUS_KEEP_UNDI;
 221                 return PXENV_EXIT_FAILURE;
 222         }
 223 #endif
 224
 225         stop_undi->Status = PXENV_STATUS_SUCCESS;
 226         return PXENV_EXIT_SUCCESS;
 227 }
 228
 229 /* PXENV_START_BASE
 230  *
 231  * Status: won't implement (requires major structural changes)
 232  */
 233 PXENV_EXIT_t pxenv_start_base ( struct s_PXENV_START_BASE *start_base ) {
 234         DBG ( "PXENV_START_BASE" );
 235
 236         start_base->Status = PXENV_STATUS_UNSUPPORTED;
 237         return PXENV_EXIT_FAILURE;
 238 }
 239
 240 /* PXENV_STOP_BASE
 241  *
 242  * Status: working
 243  */
 244 PXENV_EXIT_t pxenv_stop_base ( struct s_PXENV_STOP_BASE *stop_base ) {
 245         DBG ( "PXENV_STOP_BASE" );
 246
 247         /* The only time we will be called is when the NBP is trying
 248          * to shut down the PXE stack.  There's nothing we need to do
 249          * in this call.
 250          */
 251
 252         stop_base->Status = PXENV_STATUS_SUCCESS;
 253         return PXENV_EXIT_SUCCESS;
 254 }