Make the getmemsize() prototype available in memsizes.h, for code that
[people/xl0/gpxe.git] / src / arch / i386 / image / nbi.c
1 #include <errno.h>
2 #include <assert.h>
3 #include <realmode.h>
4 #include <gateA20.h>
5 #include <memsizes.h>
6 #include <gpxe/uaccess.h>
7 #include <gpxe/segment.h>
8 #include <gpxe/image.h>
9
10 /** @file
11  *
12  * NBI image format.
13  *
14  * The Net Boot Image format is defined by the "Draft Net Boot Image
15  * Proposal 0.3" by Jamie Honan, Gero Kuhlmann and Ken Yap.  It is now
16  * considered to be a legacy format, but it still included because a
17  * large amount of software (e.g. nymph, LTSP) makes use of NBI files.
18  *
19  * Etherboot does not implement the INT 78 callback interface
20  * described by the NBI specification.  For a callback interface on
21  * x86 architecture, use PXE.
22  *
23  */
24
25 struct image_type nbi_image_type __image_type ( PROBE_NORMAL );
26
27 /**
28  * An NBI image header
29  *
30  * Note that the length field uses a peculiar encoding; use the
31  * NBI_LENGTH() macro to decode the actual header length.
32  *
33  */
34 struct imgheader {
35         unsigned long magic;            /**< Magic number (NBI_MAGIC) */
36         union {
37                 unsigned char length;   /**< Nibble-coded header length */
38                 unsigned long flags;    /**< Image flags */
39         };
40         segoff_t location;              /**< 16-bit seg:off header location */
41         union {
42                 segoff_t segoff;        /**< 16-bit seg:off entry point */
43                 unsigned long linear;   /**< 32-bit entry point */
44         } execaddr;
45 } __attribute__ (( packed ));
46
47 /** NBI magic number */
48 #define NBI_MAGIC 0x1B031336UL
49
50 /* Interpretation of the "length" fields */
51 #define NBI_NONVENDOR_LENGTH(len)       ( ( (len) & 0x0f ) << 2 )
52 #define NBI_VENDOR_LENGTH(len)          ( ( (len) & 0xf0 ) >> 2 )
53 #define NBI_LENGTH(len) ( NBI_NONVENDOR_LENGTH(len) + NBI_VENDOR_LENGTH(len) )
54
55 /* Interpretation of the "flags" fields */
56 #define NBI_PROGRAM_RETURNS(flags)      ( (flags) & ( 1 << 8 ) )
57 #define NBI_LINEAR_EXEC_ADDR(flags)     ( (flags) & ( 1 << 31 ) )
58
59 /** NBI header length */
60 #define NBI_HEADER_LENGTH       512
61
62 /**
63  * An NBI segment header
64  *
65  * Note that the length field uses a peculiar encoding; use the
66  * NBI_LENGTH() macro to decode the actual header length.
67  *
68  */
69 struct segheader {
70         unsigned char length;           /**< Nibble-coded header length */
71         unsigned char vendortag;        /**< Vendor-defined private tag */
72         unsigned char reserved;
73         unsigned char flags;            /**< Segment flags */
74         unsigned long loadaddr;         /**< Load address */
75         unsigned long imglength;        /**< Segment length in NBI file */
76         unsigned long memlength;        /**< Segment length in memory */
77 };
78
79 /* Interpretation of the "flags" fields */
80 #define NBI_LOADADDR_FLAGS(flags)       ( (flags) & 0x03 )
81 #define NBI_LOADADDR_ABS                0x00
82 #define NBI_LOADADDR_AFTER              0x01
83 #define NBI_LOADADDR_END                0x02
84 #define NBI_LOADADDR_BEFORE             0x03
85 #define NBI_LAST_SEGHEADER(flags)       ( (flags) & ( 1 << 2 ) )
86
87 /* Define a type for passing info to a loaded program */
88 struct ebinfo {
89         uint8_t  major, minor;  /* Version */
90         uint16_t flags;         /* Bit flags */
91 };
92
93 /** Info passed to NBI image */
94 static struct ebinfo loaderinfo = {
95         VERSION_MAJOR, VERSION_MINOR,
96         0
97 };
98
99 /**
100  * Prepare a segment for an NBI image
101  *
102  * @v image             NBI image
103  * @v offset            Offset within NBI image
104  * @v filesz            Length of initialised-data portion of the segment
105  * @v memsz             Total length of the segment
106  * @v src               Source for initialised data
107  * @ret rc              Return status code
108  */
109 static int nbi_prepare_segment ( struct image *image, size_t offset __unused,
110                                  userptr_t dest, size_t filesz, size_t memsz ){
111         int rc;
112
113         if ( ( rc = prep_segment ( dest, filesz, memsz ) ) != 0 ) {
114                 DBGC ( image, "NBI %p could not prepare segment: %s\n",
115                        image, strerror ( rc ) );
116                 return rc;
117         }
118
119         return 0;
120 }
121
122 /**
123  * Load a segment for an NBI image
124  *
125  * @v image             NBI image
126  * @v offset            Offset within NBI image
127  * @v filesz            Length of initialised-data portion of the segment
128  * @v memsz             Total length of the segment
129  * @v src               Source for initialised data
130  * @ret rc              Return status code
131  */
132 static int nbi_load_segment ( struct image *image, size_t offset,
133                               userptr_t dest, size_t filesz,
134                               size_t memsz __unused ) {
135         memcpy_user ( dest, 0, image->data, offset, filesz );
136         return 0;
137 }
138
139 /**
140  * Process segments of an NBI image
141  *
142  * @v image             NBI image
143  * @v imgheader         Image header information
144  * @v process           Function to call for each segment
145  * @ret rc              Return status code
146  */
147 static int nbi_process_segments ( struct image *image,
148                                   struct imgheader *imgheader,
149                                   int ( * process ) ( struct image *image,
150                                                       size_t offset,
151                                                       userptr_t dest,
152                                                       size_t filesz,
153                                                       size_t memsz ) ) {
154         struct segheader sh;
155         size_t offset = 0;
156         size_t sh_off;
157         userptr_t dest;
158         size_t filesz;
159         size_t memsz;
160         int rc;
161         
162         /* Copy image header to target location */
163         dest = real_to_user ( imgheader->location.segment,
164                               imgheader->location.offset );
165         filesz = memsz = NBI_HEADER_LENGTH;
166         if ( ( rc = process ( image, offset, dest, filesz, memsz ) ) != 0 )
167                 return rc;
168         offset += filesz;
169
170         /* Process segments in turn */
171         sh_off = NBI_LENGTH ( imgheader->length );
172         do {
173                 /* Read segment header */
174                 copy_from_user ( &sh, image->data, sh_off, sizeof ( sh ) );
175                 if ( sh.length == 0 ) {
176                         /* Avoid infinite loop? */
177                         DBGC ( image, "NBI %p invalid segheader length 0\n",
178                                image );
179                         return -ENOEXEC;
180                 }
181                 
182                 /* Calculate segment load address */
183                 switch ( NBI_LOADADDR_FLAGS ( sh.flags ) ) {
184                 case NBI_LOADADDR_ABS:
185                         dest = phys_to_user ( sh.loadaddr );
186                         break;
187                 case NBI_LOADADDR_AFTER:
188                         dest = userptr_add ( dest, memsz + sh.loadaddr );
189                         break;
190                 case NBI_LOADADDR_BEFORE:
191                         dest = userptr_add ( dest, -sh.loadaddr );
192                         break;
193                 case NBI_LOADADDR_END:
194                         /* Not correct according to the spec, but
195                          * maintains backwards compatibility with
196                          * previous versions of Etherboot.
197                          */
198                         dest = phys_to_user ( ( extmemsize() + 1024 ) * 1024
199                                               - sh.loadaddr );
200                         break;
201                 default:
202                         /* Cannot be reached */
203                         assert ( 0 );
204                 }
205
206                 /* Process this segment */
207                 filesz = sh.imglength;
208                 memsz = sh.memlength;
209                 if ( ( offset + filesz ) > image->len ) {
210                         DBGC ( image, "NBI %p segment outside file\n", image );
211                         return -ENOEXEC;
212                 }
213                 if ( ( rc = process ( image, offset, dest,
214                                       filesz, memsz ) ) != 0 ) {
215                         return rc;
216                 }
217                 offset += filesz;
218
219                 /* Next segheader */
220                 sh_off += NBI_LENGTH ( sh.length );
221                 if ( sh_off >= NBI_HEADER_LENGTH ) {
222                         DBGC ( image, "NBI %p header overflow\n", image );
223                         return -ENOEXEC;
224                 }
225
226         } while ( ! NBI_LAST_SEGHEADER ( sh.flags ) );
227
228         if ( offset != image->len ) {
229                 DBGC ( image, "NBI %p length wrong (file %d, metadata %d)\n",
230                        image, image->len, offset );
231                 return -ENOEXEC;
232         }
233
234         return 0;
235 }
236
237 /**
238  * Load an NBI image into memory
239  *
240  * @v image             NBI image
241  * @ret rc              Return status code
242  */
243 int nbi_load ( struct image *image ) {
244         struct imgheader imgheader;
245         int rc;
246
247         /* If we don't have enough data give up */
248         if ( image->len < NBI_HEADER_LENGTH ) {
249                 DBGC ( image, "NBI %p too short for an NBI image\n", image );
250                 return -ENOEXEC;
251         }
252
253         /* Check image header */
254         copy_from_user ( &imgheader, image->data, 0, sizeof ( imgheader ) );
255         if ( imgheader.magic != NBI_MAGIC ) {
256                 DBGC ( image, "NBI %p has no NBI signature\n", image );
257                 return -ENOEXEC;
258         }
259
260         /* This is an NBI image, valid or otherwise */
261         if ( ! image->type )
262                 image->type = &nbi_image_type;
263
264         DBGC ( image, "NBI %p placing header at %hx:%hx\n", image,
265                imgheader.location.segment, imgheader.location.offset );
266
267         /* NBI files can have overlaps between segments; the bss of
268          * one segment may overlap the initialised data of another.  I
269          * assume this is a design flaw, but there are images out
270          * there that we need to work with.  We therefore do two
271          * passes: first to initialise the segments, then to copy the
272          * data.  This avoids zeroing out already-copied data.
273          */
274         if ( ( rc = nbi_process_segments ( image, &imgheader,
275                                            nbi_prepare_segment ) ) != 0 )
276                 return rc;
277         if ( ( rc = nbi_process_segments ( image, &imgheader,
278                                            nbi_load_segment ) ) != 0 )
279                 return rc;
280
281         /* Record header address in image private data field */
282         image->priv.user = real_to_user ( imgheader.location.segment,
283                                           imgheader.location.offset );
284
285         return 0;
286 }
287
288 /**
289  * Boot a 16-bit NBI image
290  *
291  * @v imgheader         Image header information
292  * @ret Never           NBI program booted successfully
293  * @ret False           NBI program returned
294  * @err ECANCELED       NBI program returned
295  *
296  */
297 static int nbi_boot16 ( struct image *image, struct imgheader *imgheader ) {
298         int discard_D, discard_S, discard_b;
299
300         DBGC ( image, "NBI %p executing 16-bit image at %04x:%04x\n", image,
301                imgheader->execaddr.segoff.segment,
302                imgheader->execaddr.segoff.offset );
303
304         gateA20_unset();
305
306 #warning "Should be providing bootp data"
307         __asm__ __volatile__ (
308                 REAL_CODE ( "pushw %%ds\n\t"    /* far pointer to bootp data */
309                             "pushw %%bx\n\t"
310                             "pushl %%esi\n\t"   /* location */
311                             "pushw %%cs\n\t"    /* lcall execaddr */
312                             "call 1f\n\t"
313                             "jmp 2f\n\t"
314                             "\n1:\n\t"
315                             "pushl %%edi\n\t"
316                             "lret\n\t"
317                             "\n2:\n\t"
318                             "addw $8,%%sp\n\t"  /* clean up stack */ )
319                 : "=D" ( discard_D ), "=S" ( discard_S ), "=b" ( discard_b )
320                 : "D" ( imgheader->execaddr.segoff ),
321                   "S" ( imgheader->location ), "b" ( 0 /* bootp data */ )
322                 : "eax", "ecx", "edx", "ebp" );
323         
324         return -ECANCELED;
325 }
326
327 /**
328  * Boot a 32-bit NBI image
329  *
330  * @v imgheader         Image header information
331  * @ret False           NBI program should not have returned
332  * @ret other           As returned by NBI program
333  * @err ECANCELED       NBI program should not have returned
334  *
335  * To distinguish between the case of an NBI program returning false,
336  * and an NBI program that should not have returned, check errno.
337  * errno will be set to ECANCELED only if the NBI program should not
338  * have returned.
339  *
340  */
341 static int nbi_boot32 ( struct image *image, struct imgheader *imgheader ) {
342         int rc;
343
344         DBGC ( image, "NBI %p executing 32-bit image at %lx\n",
345                image, imgheader->execaddr.linear );
346
347         /* no gateA20_unset for PM call */
348
349 #warning "Should be providing bootp data"
350 #warning "xstart32 no longer exists"
351 #if 0
352         rc = xstart32 ( imgheader->execaddr.linear,
353                         virt_to_phys ( &loaderinfo ),
354                         ( ( imgheader->location.segment << 4 ) +
355                           imgheader->location.offset ),
356                         0 /* bootp data */ );
357 #endif
358
359         DBGC ( image, "NBI %p returned %d\n", image, rc );
360
361         if ( ! NBI_PROGRAM_RETURNS ( imgheader->flags ) ) {
362                 /* We shouldn't have returned */
363                 rc = -ECANCELED;
364         }
365
366         return rc;
367 }
368
369 /**
370  * Execute a loaded NBI image
371  *
372  * @v image             NBI image
373  * @ret rc              Return status code
374  */
375 static int nbi_exec ( struct image *image ) {
376         struct imgheader imgheader;
377
378         copy_from_user ( &imgheader, image->priv.user, 0,
379                          sizeof ( imgheader ) );
380
381         if ( NBI_LINEAR_EXEC_ADDR ( imgheader.flags ) ) {
382                 return nbi_boot32 ( image, &imgheader );
383         } else {
384                 return nbi_boot16 ( image, &imgheader );
385         }
386 }
387
388 /** NBI image type */
389 struct image_type nbi_image_type __image_type ( PROBE_NORMAL ) = {
390         .name = "NBI",
391         .load = nbi_load,
392         .exec = nbi_exec,
393 };