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