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