wok view linld/stuff/src/LOAD.CPP @ rev 19515
linld: multi initrd support
| author | Pascal Bellard <pascal.bellard@slitaz.org> |
|---|---|
| date | Tue Nov 22 21:19:01 2016 +0100 (2016-11-22) |
| parents | |
| children | 7f92b23984dc |
line source
1 // This file is distributed under GPL
3 #include "crtl.h"
4 #include "common.h"
6 /***************
7 Memory layout assumed by kernel boot process
8 --------------------------------------------
9 Note: claims that kernel setup is relocatable are
10 still not 100% valid:
11 bzImage decompressing trashes 10000-8ffff range,
12 so rm loader -> pm kernel info is lost if it was here...
13 So I had to stick to 90000.
15 10000000+------------------------+ <- 256m
16 | initrd | initrd is at top of mem, but
17 | | not higher than 256m
18 +------------------------+
19 +------------------------+
20 | bzImage | bzImage is at 1m
21 | | VCPI/XMS/64k offset tricks used...
22 00100000+------------------------+ <- 1m
23 | video, BIOS etc | Do not use.
24 000A0000+------------------------+
25 | Reserved for BIOS | Do not use. Reserved for BIOS EBDA.
26 0009A000+------------------------+ <- stack top for kernel rm code
27 | Cmdline |
28 00098000+------------------------+ <- heap top for kernel rm code
29 | Kernel setup | The kernel real-mode code.
30 00090200+------------------------+
31 | Kernel boot sector | The kernel legacy boot sector.
32 00090000+------------------------+
33 | Zapped by ungzip | Historically zImages were loaded here
34 | (zImage once was here) | bzImages use this space for ungzipping
35 00010000+------------------------+
36 | Boot loader | <- Boot sector entry point 0000:7C00
37 00001000+------------------------+
38 | Reserved for MBR/BIOS |
39 00000800+------------------------+
40 | Typically used by MBR |
41 00000600+------------------------+
42 | BIOS use only |
43 00000000+------------------------+
44 */
46 struct first1k_t {
47 // these two set by rm setup:
48 u16 curr_curs; // 0000 saved cursor position
49 u16 ext_mem_size; // 0002 extended memory size in Kb (from int 0x15 fn 0x88)
50 u8 pad00[0x20-4];
51 // old-style cmdline (not used in LINLD (yet?))
52 u16 cl_magic; // 0020 commandline magic number (=0xA33F)
53 u16 cl_ofs; // 0022 commandline offset
54 u8 pad10[0x80-0x24];
55 // these two set by rm setup:
56 u8 hd0_disk_par[16]; // 0080 hd0-disk-parameter from intvector 0x41
57 u8 hd1_disk_par[16]; // 0090 hd1-disk-parameter from intvector 0x46
58 u8 pad20[0x01e0-0xa0];
59 // this is set by rm setup:
60 u32 alt_mem_size; // 01E0 extended memory size in Kb (from int 0x15 fn 0xe801)
61 u8 pad28[0x01f1-0x1e4];
63 u8 setup_sects; // 01F1 The size of the setup in sectors
64 // boot sector is NOT included here
65 u16 ro_flag; // 01F2 If set, the root is mounted readonly
66 u16 syssize; // 01F4 DO NOT USE - for bootsect.S use only:
67 // size of pm part of kernel
68 // (in 16 byte units, rounded up)
69 u16 swap_dev; // 01F6 DO NOT USE - obsolete
70 u16 ram_size; // 01F8 DO NOT USE - for bootsect.S use only:
71 // if nonzero then kernel
72 // (driver/block/ramdisk.c: rd_load())
73 // will try to load the contents for the ramdisk
74 // from the "root_dev" which MUST then have the
75 // floppyMAJOR
76 // The file-system on that floppy must be MINIX
77 // If rd_load() succeeds it sets the root_dev
78 // to the ramdisk for mounting it
79 u16 vid_mode; // 01FA Video mode control
80 u16 root_dev; // 01FC Default root device number
81 u16 boot_flag; // 01FE 0xAA55 magic number
82 u16 jump; // 0200 Jump instruction
83 u32 header; // 0202 Magic signature "HdrS"
84 u16 version; // 0206 Boot protocol version supported
85 u16 realmode_switch_ofs; // 0208 Hook called just before rm->pm
86 u16 realmode_switch_seg;
87 u16 start_sys_seg; // 020E
88 u16 kernel_version; // 020C Points to kernel version string
89 u8 type_of_loader; // 0210 Boot loader identifier
90 u8 loadflags; // 0211 Boot protocol option flags
91 u16 setup_move_size;// 0212 Move to high memory size (used with hooks)
92 u32 code32_start; // 0214 Boot loader hook (see below)
93 u32 initrd_buf; // 0218 initrd load address (set by boot loader)
94 u32 initrd_size; // 021C initrd size (set by boot loader)
95 u32 bootsect_kludge;// 0220 DO NOT USE - for bootsect.S use only
96 u16 heap_end_ptr; // 0224 Free memory after setup end
97 u16 pad1; // 0226 Unused
98 u32 cmd_line_ptr; // 0228 32-bit pointer to the kernel command line
99 u8 pad30[0x400-0x22c]; // 022C
100 // 02D0 up to 32 20-byte mem info structs from
101 // int 0x15 fn 0xe820
102 }; //__attribute((packed));
104 #if sizeof(first1k_t)!=0x400
105 #error BUG: Bad first1k
106 #endif
108 const u32 HdrS = 'H' + ('d'<<8) + (u32('r')<<16) + (u32('S')<<24);
110 u8* rm_buf;
111 static u16 rm_size;
112 u8 pm_high;
113 struct image_himem pm;
114 struct image_himem initrd;
116 static void memcpy_image(struct image_himem *m) {
117 if (m->fallback != m->buf)
118 memcpy32(
119 0, m->fallback, // dst seg,ofs
120 0, m->buf, // src seg,ofs
121 m->size // size
122 );
123 }
125 // Called from inside kernel just before rm->pm
126 // _loadds _saveregs: done by hand
127 void far last_ditch() {
128 cli(); // we start doing *really* destructive things to DOS/BIOS
129 // it means: do not even try to enable ints
130 // or call BIOS services after this
131 asm {
132 push ds
133 push cs
134 pop ds
135 #ifndef NO386
136 pusha
137 #else
138 push ax
139 push bx
140 push cx
141 push dx
142 #endif
143 }
144 if(pm.fallback > _1m) pm.fallback = _1m;
145 if(vcpi==0) {
146 // Move kernel
147 memcpy_image(&pm);
148 // Move initrd
149 memcpy_image(&initrd);
150 } else { //vcpi
151 vm2rm();
152 // Move kernel
153 // 'Gathering' copy in chunks of PAGE_SIZE
154 // No risk of overlapping: kernel is copied from above to 1m mark
155 pm.size = PAGE_SIZE;
156 u32 *p = pm.bufv;
157 if (p) while(*p) {
158 pm.buf = *p;
159 memcpy_image(&pm);
160 p++; pm.fallback+=PAGE_SIZE;
161 }
162 // Move initrd
163 if(initrd.fallback) {
164 // This is tricky: copy initrd backwards to reduce
165 // risk of overlapping: use the fact that initrd is copied
166 // to the very top of ram
167 // (overlapping still can happen with more than 256mb ram)
168 // (generic solution for this overwrite problem, anyone?)
169 p=initrd.bufv;
170 initrd.size = PAGE_SIZE;
171 do {
172 p++; initrd.fallback+=PAGE_SIZE;
173 } while(*p);
174 do {
175 p--; initrd.fallback-=PAGE_SIZE;
176 initrd.buf = *p;
177 memcpy_image(&initrd);
178 } while(p != initrd.bufv);
179 }
180 }
181 asm {
182 #ifndef NO386
183 popa
184 #else
185 pop dx
186 pop cx
187 pop bx
188 pop ax
189 #endif
190 pop ds
191 }
192 }
194 // register value to launch the kernel real mode code
195 #ifdef NO386
196 static u32 sssp;
197 static u32 csip;
198 extern "C" u16 topseg();
199 #else
200 const u32 sssp=0x9000A000;
201 static u32 csip=0x90200000;
202 #define topseg() 0x9000
203 #endif
205 static const char kernel_file_error[] = "Can't use kernel file";
206 char* load_kernel() {
208 #ifdef NO386
209 sssp=((u32)topseg()<<16)+0xA000;
210 csip=((u32)(topseg()+0x20)<<16);
211 #endif
212 // Open kernel, read first kb, check it
213 pm.errmsg = kernel_file_error;
214 open_image(kernel_name, &pm);
216 char *version_string;
217 {
218 struct first1k_t *first1k;
219 first1k = (first1k_t*) (rm_buf = malloc_or_die(_32k));
220 {
221 u16 rm_seek;
223 // Do not use malloc below until heap_top adjustment (see <*>)
224 if (read(pm.fd, rm_buf, rm_seek=0x400) != 0x400) {
225 readfail:
226 die(kernel_file_error);
227 }
229 if(!first1k->setup_sects) {
230 #if 1
231 if(* (int *) &first1k->pad10[0x3F-0x24] == 0x3AE8) {
232 lseek(pm.fd,rm_seek=0x200,SEEK_SET);
233 csip=((u32)topseg()<<16)+0x0042;
234 }
235 else
236 #endif
237 first1k->setup_sects=4;
238 }
239 rm_size = 0x200*(first1k->setup_sects+1); // 0th sector is not counted there
240 if(rm_size>_32k || first1k->boot_flag != 0xAA55)
241 die("It's not a kernel");
242 heap_top = rm_buf+rm_size; // <*>
244 // Read remaining rm loader
246 {
247 u16 cnt = rm_size-rm_seek;
248 if (read(pm.fd, rm_buf+rm_seek, cnt) != cnt) goto readfail;
249 }
250 }
252 // Tell rm loader some info
254 if(vid_mode) first1k->vid_mode = vid_mode;
255 if(root_dev) first1k->root_dev = root_dev;
256 version_string = 0;
258 #if 1
259 if(first1k->header == HdrS) { // starting linux 1.3.73
260 if(first1k->loadflags & 1) {
261 #else
262 if((first1k->header != HdrS) || (first1k->loadflags & 1) == 0)
263 die("I can't load bzImage low");
264 {
265 {
266 #endif
267 pm_high++;
269 // Hook on int15 to work around fn 88 DOS breakage
270 hook_int15_88();
272 // * will be called just before rm -> pm
273 first1k->realmode_switch_ofs = ofs(last_ditch);
274 first1k->realmode_switch_seg = seg(last_ditch);
275 }
276 if(first1k->kernel_version)
277 version_string = (char *) first1k+first1k->kernel_version+0x200;
278 first1k->type_of_loader = 0xff; // kernel do not know us (yet :-)
279 if(first1k->version >= 0x201) {
280 // * offset limit of the setup heap
281 // heap_end_ptr appears to be relative to the start of setup (ofs 0x0200)
282 first1k->heap_end_ptr = _32k-0x0200;
283 first1k->loadflags |= 0x80; // says to rm loader it's ok to use heap
284 }
285 // * if we will ever stop moving ourself to 0x90000
286 // we must say setup.S how much to move
287 //first1k->setup_move_size = _32k;
288 if(first1k->version >= 0x202) { // starting linux 2.4.0-test3-pre3
289 first1k->cmd_line_ptr = (((u32)(topseg()+0x0800))<<4);
290 goto cmd_line_ok;
291 }
292 }
293 first1k->cl_magic = 0xA33F;
294 first1k->cl_ofs = 0x8000;
295 }
297 cmd_line_ok:
298 // Check and enable A20 if needed
299 enable_a20_or_die();
301 // Read remaining kernel (pm part)
302 // Try to load kernel high, maybe even blindly storing it
303 // in unallocated memory as a last resort
305 pm.fallback = (u32((u16(_CS)+0x1FFF)&0xF000)<<4);
306 pm.size -= rm_size;
307 if(pm.fallback+pm.size > (((u32)topseg())<<4) || pm_high) {
308 pm.fallback = _1m+_64k;
309 }
311 load_image(&pm);
312 return version_string;
313 }
315 // Read initrd if needed
317 static const char msg_initrd[] = "Can't use initrd file";
318 void load_initrd() {
319 struct image_himem *m = &initrd;
320 if (!initrd_name && !initrd.fd) return;
321 if (!pm.fd) {
322 noinitrd:
323 puts(msg_initrd);
324 return;
325 }
326 m->errmsg = msg_initrd;
327 open_image(initrd_name, m);
329 m->fallback = (memtop()-m->size) & (~PAGE_MASK);
330 if (m->fallback < pm.fallback + pm.size) {
331 close(m->fd);
332 goto noinitrd;
333 }
335 load_image(m);
336 struct first1k_t *first1k = (first1k_t*)rm_buf;
337 if(first1k->header == HdrS) {
338 first1k->initrd_buf = m->fallback;
339 first1k->initrd_size = m->size;
340 }
341 }
343 void boot_kernel() {
345 // Shrink stack: we won't need much of it now and have no malloc() plans
346 {
347 u16 new_SP=u16(heap_top)+0x100;
348 if(_SP>new_SP) _SP=new_SP;
349 }
350 if( u16(_CS)+(u16(_SP)>>4) >= topseg() ) {
351 // Oops! We can stomp on our toes... better stop now
352 die("Loaded too close to 9000:0");
353 }
355 cli(); // we start doing destructive things to DOS
357 // Move rm loader & commandline to 0x90000
358 if(vcpi==0) {
359 memcpy32(
360 topseg(),0,
361 seg(rm_buf),ofs(rm_buf),
362 rm_size //_32k
363 );
364 memcpy32(
365 topseg()+0x0800,0,
366 seg(cmdline),ofs(cmdline),
367 PAGE_SIZE
368 );
369 } else { //vcpi
370 u32 dst=((u32)topseg()<<4);
371 u16 pos=ofs(rm_buf);
372 do {
373 memcpy_vcpi(dst,seg(rm_buf),pos);
374 dst+=PAGE_SIZE;
375 pos+=PAGE_SIZE;
376 rm_size-=PAGE_SIZE;
377 } while(s16(rm_size) > 0);
378 // overkill: copy PAGE_SIZE bytes
379 memcpy_vcpi(((u32)(topseg()+0x0800)<<4),seg(cmdline),ofs(cmdline));
380 }
382 // Jump to kernel rm code
383 set_sregs_jump_seg_ofs(csip, sssp);
384 }