?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Include file updates
[syslinux.git] / extlinux.asm
blob7ddc278a3910e30afd2ba82f58e128d821766739
1 ; -*- fundamental -*- (asm-mode sucks)
2 ; ****************************************************************************
3 ;
4 ; extlinux.asm
5 ;
6 ; A program to boot Linux kernels off an ext2/ext3 filesystem.
7 ;
8 ; Copyright (C) 1994-2006 H. Peter Anvin
9 ;
10 ; This program is free software; you can redistribute it and/or modify
11 ; it under the terms of the GNU General Public License as published by
12 ; the Free Software Foundation, Inc., 53 Temple Place Ste 330,
13 ; Boston MA 02111-1307, USA; either version 2 of the License, or
14 ; (at your option) any later version; incorporated herein by reference.
15 ;
16 ; ****************************************************************************
17
18 %define IS_EXTLINUX 1
19 %include "head.inc"
20 %include "ext2_fs.inc"
21
22 ;
23 ; Some semi-configurable constants... change on your own risk.
24 ;
25 my_id equ extlinux_id
26 ; NASM 0.98.38 croaks if these are equ's rather than macros...
27 FILENAME_MAX_LG2 equ 8 ; log2(Max filename size Including final null)
28 FILENAME_MAX equ (1 << FILENAME_MAX_LG2) ; Max mangled filename size
29 NULLFILE equ 0 ; Null character == empty filename
30 NULLOFFSET equ 0 ; Position in which to look
31 retry_count equ 16 ; How patient are we with the disk?
32 %assign HIGHMEM_SLOP 0 ; Avoid this much memory near the top
33 LDLINUX_MAGIC equ 0x3eb202fe ; A random number to identify ourselves with
34
35 MAX_OPEN_LG2 equ 6 ; log2(Max number of open files)
36 MAX_OPEN equ (1 << MAX_OPEN_LG2)
37
38 SECTOR_SHIFT equ 9
39 SECTOR_SIZE equ (1 << SECTOR_SHIFT)
40
41 MAX_SYMLINKS equ 64 ; Maximum number of symlinks per lookup
42 SYMLINK_SECTORS equ 2 ; Max number of sectors in a symlink
43 ; (should be >= FILENAME_MAX)
44
45 ;
46 ; This is what we need to do when idle
47 ;
48 %macro RESET_IDLE 0
49 ; Nothing
50 %endmacro
51 %macro DO_IDLE 0
52 ; Nothing
53 %endmacro
54
55 ;
56 ; The following structure is used for "virtual kernels"; i.e. LILO-style
57 ; option labels. The options we permit here are `kernel' and `append
58 ; Since there is no room in the bottom 64K for all of these, we
59 ; stick them at vk_seg:0000 and copy them down before we need them.
60 ;
61 struc vkernel
62 vk_vname: resb FILENAME_MAX ; Virtual name **MUST BE FIRST!**
63 vk_rname: resb FILENAME_MAX ; Real name
64 vk_appendlen: resw 1
65 alignb 4
66 vk_append: resb max_cmd_len+1 ; Command line
67 alignb 4
68 vk_end: equ $ ; Should be <= vk_size
69 endstruc
70
71 ;
72 ; Segment assignments in the bottom 640K
73 ; Stick to the low 512K in case we're using something like M-systems flash
74 ; which load a driver into low RAM (evil!!)
75 ;
76 ; 0000h - main code/data segment (and BIOS segment)
77 ;
78 real_mode_seg equ 4000h
79 cache_seg equ 3000h ; 64K area for metadata cache
80 vk_seg equ 2000h ; Virtual kernels
81 xfer_buf_seg equ 1000h ; Bounce buffer for I/O to high mem
82 comboot_seg equ real_mode_seg ; COMBOOT image loading zone
83
84 ;
85 ; File structure. This holds the information for each currently open file.
86 ;
87 struc open_file_t
88 file_left resd 1 ; Number of sectors left (0 = free)
89 file_sector resd 1 ; Next linear sector to read
90 file_in_sec resd 1 ; Sector where inode lives
91 file_in_off resw 1
92 file_mode resw 1
93 endstruc
94
95 %ifndef DEPEND
96 %if (open_file_t_size & (open_file_t_size-1))
97 %error "open_file_t is not a power of 2"
98 %endif
99 %endif
100
101 ; ---------------------------------------------------------------------------
102 ; BEGIN CODE
103 ; ---------------------------------------------------------------------------
104
105 ;
106 ; Memory below this point is reserved for the BIOS and the MBR
107 ;
108 section .earlybss
109 trackbufsize equ 8192
110 trackbuf resb trackbufsize ; Track buffer goes here
111 getcbuf resb trackbufsize
112 ; ends at 4800h
113
114 section .latebss
115 SuperBlock resb 1024 ; ext2 superblock
116 SuperInfo resq 16 ; DOS superblock expanded
117 ClustSize resd 1 ; Bytes/cluster ("block")
118 SecPerClust resd 1 ; Sectors/cluster
119 ClustMask resd 1 ; Sectors/cluster - 1
120 PtrsPerBlock1 resd 1 ; Pointers/cluster
121 PtrsPerBlock2 resd 1 ; (Pointers/cluster)^2
122 DriveNumber resb 1 ; BIOS drive number
123 ClustShift resb 1 ; Shift count for sectors/cluster
124 ClustByteShift resb 1 ; Shift count for bytes/cluster
125
126 alignb open_file_t_size
127 Files resb MAX_OPEN*open_file_t_size
128
129 ;
130 ; Constants for the xfer_buf_seg
131 ;
132 ; The xfer_buf_seg is also used to store message file buffers. We
133 ; need two trackbuffers (text and graphics), plus a work buffer
134 ; for the graphics decompressor.
135 ;
136 xbs_textbuf equ 0 ; Also hard-coded, do not change
137 xbs_vgabuf equ trackbufsize
138 xbs_vgatmpbuf equ 2*trackbufsize
139
140
141 section .text
142 ;
143 ; Some of the things that have to be saved very early are saved
144 ; "close" to the initial stack pointer offset, in order to
145 ; reduce the code size...
146 ;
147 StackBuf equ $-44-32 ; Start the stack here (grow down - 4K)
148 PartInfo equ StackBuf ; Saved partition table entry
149 FloppyTable equ PartInfo+16 ; Floppy info table (must follow PartInfo)
150 OrigFDCTabPtr equ StackBuf-4 ; The high dword on the stack
151
152 ;
153 ; Primary entry point. Tempting as though it may be, we can't put the
154 ; initial "cli" here; the jmp opcode in the first byte is part of the
155 ; "magic number" (using the term very loosely) for the DOS superblock.
156 ;
157 bootsec equ $
158 jmp short start ; 2 bytes
159 nop ; 1 byte
160 ;
161 ; "Superblock" follows -- it's in the boot sector, so it's already
162 ; loaded and ready for us
163 ;
164 bsOemName db 'EXTLINUX' ; The SYS command sets this, so...
165 ;
166 ; These are the fields we actually care about. We end up expanding them
167 ; all to dword size early in the code, so generate labels for both
168 ; the expanded and unexpanded versions.
169 ;
170 %macro superb 1
171 bx %+ %1 equ SuperInfo+($-superblock)*8+4
172 bs %+ %1 equ $
173 zb 1
174 %endmacro
175 %macro superw 1
176 bx %+ %1 equ SuperInfo+($-superblock)*8
177 bs %+ %1 equ $
178 zw 1
179 %endmacro
180 %macro superd 1
181 bx %+ %1 equ $ ; no expansion for dwords
182 bs %+ %1 equ $
183 zd 1
184 %endmacro
185 superblock equ $
186 superw BytesPerSec
187 superb SecPerClust
188 superw ResSectors
189 superb FATs
190 superw RootDirEnts
191 superw Sectors
192 superb Media
193 superw FATsecs
194 superw SecPerTrack
195 superw Heads
196 superinfo_size equ ($-superblock)-1 ; How much to expand
197 superd Hidden
198 superd HugeSectors
199 ;
200 ; This is as far as FAT12/16 and FAT32 are consistent
201 ;
202 zb 54 ; FAT12/16 need 26 more bytes,
203 ; FAT32 need 54 more bytes
204 superblock_len equ $-superblock
205
206 ;
207 ; Note we don't check the constraints above now; we did that at install
208 ; time (we hope!)
209 ;
210 start:
211 cli ; No interrupts yet, please
212 cld ; Copy upwards
213 ;
214 ; Set up the stack
215 ;
216 xor ax,ax
217 mov ss,ax
218 mov sp,StackBuf ; Just below BSS
219 mov es,ax
220 ;
221 ; DS:SI may contain a partition table entry. Preserve it for us.
222 ;
223 mov cx,8 ; Save partition info
224 mov di,sp
225 rep movsw
226
227 mov ds,ax ; Now we can initialize DS...
228
229 ;
230 ; Now sautee the BIOS floppy info block to that it will support decent-
231 ; size transfers; the floppy block is 11 bytes and is stored in the
232 ; INT 1Eh vector (brilliant waste of resources, eh?)
233 ;
234 ; Of course, if BIOSes had been properly programmed, we wouldn't have
235 ; had to waste precious space with this code.
236 ;
237 mov bx,fdctab
238 lfs si,[bx] ; FS:SI -> original fdctab
239 push fs ; Save on stack in case we need to bail
240 push si
241
242 ; Save the old fdctab even if hard disk so the stack layout
243 ; is the same. The instructions above do not change the flags
244 mov [DriveNumber],dl ; Save drive number in DL
245 and dl,dl ; If floppy disk (00-7F), assume no
246 ; partition table
247 js harddisk
248
249 floppy:
250 mov cl,6 ; 12 bytes (CX == 0)
251 ; es:di -> FloppyTable already
252 ; This should be safe to do now, interrupts are off...
253 mov [bx],di ; FloppyTable
254 mov [bx+2],ax ; Segment 0
255 fs rep movsw ; Faster to move words
256 mov cl,[bsSecPerTrack] ; Patch the sector count
257 mov [di-8],cl
258 ; AX == 0 here
259 int 13h ; Some BIOSes need this
260
261 jmp short not_harddisk
262 ;
263 ; The drive number and possibly partition information was passed to us
264 ; by the BIOS or previous boot loader (MBR). Current "best practice" is to
265 ; trust that rather than what the superblock contains.
266 ;
267 ; Would it be better to zero out bsHidden if we don't have a partition table?
268 ;
269 ; Note: di points to beyond the end of PartInfo
270 ;
271 harddisk:
272 test byte [di-16],7Fh ; Sanity check: "active flag" should
273 jnz no_partition ; be 00 or 80
274 mov eax,[di-8] ; Partition offset (dword)
275 mov [bsHidden],eax
276 no_partition:
277 ;
278 ; Get disk drive parameters (don't trust the superblock.) Don't do this for
279 ; floppy drives -- INT 13:08 on floppy drives will (may?) return info about
280 ; what the *drive* supports, not about the *media*. Fortunately floppy disks
281 ; tend to have a fixed, well-defined geometry which is stored in the superblock.
282 ;
283 ; DL == drive # still
284 mov ah,08h
285 int 13h
286 jc no_driveparm
287 and ah,ah
288 jnz no_driveparm
289 shr dx,8
290 inc dx ; Contains # of heads - 1
291 mov [bsHeads],dx
292 and cx,3fh
293 mov [bsSecPerTrack],cx
294 no_driveparm:
295 not_harddisk:
296 ;
297 ; Ready to enable interrupts, captain
298 ;
299 sti
300
301 ;
302 ; Do we have EBIOS (EDD)?
303 ;
304 eddcheck:
305 mov bx,55AAh
306 mov ah,41h ; EDD existence query
307 mov dl,[DriveNumber]
308 int 13h
309 jc .noedd
310 cmp bx,0AA55h
311 jne .noedd
312 test cl,1 ; Extended disk access functionality set
313 jz .noedd
314 ;
315 ; We have EDD support...
316 ;
317 mov byte [getlinsec.jmp+1],(getlinsec_ebios-(getlinsec.jmp+2))
318 .noedd:
319
320 ;
321 ; Load the first sector of LDLINUX.SYS; this used to be all proper
322 ; with parsing the superblock and root directory; it doesn't fit
323 ; together with EBIOS support, unfortunately.
324 ;
325 mov eax,[FirstSector] ; Sector start
326 mov bx,ldlinux_sys ; Where to load it
327 call getonesec
328
329 ; Some modicum of integrity checking
330 cmp dword [ldlinux_magic+4],LDLINUX_MAGIC^HEXDATE
331 jne kaboom
332
333 ; Go for it...
334 jmp ldlinux_ent
335
336 ;
337 ; getonesec: get one disk sector
338 ;
339 getonesec:
340 mov bp,1 ; One sector
341 ; Fall through
342
343 ;
344 ; getlinsec: load a sequence of BP floppy sector given by the linear sector
345 ; number in EAX into the buffer at ES:BX. We try to optimize
346 ; by loading up to a whole track at a time, but the user
347 ; is responsible for not crossing a 64K boundary.
348 ; (Yes, BP is weird for a count, but it was available...)
349 ;
350 ; On return, BX points to the first byte after the transferred
351 ; block.
352 ;
353 ; This routine assumes CS == DS, and trashes most registers.
354 ;
355 ; Stylistic note: use "xchg" instead of "mov" when the source is a register
356 ; that is dead from that point; this saves space. However, please keep
357 ; the order to dst,src to keep things sane.
358 ;
359 getlinsec:
360 add eax,[bsHidden] ; Add partition offset
361 xor edx,edx ; Zero-extend LBA (eventually allow 64 bits)
362
363 .jmp: jmp strict short getlinsec_cbios
364
365 ;
366 ; getlinsec_ebios:
367 ;
368 ; getlinsec implementation for EBIOS (EDD)
369 ;
370 getlinsec_ebios:
371 .loop:
372 push bp ; Sectors left
373 .retry2:
374 call maxtrans ; Enforce maximum transfer size
375 movzx edi,bp ; Sectors we are about to read
376 mov cx,retry_count
377 .retry:
378
379 ; Form DAPA on stack
380 push edx
381 push eax
382 push es
383 push bx
384 push di
385 push word 16
386 mov si,sp
387 pushad
388 mov dl,[DriveNumber]
389 push ds
390 push ss
391 pop ds ; DS <- SS
392 mov ah,42h ; Extended Read
393 int 13h
394 pop ds
395 popad
396 lea sp,[si+16] ; Remove DAPA
397 jc .error
398 pop bp
399 add eax,edi ; Advance sector pointer
400 sub bp,di ; Sectors left
401 shl di,SECTOR_SHIFT ; 512-byte sectors
402 add bx,di ; Advance buffer pointer
403 and bp,bp
404 jnz .loop
405
406 ret
407
408 .error:
409 ; Some systems seem to get "stuck" in an error state when
410 ; using EBIOS. Doesn't happen when using CBIOS, which is
411 ; good, since some other systems get timeout failures
412 ; waiting for the floppy disk to spin up.
413
414 pushad ; Try resetting the device
415 xor ax,ax
416 mov dl,[DriveNumber]
417 int 13h
418 popad
419 loop .retry ; CX-- and jump if not zero
420
421 ;shr word [MaxTransfer],1 ; Reduce the transfer size
422 ;jnz .retry2
423
424 ; Total failure. Try falling back to CBIOS.
425 mov byte [getlinsec.jmp+1],(getlinsec_cbios-(getlinsec.jmp+2))
426 ;mov byte [MaxTransfer],63 ; Max possibe CBIOS transfer
427
428 pop bp
429 ; ... fall through ...
430
431 ;
432 ; getlinsec_cbios:
433 ;
434 ; getlinsec implementation for legacy CBIOS
435 ;
436 getlinsec_cbios:
437 .loop:
438 push edx
439 push eax
440 push bp
441 push bx
442
443 movzx esi,word [bsSecPerTrack]
444 movzx edi,word [bsHeads]
445 ;
446 ; Dividing by sectors to get (track,sector): we may have
447 ; up to 2^18 tracks, so we need to use 32-bit arithmetric.
448 ;
449 div esi
450 xor cx,cx
451 xchg cx,dx ; CX <- sector index (0-based)
452 ; EDX <- 0
453 ; eax = track #
454 div edi ; Convert track to head/cyl
455
456 ; We should test this, but it doesn't fit...
457 ; cmp eax,1023
458 ; ja .error
459
460 ;
461 ; Now we have AX = cyl, DX = head, CX = sector (0-based),
462 ; BP = sectors to transfer, SI = bsSecPerTrack,
463 ; ES:BX = data target
464 ;
465
466 call maxtrans ; Enforce maximum transfer size
467
468 ; Must not cross track boundaries, so BP <= SI-CX
469 sub si,cx
470 cmp bp,si
471 jna .bp_ok
472 mov bp,si
473 .bp_ok:
474
475 shl ah,6 ; Because IBM was STOOPID
476 ; and thought 8 bits were enough
477 ; then thought 10 bits were enough...
478 inc cx ; Sector numbers are 1-based, sigh
479 or cl,ah
480 mov ch,al
481 mov dh,dl
482 mov dl,[DriveNumber]
483 xchg ax,bp ; Sector to transfer count
484 mov ah,02h ; Read sectors
485 mov bp,retry_count
486 .retry:
487 pushad
488 int 13h
489 popad
490 jc .error
491 .resume:
492 movzx ecx,al ; ECX <- sectors transferred
493 shl ax,SECTOR_SHIFT ; Convert sectors in AL to bytes in AX
494 pop bx
495 add bx,ax
496 pop bp
497 pop eax
498 pop edx
499 add eax,ecx
500 sub bp,cx
501 jnz .loop
502 ret
503
504 .error:
505 dec bp
506 jnz .retry
507
508 xchg ax,bp ; Sectors transferred <- 0
509 shr word [MaxTransfer],1
510 jnz .resume
511 ; Fall through to disk_error
512
513 ;
514 ; kaboom: write a message and bail out.
515 ;
516 disk_error:
517 kaboom:
518 xor si,si
519 mov ss,si
520 mov sp,StackBuf-4 ; Reset stack
521 mov ds,si ; Reset data segment
522 pop dword [fdctab] ; Restore FDC table
523 .patch: ; When we have full code, intercept here
524 mov si,bailmsg
525
526 ; Write error message, this assumes screen page 0
527 .loop: lodsb
528 and al,al
529 jz .done
530 mov ah,0Eh ; Write to screen as TTY
531 mov bx,0007h ; Attribute
532 int 10h
533 jmp short .loop
534 .done:
535 cbw ; AH <- 0
536 int 16h ; Wait for keypress
537 int 19h ; And try once more to boot...
538 .norge: jmp short .norge ; If int 19h returned; this is the end
539
540 ;
541 ; Truncate BP to MaxTransfer
542 ;
543 maxtrans:
544 cmp bp,[MaxTransfer]
545 jna .ok
546 mov bp,[MaxTransfer]
547 .ok: ret
548
549 ;
550 ; Error message on failure
551 ;
552 bailmsg: db 'Boot error', 0Dh, 0Ah, 0
553
554 ; This fails if the boot sector overflows
555 zb 1F8h-($-$$)
556
557 FirstSector dd 0xDEADBEEF ; Location of sector 1
558 MaxTransfer dw 0x007F ; Max transfer size
559 bootsignature dw 0AA55h
560
561 ;
562 ; ===========================================================================
563 ; End of boot sector
564 ; ===========================================================================
565 ; Start of LDLINUX.SYS
566 ; ===========================================================================
567
568 ldlinux_sys:
569
570 syslinux_banner db 0Dh, 0Ah
571 db 'EXTLINUX '
572 db version_str, ' ', date, ' ', 0
573 db 0Dh, 0Ah, 1Ah ; EOF if we "type" this in DOS
574
575 align 8, db 0
576 ldlinux_magic dd LDLINUX_MAGIC
577 dd LDLINUX_MAGIC^HEXDATE
578
579 ;
580 ; This area is patched by the installer. It is found by looking for
581 ; LDLINUX_MAGIC, plus 8 bytes.
582 ;
583 patch_area:
584 LDLDwords dw 0 ; Total dwords starting at ldlinux_sys
585 LDLSectors dw 0 ; Number of sectors - (bootsec+this sec)
586 CheckSum dd 0 ; Checksum starting at ldlinux_sys
587 ; value = LDLINUX_MAGIC - [sum of dwords]
588 CurrentDir dd 2 ; "Current" directory inode number
589
590 ; Space for up to 64 sectors, the theoretical maximum
591 SectorPtrs times 64 dd 0
592
593 ldlinux_ent:
594 ;
595 ; Note that some BIOSes are buggy and run the boot sector at 07C0:0000
596 ; instead of 0000:7C00 and the like. We don't want to add anything
597 ; more to the boot sector, so it is written to not assume a fixed
598 ; value in CS, but we don't want to deal with that anymore from now
599 ; on.
600 ;
601 jmp 0:.next
602 .next:
603
604 ;
605 ; Tell the user we got this far
606 ;
607 mov si,syslinux_banner
608 call writestr
609
610 ;
611 ; Tell the user if we're using EBIOS or CBIOS
612 ;
613 print_bios:
614 mov si,cbios_name
615 cmp byte [getlinsec.jmp+1],(getlinsec_ebios-(getlinsec.jmp+2))
616 jne .cbios
617 mov si,ebios_name
618 .cbios:
619 mov [BIOSName],si
620 call writestr
621
622 section .bss
623 %define HAVE_BIOSNAME 1
624 BIOSName resw 1
625
626 section .text
627 ;
628 ; Now we read the rest of LDLINUX.SYS. Don't bother loading the first
629 ; sector again, though.
630 ;
631 load_rest:
632 mov si,SectorPtrs
633 mov bx,7C00h+2*SECTOR_SIZE ; Where we start loading
634 mov cx,[LDLSectors]
635
636 .get_chunk:
637 jcxz .done
638 xor bp,bp
639 lodsd ; First sector of this chunk
640
641 mov edx,eax
642
643 .make_chunk:
644 inc bp
645 dec cx
646 jz .chunk_ready
647 inc edx ; Next linear sector
648 cmp [si],edx ; Does it match
649 jnz .chunk_ready ; If not, this is it
650 add si,4 ; If so, add sector to chunk
651 jmp short .make_chunk
652
653 .chunk_ready:
654 call getlinsecsr
655 shl bp,SECTOR_SHIFT
656 add bx,bp
657 jmp .get_chunk
658
659 .done:
660
661 ;
662 ; All loaded up, verify that we got what we needed.
663 ; Note: the checksum field is embedded in the checksum region, so
664 ; by the time we get to the end it should all cancel out.
665 ;
666 verify_checksum:
667 mov si,ldlinux_sys
668 mov cx,[LDLDwords]
669 mov edx,-LDLINUX_MAGIC
670 .checksum:
671 lodsd
672 add edx,eax
673 loop .checksum
674
675 and edx,edx ; Should be zero
676 jz all_read ; We're cool, go for it!
677
678 ;
679 ; Uh-oh, something went bad...
680 ;
681 mov si,checksumerr_msg
682 call writestr
683 jmp kaboom
684
685 ;
686 ; -----------------------------------------------------------------------------
687 ; Subroutines that have to be in the first sector
688 ; -----------------------------------------------------------------------------
689
690 ;
691 ;
692 ; writestr: write a null-terminated string to the console
693 ; This assumes we're on page 0. This is only used for early
694 ; messages, so it should be OK.
695 ;
696 writestr:
697 .loop: lodsb
698 and al,al
699 jz .return
700 mov ah,0Eh ; Write to screen as TTY
701 mov bx,0007h ; Attribute
702 int 10h
703 jmp short .loop
704 .return: ret
705
706
707 ; getlinsecsr: save registers, call getlinsec, restore registers
708 ;
709 getlinsecsr: pushad
710 call getlinsec
711 popad
712 ret
713
714 ;
715 ; Checksum error message
716 ;
717 checksumerr_msg db ' Load error - ', 0 ; Boot failed appended
718
719 ;
720 ; BIOS type string
721 ;
722 cbios_name db 'CBIOS', 0
723 ebios_name db 'EBIOS', 0
724
725 ;
726 ; Debug routine
727 ;
728 %ifdef debug
729 safedumpregs:
730 cmp word [Debug_Magic],0D00Dh
731 jnz nc_return
732 jmp dumpregs
733 %endif
734
735 rl_checkpt equ $ ; Must be <= 8000h
736
737 rl_checkpt_off equ ($-$$)
738 %ifndef DEPEND
739 %if rl_checkpt_off > 400h
740 %error "Sector 1 overflow"
741 %endif
742 %endif
743
744 ; ----------------------------------------------------------------------------
745 ; End of code and data that have to be in the first sector
746 ; ----------------------------------------------------------------------------
747
748 all_read:
749 ;
750 ; Let the user (and programmer!) know we got this far. This used to be
751 ; in Sector 1, but makes a lot more sense here.
752 ;
753 mov si,copyright_str
754 call writestr
755
756 ;
757 ; Insane hack to expand the DOS superblock to dwords
758 ;
759 expand_super:
760 xor eax,eax
761 mov si,superblock
762 mov di,SuperInfo
763 mov cx,superinfo_size
764 .loop:
765 lodsw
766 dec si
767 stosd ; Store expanded word
768 xor ah,ah
769 stosd ; Store expanded byte
770 loop .loop
771
772 ;
773 ; Load the real (ext2) superblock; 1024 bytes long at offset 1024
774 ;
775 mov bx,SuperBlock
776 mov eax,1024 >> SECTOR_SHIFT
777 mov bp,ax
778 call getlinsec
779
780 ;
781 ; Compute some values...
782 ;
783 xor edx,edx
784 inc edx
785
786 ; s_log_block_size = log2(blocksize) - 10
787 mov cl,[SuperBlock+s_log_block_size]
788 add cl,10
789 mov [ClustByteShift],cl
790 mov eax,edx
791 shl eax,cl
792 mov [ClustSize],eax
793
794 sub cl,SECTOR_SHIFT
795 mov [ClustShift],cl
796 shr eax,SECTOR_SHIFT
797 mov [SecPerClust],eax
798 dec eax
799 mov [ClustMask],eax
800
801 add cl,SECTOR_SHIFT-2 ; 4 bytes/pointer
802 shl edx,cl
803 mov [PtrsPerBlock1],edx
804 shl edx,cl
805 mov [PtrsPerBlock2],edx
806
807 ;
808 ; Common initialization code
809 ;
810 %include "init.inc"
811 %include "cpuinit.inc"
812
813 ;
814 ; Initialize the metadata cache
815 ;
816 call initcache
817
818 ;
819 ; Now, everything is "up and running"... patch kaboom for more
820 ; verbosity and using the full screen system
821 ;
822 ; E9 = JMP NEAR
823 mov dword [kaboom.patch],0e9h+((kaboom2-(kaboom.patch+3)) << 8)
824
825 ;
826 ; Now we're all set to start with our *real* business. First load the
827 ; configuration file (if any) and parse it.
828 ;
829 ; In previous versions I avoided using 32-bit registers because of a
830 ; rumour some BIOSes clobbered the upper half of 32-bit registers at
831 ; random. I figure, though, that if there are any of those still left
832 ; they probably won't be trying to install Linux on them...
833 ;
834 ; The code is still ripe with 16-bitisms, though. Not worth the hassle
835 ; to take'm out. In fact, we may want to put them back if we're going
836 ; to boot ELKS at some point.
837 ;
838
839 ;
840 ; Load configuration file
841 ;
842 load_config:
843 mov di,ConfigName
844 call open
845 jz no_config_file
846
847 ;
848 ; Now we have the config file open. Parse the config file and
849 ; run the user interface.
850 ;
851 %include "ui.inc"
852
853 ;
854 ; Linux kernel loading code is common.
855 ;
856 %include "runkernel.inc"
857
858 ;
859 ; COMBOOT-loading code
860 ;
861 %include "comboot.inc"
862 %include "com32.inc"
863 %include "cmdline.inc"
864
865 ;
866 ; Boot sector loading code
867 ;
868 %include "bootsect.inc"
869
870
871 ;
872 ; getlinsec_ext: same as getlinsec, except load any sector from the zero
873 ; block as all zeros; use to load any data derived
874 ; from an ext2 block pointer, i.e. anything *except the
875 ; superblock.*
876 ;
877 getonesec_ext:
878 mov bp,1
879
880 getlinsec_ext:
881 cmp eax,[SecPerClust]
882 jae getlinsec ; Nothing fancy
883
884 ; If we get here, at least part of what we want is in the
885 ; zero block. Zero one sector at a time and loop.
886 push eax
887 push cx
888 xchg di,bx
889 xor eax,eax
890 mov cx,SECTOR_SIZE >> 2
891 rep stosd
892 xchg di,bx
893 pop cx
894 pop eax
895 inc eax
896 dec bp
897 jnz getlinsec_ext
898 ret
899
900 ;
901 ; Abort loading code
902 ;
903 %include "abort.inc"
904
905 ;
906 ; allocate_file: Allocate a file structure
907 ;
908 ; If successful:
909 ; ZF set
910 ; BX = file pointer
911 ; In unsuccessful:
912 ; ZF clear
913 ;
914 allocate_file:
915 TRACER 'a'
916 push cx
917 mov bx,Files
918 mov cx,MAX_OPEN
919 .check: cmp dword [bx], byte 0
920 je .found
921 add bx,open_file_t_size ; ZF = 0
922 loop .check
923 ; ZF = 0 if we fell out of the loop
924 .found: pop cx
925 ret
926 ;
927 ; open_inode:
928 ; Open a file indicated by an inode number in EAX
929 ;
930 ; NOTE: This file considers finding a zero-length file an
931 ; error. This is so we don't have to deal with that special
932 ; case elsewhere in the program (most loops have the test
933 ; at the end).
934 ;
935 ; If successful:
936 ; ZF clear
937 ; SI = file pointer
938 ; DX:AX = EAX = file length in bytes
939 ; ThisInode = the first 128 bytes of the inode
940 ; If unsuccessful
941 ; ZF set
942 ;
943 ; Assumes CS == DS == ES.
944 ;
945 open_inode.allocate_failure:
946 xor eax,eax
947 pop bx
948 pop di
949 ret
950
951 open_inode:
952 push di
953 push bx
954 call allocate_file
955 jnz .allocate_failure
956
957 push cx
958 push gs
959 ; First, get the appropriate inode group and index
960 dec eax ; There is no inode 0
961 xor edx,edx
962 mov [bx+file_sector],edx
963 div dword [SuperBlock+s_inodes_per_group]
964 ; EAX = inode group; EDX = inode within group
965 push edx
966
967 ; Now, we need the block group descriptor.
968 ; To get that, we first need the relevant descriptor block.
969
970 shl eax, ext2_group_desc_lg2size ; Get byte offset in desc table
971 xor edx,edx
972 div dword [ClustSize]
973 ; eax = block #, edx = offset in block
974 add eax,dword [SuperBlock+s_first_data_block]
975 inc eax ; s_first_data_block+1
976 mov cl,[ClustShift]
977 shl eax,cl
978 push edx
979 shr edx,SECTOR_SHIFT
980 add eax,edx
981 pop edx
982 and dx,SECTOR_SIZE-1
983 call getcachesector ; Get the group descriptor
984 add si,dx
985 mov esi,[gs:si+bg_inode_table] ; Get inode table block #
986 pop eax ; Get inode within group
987 movzx edx, word [SuperBlock+s_inode_size]
988 mul edx
989 ; edx:eax = byte offset in inode table
990 div dword [ClustSize]
991 ; eax = block # versus inode table, edx = offset in block
992 add eax,esi
993 shl eax,cl ; Turn into sector
994 push dx
995 shr edx,SECTOR_SHIFT
996 add eax,edx
997 mov [bx+file_in_sec],eax
998 pop dx
999 and dx,SECTOR_SIZE-1
1000 mov [bx+file_in_off],dx
1001
1002 call getcachesector
1003 add si,dx
1004 mov cx,EXT2_GOOD_OLD_INODE_SIZE >> 2
1005 mov di,ThisInode
1006 gs rep movsd
1007
1008 mov ax,[ThisInode+i_mode]
1009 mov [bx+file_mode],ax
1010 mov eax,[ThisInode+i_size]
1011 push eax
1012 add eax,SECTOR_SIZE-1
1013 shr eax,SECTOR_SHIFT
1014 mov [bx+file_left],eax
1015 pop eax
1016 mov si,bx
1017 mov edx,eax
1018 shr edx,16 ; 16-bitism, sigh
1019 and eax,eax ; ZF clear unless zero-length file
1020 pop gs
1021 pop cx
1022 pop bx
1023 pop di
1024 ret
1025
1026 section .latebss
1027 alignb 4
1028 ThisInode resb EXT2_GOOD_OLD_INODE_SIZE ; The most recently opened inode
1029
1030 section .text
1031 ;
1032 ; close:
1033 ; Deallocates a file structure (pointer in SI)
1034 ; Assumes CS == DS.
1035 ;
1036 close:
1037 mov dword [si],0 ; First dword == file_left
1038 ret
1039
1040 ;
1041 ; searchdir:
1042 ; Search the root directory for a pre-mangled filename in DS:DI.
1043 ;
1044 ; NOTE: This file considers finding a zero-length file an
1045 ; error. This is so we don't have to deal with that special
1046 ; case elsewhere in the program (most loops have the test
1047 ; at the end).
1048 ;
1049 ; If successful:
1050 ; ZF clear
1051 ; SI = file pointer
1052 ; DX:AX = EAX = file length in bytes
1053 ; If unsuccessful
1054 ; ZF set
1055 ;
1056 ; Assumes CS == DS == ES; *** IS THIS CORRECT ***?
1057 ;
1058 searchdir:
1059 push bx
1060 push cx
1061 push bp
1062 mov byte [SymlinkCtr],MAX_SYMLINKS
1063
1064 mov eax,[CurrentDir]
1065 .begin_path:
1066 .leadingslash:
1067 cmp byte [di],'/' ; Absolute filename?
1068 jne .gotdir
1069 mov eax,EXT2_ROOT_INO
1070 inc di ; Skip slash
1071 jmp .leadingslash
1072 .gotdir:
1073
1074 ; At this point, EAX contains the directory inode,
1075 ; and DS:DI contains a pathname tail.
1076 .open:
1077 push eax ; Save directory inode
1078
1079 call open_inode
1080 jz .done ; If error, done
1081
1082 mov cx,[si+file_mode]
1083 shr cx,S_IFSHIFT ; Get file type
1084
1085 cmp cx,T_IFDIR
1086 je .directory
1087
1088 add sp,4 ; Drop directory inode
1089
1090 cmp cx,T_IFREG
1091 je .file
1092 cmp cx,T_IFLNK
1093 je .symlink
1094
1095 ; Otherwise, something bad...
1096 .err:
1097 call close
1098 .err_noclose:
1099 xor eax,eax
1100 xor si,si
1101 cwd ; DX <- 0
1102
1103 .done:
1104 and eax,eax ; Set/clear ZF
1105 pop bp
1106 pop cx
1107 pop bx
1108 ret
1109
1110 ;
1111 ; It's a file.
1112 ;
1113 .file:
1114 cmp byte [di],0 ; End of path?
1115 je .done ; If so, done
1116 jmp .err ; Otherwise, error
1117
1118 ;
1119 ; It's a directory.
1120 ;
1121 .directory:
1122 pop dword [ThisDir] ; Remember what directory we're searching
1123
1124 cmp byte [di],0 ; More path?
1125 je .err ; If not, bad
1126
1127 .skipslash: ; Skip redundant slashes
1128 cmp byte [di],'/'
1129 jne .readdir
1130 inc di
1131 jmp .skipslash
1132
1133 .readdir:
1134 mov bx,trackbuf
1135 push bx
1136 mov cx,[SecPerClust]
1137 call getfssec
1138 pop bx
1139 pushf ; Save EOF flag
1140 push si ; Save filesystem pointer
1141 .getent:
1142 cmp dword [bx+d_inode],0
1143 je .endblock
1144
1145 push di
1146 movzx cx,byte [bx+d_name_len]
1147 lea si,[bx+d_name]
1148 repe cmpsb
1149 je .maybe
1150 .nope:
1151 pop di
1152
1153 add bx,[bx+d_rec_len]
1154 jmp .getent
1155
1156 .endblock:
1157 pop si
1158 popf
1159 jnc .readdir ; There is more
1160 jmp .err ; Otherwise badness...
1161
1162 .maybe:
1163 mov eax,[bx+d_inode]
1164
1165 ; Does this match the end of the requested filename?
1166 cmp byte [di],0
1167 je .finish
1168 cmp byte [di],'/'
1169 jne .nope
1170
1171 ; We found something; now we need to open the file
1172 .finish:
1173 pop bx ; Adjust stack (di)
1174 pop si
1175 call close ; Close directory
1176 pop bx ; Adjust stack (flags)
1177 jmp .open
1178
1179 ;
1180 ; It's a symlink. We have to determine if it's a fast symlink
1181 ; (data stored in the inode) or not (data stored as a regular
1182 ; file.) Either which way, we start from the directory
1183 ; which we just visited if relative, or from the root directory
1184 ; if absolute, and append any remaining part of the path.
1185 ;
1186 .symlink:
1187 dec byte [SymlinkCtr]
1188 jz .err ; Too many symlink references
1189
1190 cmp eax,SYMLINK_SECTORS*SECTOR_SIZE
1191 jae .err ; Symlink too long
1192
1193 ; Computation for fast symlink, as defined by ext2/3 spec
1194 xor ecx,ecx
1195 cmp [ThisInode+i_file_acl],ecx
1196 setne cl ; ECX <- i_file_acl ? 1 : 0
1197 cmp [ThisInode+i_blocks],ecx
1198 jne .slow_symlink
1199
1200 ; It's a fast symlink
1201 .fast_symlink:
1202 call close ; We've got all we need
1203 mov si,ThisInode+i_block
1204
1205 push di
1206 mov di,SymlinkTmpBuf
1207 mov ecx,eax
1208 rep movsb
1209 pop si
1210
1211 .symlink_finish:
1212 cmp byte [si],0
1213 je .no_slash
1214 mov al,'/'
1215 stosb
1216 .no_slash:
1217 mov bp,SymlinkTmpBufEnd
1218 call strecpy
1219 jc .err_noclose ; Buffer overflow
1220
1221 ; Now copy it to the "real" buffer; we need to have
1222 ; two buffers so we avoid overwriting the tail on the
1223 ; next copy
1224 mov si,SymlinkTmpBuf
1225 mov di,SymlinkBuf
1226 push di
1227 call strcpy
1228 pop di
1229 mov eax,[ThisDir] ; Resume searching previous directory
1230 jmp .begin_path
1231
1232 .slow_symlink:
1233 mov bx,SymlinkTmpBuf
1234 mov cx,SYMLINK_SECTORS
1235 call getfssec
1236 ; The EOF closed the file
1237
1238 mov si,di ; SI = filename tail
1239 mov di,SymlinkTmpBuf
1240 add di,ax ; AX = file length
1241 jmp .symlink_finish
1242
1243
1244 section .bss
1245 alignb 4
1246 SymlinkBuf resb SYMLINK_SECTORS*SECTOR_SIZE+64
1247 SymlinkTmpBuf equ trackbuf
1248 SymlinkTmpBufEnd equ trackbuf+SYMLINK_SECTORS*SECTOR_SIZE+64
1249 ThisDir resd 1
1250 SymlinkCtr resb 1
1251
1252 section .text
1253 ;
1254 ; mangle_name: Mangle a filename pointed to by DS:SI into a buffer pointed
1255 ; to by ES:DI; ends on encountering any whitespace.
1256 ;
1257 ; This verifies that a filename is < FILENAME_MAX characters,
1258 ; doesn't contain whitespace, zero-pads the output buffer,
1259 ; and removes redundant slashes,
1260 ; so "repe cmpsb" can do a compare, and the
1261 ; path-searching routine gets a bit of an easier job.
1262 ;
1263 ; FIX: we may want to support \-escapes here (and this would
1264 ; be the place.)
1265 ;
1266 mangle_name:
1267 push bx
1268 xor ax,ax
1269 mov cx,FILENAME_MAX-1
1270 mov bx,di
1271
1272 .mn_loop:
1273 lodsb
1274 cmp al,' ' ; If control or space, end
1275 jna .mn_end
1276 cmp al,ah ; Repeated slash?
1277 je .mn_skip
1278 xor ah,ah
1279 cmp al,'/'
1280 jne .mn_ok
1281 mov ah,al
1282 .mn_ok stosb
1283 .mn_skip: loop .mn_loop
1284 .mn_end:
1285 cmp bx,di ; At the beginning of the buffer?
1286 jbe .mn_zero
1287 cmp byte [di-1],'/' ; Terminal slash?
1288 jne .mn_zero
1289 .mn_kill: dec di ; If so, remove it
1290 inc cx
1291 jmp short .mn_end
1292 .mn_zero:
1293 inc cx ; At least one null byte
1294 xor ax,ax ; Zero-fill name
1295 rep stosb
1296 pop bx
1297 ret ; Done
1298
1299 ;
1300 ; unmangle_name: Does the opposite of mangle_name; converts a DOS-mangled
1301 ; filename to the conventional representation. This is needed
1302 ; for the BOOT_IMAGE= parameter for the kernel.
1303 ; NOTE: A 13-byte buffer is mandatory, even if the string is
1304 ; known to be shorter.
1305 ;
1306 ; DS:SI -> input mangled file name
1307 ; ES:DI -> output buffer
1308 ;
1309 ; On return, DI points to the first byte after the output name,
1310 ; which is set to a null byte.
1311 ;
1312 unmangle_name: call strcpy
1313 dec di ; Point to final null byte
1314 ret
1315
1316 ;
1317 ;
1318 ; kaboom2: once everything is loaded, replace the part of kaboom
1319 ; starting with "kaboom.patch" with this part
1320
1321 kaboom2:
1322 mov si,err_bootfailed
1323 call cwritestr
1324 call getchar
1325 call vgaclearmode
1326 int 19h ; And try once more to boot...
1327 .norge: jmp short .norge ; If int 19h returned; this is the end
1328
1329
1330 ;
1331 ; linsector: Convert a linear sector index in a file to a linear sector number
1332 ; EAX -> linear sector number
1333 ; DS:SI -> open_file_t
1334 ;
1335 ; Returns next sector number in EAX; CF on EOF (not an error!)
1336 ;
1337 linsector:
1338 push gs
1339 push ebx
1340 push esi
1341 push edi
1342 push ecx
1343 push edx
1344 push ebp
1345
1346 push eax ; Save sector index
1347 mov cl,[ClustShift]
1348 shr eax,cl ; Convert to block number
1349 push eax
1350 mov eax,[si+file_in_sec]
1351 mov bx,si
1352 call getcachesector ; Get inode
1353 add si,[bx+file_in_off] ; Get *our* inode
1354 pop eax
1355 lea ebx,[i_block+4*eax]
1356 cmp eax,EXT2_NDIR_BLOCKS
1357 jb .direct
1358 mov ebx,i_block+4*EXT2_IND_BLOCK
1359 sub eax,EXT2_NDIR_BLOCKS
1360 mov ebp,[PtrsPerBlock1]
1361 cmp eax,ebp
1362 jb .ind1
1363 mov ebx,i_block+4*EXT2_DIND_BLOCK
1364 sub eax,ebp
1365 mov ebp,[PtrsPerBlock2]
1366 cmp eax,ebp
1367 jb .ind2
1368 mov ebx,i_block+4*EXT2_TIND_BLOCK
1369 sub eax,ebp
1370
1371 .ind3:
1372 ; Triple indirect; eax contains the block no
1373 ; with respect to the start of the tind area;
1374 ; ebx contains the pointer to the tind block.
1375 xor edx,edx
1376 div dword [PtrsPerBlock2]
1377 ; EAX = which dind block, EDX = pointer within dind block
1378 push ax
1379 shr eax,SECTOR_SHIFT-2
1380 mov ebp,[gs:si+bx]
1381 shl ebp,cl
1382 add eax,ebp
1383 call getcachesector
1384 pop bx
1385 and bx,(SECTOR_SIZE >> 2)-1
1386 shl bx,2
1387 mov eax,edx ; The ind2 code wants the remainder...
1388
1389 .ind2:
1390 ; Double indirect; eax contains the block no
1391 ; with respect to the start of the dind area;
1392 ; ebx contains the pointer to the dind block.
1393 xor edx,edx
1394 div dword [PtrsPerBlock1]
1395 ; EAX = which ind block, EDX = pointer within ind block
1396 push ax
1397 shr eax,SECTOR_SHIFT-2
1398 mov ebp,[gs:si+bx]
1399 shl ebp,cl
1400 add eax,ebp
1401 call getcachesector
1402 pop bx
1403 and bx,(SECTOR_SIZE >> 2)-1
1404 shl bx,2
1405 mov eax,edx ; The int1 code wants the remainder...
1406
1407 .ind1:
1408 ; Single indirect; eax contains the block no
1409 ; with respect to the start of the ind area;
1410 ; ebx contains the pointer to the ind block.
1411 push ax
1412 shr eax,SECTOR_SHIFT-2
1413 mov ebp,[gs:si+bx]
1414 shl ebp,cl
1415 add eax,ebp
1416 call getcachesector
1417 pop bx
1418 and bx,(SECTOR_SIZE >> 2)-1
1419 shl bx,2
1420
1421 .direct:
1422 mov ebx,[gs:bx+si] ; Get the pointer
1423
1424 pop eax ; Get the sector index again
1425 shl ebx,cl ; Convert block number to sector
1426 and eax,[ClustMask] ; Add offset within block
1427 add eax,ebx
1428
1429 pop ebp
1430 pop edx
1431 pop ecx
1432 pop edi
1433 pop esi
1434 pop ebx
1435 pop gs
1436 ret
1437
1438 ;
1439 ; getfssec: Get multiple sectors from a file
1440 ;
1441 ; Same as above, except SI is a pointer to a open_file_t
1442 ;
1443 ; ES:BX -> Buffer
1444 ; DS:SI -> Pointer to open_file_t
1445 ; CX -> Sector count (0FFFFh = until end of file)
1446 ; Must not exceed the ES segment
1447 ; Returns CF=1 on EOF (not necessarily error)
1448 ; All arguments are advanced to reflect data read.
1449 ;
1450 getfssec:
1451 push ebp
1452 push eax
1453 push edx
1454 push edi
1455
1456 movzx ecx,cx
1457 cmp ecx,[si] ; Number of sectors left
1458 jbe .lenok
1459 mov cx,[si]
1460 .lenok:
1461 .getfragment:
1462 mov eax,[si+file_sector] ; Current start index
1463 mov edi,eax
1464 call linsector
1465 push eax ; Fragment start sector
1466 mov edx,eax
1467 xor ebp,ebp ; Fragment sector count
1468 .getseccnt:
1469 inc bp
1470 dec cx
1471 jz .do_read
1472 xor eax,eax
1473 mov ax,es
1474 shl ax,4
1475 add ax,bx ; Now DI = how far into 64K block we are
1476 not ax ; Bytes left in 64K block
1477 inc eax
1478 shr eax,SECTOR_SHIFT ; Sectors left in 64K block
1479 cmp bp,ax
1480 jnb .do_read ; Unless there is at least 1 more sector room...
1481 inc edi ; Sector index
1482 inc edx ; Linearly next sector
1483 mov eax,edi
1484 call linsector
1485 ; jc .do_read
1486 cmp edx,eax
1487 je .getseccnt
1488 .do_read:
1489 pop eax ; Linear start sector
1490 pushad
1491 call getlinsec_ext
1492 popad
1493 push bp
1494 shl bp,9
1495 add bx,bp ; Adjust buffer pointer
1496 pop bp
1497 add [si+file_sector],ebp ; Next sector index
1498 sub [si],ebp ; Sectors consumed
1499 jcxz .done
1500 jnz .getfragment
1501 ; Fall through
1502 .done:
1503 cmp dword [si],1 ; Did we run out of file?
1504 ; CF set if [SI] < 1, i.e. == 0
1505 pop edi
1506 pop edx
1507 pop eax
1508 pop ebp
1509 ret
1510
1511 ; -----------------------------------------------------------------------------
1512 ; Common modules
1513 ; -----------------------------------------------------------------------------
1514
1515 %include "getc.inc" ; getc et al
1516 %include "conio.inc" ; Console I/O
1517 %include "plaincon.inc" ; writechr
1518 %include "writestr.inc" ; String output
1519 %include "parseconfig.inc" ; High-level config file handling
1520 %include "parsecmd.inc" ; Low-level config file handling
1521 %include "bcopy32.inc" ; 32-bit bcopy
1522 %include "loadhigh.inc" ; Load a file into high memory
1523 %include "font.inc" ; VGA font stuff
1524 %include "graphics.inc" ; VGA graphics
1525 %include "highmem.inc" ; High memory sizing
1526 %include "strcpy.inc" ; strcpy()
1527 %include "strecpy.inc" ; strcpy with end pointer check
1528 %include "cache.inc"
1529
1530 ; -----------------------------------------------------------------------------
1531 ; Begin data section
1532 ; -----------------------------------------------------------------------------
1533
1534 section .data
1535 copyright_str db ' Copyright (C) 1994-', year, ' H. Peter Anvin'
1536 db CR, LF, 0
1537 boot_prompt db 'boot: ', 0
1538 wipe_char db BS, ' ', BS, 0
1539 err_notfound db 'Could not find kernel image: ',0
1540 err_notkernel db CR, LF, 'Invalid or corrupt kernel image.', CR, LF, 0
1541 err_noram db 'It appears your computer has less than '
1542 asciidec dosram_k
1543 db 'K of low ("DOS")'
1544 db CR, LF
1545 db 'RAM. Linux needs at least this amount to boot. If you get'
1546 db CR, LF
1547 db 'this message in error, hold down the Ctrl key while'
1548 db CR, LF
1549 db 'booting, and I will take your word for it.', CR, LF, 0
1550 err_badcfg db 'Unknown keyword in extlinux.conf.', CR, LF, 0
1551 err_noparm db 'Missing parameter in extlinux.conf.', CR, LF, 0
1552 err_noinitrd db CR, LF, 'Could not find ramdisk image: ', 0
1553 err_nohighmem db 'Not enough memory to load specified kernel.', CR, LF, 0
1554 err_highload db CR, LF, 'Kernel transfer failure.', CR, LF, 0
1555 err_oldkernel db 'Cannot load a ramdisk with an old kernel image.'
1556 db CR, LF, 0
1557 err_notdos db ': attempted DOS system call', CR, LF, 0
1558 err_comlarge db 'COMBOOT image too large.', CR, LF, 0
1559 err_bssimage db 'BSS images not supported.', CR, LF, 0
1560 err_a20 db CR, LF, 'A20 gate not responding!', CR, LF, 0
1561 err_bootfailed db CR, LF, 'Boot failed: please change disks and press '
1562 db 'a key to continue.', CR, LF, 0
1563 ready_msg db 'Ready.', CR, LF, 0
1564 crlfloading_msg db CR, LF
1565 loading_msg db 'Loading ', 0
1566 dotdot_msg db '.'
1567 dot_msg db '.', 0
1568 aborted_msg db ' aborted.' ; Fall through to crlf_msg!
1569 crlf_msg db CR, LF
1570 null_msg db 0
1571 crff_msg db CR, FF, 0
1572 ConfigName db 'extlinux.conf',0 ; Unmangled form
1573
1574 ;
1575 ; Command line options we'd like to take a look at
1576 ;
1577 ; mem= and vga= are handled as normal 32-bit integer values
1578 initrd_cmd db 'initrd='
1579 initrd_cmd_len equ 7
1580
1581 ;
1582 ; Config file keyword table
1583 ;
1584 %include "keywords.inc"
1585
1586 ;
1587 ; Extensions to search for (in *forward* order).
1588 ;
1589 align 4, db 0
1590 exten_table: db '.cbt' ; COMBOOT (specific)
1591 db '.img' ; Disk image
1592 db '.bs', 0 ; Boot sector
1593 db '.com' ; COMBOOT (same as DOS)
1594 db '.c32' ; COM32
1595 exten_table_end:
1596 dd 0, 0 ; Need 8 null bytes here
1597
1598 ;
1599 ; Misc initialized (data) variables
1600 ;
1601 %ifdef debug ; This code for debugging only
1602 debug_magic dw 0D00Dh ; Debug code sentinel
1603 %endif
1604
1605 alignb 4, db 0
1606 BufSafe dw trackbufsize/SECTOR_SIZE ; Clusters we can load into trackbuf
1607 BufSafeSec dw trackbufsize/SECTOR_SIZE ; = how many sectors?
1608 BufSafeBytes dw trackbufsize ; = how many bytes?
1609 EndOfGetCBuf dw getcbuf+trackbufsize ; = getcbuf+BufSafeBytes
1610 %ifndef DEPEND
1611 %if ( trackbufsize % SECTOR_SIZE ) != 0
1612 %error trackbufsize must be a multiple of SECTOR_SIZE
1613 %endif
1614 %endif
The Syslinux boot loader collection