Include stdlib.h rather than malloc.h
[people/meteger/gpxe.git] / 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 <stdlib.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         get_cached_info->BufferSize = len;
126
127         free ( data );
128         get_cached_info->Status = PXENV_STATUS_SUCCESS;
129         return PXENV_EXIT_SUCCESS;
130
131  err:
132         if ( data )
133                 free ( data );
134         get_cached_info->Status = PXENV_STATUS_OUT_OF_RESOURCES;
135         return PXENV_EXIT_FAILURE;
136 }
137
138 /* PXENV_RESTART_TFTP
139  *
140  * Status: working
141  */
142 PXENV_EXIT_t pxenv_restart_tftp ( struct s_PXENV_TFTP_READ_FILE
143                                   *restart_tftp ) {
144         DBG ( "PXENV_RESTART_TFTP" );
145
146 #if 0
147         /* Words cannot describe the complete mismatch between the PXE
148          * specification and any possible version of reality...
149          */
150         restart_tftp->Buffer = PXE_LOAD_ADDRESS; /* Fixed by spec, apparently */
151         restart_tftp->BufferSize = get_free_base_memory() - PXE_LOAD_ADDRESS; /* Near enough */
152         DBG ( "(" );
153         tftp_exit = pxe_api_call ( PXENV_TFTP_READ_FILE, (union u_PXENV_ANY*)restart_tftp );
154         DBG ( ")" );
155         if ( tftp_exit != PXENV_EXIT_SUCCESS ) return tftp_exit;
156
157         /* Fire up the new NBP */
158         restart_tftp->Status = xstartpxe();
159 #endif
160
161         /* Not sure what "SUCCESS" actually means, since we can only
162          * return if the new NBP failed to boot...
163          */
164         return PXENV_EXIT_SUCCESS;
165 }
166
167 /* PXENV_START_UNDI
168  *
169  * Status: working
170  */
171 PXENV_EXIT_t pxenv_start_undi ( struct s_PXENV_START_UNDI *start_undi ) {
172
173         DBG ( "PXENV_START_UNDI" );
174
175 #if 0
176         /* Record PCI bus & devfn passed by caller, so we know which
177          * NIC they want to use.
178          *
179          * If they don't match our already-existing NIC structure, set
180          * values to ensure that the specified NIC is used at the next
181          * call to pxe_intialise_nic().
182          */
183         bus = ( start_undi->AX >> 8 ) & 0xff;
184         devfn = start_undi->AX & 0xff;
185
186 #warning "device probing mechanism has completely changed"
187 #if 0
188         if ( ( pci->dev.driver == NULL ) ||
189              ( pci->dev.bus != bus ) || ( pci->dev.devfn != devfn ) ) {
190                 /* This is quite a bit of a hack and relies on
191                  * knowledge of the internal operation of Etherboot's
192                  * probe mechanism.
193                  */
194                 DBG ( " set PCI %hhx:%hhx.%hhx",
195                       bus, PCI_SLOT(devfn), PCI_FUNC(devfn) );
196                 dev->type = BOOT_NIC;
197                 dev->to_probe = PROBE_PCI;
198                 memset ( &dev->state, 0, sizeof(dev->state) );
199                 pci->advance = 1;
200                 pci->dev.use_specified = 1;
201                 pci->dev.bus = bus;
202                 pci->dev.devfn = devfn;
203         }
204 #endif
205
206 #endif
207
208         start_undi->Status = PXENV_STATUS_SUCCESS;
209         return PXENV_EXIT_SUCCESS;
210 }
211
212 /* PXENV_STOP_UNDI
213  *
214  * Status: working
215  */
216 PXENV_EXIT_t pxenv_stop_undi ( struct s_PXENV_STOP_UNDI *stop_undi ) {
217         DBG ( "PXENV_STOP_UNDI" );
218
219 #if 0
220         if ( ! ensure_pxe_state(CAN_UNLOAD) ) {
221                 stop_undi->Status = PXENV_STATUS_KEEP_UNDI;
222                 return PXENV_EXIT_FAILURE;
223         }
224 #endif
225
226         stop_undi->Status = PXENV_STATUS_SUCCESS;
227         return PXENV_EXIT_SUCCESS;
228 }
229
230 /* PXENV_START_BASE
231  *
232  * Status: won't implement (requires major structural changes)
233  */
234 PXENV_EXIT_t pxenv_start_base ( struct s_PXENV_START_BASE *start_base ) {
235         DBG ( "PXENV_START_BASE" );
236
237         start_base->Status = PXENV_STATUS_UNSUPPORTED;
238         return PXENV_EXIT_FAILURE;
239 }
240
241 /* PXENV_STOP_BASE
242  *
243  * Status: working
244  */
245 PXENV_EXIT_t pxenv_stop_base ( struct s_PXENV_STOP_BASE *stop_base ) {
246         DBG ( "PXENV_STOP_BASE" );
247
248         /* The only time we will be called is when the NBP is trying
249          * to shut down the PXE stack.  There's nothing we need to do
250          * in this call.
251          */
252
253         stop_base->Status = PXENV_STATUS_SUCCESS;
254         return PXENV_EXIT_SUCCESS;
255 }