| blob | 0c105163d8030f45d4f6a2751f138a7b1f8ff04f |
1 ;; -----------------------------------------------------------------------
2 ;;
3 ;; Copyright 1994-2006 H. Peter Anvin - All Rights Reserved
4 ;;
5 ;; This program is free software; you can redistribute it and/or modify
6 ;; it under the terms of the GNU General Public License as published by
7 ;; the Free Software Foundation, Inc., 53 Temple Place Ste 330,
8 ;; Boston MA 02111-1307, USA; either version 2 of the License, or
9 ;; (at your option) any later version; incorporated herein by reference.
10 ;;
11 ;; -----------------------------------------------------------------------
13 ;;
14 ;; runkernel.inc
15 ;;
16 ;; Common code for running a Linux kernel
17 ;;
19 ;
20 ; Hook macros, that may or may not be defined
21 ;
22 %ifndef HAVE_SPECIAL_APPEND
23 %macro SPECIAL_APPEND 0
24 %endmacro
25 %endif
27 %ifndef HAVE_UNLOAD_PREP
28 %macro UNLOAD_PREP 0
29 %endmacro
30 %endif
32 ;
33 ; A Linux kernel consists of three parts: boot sector, setup code, and
34 ; kernel code. The boot sector is never executed when using an external
35 ; booting utility, but it contains some status bytes that are necessary.
36 ;
37 ; First check that our kernel is at least 1K, or else it isn't long
38 ; enough to have the appropriate headers.
39 ;
40 ; We used to require the kernel to be 64K or larger, but it has gotten
41 ; popular to use the Linux kernel format for other things, which may
42 ; not be so large.
43 ;
44 ; Additionally, we used to have a test for 8 MB or smaller. Equally
45 ; obsolete.
46 ;
47 is_linux_kernel:
48 and dx,dx
49 jnz kernel_sane
50 cmp ax,1024 ; Bootsect + 1 setup sect
51 jb kernel_corrupt
52 kernel_sane: push ax
53 push dx
54 push si
55 mov si,loading_msg
56 call cwritestr
57 ;
58 ; Now start transferring the kernel
59 ;
60 push word real_mode_seg
61 pop es
63 movzx eax,ax ; Fix this by using a 32-bit
64 shl edx,16 ; register for the kernel size
65 or eax,edx
66 mov [KernelSize],eax
67 add eax,SECTOR_SIZE-1
68 shr eax,SECTOR_SHIFT
69 mov [KernelSects],eax ; Total sectors in kernel
71 ;
72 ; Now, if we transfer these straight, we'll hit 64K boundaries. Hence we
73 ; have to see if we're loading more than 64K, and if so, load it step by
74 ; step.
75 ;
77 ;
78 ; Start by loading the bootsector/setup code, to see if we need to
79 ; do something funky. It should fit in the first 32K (loading 64K won't
80 ; work since we might have funny stuff up near the end of memory).
81 ; If we have larger than 32K clusters, yes, we're hosed.
82 ;
83 call abort_check ; Check for abort key
84 mov ecx,8000h >> SECTOR_SHIFT ; Half a moby (32K)
85 cmp ecx,[KernelSects]
86 jna .normalkernel
87 mov ecx,[KernelSects]
88 .normalkernel:
89 sub [KernelSects],ecx
90 xor bx,bx
91 pop si ; Cluster pointer on stack
92 call getfssec
93 cmp word [es:bs_bootsign],0AA55h
94 jne kernel_corrupt ; Boot sec signature missing
96 ;
97 ; Save the cluster pointer for later...
98 ;
99 push si
100 ;
101 ; Get the BIOS' idea of what the size of high memory is.
102 ;
103 call highmemsize
104 ;
105 ; Construct the command line (append options have already been copied)
106 ;
107 construct_cmdline:
108 mov di,[CmdLinePtr]
109 mov si,boot_image ; BOOT_IMAGE=
110 mov cx,boot_image_len
111 rep movsb
112 mov si,KernelCName ; Unmangled kernel name
113 mov cx,[KernelCNameLen]
114 rep movsb
115 mov al,' ' ; Space
116 stosb
118 SPECIAL_APPEND ; Module-specific hook
120 mov si,[CmdOptPtr] ; Options from user input
121 call strcpy
123 ;
124 ; Scan through the command line for anything that looks like we might be
125 ; interested in. The original version of this code automatically assumed
126 ; the first option was BOOT_IMAGE=, but that is no longer certain.
127 ;
128 mov si,cmd_line_here
129 xor ax,ax
130 mov [InitRDPtr],ax ; No initrd= option (yet)
131 push es ; Set DS <- real_mode_seg
132 pop ds
133 get_next_opt: lodsb
134 and al,al
135 jz cmdline_end
136 cmp al,' '
137 jbe get_next_opt
138 dec si
139 mov eax,[si]
140 cmp eax,'vga='
141 je is_vga_cmd
142 cmp eax,'mem='
143 je is_mem_cmd
144 %if IS_PXELINUX
145 cmp eax,'keep' ; Is it "keeppxe"?
146 jne .notkeep
147 cmp dword [si+3],'ppxe'
148 jne .notkeep
149 cmp byte [si+7],' ' ; Must be whitespace or EOS
150 ja .notkeep
151 or byte [cs:KeepPXE],1
152 .notkeep:
153 %endif
154 push es ; Save ES -> real_mode_seg
155 push cs
156 pop es ; Set ES <- normal DS
157 mov di,initrd_cmd
158 mov cx,initrd_cmd_len
159 repe cmpsb
160 jne .not_initrd
162 cmp al,' '
163 jbe .noramdisk
164 mov [cs:InitRDPtr],si
165 jmp .not_initrd
166 .noramdisk:
167 xor ax,ax
168 mov [cs:InitRDPtr],ax
169 .not_initrd: pop es ; Restore ES -> real_mode_seg
170 skip_this_opt: lodsb ; Load from command line
171 cmp al,' '
172 ja skip_this_opt
173 dec si
174 jmp short get_next_opt
175 is_vga_cmd:
176 add si,4
177 mov eax,[si-1]
178 mov bx,-1
179 cmp eax,'=nor' ; vga=normal
180 je vc0
181 dec bx ; bx <- -2
182 cmp eax,'=ext' ; vga=ext
183 je vc0
184 dec bx ; bx <- -3
185 cmp eax,'=ask' ; vga=ask
186 je vc0
187 call parseint ; vga=<number>
188 jc skip_this_opt ; Not an integer
189 vc0: mov [bs_vidmode],bx ; Set video mode
190 jmp short skip_this_opt
191 is_mem_cmd:
192 add si,4
193 call parseint
194 jc skip_this_opt ; Not an integer
195 %if HIGHMEM_SLOP != 0
196 sub ebx,HIGHMEM_SLOP
197 %endif
198 mov [cs:HighMemSize],ebx
199 jmp short skip_this_opt
200 cmdline_end:
201 push cs ; Restore standard DS
202 pop ds
203 sub si,cmd_line_here
204 mov [CmdLineLen],si ; Length including final null
205 ;
206 ; Now check if we have a large kernel, which needs to be loaded high
207 ;
208 mov dword [RamdiskMax], HIGHMEM_MAX ; Default initrd limit
209 cmp dword [es:su_header],HEADER_ID ; New setup code ID
210 jne old_kernel ; Old kernel, load low
211 cmp word [es:su_version],0200h ; Setup code version 2.0
212 jb old_kernel ; Old kernel, load low
213 cmp word [es:su_version],0201h ; Version 2.01+?
214 jb new_kernel ; If 2.00, skip this step
215 mov word [es:su_heapend],linux_stack ; Set up the heap
216 or byte [es:su_loadflags],80h ; Let the kernel know we care
217 cmp word [es:su_version],0203h ; Version 2.03+?
218 jb new_kernel ; Not 2.03+
219 mov eax,[es:su_ramdisk_max]
220 mov [RamdiskMax],eax ; Set the ramdisk limit
222 ;
223 ; We definitely have a new-style kernel. Let the kernel know who we are,
224 ; and that we are clueful
225 ;
226 new_kernel:
227 mov byte [es:su_loader],my_id ; Show some ID
228 movzx ax,byte [es:bs_setupsecs] ; Variable # of setup sectors
229 mov [SetupSecs],ax
230 xor eax,eax
231 mov [es:su_ramdisklen],eax ; No initrd loaded yet
233 ;
234 ; About to load the kernel. This is a modern kernel, so use the boot flags
235 ; we were provided.
236 ;
237 mov al,[es:su_loadflags]
238 mov [LoadFlags],al
239 ;
240 ; Load the kernel. We always load it at 100000h even if we're supposed to
241 ; load it "low"; for a "low" load we copy it down to low memory right before
242 ; jumping to it.
243 ;
244 read_kernel:
245 mov si,KernelCName ; Print kernel name part of
246 call cwritestr ; "Loading" message
247 mov si,dotdot_msg ; Print dots
248 call cwritestr
250 mov eax,[HighMemSize]
251 sub eax,100000h ; Load address
252 cmp eax,[KernelSize]
253 jb no_high_mem ; Not enough high memory
254 ;
255 ; Move the stuff beyond the setup code to high memory at 100000h
256 ;
257 movzx esi,word [SetupSecs] ; Setup sectors
258 inc si ; plus 1 boot sector
259 shl si,9 ; Convert to bytes
260 mov ecx,8000h ; 32K
261 sub ecx,esi ; Number of bytes to copy
262 push ecx
263 add esi,(real_mode_seg << 4) ; Pointer to source
264 mov edi,100000h ; Copy to address 100000h
266 call bcopy ; Transfer to high memory
268 ; On exit EDI -> where to load the rest
270 mov si,dot_msg ; Progress report
271 call cwritestr
272 call abort_check
274 pop ecx ; Number of bytes in the initial portion
275 pop si ; Restore file handle/cluster pointer
276 mov eax,[KernelSize]
277 sub eax,8000h ; Amount of kernel not yet loaded
278 jbe high_load_done ; Zero left (tiny kernel)
280 xor dx,dx ; No padding needed
281 mov bx,dot_pause ; Print dots...
282 call load_high ; Copy the file
284 high_load_done:
285 mov [KernelEnd],edi
286 mov ax,real_mode_seg ; Set to real mode seg
287 mov es,ax
289 mov si,dot_msg
290 call cwritestr
292 ;
293 ; Now see if we have an initial RAMdisk; if so, do requisite computation
294 ; We know we have a new kernel; the old_kernel code already will have objected
295 ; if we tried to load initrd using an old kernel
296 ;
297 load_initrd:
298 cmp word [InitRDPtr],0
299 jz nk_noinitrd
300 call parse_load_initrd
301 nk_noinitrd:
302 ;
303 ; Abandon hope, ye that enter here! We do no longer permit aborts.
304 ;
305 call abort_check ; Last chance!!
307 mov si,ready_msg
308 call cwritestr
310 call vgaclearmode ; We can't trust ourselves after this
312 UNLOAD_PREP ; Module-specific hook
314 ;
315 ; Now, if we were supposed to load "low", copy the kernel down to 10000h
316 ; and the real mode stuff to 90000h. We assume that all bzImage kernels are
317 ; capable of starting their setup from a different address.
318 ;
319 mov ax,real_mode_seg
320 mov fs,ax
322 ;
323 ; Copy command line. Unfortunately, the kernel boot protocol requires
324 ; the command line to exist in the 9xxxxh range even if the rest of the
325 ; setup doesn't.
326 ;
327 cli ; In case of hooked interrupts
328 test byte [LoadFlags],LOAD_HIGH
329 jz need_high_cmdline
330 cmp word [fs:su_version],0202h ; Support new cmdline protocol?
331 jb need_high_cmdline
332 ; New cmdline protocol
333 ; Store 32-bit (flat) pointer to command line
334 mov dword [fs:su_cmd_line_ptr],(real_mode_seg << 4) + cmd_line_here
335 jmp short in_proper_place
337 need_high_cmdline:
338 ;
339 ; Copy command line up to 90000h
340 ;
341 mov ax,9000h ; Note AL <- 0
342 mov es,ax
343 mov si,cmd_line_here
344 mov di,si
345 mov [fs:kern_cmd_magic],word CMD_MAGIC ; Store magic
346 mov [fs:kern_cmd_offset],di ; Store pointer
348 mov cx,[CmdLineLen]
349 cmp cx,255
350 jna .len_ok
351 mov cx,255 ; Protocol < 0x202 has 255 as hard limit
352 .len_ok:
353 fs rep movsb
354 stosb ; Final null, note AL == 0 already
356 push fs
357 pop es
359 test byte [LoadFlags],LOAD_HIGH
360 jnz in_proper_place ; If high load, we're done
362 ;
363 ; Loading low; we can't assume it's safe to run in place.
364 ;
365 ; Copy real_mode stuff up to 90000h
366 ;
367 mov ax,9000h
368 mov es,ax
369 mov cx,[SetupSecs]
370 inc cx ; Setup + boot sector
371 shl cx,7 ; Sectors -> dwords
372 xor si,si
373 xor di,di
374 fs rep movsd ; Copy setup + boot sector
375 ;
376 ; Some kernels in the 1.2 ballpark but pre-bzImage have more than 4
377 ; setup sectors, but the boot protocol had not yet been defined. They
378 ; rely on a signature to figure out if they need to copy stuff from
379 ; the "protected mode" kernel area. Unfortunately, we used that area
380 ; as a transfer buffer, so it's going to find the signature there.
381 ; Hence, zero the low 32K beyond the setup area.
382 ;
383 mov di,[SetupSecs]
384 inc di ; Setup + boot sector
385 mov cx,32768/512 ; Sectors/32K
386 sub cx,di ; Remaining sectors
387 shl di,9 ; Sectors -> bytes
388 shl cx,7 ; Sectors -> dwords
389 xor eax,eax
390 rep stosd ; Clear region
391 ;
392 ; Copy the kernel down to the "low" location
393 ;
394 mov ecx,[KernelSize]
395 mov esi,100000h
396 mov edi,10000h
397 call bcopy
399 ;
400 ; Now everything is where it needs to be...
401 ;
402 ; When we get here, es points to the final segment, either
403 ; 9000h or real_mode_seg
404 ;
405 in_proper_place:
407 ;
408 ; If the default root device is set to FLOPPY (0000h), change to
409 ; /dev/fd0 (0200h)
410 ;
411 cmp word [es:bs_rootdev],byte 0
412 jne root_not_floppy
413 mov word [es:bs_rootdev],0200h
414 root_not_floppy:
416 ;
417 ; Copy the disk table to high memory, then re-initialize the floppy
418 ; controller
419 ;
420 %if IS_SYSLINUX || IS_MDSLINUX
421 lgs si,[cs:fdctab]
422 mov di,linux_fdctab
423 mov cx,6 ; 12 bytes
424 gs rep movsw
425 mov [cs:fdctab],word linux_fdctab ; Save new floppy tab pos
426 mov [cs:fdctab+2],es
427 %endif
428 ;
429 ; Linux wants the floppy motor shut off before starting the kernel,
430 ; at least bootsect.S seems to imply so.
431 ;
432 kill_motor:
433 xor ax,ax
434 xor dx,dx
435 int 13h
437 ;
438 ; If we're debugging, wait for a keypress so we can read any debug messages
439 ;
440 %ifdef debug
441 xor ax,ax
442 int 16h
443 %endif
444 ;
445 ; Set up segment registers and the Linux real-mode stack
446 ; Note: es == the real mode segment
447 ;
448 cli
449 mov bx,es
450 mov ds,bx
451 mov fs,bx
452 mov gs,bx
453 mov ss,bx
454 mov sp,linux_stack
455 ;
456 ; We're done... now RUN THAT KERNEL!!!!
457 ; Setup segment == real mode segment + 020h; we need to jump to offset
458 ; zero in the real mode segment.
459 ;
460 add bx,020h
461 push bx
462 push word 0h
463 retf
465 ;
466 ; Load an older kernel. Older kernels always have 4 setup sectors, can't have
467 ; initrd, and are always loaded low.
468 ;
469 old_kernel:
470 cmp word [InitRDPtr],0 ; Old kernel can't have initrd
471 je load_old_kernel
472 mov si,err_oldkernel
473 jmp abort_load
474 load_old_kernel:
475 mov word [SetupSecs],4 ; Always 4 setup sectors
476 mov byte [LoadFlags],0 ; Always low
477 jmp read_kernel
479 ;
480 ; parse_load_initrd
481 ;
482 ; Parse an initrd= option and load the initrds. Note that we load
483 ; from the high end of memory first, so we parse this option from
484 ; left to right.
485 ;
486 parse_load_initrd:
487 push es
488 push ds
489 mov ax,real_mode_seg
490 mov ds,ax
491 push cs
492 pop es ; DS == real_mode_seg, ES == CS
494 mov si,[cs:InitRDPtr]
495 .find_end:
496 lodsb
497 cmp al,' '
498 ja .find_end
499 ; Now SI points to one character beyond the
500 ; byte that ended this option.
502 .get_chunk:
503 dec si
505 ; DS:SI points to a termination byte
507 xor ax,ax
508 xchg al,[si] ; Zero-terminate
509 push si ; Save ending byte address
510 push ax ; Save ending byte
512 .find_start:
513 dec si
514 cmp si,[cs:InitRDPtr]
515 je .got_start
516 cmp byte [si],','
517 jne .find_start
519 ; It's a comma byte
520 inc si
522 .got_start:
523 push si
524 mov di,InitRD ; Target buffer for mangled name
525 call mangle_name
526 call loadinitrd
527 pop si
529 pop ax
530 pop di
531 mov [di],al ; Restore ending byte
533 cmp si,[cs:InitRDPtr]
534 ja .get_chunk
536 pop ds
537 pop es
538 ret
540 ;
541 ; Load RAM disk into high memory
542 ;
543 ; Input: InitRD - set to the mangled name of the initrd
544 ;
545 loadinitrd:
546 push ds
547 push es
548 mov ax,cs ; CS == DS == ES
549 mov ds,ax
550 mov es,ax
551 mov si,InitRD
552 mov di,InitRDCName
553 call unmangle_name ; Create human-readable name
554 sub di,InitRDCName
555 mov [InitRDCNameLen],di
556 mov di,InitRD
557 call searchdir ; Look for it in directory
558 jz .notthere
560 mov cx,dx
561 shl ecx,16
562 mov cx,ax ; ECX <- ram disk length
564 mov ax,real_mode_seg
565 mov es,ax
567 push ecx ; Bytes to load
568 cmp dword [es:su_ramdisklen],0
569 je .nopadding ; Don't pad the last initrd
570 add ecx,4095
571 and cx,0F000h
572 .nopadding:
573 add [es:su_ramdisklen],ecx
574 mov edx,[HighMemSize] ; End of memory
575 dec edx
576 mov eax,[RamdiskMax] ; Highest address allowed by kernel
577 cmp edx,eax
578 jna .memsize_ok
579 mov edx,eax ; Adjust to fit inside limit
580 .memsize_ok:
581 inc edx
582 and dx,0F000h ; Round down to 4K boundary
583 sub edx,ecx ; Subtract size of ramdisk
584 and dx,0F000h ; Round down to 4K boundary
585 cmp edx,[KernelEnd] ; Are we hitting the kernel image?
586 jb no_high_mem
588 mov [es:su_ramdiskat],edx ; Load address
589 mov [RamdiskMax],edx ; Next initrd loaded here
591 mov edi,edx ; initrd load address
592 push si
593 mov si,crlfloading_msg ; Write "Loading "
594 call cwritestr
595 mov si,InitRDCName ; Write ramdisk name
596 call cwritestr
597 mov si,dotdot_msg ; Write dots
598 call cwritestr
599 pop si
601 pop eax ; Bytes to load
602 mov dx,0FFFh ; Pad to page
603 mov bx,dot_pause ; Print dots...
604 call load_high ; Load the file
606 pop es
607 pop ds
608 jmp crlf ; Print carriage return and return
610 .notthere:
611 mov si,err_noinitrd
612 call cwritestr
613 mov si,InitRDCName
614 call cwritestr
615 mov si,crlf_msg
616 jmp abort_load
618 no_high_mem: ; Error routine
619 mov si,err_nohighmem
620 jmp abort_load
622 ret
624 section .data
625 boot_image db 'BOOT_IMAGE='
626 boot_image_len equ $-boot_image
628 section .bss
629 alignb 4
630 RamdiskMax resd 1 ; Highest address for ramdisk
631 KernelSize resd 1 ; Size of kernel in bytes
632 KernelSects resd 1 ; Size of kernel in sectors
633 KernelEnd resd 1 ; Ending address of the kernel image
634 CmdLineLen resw 1 ; Length of command line including null
635 SetupSecs resw 1 ; Number of setup sectors
636 InitRDPtr resw 1 ; Pointer to initrd= option in command line
637 LoadFlags resb 1 ; Loadflags from kernel