[pxe] Treat PXENV_RESTART_TFTP as unreturnable
[people/pcmattman/gpxe.git] / src / arch / i386 / interface / pxe / pxe_call.c
1 /*
2  * Copyright (C) 2006 Michael Brown <mbrown@fensystems.co.uk>.
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License as
6  * published by the Free Software Foundation; either version 2 of the
7  * License, or any later version.
8  *
9  * This program is distributed in the hope that it will be useful, but
10  * WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17  */
18
19 FILE_LICENCE ( GPL2_OR_LATER );
20
21 #include <gpxe/uaccess.h>
22 #include <gpxe/init.h>
23 #include <setjmp.h>
24 #include <registers.h>
25 #include <biosint.h>
26 #include <pxe.h>
27 #include <pxe_call.h>
28
29 /** @file
30  *
31  * PXE API entry point
32  */
33
34 /** Vector for chaining INT 1A */
35 extern struct segoff __text16 ( pxe_int_1a_vector );
36 #define pxe_int_1a_vector __use_text16 ( pxe_int_1a_vector )
37
38 /** INT 1A handler */
39 extern void pxe_int_1a ( void );
40
41 /** INT 1A hooked flag */
42 static int int_1a_hooked = 0;
43
44 /** A function pointer to hold any PXE API call
45  *
46  * Used by pxe_api_call() to avoid large swathes of duplicated code.
47  */
48 union pxenv_call {
49         PXENV_EXIT_t ( * any ) ( union u_PXENV_ANY * );
50         PXENV_EXIT_t ( * unknown ) ( struct s_PXENV_UNKNOWN * );
51         PXENV_EXIT_t ( * unload_stack ) ( struct s_PXENV_UNLOAD_STACK * );
52         PXENV_EXIT_t ( * get_cached_info )
53                         ( struct s_PXENV_GET_CACHED_INFO * );
54         PXENV_EXIT_t ( * restart_tftp ) ( struct s_PXENV_TFTP_READ_FILE * );
55         PXENV_EXIT_t ( * start_undi ) ( struct s_PXENV_START_UNDI * );
56         PXENV_EXIT_t ( * stop_undi ) ( struct s_PXENV_STOP_UNDI * );
57         PXENV_EXIT_t ( * start_base ) ( struct s_PXENV_START_BASE * );
58         PXENV_EXIT_t ( * stop_base ) ( struct s_PXENV_STOP_BASE * );
59         PXENV_EXIT_t ( * tftp_open ) ( struct s_PXENV_TFTP_OPEN * );
60         PXENV_EXIT_t ( * tftp_close ) ( struct s_PXENV_TFTP_CLOSE * );
61         PXENV_EXIT_t ( * tftp_read ) ( struct s_PXENV_TFTP_READ * );
62         PXENV_EXIT_t ( * tftp_read_file ) ( struct s_PXENV_TFTP_READ_FILE * );
63         PXENV_EXIT_t ( * tftp_get_fsize ) ( struct s_PXENV_TFTP_GET_FSIZE * );
64         PXENV_EXIT_t ( * udp_open ) ( struct s_PXENV_UDP_OPEN * );
65         PXENV_EXIT_t ( * udp_close ) ( struct s_PXENV_UDP_CLOSE * );
66         PXENV_EXIT_t ( * udp_write ) ( struct s_PXENV_UDP_WRITE * );
67         PXENV_EXIT_t ( * udp_read ) ( struct s_PXENV_UDP_READ * );
68         PXENV_EXIT_t ( * undi_startup ) ( struct s_PXENV_UNDI_STARTUP * );
69         PXENV_EXIT_t ( * undi_cleanup ) ( struct s_PXENV_UNDI_CLEANUP * );
70         PXENV_EXIT_t ( * undi_initialize )
71                         ( struct s_PXENV_UNDI_INITIALIZE * );
72         PXENV_EXIT_t ( * undi_reset_adapter ) ( struct s_PXENV_UNDI_RESET * );
73         PXENV_EXIT_t ( * undi_shutdown ) ( struct s_PXENV_UNDI_SHUTDOWN * );
74         PXENV_EXIT_t ( * undi_open ) ( struct s_PXENV_UNDI_OPEN * );
75         PXENV_EXIT_t ( * undi_close ) ( struct s_PXENV_UNDI_CLOSE * );
76         PXENV_EXIT_t ( * undi_transmit ) ( struct s_PXENV_UNDI_TRANSMIT * );
77         PXENV_EXIT_t ( * undi_set_mcast_address )
78                         ( struct s_PXENV_UNDI_SET_MCAST_ADDRESS * );
79         PXENV_EXIT_t ( * undi_set_station_address )
80                         ( struct s_PXENV_UNDI_SET_STATION_ADDRESS * );
81         PXENV_EXIT_t ( * undi_set_packet_filter )
82                         ( struct s_PXENV_UNDI_SET_PACKET_FILTER * );
83         PXENV_EXIT_t ( * undi_get_information )
84                         ( struct s_PXENV_UNDI_GET_INFORMATION * );
85         PXENV_EXIT_t ( * undi_get_statistics )
86                         ( struct s_PXENV_UNDI_GET_STATISTICS * );
87         PXENV_EXIT_t ( * undi_clear_statistics )
88                         ( struct s_PXENV_UNDI_CLEAR_STATISTICS * );
89         PXENV_EXIT_t ( * undi_initiate_diags )
90                         ( struct s_PXENV_UNDI_INITIATE_DIAGS * );
91         PXENV_EXIT_t ( * undi_force_interrupt )
92                         ( struct s_PXENV_UNDI_FORCE_INTERRUPT * );
93         PXENV_EXIT_t ( * undi_get_mcast_address )
94                         ( struct s_PXENV_UNDI_GET_MCAST_ADDRESS * );
95         PXENV_EXIT_t ( * undi_get_nic_type )
96                         ( struct s_PXENV_UNDI_GET_NIC_TYPE * );
97         PXENV_EXIT_t ( * undi_get_iface_info )
98                         ( struct s_PXENV_UNDI_GET_IFACE_INFO * );
99         PXENV_EXIT_t ( * undi_get_state ) ( struct s_PXENV_UNDI_GET_STATE * );
100         PXENV_EXIT_t ( * undi_isr ) ( struct s_PXENV_UNDI_ISR * );
101         PXENV_EXIT_t ( * file_open ) ( struct s_PXENV_FILE_OPEN * );
102         PXENV_EXIT_t ( * file_close ) ( struct s_PXENV_FILE_CLOSE * );
103         PXENV_EXIT_t ( * file_select ) ( struct s_PXENV_FILE_SELECT * );
104         PXENV_EXIT_t ( * file_read ) ( struct s_PXENV_FILE_READ * );
105         PXENV_EXIT_t ( * get_file_size ) ( struct s_PXENV_GET_FILE_SIZE * );
106         PXENV_EXIT_t ( * file_exec ) ( struct s_PXENV_FILE_EXEC * );
107         PXENV_EXIT_t ( * file_api_check ) ( struct s_PXENV_FILE_API_CHECK * );
108         PXENV_EXIT_t ( * file_exit_hook ) ( struct s_PXENV_FILE_EXIT_HOOK * );
109 };
110
111 /**
112  * Handle an unknown PXE API call
113  *
114  * @v pxenv_unknown                     Pointer to a struct s_PXENV_UNKNOWN
115  * @ret #PXENV_EXIT_FAILURE             Always
116  * @err #PXENV_STATUS_UNSUPPORTED       Always
117  */
118 static PXENV_EXIT_t pxenv_unknown ( struct s_PXENV_UNKNOWN *pxenv_unknown ) {
119         pxenv_unknown->Status = PXENV_STATUS_UNSUPPORTED;
120         return PXENV_EXIT_FAILURE;
121 }
122
123 /**
124  * Dispatch PXE API call
125  *
126  * @v bx                PXE opcode
127  * @v es:di             Address of PXE parameter block
128  * @ret ax              PXE exit code
129  */
130 __asmcall void pxe_api_call ( struct i386_all_regs *ix86 ) {
131         int opcode = ix86->regs.bx;
132         userptr_t parameters = real_to_user ( ix86->segs.es, ix86->regs.di );
133         size_t param_len;
134         union u_PXENV_ANY pxenv_any;
135         union pxenv_call pxenv_call;
136         PXENV_EXIT_t ret;
137
138         switch ( opcode ) {
139         case PXENV_UNLOAD_STACK:
140                 pxenv_call.unload_stack = pxenv_unload_stack;
141                 param_len = sizeof ( pxenv_any.unload_stack );
142                 break;
143         case PXENV_GET_CACHED_INFO:
144                 pxenv_call.get_cached_info = pxenv_get_cached_info;
145                 param_len = sizeof ( pxenv_any.get_cached_info );
146                 break;
147         case PXENV_RESTART_TFTP:
148                 pxenv_call.restart_tftp = pxenv_restart_tftp;
149                 param_len = sizeof ( pxenv_any.restart_tftp );
150                 break;
151         case PXENV_START_UNDI:
152                 pxenv_call.start_undi = pxenv_start_undi;
153                 param_len = sizeof ( pxenv_any.start_undi );
154                 break;
155         case PXENV_STOP_UNDI:
156                 pxenv_call.stop_undi = pxenv_stop_undi;
157                 param_len = sizeof ( pxenv_any.stop_undi );
158                 break;
159         case PXENV_START_BASE:
160                 pxenv_call.start_base = pxenv_start_base;
161                 param_len = sizeof ( pxenv_any.start_base );
162                 break;
163         case PXENV_STOP_BASE:
164                 pxenv_call.stop_base = pxenv_stop_base;
165                 param_len = sizeof ( pxenv_any.stop_base );
166                 break;
167         case PXENV_TFTP_OPEN:
168                 pxenv_call.tftp_open = pxenv_tftp_open;
169                 param_len = sizeof ( pxenv_any.tftp_open );
170                 break;
171         case PXENV_TFTP_CLOSE:
172                 pxenv_call.tftp_close = pxenv_tftp_close;
173                 param_len = sizeof ( pxenv_any.tftp_close );
174                 break;
175         case PXENV_TFTP_READ:
176                 pxenv_call.tftp_read = pxenv_tftp_read;
177                 param_len = sizeof ( pxenv_any.tftp_read );
178                 break;
179         case PXENV_TFTP_READ_FILE:
180                 pxenv_call.tftp_read_file = pxenv_tftp_read_file;
181                 param_len = sizeof ( pxenv_any.tftp_read_file );
182                 break;
183         case PXENV_TFTP_GET_FSIZE:
184                 pxenv_call.tftp_get_fsize = pxenv_tftp_get_fsize;
185                 param_len = sizeof ( pxenv_any.tftp_get_fsize );
186                 break;
187         case PXENV_UDP_OPEN:
188                 pxenv_call.udp_open = pxenv_udp_open;
189                 param_len = sizeof ( pxenv_any.udp_open );
190                 break;
191         case PXENV_UDP_CLOSE:
192                 pxenv_call.udp_close = pxenv_udp_close;
193                 param_len = sizeof ( pxenv_any.udp_close );
194                 break;
195         case PXENV_UDP_WRITE:
196                 pxenv_call.udp_write = pxenv_udp_write;
197                 param_len = sizeof ( pxenv_any.udp_write );
198                 break;
199         case PXENV_UDP_READ:
200                 pxenv_call.udp_read = pxenv_udp_read;
201                 param_len = sizeof ( pxenv_any.udp_read );
202                 break;
203         case PXENV_UNDI_STARTUP:
204                 pxenv_call.undi_startup = pxenv_undi_startup;
205                 param_len = sizeof ( pxenv_any.undi_startup );
206                 break;
207         case PXENV_UNDI_CLEANUP:
208                 pxenv_call.undi_cleanup = pxenv_undi_cleanup;
209                 param_len = sizeof ( pxenv_any.undi_cleanup );
210                 break;
211         case PXENV_UNDI_INITIALIZE:
212                 pxenv_call.undi_initialize = pxenv_undi_initialize;
213                 param_len = sizeof ( pxenv_any.undi_initialize );
214                 break;
215         case PXENV_UNDI_RESET_ADAPTER:
216                 pxenv_call.undi_reset_adapter = pxenv_undi_reset_adapter;
217                 param_len = sizeof ( pxenv_any.undi_reset_adapter );
218                 break;
219         case PXENV_UNDI_SHUTDOWN:
220                 pxenv_call.undi_shutdown = pxenv_undi_shutdown;
221                 param_len = sizeof ( pxenv_any.undi_shutdown );
222                 break;
223         case PXENV_UNDI_OPEN:
224                 pxenv_call.undi_open = pxenv_undi_open;
225                 param_len = sizeof ( pxenv_any.undi_open );
226                 break;
227         case PXENV_UNDI_CLOSE:
228                 pxenv_call.undi_close = pxenv_undi_close;
229                 param_len = sizeof ( pxenv_any.undi_close );
230                 break;
231         case PXENV_UNDI_TRANSMIT:
232                 pxenv_call.undi_transmit = pxenv_undi_transmit;
233                 param_len = sizeof ( pxenv_any.undi_transmit );
234                 break;
235         case PXENV_UNDI_SET_MCAST_ADDRESS:
236                 pxenv_call.undi_set_mcast_address =
237                         pxenv_undi_set_mcast_address;
238                 param_len = sizeof ( pxenv_any.undi_set_mcast_address );
239                 break;
240         case PXENV_UNDI_SET_STATION_ADDRESS:
241                 pxenv_call.undi_set_station_address =
242                         pxenv_undi_set_station_address;
243                 param_len = sizeof ( pxenv_any.undi_set_station_address );
244                 break;
245         case PXENV_UNDI_SET_PACKET_FILTER:
246                 pxenv_call.undi_set_packet_filter =
247                         pxenv_undi_set_packet_filter;
248                 param_len = sizeof ( pxenv_any.undi_set_packet_filter );
249                 break;
250         case PXENV_UNDI_GET_INFORMATION:
251                 pxenv_call.undi_get_information = pxenv_undi_get_information;
252                 param_len = sizeof ( pxenv_any.undi_get_information );
253                 break;
254         case PXENV_UNDI_GET_STATISTICS:
255                 pxenv_call.undi_get_statistics = pxenv_undi_get_statistics;
256                 param_len = sizeof ( pxenv_any.undi_get_statistics );
257                 break;
258         case PXENV_UNDI_CLEAR_STATISTICS:
259                 pxenv_call.undi_clear_statistics = pxenv_undi_clear_statistics;
260                 param_len = sizeof ( pxenv_any.undi_clear_statistics );
261                 break;
262         case PXENV_UNDI_INITIATE_DIAGS:
263                 pxenv_call.undi_initiate_diags = pxenv_undi_initiate_diags;
264                 param_len = sizeof ( pxenv_any.undi_initiate_diags );
265                 break;
266         case PXENV_UNDI_FORCE_INTERRUPT:
267                 pxenv_call.undi_force_interrupt = pxenv_undi_force_interrupt;
268                 param_len = sizeof ( pxenv_any.undi_force_interrupt );
269                 break;
270         case PXENV_UNDI_GET_MCAST_ADDRESS:
271                 pxenv_call.undi_get_mcast_address =
272                         pxenv_undi_get_mcast_address;
273                 param_len = sizeof ( pxenv_any.undi_get_mcast_address );
274                 break;
275         case PXENV_UNDI_GET_NIC_TYPE:
276                 pxenv_call.undi_get_nic_type = pxenv_undi_get_nic_type;
277                 param_len = sizeof ( pxenv_any.undi_get_nic_type );
278                 break;
279         case PXENV_UNDI_GET_IFACE_INFO:
280                 pxenv_call.undi_get_iface_info = pxenv_undi_get_iface_info;
281                 param_len = sizeof ( pxenv_any.undi_get_iface_info );
282                 break;
283         case PXENV_UNDI_ISR:
284                 pxenv_call.undi_isr = pxenv_undi_isr;
285                 param_len = sizeof ( pxenv_any.undi_isr );
286                 break;
287         case PXENV_FILE_OPEN:
288                 pxenv_call.file_open = pxenv_file_open;
289                 param_len = sizeof ( pxenv_any.file_open );
290                 break;
291         case PXENV_FILE_CLOSE:
292                 pxenv_call.file_close = pxenv_file_close;
293                 param_len = sizeof ( pxenv_any.file_close );
294                 break;
295         case PXENV_FILE_SELECT:
296                 pxenv_call.file_select = pxenv_file_select;
297                 param_len = sizeof ( pxenv_any.file_select );
298                 break;
299         case PXENV_FILE_READ:
300                 pxenv_call.file_read = pxenv_file_read;
301                 param_len = sizeof ( pxenv_any.file_read );
302                 break;
303         case PXENV_GET_FILE_SIZE:
304                 pxenv_call.get_file_size = pxenv_get_file_size;
305                 param_len = sizeof ( pxenv_any.get_file_size );
306                 break;
307         case PXENV_FILE_EXEC:
308                 pxenv_call.file_exec = pxenv_file_exec;
309                 param_len = sizeof ( pxenv_any.file_exec );
310                 break;
311         case PXENV_FILE_API_CHECK:
312                 pxenv_call.file_api_check = pxenv_file_api_check;
313                 param_len = sizeof ( pxenv_any.file_api_check );
314                 break;
315         case PXENV_FILE_EXIT_HOOK:
316                 pxenv_call.file_exit_hook = pxenv_file_exit_hook;
317                 param_len = sizeof ( pxenv_any.file_exit_hook );
318                 break;
319         default:
320                 DBG ( "PXENV_UNKNOWN_%hx", opcode );
321                 pxenv_call.unknown = pxenv_unknown;
322                 param_len = sizeof ( pxenv_any.unknown );
323                 break;
324         }
325
326         /* Copy parameter block from caller */
327         copy_from_user ( &pxenv_any, parameters, 0, param_len );
328
329         /* Set default status in case child routine fails to do so */
330         pxenv_any.Status = PXENV_STATUS_FAILURE;
331
332         /* Hand off to relevant API routine */
333         DBG ( "[" );
334         ret = pxenv_call.any ( &pxenv_any );
335         if ( pxenv_any.Status != PXENV_STATUS_SUCCESS ) {
336                 DBG ( " %02x", pxenv_any.Status );
337         }
338         if ( ret != PXENV_EXIT_SUCCESS ) {
339                 DBG ( ret == PXENV_EXIT_FAILURE ? " err" : " ??" );
340         }
341         DBG ( "]" );
342         
343         /* Copy modified parameter block back to caller and return */
344         copy_to_user ( parameters, 0, &pxenv_any, param_len );
345         ix86->regs.ax = ret;
346 }
347
348 /**
349  * Dispatch weak PXE API call with PXE stack available
350  *
351  * @v ix86              Registers for PXE call
352  * @ret present         Zero (PXE stack present)
353  */
354 int pxe_api_call_weak ( struct i386_all_regs *ix86 )
355 {
356         pxe_api_call ( ix86 );
357         return 0;
358 }
359
360 /**
361  * Dispatch PXE loader call
362  *
363  * @v es:di             Address of PXE parameter block
364  * @ret ax              PXE exit code
365  */
366 __asmcall void pxe_loader_call ( struct i386_all_regs *ix86 ) {
367         userptr_t uparams = real_to_user ( ix86->segs.es, ix86->regs.di );
368         struct s_UNDI_LOADER params;
369         PXENV_EXIT_t ret;
370
371         /* Copy parameter block from caller */
372         copy_from_user ( &params, uparams, 0, sizeof ( params ) );
373
374         /* Fill in ROM segment address */
375         ppxe.UNDIROMID.segment = ix86->segs.ds;
376
377         /* Set default status in case child routine fails to do so */
378         params.Status = PXENV_STATUS_FAILURE;
379
380         /* Call UNDI loader */
381         ret = undi_loader ( &params );
382
383         /* Copy modified parameter block back to caller and return */
384         copy_to_user ( uparams, 0, &params, sizeof ( params ) );
385         ix86->regs.ax = ret;
386 }
387
388 /**
389  * Calculate byte checksum as used by PXE
390  *
391  * @v data              Data
392  * @v size              Length of data
393  * @ret sum             Checksum
394  */
395 static uint8_t pxe_checksum ( void *data, size_t size ) {
396         uint8_t *bytes = data;
397         uint8_t sum = 0;
398
399         while ( size-- ) {
400                 sum += *bytes++;
401         }
402         return sum;
403 }
404
405 /**
406  * Initialise !PXE and PXENV+ structures
407  *
408  */
409 static void pxe_init_structures ( void ) {
410         uint32_t rm_cs_phys = ( rm_cs << 4 );
411         uint32_t rm_ds_phys = ( rm_ds << 4 );
412
413         /* Fill in missing segment fields */
414         ppxe.EntryPointSP.segment = rm_cs;
415         ppxe.EntryPointESP.segment = rm_cs;
416         ppxe.Stack.segment_address = rm_ds;
417         ppxe.Stack.Physical_address = rm_ds_phys;
418         ppxe.UNDIData.segment_address = rm_ds;
419         ppxe.UNDIData.Physical_address = rm_ds_phys;
420         ppxe.UNDICode.segment_address = rm_cs;
421         ppxe.UNDICode.Physical_address = rm_cs_phys;
422         ppxe.UNDICodeWrite.segment_address = rm_cs;
423         ppxe.UNDICodeWrite.Physical_address = rm_cs_phys;
424         pxenv.RMEntry.segment = rm_cs;
425         pxenv.StackSeg = rm_ds;
426         pxenv.UNDIDataSeg = rm_ds;
427         pxenv.UNDICodeSeg = rm_cs;
428         pxenv.PXEPtr.segment = rm_cs;
429
430         /* Update checksums */
431         ppxe.StructCksum -= pxe_checksum ( &ppxe, sizeof ( ppxe ) );
432         pxenv.Checksum -= pxe_checksum ( &pxenv, sizeof ( pxenv ) );
433 }
434
435 /** PXE structure initialiser */
436 struct init_fn pxe_init_fn __init_fn ( INIT_NORMAL ) = {
437         .initialise = pxe_init_structures,
438 };
439
440 /**
441  * Activate PXE stack
442  *
443  * @v netdev            Net device to use as PXE net device
444  */
445 void pxe_activate ( struct net_device *netdev ) {
446
447         /* Ensure INT 1A is hooked */
448         if ( ! int_1a_hooked ) {
449                 hook_bios_interrupt ( 0x1a, ( unsigned int ) pxe_int_1a,
450                                       &pxe_int_1a_vector );
451                 int_1a_hooked = 1;
452         }
453
454         /* Set PXE network device */
455         pxe_set_netdev ( netdev );
456 }
457
458 /**
459  * Deactivate PXE stack
460  *
461  * @ret rc              Return status code
462  */
463 int pxe_deactivate ( void ) {
464         int rc;
465
466         /* Clear PXE network device */
467         pxe_set_netdev ( NULL );
468
469         /* Ensure INT 1A is unhooked, if possible */
470         if ( int_1a_hooked ) {
471                 if ( ( rc = unhook_bios_interrupt ( 0x1a,
472                                                     (unsigned int) pxe_int_1a,
473                                                     &pxe_int_1a_vector ))!= 0){
474                         DBG ( "Could not unhook INT 1A: %s\n",
475                               strerror ( rc ) );
476                         return rc;
477                 }
478                 int_1a_hooked = 0;
479         }
480
481         return 0;
482 }
483
484 /** Jump buffer for PXENV_RESTART_TFTP */
485 rmjmp_buf pxe_restart_nbp;
486
487 /**
488  * Start PXE NBP at 0000:7c00
489  *
490  * @ret rc              Return status code
491  */
492 int pxe_start_nbp ( void ) {
493         int jmp;
494         int discard_b, discard_c, discard_d, discard_D;
495         uint16_t rc;
496
497         /* Allow restarting NBP via PXENV_RESTART_TFTP */
498         jmp = rmsetjmp ( pxe_restart_nbp );
499         if ( jmp )
500                 DBG ( "Restarting NBP (%x)\n", jmp );
501
502         /* Far call to PXE NBP */
503         __asm__ __volatile__ ( REAL_CODE ( "movw %%cx, %%es\n\t"
504                                            "pushw %%es\n\t"
505                                            "pushw %%di\n\t"
506                                            "sti\n\t"
507                                            "lcall $0, $0x7c00\n\t"
508                                            "addw $4, %%sp\n\t" )
509                                : "=a" ( rc ), "=b" ( discard_b ),
510                                  "=c" ( discard_c ), "=d" ( discard_d ),
511                                  "=D" ( discard_D )
512                                : "a" ( 0 ), "b" ( __from_text16 ( &pxenv ) ),
513                                  "c" ( rm_cs ),
514                                  "d" ( virt_to_phys ( &pxenv ) ),
515                                  "D" ( __from_text16 ( &ppxe ) )
516                                : "esi", "ebp", "memory" );
517
518         return rc;
519 }