00f752634c1884e82fc584048b67f46e0cf69a69
[people/sha0/gpxe.git] / src / arch / i386 / image / com32.c
1 /*
2  * Copyright (C) 2008 Daniel Verkamp <daniel@drv.nu>.
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 /**
20  * @file
21  *
22  * SYSLINUX COM32 image format
23  *
24  */
25
26 #include <stdint.h>
27 #include <stdlib.h>
28 #include <string.h>
29 #include <strings.h>
30 #include <errno.h>
31 #include <assert.h>
32 #include <realmode.h>
33 #include <basemem.h>
34 #include <comboot.h>
35 #include <gpxe/uaccess.h>
36 #include <gpxe/image.h>
37 #include <gpxe/segment.h>
38 #include <gpxe/init.h>
39 #include <gpxe/memmap.h>
40
41 struct image_type com32_image_type __image_type ( PROBE_NORMAL );
42
43 /**
44  * Execute COMBOOT image
45  *
46  * @v image             COM32 image
47  * @ret rc              Return status code
48  */
49 static int com32_exec ( struct image *image ) {
50         struct memory_map memmap;
51         unsigned int i;
52         int state;
53         uint32_t avail_mem_top;
54
55         state = setjmp ( comboot_return );
56
57         switch ( state ) {
58         case 0: /* First time through; invoke COM32 program */
59
60                 /* Get memory map */
61                 get_memmap ( &memmap );
62
63                 /* Find end of block covering COM32 image loading area */
64                 for ( i = 0, avail_mem_top = 0 ; i < memmap.count ; i++ ) {
65                         if ( (memmap.regions[i].start <= COM32_START_PHYS) &&
66                              (memmap.regions[i].end > COM32_START_PHYS + image->len) ) {
67                                 avail_mem_top = memmap.regions[i].end;
68                                 break;
69                         }
70                 }
71
72                 DBGC ( image, "COM32 %p: available memory top = 0x%x\n",
73                        image, avail_mem_top );
74
75                 assert ( avail_mem_top != 0 );
76
77                 com32_external_esp = phys_to_virt ( avail_mem_top );
78
79                 /* Hook COMBOOT API interrupts */
80                 hook_comboot_interrupts();
81
82                 /* Unregister image, so that a "boot" command doesn't
83                  * throw us into an execution loop.  We never
84                  * reregister ourselves; COMBOOT images expect to be
85                  * removed on exit.
86                  */
87                 unregister_image ( image );
88
89                 __asm__ __volatile__ (
90                         "movl %%esp, (com32_internal_esp)\n\t" /* Save internal virtual address space ESP */
91                         "movl (com32_external_esp), %%esp\n\t" /* Switch to COM32 ESP (top of available memory) */
92                         "call _virt_to_phys\n\t"               /* Switch to flat physical address space */
93                         "pushl %0\n\t"                         /* Pointer to CDECL helper function */
94                         "pushl %1\n\t"                         /* Pointer to FAR call helper function */
95                         "pushl %2\n\t"                         /* Size of low memory bounce buffer */
96                         "pushl %3\n\t"                         /* Pointer to low memory bounce buffer */
97                         "pushl %4\n\t"                         /* Pointer to INT call helper function */
98                         "pushl %5\n\t"                         /* Pointer to the command line arguments */
99                         "pushl $6\n\t"                         /* Number of additional arguments */
100                         "call *%6\n\t"                         /* Execute image */
101                         "call _phys_to_virt\n\t"               /* Switch back to internal virtual address space */
102                         "movl (com32_internal_esp), %%esp\n\t" /* Switch back to internal stack */
103                 :
104                 :
105                         /* %0 */ "r" ( virt_to_phys ( com32_cfarcall_wrapper ) ),
106                         /* %1 */ "r" ( virt_to_phys ( com32_farcall_wrapper ) ),
107                         /* %2 */ "r" ( get_fbms() * 1024 - (COM32_BOUNCE_SEG << 4) ),
108                         /* %3 */ "i" ( COM32_BOUNCE_SEG << 4 ),
109                         /* %4 */ "r" ( virt_to_phys ( com32_intcall_wrapper ) ),
110                         /* %5 */ "r" ( virt_to_phys ( image->cmdline ) ),
111                         /* %6 */ "r" ( COM32_START_PHYS )
112                 :
113                         "memory" );
114                 DBGC ( image, "COM32 %p: returned\n", image );
115                 break;
116
117         case COMBOOT_EXIT:
118                 DBGC ( image, "COM32 %p: exited\n", image );
119                 break;
120
121         case COMBOOT_EXIT_RUN_KERNEL:
122                 DBGC ( image, "COM32 %p: exited to run kernel %p\n",
123                        image, comboot_replacement_image );
124                 image->replacement = comboot_replacement_image;
125                 comboot_replacement_image = NULL;
126                 image_autoload ( image->replacement );
127                 break;
128
129         case COMBOOT_EXIT_COMMAND:
130                 DBGC ( image, "COM32 %p: exited after executing command\n",
131                        image );
132                 break;
133
134         default:
135                 assert ( 0 );
136                 break;
137         }
138
139         unhook_comboot_interrupts();
140         comboot_force_text_mode();
141
142         return 0;
143 }
144
145 /**
146  * Check image name extension
147  * 
148  * @v image             COM32 image
149  * @ret rc              Return status code
150  */
151 static int com32_identify ( struct image *image ) {
152         const char *ext;
153         static const uint8_t magic[] = { 0xB8, 0xFF, 0x4C, 0xCD, 0x21 };
154         uint8_t buf[5];
155         
156         if ( image->len >= 5 ) {
157                 /* Check for magic number
158                  * mov eax,21cd4cffh
159                  * B8 FF 4C CD 21
160                  */
161                 copy_from_user ( buf, image->data, 0, sizeof(buf) );
162                 if ( ! memcmp ( buf, magic, sizeof(buf) ) ) {
163                         DBGC ( image, "COM32 %p: found magic number\n",
164                                image );
165                         return 0;
166                 }
167         }
168
169         /* Magic number not found; check filename extension */
170
171         ext = strrchr( image->name, '.' );
172
173         if ( ! ext ) {
174                 DBGC ( image, "COM32 %p: no extension\n",
175                        image );
176                 return -ENOEXEC;
177         }
178
179         ++ext;
180
181         if ( strcasecmp( ext, "c32" ) ) {
182                 DBGC ( image, "COM32 %p: unrecognized extension %s\n",
183                        image, ext );
184                 return -ENOEXEC;
185         }
186
187         return 0;
188 }
189
190
191 /**
192  * Load COM32 image into memory
193  * @v image             COM32 image
194  * @ret rc              Return status code
195  */
196 static int comboot_load_image ( struct image *image ) {
197         size_t filesz, memsz;
198         userptr_t buffer;
199         int rc;
200
201         filesz = image->len;
202         memsz = filesz;
203         buffer = phys_to_user ( COM32_START_PHYS );
204         if ( ( rc = prep_segment ( buffer, filesz, memsz ) ) != 0 ) {
205                 DBGC ( image, "COM32 %p: could not prepare segment: %s\n",
206                        image, strerror ( rc ) );
207                 return rc;
208         }
209
210         /* Copy image to segment */
211         memcpy_user ( buffer, 0, image->data, 0, filesz );
212
213         return 0;
214 }
215
216 /**
217  * Prepare COM32 low memory bounce buffer
218  * @v image             COM32 image
219  * @ret rc              Return status code
220  */
221 static int comboot_prepare_bounce_buffer ( struct image * image ) {
222         unsigned int seg;
223         userptr_t seg_userptr;
224         size_t filesz, memsz;
225         int rc;
226
227         seg = COM32_BOUNCE_SEG;
228         seg_userptr = real_to_user ( seg, 0 );
229
230         /* Ensure the entire 64k segment is free */
231         memsz = 0xFFFF;
232         filesz = 0;
233
234         /* Prepare, verify, and load the real-mode segment */
235         if ( ( rc = prep_segment ( seg_userptr, filesz, memsz ) ) != 0 ) {
236                 DBGC ( image, "COM32 %p: could not prepare bounce buffer segment: %s\n",
237                        image, strerror ( rc ) );
238                 return rc;
239         }
240
241         return 0;
242 }
243
244 /**
245  * Load COM32 image into memory
246  *
247  * @v image             COM32 image
248  * @ret rc              Return status code
249  */
250 static int com32_load ( struct image *image ) {
251         int rc;
252
253         DBGC ( image, "COM32 %p: name '%s', cmdline '%s'\n",
254                image, image->name, image->cmdline );
255
256         /* Check if this is a COMBOOT image */
257         if ( ( rc = com32_identify ( image ) ) != 0 ) {
258                 return rc;
259         }
260
261         /* This is a COM32 image, valid or otherwise */
262         if ( ! image->type )
263                 image->type = &com32_image_type;
264
265         /* Load image */
266         if ( ( rc = comboot_load_image ( image ) ) != 0 ) {
267                 return rc;
268         }
269
270         /* Prepare bounce buffer segment */
271         if ( ( rc = comboot_prepare_bounce_buffer ( image ) ) != 0 ) {
272                 return rc;
273         }
274
275         return 0;
276 }
277
278 /** SYSLINUX COM32 image type */
279 struct image_type com32_image_type __image_type ( PROBE_NORMAL ) = {
280         .name = "COM32",
281         .load = com32_load,
282         .exec = com32_exec,
283 };