extlinux.asm

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