?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Document the file renaming from .doc -> .txt
[syslinux.git] / isolinux.asm
blobc24576972103a31bbba30dad6bebb2942eb87162
1 ; -*- fundamental -*- (asm-mode sucks)
2 ; ****************************************************************************
3 ;
4 ; isolinux.asm
5 ;
6 ; A program to boot Linux kernels off a CD-ROM using the El Torito
7 ; boot standard in "no emulation" mode, making the entire filesystem
8 ; available. It is based on the SYSLINUX boot loader for MS-DOS
9 ; floppies.
10 ;
11 ; Copyright 1994-2008 H. Peter Anvin - All Rights Reserved
12 ;
13 ; This program is free software; you can redistribute it and/or modify
14 ; it under the terms of the GNU General Public License as published by
15 ; the Free Software Foundation, Inc., 53 Temple Place Ste 330,
16 ; Boston MA 02111-1307, USA; either version 2 of the License, or
17 ; (at your option) any later version; incorporated herein by reference.
18 ;
19 ; ****************************************************************************
20
21 %define IS_ISOLINUX 1
22 %include "head.inc"
23
24 ;
25 ; Some semi-configurable constants... change on your own risk.
26 ;
27 my_id equ isolinux_id
28 FILENAME_MAX_LG2 equ 8 ; log2(Max filename size Including final null)
29 FILENAME_MAX equ (1 << FILENAME_MAX_LG2)
30 NULLFILE equ 0 ; Zero byte == null file name
31 NULLOFFSET equ 0 ; Position in which to look
32 retry_count equ 6 ; How patient are we with the BIOS?
33 %assign HIGHMEM_SLOP 128*1024 ; Avoid this much memory near the top
34 MAX_OPEN_LG2 equ 6 ; log2(Max number of open files)
35 MAX_OPEN equ (1 << MAX_OPEN_LG2)
36 SECTOR_SHIFT equ 11 ; 2048 bytes/sector (El Torito requirement)
37 SECTOR_SIZE equ (1 << SECTOR_SHIFT)
38
39 ;
40 ; This is what we need to do when idle
41 ;
42 %macro RESET_IDLE 0
43 ; Nothing
44 %endmacro
45 %macro DO_IDLE 0
46 ; Nothing
47 %endmacro
48
49 ;
50 ; The following structure is used for "virtual kernels"; i.e. LILO-style
51 ; option labels. The options we permit here are `kernel' and `append
52 ; Since there is no room in the bottom 64K for all of these, we
53 ; stick them in high memory and copy them down before we need them.
54 ;
55 struc vkernel
56 vk_vname: resb FILENAME_MAX ; Virtual name **MUST BE FIRST!**
57 vk_rname: resb FILENAME_MAX ; Real name
58 vk_appendlen: resw 1
59 vk_type: resb 1 ; Type of file
60 alignb 4
61 vk_append: resb max_cmd_len+1 ; Command line
62 alignb 4
63 vk_end: equ $ ; Should be <= vk_size
64 endstruc
65
66 ;
67 ; Segment assignments in the bottom 640K
68 ; 0000h - main code/data segment (and BIOS segment)
69 ;
70 real_mode_seg equ 2000h
71 xfer_buf_seg equ 1000h ; Bounce buffer for I/O to high mem
72 comboot_seg equ real_mode_seg ; COMBOOT image loading zone
73
74 ;
75 ; File structure. This holds the information for each currently open file.
76 ;
77 struc open_file_t
78 file_sector resd 1 ; Sector pointer (0 = structure free)
79 file_left resd 1 ; Number of sectors left
80 endstruc
81
82 %ifndef DEPEND
83 %if (open_file_t_size & (open_file_t_size-1))
84 %error "open_file_t is not a power of 2"
85 %endif
86 %endif
87
88 struc dir_t
89 dir_lba resd 1 ; Directory start (LBA)
90 dir_len resd 1 ; Length in bytes
91 dir_clust resd 1 ; Length in clusters
92 endstruc
93
94 ; ---------------------------------------------------------------------------
95 ; BEGIN CODE
96 ; ---------------------------------------------------------------------------
97
98 ;
99 ; Memory below this point is reserved for the BIOS and the MBR
100 ;
101 section .earlybss
102 trackbufsize equ 8192
103 trackbuf resb trackbufsize ; Track buffer goes here
104 ; ends at 2800h
105
106 ; Some of these are touched before the whole image
107 ; is loaded. DO NOT move this to .uibss.
108 section .bss1
109 alignb 4
110 ISOFileName resb 64 ; ISO filename canonicalization buffer
111 ISOFileNameEnd equ $
112 CurDir resb dir_t_size ; Current directory
113 RootDir resb dir_t_size ; Root directory
114 FirstSecSum resd 1 ; Checksum of bytes 64-2048
115 ImageDwords resd 1 ; isolinux.bin size, dwords
116 InitStack resd 1 ; Initial stack pointer (SS:SP)
117 DiskSys resw 1 ; Last INT 13h call
118 ImageSectors resw 1 ; isolinux.bin size, sectors
119 DiskError resb 1 ; Error code for disk I/O
120 DriveNumber resb 1 ; CD-ROM BIOS drive number
121 ISOFlags resb 1 ; Flags for ISO directory search
122 RetryCount resb 1 ; Used for disk access retries
123
124 _spec_start equ $
125
126 ;
127 ; El Torito spec packet
128 ;
129
130 alignb 8
131 spec_packet: resb 1 ; Size of packet
132 sp_media: resb 1 ; Media type
133 sp_drive: resb 1 ; Drive number
134 sp_controller: resb 1 ; Controller index
135 sp_lba: resd 1 ; LBA for emulated disk image
136 sp_devspec: resw 1 ; IDE/SCSI information
137 sp_buffer: resw 1 ; User-provided buffer
138 sp_loadseg: resw 1 ; Load segment
139 sp_sectors: resw 1 ; Sector count
140 sp_chs: resb 3 ; Simulated CHS geometry
141 sp_dummy: resb 1 ; Scratch, safe to overwrite
142
143 ;
144 ; EBIOS drive parameter packet
145 ;
146 alignb 8
147 drive_params: resw 1 ; Buffer size
148 dp_flags: resw 1 ; Information flags
149 dp_cyl: resd 1 ; Physical cylinders
150 dp_head: resd 1 ; Physical heads
151 dp_sec: resd 1 ; Physical sectors/track
152 dp_totalsec: resd 2 ; Total sectors
153 dp_secsize: resw 1 ; Bytes per sector
154 dp_dpte: resd 1 ; Device Parameter Table
155 dp_dpi_key: resw 1 ; 0BEDDh if rest valid
156 dp_dpi_len: resb 1 ; DPI len
157 resb 1
158 resw 1
159 dp_bus: resb 4 ; Host bus type
160 dp_interface: resb 8 ; Interface type
161 db_i_path: resd 2 ; Interface path
162 db_d_path: resd 2 ; Device path
163 resb 1
164 db_dpi_csum: resb 1 ; Checksum for DPI info
165
166 ;
167 ; EBIOS disk address packet
168 ;
169 alignb 8
170 dapa: resw 1 ; Packet size
171 .count: resw 1 ; Block count
172 .off: resw 1 ; Offset of buffer
173 .seg: resw 1 ; Segment of buffer
174 .lba: resd 2 ; LBA (LSW, MSW)
175
176 ;
177 ; Spec packet for disk image emulation
178 ;
179 alignb 8
180 dspec_packet: resb 1 ; Size of packet
181 dsp_media: resb 1 ; Media type
182 dsp_drive: resb 1 ; Drive number
183 dsp_controller: resb 1 ; Controller index
184 dsp_lba: resd 1 ; LBA for emulated disk image
185 dsp_devspec: resw 1 ; IDE/SCSI information
186 dsp_buffer: resw 1 ; User-provided buffer
187 dsp_loadseg: resw 1 ; Load segment
188 dsp_sectors: resw 1 ; Sector count
189 dsp_chs: resb 3 ; Simulated CHS geometry
190 dsp_dummy: resb 1 ; Scratch, safe to overwrite
191
192 alignb 4
193 _spec_end equ $
194 _spec_len equ _spec_end - _spec_start
195
196 alignb open_file_t_size
197 Files resb MAX_OPEN*open_file_t_size
198
199 section .text
200 ;;
201 ;; Primary entry point. Because BIOSes are buggy, we only load the first
202 ;; CD-ROM sector (2K) of the file, so the number one priority is actually
203 ;; loading the rest.
204 ;;
205 StackBuf equ $-44 ; 44 bytes needed for
206 ; the bootsector chainloading
207 ; code!
208 OrigESDI equ StackBuf-4 ; The high dword on the stack
209
210 bootsec equ $
211
212 _start: ; Far jump makes sure we canonicalize the address
213 cli
214 jmp 0:_start1
215 times 8-($-$$) nop ; Pad to file offset 8
216
217 ; This table hopefully gets filled in by mkisofs using the
218 ; -boot-info-table option. If not, the values in this
219 ; table are default values that we can use to get us what
220 ; we need, at least under a certain set of assumptions.
221 bi_pvd: dd 16 ; LBA of primary volume descriptor
222 bi_file: dd 0 ; LBA of boot file
223 bi_length: dd 0xdeadbeef ; Length of boot file
224 bi_csum: dd 0xdeadbeef ; Checksum of boot file
225 bi_reserved: times 10 dd 0xdeadbeef ; Reserved
226
227 _start1: mov [cs:InitStack],sp ; Save initial stack pointer
228 mov [cs:InitStack+2],ss
229 xor ax,ax
230 mov ss,ax
231 mov sp,StackBuf ; Set up stack
232 push es ; Save initial ES:DI -> $PnP pointer
233 push di
234 mov ds,ax
235 mov es,ax
236 mov fs,ax
237 mov gs,ax
238 sti
239
240 cld
241 ; Show signs of life
242 mov si,syslinux_banner
243 call writestr
244 %ifdef DEBUG_MESSAGES
245 mov si,copyright_str
246 call writestr
247 %endif
248
249 ;
250 ; Before modifying any memory, get the checksum of bytes
251 ; 64-2048
252 ;
253 initial_csum: xor edi,edi
254 mov si,_start1
255 mov cx,(SECTOR_SIZE-64) >> 2
256 .loop: lodsd
257 add edi,eax
258 loop .loop
259 mov [FirstSecSum],edi
260
261 mov [DriveNumber],dl
262 %ifdef DEBUG_MESSAGES
263 mov si,startup_msg
264 call writemsg
265 mov al,dl
266 call writehex2
267 call crlf
268 %endif
269 ;
270 ; Initialize spec packet buffers
271 ;
272 mov di,_spec_start
273 mov cx,_spec_len >> 2
274 xor eax,eax
275 rep stosd
276
277 ; Initialize length field of the various packets
278 mov byte [spec_packet],13h
279 mov byte [drive_params],30
280 mov byte [dapa],16
281 mov byte [dspec_packet],13h
282
283 ; Other nonzero fields
284 inc word [dsp_sectors]
285
286 ; Now figure out what we're actually doing
287 ; Note: use passed-in DL value rather than 7Fh because
288 ; at least some BIOSes will get the wrong value otherwise
289 mov ax,4B01h ; Get disk emulation status
290 mov dl,[DriveNumber]
291 mov si,spec_packet
292 call int13
293 jc award_hack ; changed for BrokenAwardHack
294 mov dl,[DriveNumber]
295 cmp [sp_drive],dl ; Should contain the drive number
296 jne spec_query_failed
297
298 %ifdef DEBUG_MESSAGES
299 mov si,spec_ok_msg
300 call writemsg
301 mov al,byte [sp_drive]
302 call writehex2
303 call crlf
304 %endif
305
306 found_drive:
307 ; Alright, we have found the drive. Now, try to find the
308 ; boot file itself. If we have a boot info table, life is
309 ; good; if not, we have to make some assumptions, and try
310 ; to figure things out ourselves. In particular, the
311 ; assumptions we have to make are:
312 ; - single session only
313 ; - only one boot entry (no menu or other alternatives)
314
315 cmp dword [bi_file],0 ; Address of code to load
316 jne found_file ; Boot info table present :)
317
318 %ifdef DEBUG_MESSAGES
319 mov si,noinfotable_msg
320 call writemsg
321 %endif
322
323 ; No such luck. See if the spec packet contained one.
324 mov eax,[sp_lba]
325 and eax,eax
326 jz set_file ; Good enough
327
328 %ifdef DEBUG_MESSAGES
329 mov si,noinfoinspec_msg
330 call writemsg
331 %endif
332
333 ; No such luck. Get the Boot Record Volume, assuming single
334 ; session disk, and that we're the first entry in the chain
335 mov eax,17 ; Assumed address of BRV
336 mov bx,trackbuf
337 call getonesec
338
339 mov eax,[trackbuf+47h] ; Get boot catalog address
340 mov bx,trackbuf
341 call getonesec ; Get boot catalog
342
343 mov eax,[trackbuf+28h] ; First boot entry
344 ; And hope and pray this is us...
345
346 ; Some BIOSes apparently have limitations on the size
347 ; that may be loaded (despite the El Torito spec being very
348 ; clear on the fact that it must all be loaded.) Therefore,
349 ; we load it ourselves, and *bleep* the BIOS.
350
351 set_file:
352 mov [bi_file],eax
353
354 found_file:
355 ; Set up boot file sizes
356 mov eax,[bi_length]
357 sub eax,SECTOR_SIZE-3
358 shr eax,2 ; bytes->dwords
359 mov [ImageDwords],eax ; boot file dwords
360 add eax,(2047 >> 2)
361 shr eax,9 ; dwords->sectors
362 mov [ImageSectors],ax ; boot file sectors
363
364 mov eax,[bi_file] ; Address of code to load
365 inc eax ; Don't reload bootstrap code
366 %ifdef DEBUG_MESSAGES
367 mov si,offset_msg
368 call writemsg
369 call writehex8
370 call crlf
371 %endif
372
373 ; Just in case some BIOSes have problems with
374 ; segment wraparound, use the normalized address
375 mov bx,((7C00h+2048) >> 4)
376 mov es,bx
377 xor bx,bx
378 mov bp,[ImageSectors]
379 %ifdef DEBUG_MESSAGES
380 push ax
381 mov si,size_msg
382 call writemsg
383 mov ax,bp
384 call writehex4
385 call crlf
386 pop ax
387 %endif
388 call getlinsec
389
390 push ds
391 pop es
392
393 %ifdef DEBUG_MESSAGES
394 mov si,loaded_msg
395 call writemsg
396 %endif
397
398 ; Verify the checksum on the loaded image.
399 verify_image:
400 mov si,7C00h+2048
401 mov bx,es
402 mov ecx,[ImageDwords]
403 mov edi,[FirstSecSum] ; First sector checksum
404 .loop es lodsd
405 add edi,eax
406 dec ecx
407 jz .done
408 and si,si
409 jnz .loop
410 ; SI wrapped around, advance ES
411 add bx,1000h
412 mov es,bx
413 jmp short .loop
414 .done: mov ax,ds
415 mov es,ax
416 cmp [bi_csum],edi
417 je integrity_ok
418
419 mov si,checkerr_msg
420 call writemsg
421 jmp kaboom
422
423 integrity_ok:
424 %ifdef DEBUG_MESSAGES
425 mov si,allread_msg
426 call writemsg
427 %endif
428 jmp all_read ; Jump to main code
429
430 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
431 ;; Start of BrokenAwardHack --- 10-nov-2002 Knut_Petersen@t-online.de
432 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
433 ;;
434 ;; There is a problem with certain versions of the AWARD BIOS ...
435 ;; the boot sector will be loaded and executed correctly, but, because the
436 ;; int 13 vector points to the wrong code in the BIOS, every attempt to
437 ;; load the spec packet will fail. We scan for the equivalent of
438 ;;
439 ;; mov ax,0201h
440 ;; mov bx,7c00h
441 ;; mov cx,0006h
442 ;; mov dx,0180h
443 ;; pushf
444 ;; call <direct far>
445 ;;
446 ;; and use <direct far> as the new vector for int 13. The code above is
447 ;; used to load the boot code into ram, and there should be no reason
448 ;; for anybody to change it now or in the future. There are no opcodes
449 ;; that use encodings relativ to IP, so scanning is easy. If we find the
450 ;; code above in the BIOS code we can be pretty sure to run on a machine
451 ;; with an broken AWARD BIOS ...
452 ;;
453 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
454 ;;
455 %ifdef DEBUG_MESSAGES ;;
456 ;;
457 award_notice db "Trying BrokenAwardHack first ...",CR,LF,0 ;;
458 award_not_orig db "BAH: Original Int 13 vector : ",0 ;;
459 award_not_new db "BAH: Int 13 vector changed to : ",0 ;;
460 award_not_succ db "BAH: SUCCESS",CR,LF,0 ;;
461 award_not_fail db "BAH: FAILURE" ;;
462 award_not_crlf db CR,LF,0 ;;
463 ;;
464 %endif ;;
465 ;;
466 award_oldint13 dd 0 ;;
467 award_string db 0b8h,1,2,0bbh,0,7ch,0b9h,6,0,0bah,80h,1,09ch,09ah ;;
468 ;;
469 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
470 award_hack: mov si,spec_err_msg ; Moved to this place from
471 call writemsg ; spec_query_faild
472 ;
473 %ifdef DEBUG_MESSAGES ;
474 ;
475 mov si,award_notice ; display our plan
476 call writemsg ;
477 mov si,award_not_orig ; display original int 13
478 call writemsg ; vector
479 %endif ;
480 mov eax,[13h*4] ;
481 mov [award_oldint13],eax ;
482 ;
483 %ifdef DEBUG_MESSAGES ;
484 ;
485 call writehex8 ;
486 mov si,award_not_crlf ;
487 call writestr ;
488 %endif ;
489 push es ; save ES
490 mov ax,0f000h ; ES = BIOS Seg
491 mov es,ax ;
492 cld ;
493 xor di,di ; start at ES:DI = f000:0
494 award_loop: push di ; save DI
495 mov si,award_string ; scan for award_string
496 mov cx,7 ; length of award_string = 7dw
497 repz cmpsw ; compare
498 pop di ; restore DI
499 jcxz award_found ; jmp if found
500 inc di ; not found, inc di
501 jno award_loop ;
502 ;
503 award_failed: pop es ; No, not this way :-((
504 award_fail2: ;
505 ;
506 %ifdef DEBUG_MESSAGES ;
507 ;
508 mov si,award_not_fail ; display failure ...
509 call writemsg ;
510 %endif ;
511 mov eax,[award_oldint13] ; restore the original int
512 or eax,eax ; 13 vector if there is one
513 jz spec_query_failed ; and try other workarounds
514 mov [13h*4],eax ;
515 jmp spec_query_failed ;
516 ;
517 award_found: mov eax,[es:di+0eh] ; load possible int 13 addr
518 pop es ; restore ES
519 ;
520 cmp eax,[award_oldint13] ; give up if this is the
521 jz award_failed ; active int 13 vector,
522 mov [13h*4],eax ; otherwise change 0:13h*4
523 ;
524 ;
525 %ifdef DEBUG_MESSAGES ;
526 ;
527 push eax ; display message and
528 mov si,award_not_new ; new vector address
529 call writemsg ;
530 pop eax ;
531 call writehex8 ;
532 mov si,award_not_crlf ;
533 call writestr ;
534 %endif ;
535 mov ax,4B01h ; try to read the spec packet
536 mov dl,[DriveNumber] ; now ... it should not fail
537 mov si,spec_packet ; any longer
538 int 13h ;
539 jc award_fail2 ;
540 ;
541 %ifdef DEBUG_MESSAGES ;
542 ;
543 mov si,award_not_succ ; display our SUCCESS
544 call writemsg ;
545 %endif ;
546 jmp found_drive ; and leave error recovery code
547 ;
548 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
549 ;; End of BrokenAwardHack ---- 10-nov-2002 Knut_Petersen@t-online.de
550 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
551
552
553 ; INT 13h, AX=4B01h, DL=<passed in value> failed.
554 ; Try to scan the entire 80h-FFh from the end.
555
556 spec_query_failed:
557
558 ; some code moved to BrokenAwardHack
559
560 mov dl,0FFh
561 .test_loop: pusha
562 mov ax,4B01h
563 mov si,spec_packet
564 mov byte [si],13h ; Size of buffer
565 call int13
566 popa
567 jc .still_broken
568
569 mov si,maybe_msg
570 call writemsg
571 mov al,dl
572 call writehex2
573 call crlf
574
575 cmp byte [sp_drive],dl
576 jne .maybe_broken
577
578 ; Okay, good enough...
579 mov si,alright_msg
580 call writemsg
581 .found_drive0: mov [DriveNumber],dl
582 .found_drive: jmp found_drive
583
584 ; Award BIOS 4.51 apparently passes garbage in sp_drive,
585 ; but if this was the drive number originally passed in
586 ; DL then consider it "good enough"
587 .maybe_broken:
588 mov al,[DriveNumber]
589 cmp al,dl
590 je .found_drive
591
592 ; Intel Classic R+ computer with Adaptec 1542CP BIOS 1.02
593 ; passes garbage in sp_drive, and the drive number originally
594 ; passed in DL does not have 80h bit set.
595 or al,80h
596 cmp al,dl
597 je .found_drive0
598
599 .still_broken: dec dx
600 cmp dl, 80h
601 jnb .test_loop
602
603 ; No spec packet anywhere. Some particularly pathetic
604 ; BIOSes apparently don't even implement function
605 ; 4B01h, so we can't query a spec packet no matter
606 ; what. If we got a drive number in DL, then try to
607 ; use it, and if it works, then well...
608 mov dl,[DriveNumber]
609 cmp dl,81h ; Should be 81-FF at least
610 jb fatal_error ; If not, it's hopeless
611
612 ; Write a warning to indicate we're on *very* thin ice now
613 mov si,nospec_msg
614 call writemsg
615 mov al,dl
616 call writehex2
617 call crlf
618 mov si,trysbm_msg
619 call writemsg
620 jmp .found_drive ; Pray that this works...
621
622 fatal_error:
623 mov si,nothing_msg
624 call writemsg
625
626 .norge: jmp short .norge
627
628 ; Information message (DS:SI) output
629 ; Prefix with "isolinux: "
630 ;
631 writemsg: push ax
632 push si
633 mov si,isolinux_str
634 call writestr
635 pop si
636 call writestr
637 pop ax
638 ret
639
640 ;
641 ; Write a character to the screen. There is a more "sophisticated"
642 ; version of this in the subsequent code, so we patch the pointer
643 ; when appropriate.
644 ;
645
646 writechr:
647 jmp near writechr_simple ; 3-byte jump
648
649 writechr_simple:
650 pushfd
651 pushad
652 mov ah,0Eh
653 xor bx,bx
654 int 10h
655 popad
656 popfd
657 ret
658
659 ;
660 ; int13: save all the segment registers and call INT 13h
661 ; Some CD-ROM BIOSes have been found to corrupt segment registers.
662 ;
663 int13:
664
665 push ds
666 push es
667 push fs
668 push gs
669 int 13h
670 pop gs
671 pop fs
672 pop es
673 pop ds
674 ret
675
676 ;
677 ; Get one sector. Convenience entry point.
678 ;
679 getonesec:
680 mov bp,1
681 ; Fall through to getlinsec
682
683 ;
684 ; Get linear sectors - EBIOS LBA addressing, 2048-byte sectors.
685 ;
686 ; Note that we can't always do this as a single request, because at least
687 ; Phoenix BIOSes has a 127-sector limit. To be on the safe side, stick
688 ; to 32 sectors (64K) per request.
689 ;
690 ; Input:
691 ; EAX - Linear sector number
692 ; ES:BX - Target buffer
693 ; BP - Sector count
694 ;
695 getlinsec:
696 mov si,dapa ; Load up the DAPA
697 mov [si+4],bx
698 mov bx,es
699 mov [si+6],bx
700 mov [si+8],eax
701 .loop:
702 push bp ; Sectors left
703 cmp bp,[MaxTransfer]
704 jbe .bp_ok
705 mov bp,[MaxTransfer]
706 .bp_ok:
707 mov [si+2],bp
708 push si
709 mov dl,[DriveNumber]
710 mov ah,42h ; Extended Read
711 call xint13
712 pop si
713 pop bp
714 movzx eax,word [si+2] ; Sectors we read
715 add [si+8],eax ; Advance sector pointer
716 sub bp,ax ; Sectors left
717 shl ax,SECTOR_SHIFT-4 ; 2048-byte sectors -> segment
718 add [si+6],ax ; Advance buffer pointer
719 and bp,bp
720 jnz .loop
721 mov eax,[si+8] ; Next sector
722 ret
723
724 ; INT 13h with retry
725 xint13: mov byte [RetryCount],retry_count
726 .try: pushad
727 call int13
728 jc .error
729 add sp,byte 8*4 ; Clean up stack
730 ret
731 .error:
732 mov [DiskError],ah ; Save error code
733 popad
734 mov [DiskSys],ax ; Save system call number
735 dec byte [RetryCount]
736 jz .real_error
737 push ax
738 mov al,[RetryCount]
739 mov ah,[dapa+2] ; Sector transfer count
740 cmp al,2 ; Only 2 attempts left
741 ja .nodanger
742 mov ah,1 ; Drop transfer size to 1
743 jmp short .setsize
744 .nodanger:
745 cmp al,retry_count-2
746 ja .again ; First time, just try again
747 shr ah,1 ; Otherwise, try to reduce
748 adc ah,0 ; the max transfer size, but not to 0
749 .setsize:
750 mov [MaxTransfer],ah
751 mov [dapa+2],ah
752 .again:
753 pop ax
754 jmp .try
755
756 .real_error: mov si,diskerr_msg
757 call writemsg
758 mov al,[DiskError]
759 call writehex2
760 mov si,oncall_str
761 call writestr
762 mov ax,[DiskSys]
763 call writehex4
764 mov si,ondrive_str
765 call writestr
766 mov al,dl
767 call writehex2
768 call crlf
769 ; Fall through to kaboom
770
771 ;
772 ; kaboom: write a message and bail out. Wait for a user keypress,
773 ; then do a hard reboot.
774 ;
775 kaboom:
776 RESET_STACK_AND_SEGS AX
777 mov si,err_bootfailed
778 call cwritestr
779 call getchar
780 cli
781 mov word [BIOS_magic],0 ; Cold reboot
782 jmp 0F000h:0FFF0h ; Reset vector address
783
784 ; -----------------------------------------------------------------------------
785 ; Common modules needed in the first sector
786 ; -----------------------------------------------------------------------------
787
788 %include "writestr.inc" ; String output
789 writestr equ cwritestr
790 %include "writehex.inc" ; Hexadecimal output
791
792 ; -----------------------------------------------------------------------------
793 ; Data that needs to be in the first sector
794 ; -----------------------------------------------------------------------------
795
796 syslinux_banner db CR, LF, 'ISOLINUX ', version_str, ' ', date, ' ', 0
797 copyright_str db ' Copyright (C) 1994-', year, ' H. Peter Anvin'
798 db CR, LF, 0
799 isolinux_str db 'isolinux: ', 0
800 %ifdef DEBUG_MESSAGES
801 startup_msg: db 'Starting up, DL = ', 0
802 spec_ok_msg: db 'Loaded spec packet OK, drive = ', 0
803 secsize_msg: db 'Sector size appears to be ', 0
804 offset_msg: db 'Loading main image from LBA = ', 0
805 size_msg: db 'Sectors to load = ', 0
806 loaded_msg: db 'Loaded boot image, verifying...', CR, LF, 0
807 verify_msg: db 'Image checksum verified.', CR, LF, 0
808 allread_msg db 'Main image read, jumping to main code...', CR, LF, 0
809 %endif
810 noinfotable_msg db 'No boot info table, assuming single session disk...', CR, LF, 0
811 noinfoinspec_msg db 'Spec packet missing LBA information, trying to wing it...', CR, LF, 0
812 spec_err_msg: db 'Loading spec packet failed, trying to wing it...', CR, LF, 0
813 maybe_msg: db 'Found something at drive = ', 0
814 alright_msg: db 'Looks like it might be right, continuing...', CR, LF, 0
815 nospec_msg db 'Extremely broken BIOS detected, last ditch attempt with drive = ', 0
816 nothing_msg: db 'Failed to locate CD-ROM device; boot failed.', CR, LF
817 trysbm_msg db 'See http://syslinux.zytor.com/sbm for more information.', CR, LF, 0
818 diskerr_msg: db 'Disk error ', 0
819 oncall_str: db ', AX = ',0
820 ondrive_str: db ', drive ', 0
821 checkerr_msg: db 'Image checksum error, sorry...', CR, LF, 0
822
823 err_bootfailed db CR, LF, 'Boot failed: press a key to retry...'
824 bailmsg equ err_bootfailed
825 crlf_msg db CR, LF
826 null_msg db 0
827
828 alignb 4, db 0
829 MaxTransfer dw 32 ; Max sectors per transfer
830
831 rl_checkpt equ $ ; Must be <= 800h
832
833 rl_checkpt_off equ ($-$$)
834 ;%ifndef DEPEND
835 ;%if rl_checkpt_off > 0x800
836 ;%error "Sector 0 overflow"
837 ;%endif
838 ;%endif
839
840 ; ----------------------------------------------------------------------------
841 ; End of code and data that have to be in the first sector
842 ; ----------------------------------------------------------------------------
843
844 all_read:
845
846 ; Test tracers
847 TRACER 'T'
848 TRACER '>'
849
850 ;
851 ; Common initialization code
852 ;
853 %include "init.inc"
854 %include "cpuinit.inc"
855
856 ; Patch the writechr routine to point to the full code
857 mov word [writechr+1], writechr_full-(writechr+3)
858
859 ; Tell the user we got this far...
860 %ifndef DEBUG_MESSAGES ; Gets messy with debugging on
861 mov si,copyright_str
862 call writestr
863 %endif
864
865 ;
866 ; Now we're all set to start with our *real* business. First load the
867 ; configuration file (if any) and parse it.
868 ;
869 ; In previous versions I avoided using 32-bit registers because of a
870 ; rumour some BIOSes clobbered the upper half of 32-bit registers at
871 ; random. I figure, though, that if there are any of those still left
872 ; they probably won't be trying to install Linux on them...
873 ;
874 ; The code is still ripe with 16-bitisms, though. Not worth the hassle
875 ; to take'm out. In fact, we may want to put them back if we're going
876 ; to boot ELKS at some point.
877 ;
878
879 ;
880 ; Now, we need to sniff out the actual filesystem data structures.
881 ; mkisofs gave us a pointer to the primary volume descriptor
882 ; (which will be at 16 only for a single-session disk!); from the PVD
883 ; we should be able to find the rest of what we need to know.
884 ;
885 get_fs_structures:
886 mov eax,[bi_pvd]
887 mov bx,trackbuf
888 call getonesec
889
890 mov eax,[trackbuf+156+2]
891 mov [RootDir+dir_lba],eax
892 mov [CurDir+dir_lba],eax
893 %ifdef DEBUG_MESSAGES
894 mov si,dbg_rootdir_msg
895 call writemsg
896 call writehex8
897 call crlf
898 %endif
899 mov eax,[trackbuf+156+10]
900 mov [RootDir+dir_len],eax
901 mov [CurDir+dir_len],eax
902 add eax,SECTOR_SIZE-1
903 shr eax,SECTOR_SHIFT
904 mov [RootDir+dir_clust],eax
905 mov [CurDir+dir_clust],eax
906
907 ; Look for an isolinux directory, and if found,
908 ; make it the current directory instead of the root
909 ; directory.
910 mov di,boot_dir ; Search for /boot/isolinux
911 mov al,02h
912 call searchdir_iso
913 jnz .found_dir
914 mov di,isolinux_dir
915 mov al,02h ; Search for /isolinux
916 call searchdir_iso
917 jz .no_isolinux_dir
918 .found_dir:
919 mov [CurDir+dir_len],eax
920 mov eax,[si+file_left]
921 mov [CurDir+dir_clust],eax
922 xor eax,eax ; Free this file pointer entry
923 xchg eax,[si+file_sector]
924 mov [CurDir+dir_lba],eax
925 %ifdef DEBUG_MESSAGES
926 push si
927 mov si,dbg_isodir_msg
928 call writemsg
929 pop si
930 call writehex8
931 call crlf
932 %endif
933 .no_isolinux_dir:
934
935 ;
936 ; Locate the configuration file
937 ;
938 load_config:
939 %ifdef DEBUG_MESSAGES
940 mov si,dbg_config_msg
941 call writemsg
942 %endif
943
944 mov si,config_name
945 mov di,ConfigName
946 call strcpy
947
948 mov di,ConfigName
949 call open
950 jz no_config_file ; Not found or empty
951
952 %ifdef DEBUG_MESSAGES
953 mov si,dbg_configok_msg
954 call writemsg
955 %endif
956
957 ;
958 ; Now we have the config file open. Parse the config file and
959 ; run the user interface.
960 ;
961 %include "ui.inc"
962
963 ;
964 ; Enable disk emulation. The kind of disk we emulate is dependent on the size of
965 ; the file: 1200K, 1440K or 2880K floppy, otherwise harddisk.
966 ;
967 is_disk_image:
968 TRACER CR
969 TRACER LF
970 TRACER 'D'
971 TRACER ':'
972
973 shl edx,16
974 mov dx,ax ; Set EDX <- file size
975 mov di,img_table
976 mov cx,img_table_count
977 mov eax,[si+file_sector] ; Starting LBA of file
978 mov [dsp_lba],eax ; Location of file
979 mov byte [dsp_drive], 0 ; 00h floppy, 80h hard disk
980 .search_table:
981 TRACER 't'
982 mov eax,[di+4]
983 cmp edx,[di]
984 je .type_found
985 add di,8
986 loop .search_table
987
988 ; Hard disk image. Need to examine the partition table
989 ; in order to deduce the C/H/S geometry. Sigh.
990 .hard_disk_image:
991 TRACER 'h'
992 cmp edx,512
993 jb .bad_image
994
995 mov bx,trackbuf
996 mov cx,1 ; Load 1 sector
997 call getfssec
998
999 cmp word [trackbuf+510],0aa55h ; Boot signature
1000 jne .bad_image ; Image not bootable
1001
1002 mov cx,4 ; 4 partition entries
1003 mov di,trackbuf+446 ; Start of partition table
1004
1005 xor ax,ax ; Highest sector(al) head(ah)
1006
1007 .part_scan:
1008 cmp byte [di+4], 0
1009 jz .part_loop
1010 lea si,[di+1]
1011 call .hs_check
1012 add si,byte 4
1013 call .hs_check
1014 .part_loop:
1015 add di,byte 16
1016 loop .part_scan
1017
1018 push eax ; H/S
1019 push edx ; File size
1020 mov bl,ah
1021 xor bh,bh
1022 inc bx ; # of heads in BX
1023 xor ah,ah ; # of sectors in AX
1024 cwde ; EAX[31:16] <- 0
1025 mul bx
1026 shl eax,9 ; Convert to bytes
1027 ; Now eax contains the number of bytes per cylinder
1028 pop ebx ; File size
1029 xor edx,edx
1030 div ebx
1031 and edx,edx
1032 jz .no_remainder
1033 inc eax ; Fractional cylinder...
1034 ; Now (e)ax contains the number of cylinders
1035 .no_remainder: cmp eax,1024
1036 jna .ok_cyl
1037 mov ax,1024 ; Max possible #
1038 .ok_cyl: dec ax ; Convert to max cylinder no
1039 pop ebx ; S(bl) H(bh)
1040 shl ah,6
1041 or bl,ah
1042 xchg ax,bx
1043 shl eax,16
1044 mov ah,bl
1045 mov al,4 ; Hard disk boot
1046 mov byte [dsp_drive], 80h ; Drive 80h = hard disk
1047
1048 .type_found:
1049 TRACER 'T'
1050 mov bl,[sp_media]
1051 and bl,0F0h ; Copy controller info bits
1052 or al,bl
1053 mov [dsp_media],al ; Emulation type
1054 shr eax,8
1055 mov [dsp_chs],eax ; C/H/S geometry
1056 mov ax,[sp_devspec] ; Copy device spec
1057 mov [dsp_devspec],ax
1058 mov al,[sp_controller] ; Copy controller index
1059 mov [dsp_controller],al
1060
1061 TRACER 'V'
1062 call vgaclearmode ; Reset video
1063
1064 mov ax,4C00h ; Enable emulation and boot
1065 mov si,dspec_packet
1066 mov dl,[DriveNumber]
1067 lss sp,[InitStack]
1068 TRACER 'X'
1069
1070 call int13
1071
1072 ; If this returns, we have problems
1073 .bad_image:
1074 mov si,err_disk_image
1075 call cwritestr
1076 jmp enter_command
1077
1078 ;
1079 ; Look for the highest seen H/S geometry
1080 ; We compute cylinders separately
1081 ;
1082 .hs_check:
1083 mov bl,[si] ; Head #
1084 cmp bl,ah
1085 jna .done_track
1086 mov ah,bl ; New highest head #
1087 .done_track: mov bl,[si+1]
1088 and bl,3Fh ; Sector #
1089 cmp bl,al
1090 jna .done_sector
1091 mov al,bl
1092 .done_sector: ret
1093
1094 ;
1095 ; Boot a specified local disk. AX specifies the BIOS disk number; or
1096 ; 0xFFFF in case we should execute INT 18h ("next device.")
1097 ;
1098 local_boot:
1099 call vgaclearmode
1100 lss sp,[cs:Stack] ; Restore stack pointer
1101 xor dx,dx
1102 mov ds,dx
1103 mov es,dx
1104 mov fs,dx
1105 mov gs,dx
1106 mov si,localboot_msg
1107 call writestr
1108 cmp ax,-1
1109 je .int18
1110
1111 ; Load boot sector from the specified BIOS device and jump to it.
1112 mov dl,al
1113 xor dh,dh
1114 push dx
1115 xor ax,ax ; Reset drive
1116 call xint13
1117 mov ax,0201h ; Read one sector
1118 mov cx,0001h ; C/H/S = 0/0/1 (first sector)
1119 mov bx,trackbuf
1120 call xint13
1121 pop dx
1122 cli ; Abandon hope, ye who enter here
1123 mov si,trackbuf
1124 mov di,07C00h
1125 mov cx,512 ; Probably overkill, but should be safe
1126 rep movsd
1127 lss sp,[cs:InitStack]
1128 jmp 0:07C00h ; Jump to new boot sector
1129
1130 .int18:
1131 int 18h ; Hope this does the right thing...
1132 jmp kaboom ; If we returned, oh boy...
1133
1134 ;
1135 ; close_file:
1136 ; Deallocates a file structure (pointer in SI)
1137 ; Assumes CS == DS.
1138 ;
1139 close_file:
1140 and si,si
1141 jz .closed
1142 mov dword [si],0 ; First dword == file_left
1143 .closed: ret
1144
1145 ;
1146 ; searchdir:
1147 ;
1148 ; Open a file
1149 ;
1150 ; On entry:
1151 ; DS:DI = filename
1152 ; If successful:
1153 ; ZF clear
1154 ; SI = file pointer
1155 ; DX:AX or EAX = file length in bytes
1156 ; If unsuccessful
1157 ; ZF set
1158 ;
1159 ; Assumes CS == DS == ES, and trashes BX and CX.
1160 ;
1161 ; searchdir_iso is a special entry point for ISOLINUX only. In addition
1162 ; to the above, searchdir_iso passes a file flag mask in AL. This is useful
1163 ; for searching for directories.
1164 ;
1165 alloc_failure:
1166 xor ax,ax ; ZF <- 1
1167 ret
1168
1169 searchdir:
1170 xor al,al
1171 searchdir_iso:
1172 mov [ISOFlags],al
1173 TRACER 'S'
1174 call allocate_file ; Temporary file structure for directory
1175 jnz alloc_failure
1176 push es
1177 push ds
1178 pop es ; ES = DS
1179 mov si,CurDir
1180 cmp byte [di],'/' ; If filename begins with slash
1181 jne .not_rooted
1182 inc di ; Skip leading slash
1183 mov si,RootDir ; Reference root directory instead
1184 .not_rooted:
1185 mov eax,[si+dir_clust]
1186 mov [bx+file_left],eax
1187 mov eax,[si+dir_lba]
1188 mov [bx+file_sector],eax
1189 mov edx,[si+dir_len]
1190
1191 .look_for_slash:
1192 mov ax,di
1193 .scan:
1194 mov cl,[di]
1195 inc di
1196 and cl,cl
1197 jz .isfile
1198 cmp cl,'/'
1199 jne .scan
1200 mov [di-1],byte 0 ; Terminate at directory name
1201 mov cl,02h ; Search for directory
1202 xchg cl,[ISOFlags]
1203
1204 push di ; Save these...
1205 push cx
1206
1207 ; Create recursion stack frame...
1208 push word .resume ; Where to "return" to
1209 push es
1210 .isfile: xchg ax,di
1211
1212 .getsome:
1213 ; Get a chunk of the directory
1214 ; This relies on the fact that ISOLINUX doesn't change SI
1215 mov si,trackbuf
1216 TRACER 'g'
1217 pushad
1218 xchg bx,si
1219 mov cx,[BufSafe]
1220 call getfssec
1221 popad
1222
1223 .compare:
1224 movzx eax,byte [si] ; Length of directory entry
1225 cmp al,33
1226 jb .next_sector
1227 TRACER 'c'
1228 mov cl,[si+25]
1229 xor cl,[ISOFlags]
1230 test cl, byte 8Eh ; Unwanted file attributes!
1231 jnz .not_file
1232 pusha
1233 movzx cx,byte [si+32] ; File identifier length
1234 add si,byte 33 ; File identifier offset
1235 TRACER 'i'
1236 call iso_compare_names
1237 popa
1238 je .success
1239 .not_file:
1240 sub edx,eax ; Decrease bytes left
1241 jbe .failure
1242 add si,ax ; Advance pointer
1243
1244 .check_overrun:
1245 ; Did we finish the buffer?
1246 cmp si,trackbuf+trackbufsize
1247 jb .compare ; No, keep going
1248
1249 jmp short .getsome ; Get some more directory
1250
1251 .next_sector:
1252 ; Advance to the beginning of next sector
1253 lea ax,[si+SECTOR_SIZE-1]
1254 and ax,~(SECTOR_SIZE-1)
1255 sub ax,si
1256 jmp short .not_file ; We still need to do length checks
1257
1258 .failure: xor eax,eax ; ZF = 1
1259 mov [bx+file_sector],eax
1260 pop es
1261 ret
1262
1263 .success:
1264 mov eax,[si+2] ; Location of extent
1265 mov [bx+file_sector],eax
1266 mov eax,[si+10] ; Data length
1267 push eax
1268 add eax,SECTOR_SIZE-1
1269 shr eax,SECTOR_SHIFT
1270 mov [bx+file_left],eax
1271 pop eax
1272 mov edx,eax
1273 shr edx,16
1274 and bx,bx ; ZF = 0
1275 mov si,bx
1276 pop es
1277 ret
1278
1279 .resume: ; We get here if we were only doing part of a lookup
1280 ; This relies on the fact that .success returns bx == si
1281 xchg edx,eax ; Directory length in edx
1282 pop cx ; Old ISOFlags
1283 pop di ; Next filename pointer
1284 mov byte [di-1], '/' ; Restore slash
1285 mov [ISOFlags],cl ; Restore the flags
1286 jz .failure ; Did we fail? If so fail for real!
1287 jmp .look_for_slash ; Otherwise, next level
1288
1289 ;
1290 ; allocate_file: Allocate a file structure
1291 ;
1292 ; If successful:
1293 ; ZF set
1294 ; BX = file pointer
1295 ; In unsuccessful:
1296 ; ZF clear
1297 ;
1298 allocate_file:
1299 TRACER 'a'
1300 push cx
1301 mov bx,Files
1302 mov cx,MAX_OPEN
1303 .check: cmp dword [bx], byte 0
1304 je .found
1305 add bx,open_file_t_size ; ZF = 0
1306 loop .check
1307 ; ZF = 0 if we fell out of the loop
1308 .found: pop cx
1309 ret
1310
1311 ;
1312 ; iso_compare_names:
1313 ; Compare the names DS:SI and DS:DI and report if they are
1314 ; equal from an ISO 9660 perspective. SI is the name from
1315 ; the filesystem; CX indicates its length, and ';' terminates.
1316 ; DI is expected to end with a null.
1317 ;
1318 ; Note: clobbers AX, CX, SI, DI; assumes DS == ES == base segment
1319 ;
1320
1321 iso_compare_names:
1322 ; First, terminate and canonicalize input filename
1323 push di
1324 mov di,ISOFileName
1325 .canon_loop: jcxz .canon_end
1326 lodsb
1327 dec cx
1328 cmp al,';'
1329 je .canon_end
1330 and al,al
1331 je .canon_end
1332 stosb
1333 cmp di,ISOFileNameEnd-1 ; Guard against buffer overrun
1334 jb .canon_loop
1335 .canon_end:
1336 cmp di,ISOFileName
1337 jbe .canon_done
1338 cmp byte [di-1],'.' ; Remove terminal dots
1339 jne .canon_done
1340 dec di
1341 jmp short .canon_end
1342 .canon_done:
1343 mov [di],byte 0 ; Null-terminate string
1344 pop di
1345 mov si,ISOFileName
1346 .compare:
1347 lodsb
1348 mov ah,[di]
1349 inc di
1350 and ax,ax
1351 jz .success ; End of string for both
1352 and al,al ; Is either one end of string?
1353 jz .failure ; If so, failure
1354 and ah,ah
1355 jz .failure
1356 or ax,2020h ; Convert to lower case
1357 cmp al,ah
1358 je .compare
1359 .failure: and ax,ax ; ZF = 0 (at least one will be nonzero)
1360 .success: ret
1361
1362 ;
1363 ; mangle_name: Mangle a filename pointed to by DS:SI into a buffer pointed
1364 ; to by ES:DI; ends on encountering any whitespace.
1365 ; DI is preserved.
1366 ;
1367 ; This verifies that a filename is < FILENAME_MAX characters,
1368 ; doesn't contain whitespace, zero-pads the output buffer,
1369 ; and removes trailing dots and redundant slashes,
1370 ; so "repe cmpsb" can do a compare, and the
1371 ; path-searching routine gets a bit of an easier job.
1372 ;
1373 mangle_name:
1374 push di
1375 push bx
1376 xor ax,ax
1377 mov cx,FILENAME_MAX-1
1378 mov bx,di
1379
1380 .mn_loop:
1381 lodsb
1382 cmp al,' ' ; If control or space, end
1383 jna .mn_end
1384 cmp al,ah ; Repeated slash?
1385 je .mn_skip
1386 xor ah,ah
1387 cmp al,'/'
1388 jne .mn_ok
1389 mov ah,al
1390 .mn_ok stosb
1391 .mn_skip: loop .mn_loop
1392 .mn_end:
1393 cmp bx,di ; At the beginning of the buffer?
1394 jbe .mn_zero
1395 cmp byte [es:di-1],'.' ; Terminal dot?
1396 je .mn_kill
1397 cmp byte [es:di-1],'/' ; Terminal slash?
1398 jne .mn_zero
1399 .mn_kill: dec di ; If so, remove it
1400 inc cx
1401 jmp short .mn_end
1402 .mn_zero:
1403 inc cx ; At least one null byte
1404 xor ax,ax ; Zero-fill name
1405 rep stosb
1406 pop bx
1407 pop di
1408 ret ; Done
1409
1410 ;
1411 ; unmangle_name: Does the opposite of mangle_name; converts a DOS-mangled
1412 ; filename to the conventional representation. This is needed
1413 ; for the BOOT_IMAGE= parameter for the kernel.
1414 ;
1415 ; DS:SI -> input mangled file name
1416 ; ES:DI -> output buffer
1417 ;
1418 ; On return, DI points to the first byte after the output name,
1419 ; which is set to a null byte.
1420 ;
1421 unmangle_name: call strcpy
1422 dec di ; Point to final null byte
1423 ret
1424
1425 ;
1426 ; getfssec: Get multiple clusters from a file, given the file pointer.
1427 ;
1428 ; On entry:
1429 ; ES:BX -> Buffer
1430 ; SI -> File pointer
1431 ; CX -> Cluster count
1432 ; On exit:
1433 ; SI -> File pointer (or 0 on EOF)
1434 ; CF = 1 -> Hit EOF
1435 ;
1436 getfssec:
1437 TRACER 'F'
1438
1439 push ds
1440 push cs
1441 pop ds ; DS <- CS
1442
1443 movzx ecx,cx
1444 cmp ecx,[si+file_left]
1445 jna .ok_size
1446 mov ecx,[si+file_left]
1447 .ok_size:
1448
1449 mov bp,cx
1450 push cx
1451 push si
1452 mov eax,[si+file_sector]
1453 TRACER 'l'
1454 call getlinsec
1455 xor ecx,ecx
1456 pop si
1457 pop cx
1458
1459 add [si+file_sector],ecx
1460 sub [si+file_left],ecx
1461 ja .not_eof ; CF = 0
1462
1463 xor ecx,ecx
1464 mov [si+file_sector],ecx ; Mark as unused
1465 xor si,si
1466 stc
1467
1468 .not_eof:
1469 pop ds
1470 TRACER 'f'
1471 ret
1472
1473 ; -----------------------------------------------------------------------------
1474 ; Common modules
1475 ; -----------------------------------------------------------------------------
1476
1477 %include "getc.inc" ; getc et al
1478 %include "conio.inc" ; Console I/O
1479 %include "configinit.inc" ; Initialize configuration
1480 %include "parseconfig.inc" ; High-level config file handling
1481 %include "parsecmd.inc" ; Low-level config file handling
1482 %include "bcopy32.inc" ; 32-bit bcopy
1483 %include "loadhigh.inc" ; Load a file into high memory
1484 %include "font.inc" ; VGA font stuff
1485 %include "graphics.inc" ; VGA graphics
1486 %include "highmem.inc" ; High memory sizing
1487 %include "strcpy.inc" ; strcpy()
1488 %include "rawcon.inc" ; Console I/O w/o using the console functions
1489 %include "adv.inc" ; Auxillary Data Vector
1490
1491 ; -----------------------------------------------------------------------------
1492 ; Begin data section
1493 ; -----------------------------------------------------------------------------
1494
1495 section .data
1496
1497 localboot_msg db 'Booting from local disk...', CR, LF, 0
1498 default_str db 'default', 0
1499 default_len equ ($-default_str)
1500 boot_dir db '/boot' ; /boot/isolinux
1501 isolinux_dir db '/isolinux', 0
1502 config_name db 'isolinux.cfg', 0
1503 err_disk_image db 'Cannot load disk image (invalid file)?', CR, LF, 0
1504
1505 %ifdef DEBUG_MESSAGES
1506 dbg_rootdir_msg db 'Root directory at LBA = ', 0
1507 dbg_isodir_msg db 'isolinux directory at LBA = ', 0
1508 dbg_config_msg db 'About to load config file...', CR, LF, 0
1509 dbg_configok_msg db 'Configuration file opened...', CR, LF, 0
1510 %endif
1511 ;
1512 ; Command line options we'd like to take a look at
1513 ;
1514 ; mem= and vga= are handled as normal 32-bit integer values
1515 initrd_cmd db 'initrd='
1516 initrd_cmd_len equ 7
1517
1518 ;
1519 ; Config file keyword table
1520 ;
1521 %include "keywords.inc"
1522
1523 ;
1524 ; Extensions to search for (in *forward* order).
1525 ;
1526 align 4, db 0
1527 exten_table: db '.cbt' ; COMBOOT (specific)
1528 db '.img' ; Disk image
1529 db '.bin' ; CD boot sector
1530 db '.com' ; COMBOOT (same as DOS)
1531 db '.c32' ; COM32
1532 exten_table_end:
1533 dd 0, 0 ; Need 8 null bytes here
1534
1535 ;
1536 ; Floppy image table
1537 ;
1538 align 4, db 0
1539 img_table_count equ 3
1540 img_table:
1541 dd 1200*1024 ; 1200K floppy
1542 db 1 ; Emulation type
1543 db 80-1 ; Max cylinder
1544 db 15 ; Max sector
1545 db 2-1 ; Max head
1546
1547 dd 1440*1024 ; 1440K floppy
1548 db 2 ; Emulation type
1549 db 80-1 ; Max cylinder
1550 db 18 ; Max sector
1551 db 2-1 ; Max head
1552
1553 dd 2880*1024 ; 2880K floppy
1554 db 3 ; Emulation type
1555 db 80-1 ; Max cylinder
1556 db 36 ; Max sector
1557 db 2-1 ; Max head
1558
1559 ;
1560 ; Misc initialized (data) variables
1561 ;
1562
1563 ;
1564 ; Variables that are uninitialized in SYSLINUX but initialized here
1565 ;
1566 ; **** ISOLINUX:: We may have to make this flexible, based on what the
1567 ; **** BIOS expects our "sector size" to be.
1568 ;
1569 alignb 4, db 0
1570 BufSafe dw trackbufsize/SECTOR_SIZE ; Clusters we can load into trackbuf
1571 BufSafeBytes dw trackbufsize ; = how many bytes?
1572 %ifndef DEPEND
1573 %if ( trackbufsize % SECTOR_SIZE ) != 0
1574 %error trackbufsize must be a multiple of SECTOR_SIZE
1575 %endif
1576 %endif
The Syslinux boot loader collection