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