initial import of sc2010 scripts ..HEADmaster

118 files changed, 22664 insertions, 0 deletions

diff --git a/contrib/syslinux-4.02/core/Makefile b/contrib/syslinux-4.02/core/Makefile
new file mode 100644
index 0000000..1330fb9
--- /dev/null
+++ b/contrib/syslinux-4.02/core/Makefile
@@ -0,0 +1,137 @@
+## -----------------------------------------------------------------------
+##
+##   Copyright 1998-2009 H. Peter Anvin - All Rights Reserved
+##   Copyright 2009-2010 Intel Corporation; author: H. Peter Anvin
+##
+##   This program is free software; you can redistribute it and/or modify
+##   it under the terms of the GNU General Public License as published by
+##   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
+##   Boston MA 02111-1307, USA; either version 2 of the License, or
+##   (at your option) any later version; incorporated herein by reference.
+##
+## -----------------------------------------------------------------------
+
+#
+# Makefile for the SYSLINUX core
+#
+
+# No builtin rules
+MAKEFLAGS += -r
+MAKE      += -r
+
+topdir = ..
+include $(topdir)/MCONFIG.embedded
+-include $(topdir)/version.mk
+
+OPTFLAGS =
+INCLUDES = -I./include -I$(com32)/include
+
+# This is very similar to cp437; technically it's for Norway and Denmark,
+# but it's unlikely the characters that are different will be used in
+# filenames by other users.
+CODEPAGE = cp865
+
+# The targets to build in this directory...
+BTARGET  = kwdhash.gen \
+	   ldlinux.bss ldlinux.sys ldlinux.bin \
+	   isolinux.bin isolinux-debug.bin pxelinux.0
+
+# All primary source files for the main syslinux files
+NASMSRC	 := $(wildcard *.asm)
+NASMHDR  := $(wildcard *.inc)
+CSRC	 := $(wildcard *.c */*.c */*/*.c)
+SSRC	 := $(wildcard *.S */*.S */*/*.S)
+CHDR	 := $(wildcard *.h)
+OTHERSRC := keywords
+ALLSRC    = $(NASMSRC) $(NASMHDR) $(CSRC) $(SSRC) $(CHDR) $(OTHERSRC)
+
+COBJ	 := $(patsubst %.c,%.o,$(CSRC))
+SOBJ	 := $(patsubst %.S,%.o,$(SSRC))
+
+LIB	 = libcore.a
+LIBS	 = $(LIB) $(com32)/lib/libcomcore.a $(LIBGCC)
+LIBOBJS	 = $(COBJ) $(SOBJ)
+
+NASMDEBUG = -g -F dwarf
+NASMOPT  += $(NASMDEBUG)
+
+PREPCORE = ../lzo/prepcore
+
+# CFLAGS	+= -DDEBUG=1
+
+# The DATE is set on the make command line when building binaries for
+# official release.  Otherwise, substitute a hex string that is pretty much
+# guaranteed to be unique to be unique from build to build.
+ifndef HEXDATE
+HEXDATE := $(shell $(PERL) ../now.pl $(SRCS))
+endif
+ifndef DATE
+DATE    := $(shell sh ../gen-id.sh $(VERSION) $(HEXDATE))
+endif
+
+all: $(BTARGET)
+
+kwdhash.gen: keywords genhash.pl
+	$(PERL) genhash.pl < keywords > kwdhash.gen
+
+.PRECIOUS: %.elf
+
+%.raw: %.elf
+	$(OBJCOPY) -O binary $< $(@:.bin=.raw)
+
+%.bin: %.raw $(PREPCORE)
+	$(PREPCORE) $< $@
+
+%.o: %.asm kwdhash.gen ../version.gen
+	$(NASM) -f elf $(NASMOPT) -DDATE_STR="'$(DATE)'" \
+		-DHEXDATE="$(HEXDATE)" \
+		-l $(@:.o=.lsr) -o $@ -MP -MD .$@.d $<
+
+%.elf: %.o $(LIBS) syslinux.ld
+	$(LD) $(LDFLAGS) -T syslinux.ld -M -o $@ $< \
+		--start-group $(LIBS) --end-group \
+		> $(@:.elf=.map)
+	$(OBJDUMP) -h $@ > $(@:.elf=.sec)
+	$(PERL) lstadjust.pl $(@:.elf=.lsr) $(@:.elf=.sec) $(@:.elf=.lst)
+
+$(LIB): $(LIBOBJS)
+	rm -f $@
+	$(AR) cq $@ $^
+	$(RANLIB) $@
+
+pxelinux.0: pxelinux.bin
+	cp -f $< $@
+
+ldlinux.bss: ldlinux.bin
+	dd if=$< of=$@ bs=512 count=1
+
+ldlinux.sys: ldlinux.bin
+	dd if=$< of=$@ bs=512 skip=1
+
+codepage.cp: ../codepage/$(CODEPAGE).cp
+	cp -f $< $@
+
+codepage.o: codepage.S codepage.cp
+
+install: installer
+
+install-lib: installer
+
+install-all: install install-lib
+
+netinstall: installer
+
+tidy dist:
+	rm -f codepage.cp *.o *.elf *.a stupid.* patch.offset .depend .*.d
+	rm -f *.elf.tmp *.sym
+	rm -f *.lsr *.lst *.map *.sec *.raw
+	rm -f */*.o */*/*.o */*.lst */*/*.lst */.*.d */*/.*.d
+	rm -f $(OBSOLETE) $(LIB)
+
+clean: tidy
+
+spotless: clean
+	rm -f $(BTARGET) *.bin *_bin.c
+
+# Include dependencies file
+-include .*.d */.*.d */*/.*.d
diff --git a/contrib/syslinux-4.02/core/abort.inc b/contrib/syslinux-4.02/core/abort.inc
new file mode 100644
index 0000000..9b18136
--- /dev/null
+++ b/contrib/syslinux-4.02/core/abort.inc
@@ -0,0 +1,84 @@
+; -----------------------------------------------------------------------
+;
+;   Copyright 2005-2009 H. Peter Anvin - All Rights Reserved
+;   Copyright 2009 Intel Corporation; author: H. Peter Anvin
+;
+;   This program is free software; you can redistribute it and/or modify
+;   it under the terms of the GNU General Public License as published by
+;   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
+;   Boston MA 02111-1307, USA; either version 2 of the License, or
+;   (at your option) any later version; incorporated herein by reference.
+;
+; -----------------------------------------------------------------------
+
+;
+; abort.inc
+;
+; Code to terminate a kernel load
+;
+
+		section .text16
+
+;
+; dot_pause: same as abort_check, except prints a dot, too
+;            assumes CS == DS
+;
+dot_pause:
+		push si
+		mov si,dot_msg
+		call writestr_qchk
+		pop si
+		; fall through
+
+;
+; abort_check: let the user abort with <ESC> or <Ctrl-C>
+;
+abort_check:
+		call reset_idle			; Not idle despite pollchar
+		call pollchar
+		jz .ret1
+		pusha
+		call getchar
+		cmp al,27			; <ESC>
+		je .kill
+		cmp al,3			; <Ctrl-C>
+		je .kill
+.ret2:		popa
+.ret1:		ret
+
+.kill:		mov si,aborted_msg
+		mov bx,enter_command
+		jmp abort_load_chain
+
+;
+; abort_load: Called by various routines which wants to print a fatal
+;             error message and return to the command prompt.  Since this
+;             may happen at just about any stage of the boot process, assume
+;             our state is messed up, and just reset the segment registers
+;             and the stack forcibly.
+;
+;             SI    = offset (in _text) of error message to print
+;	      BX    = future entry point (abort_load_chain)
+;
+abort_load:
+		mov bx,error_or_command
+abort_load_chain:
+		RESET_STACK_AND_SEGS AX
+                call writestr                  ; Expects SI -> error msg
+
+		; Return to the command prompt
+		jmp bx
+
+;
+; error_or_command: Execute ONERROR if appropriate, otherwise enter_command
+;
+error_or_command:
+		mov cx,[OnerrorLen]
+		and cx,cx
+		jnz on_error
+		jmp enter_command
+
+		section .data16
+aborted_msg	db ' aborted.', CR, LF, 0
+
+		section .text16
diff --git a/contrib/syslinux-4.02/core/adv.inc b/contrib/syslinux-4.02/core/adv.inc
new file mode 100644
index 0000000..0b45a6c
--- /dev/null
+++ b/contrib/syslinux-4.02/core/adv.inc
@@ -0,0 +1,509 @@
+;; -----------------------------------------------------------------------
+;;
+;;   Copyright 2007-2008 H. Peter Anvin - All Rights Reserved
+;;
+;;   This program is free software; you can redistribute it and/or modify
+;;   it under the terms of the GNU General Public License as published by
+;;   the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+;;   Boston MA 02110-1301, USA; either version 2 of the License, or
+;;   (at your option) any later version; incorporated herein by reference.
+;;
+;; -----------------------------------------------------------------------
+
+;;
+;; adv.inc
+;;
+;; The auxillary data vector and its routines
+;;
+;; The auxillary data vector is a 512-byte aligned block that on the
+;; disk-based derivatives can be part of the syslinux file itself.  It
+;; exists in two copies; when written, both copies are written (with a
+;; sync in between, if from the operating system.)  The first two
+;; dwords are magic number and inverse checksum, then follows the data
+;; area as a tagged array similar to BOOTP/DHCP, finally a tail
+;; signature.
+;;
+;; Note that unlike BOOTP/DHCP, zero terminates the chain, and FF
+;; has no special meaning.
+;;
+
+;;
+;; List of ADV tags...
+;;
+ADV_BOOTONCE	equ 1
+
+;;
+;; Other ADV data...
+;;
+ADV_MAGIC1	equ 0x5a2d2fa5			; Head signature
+ADV_MAGIC2	equ 0xa3041767			; Total checksum
+ADV_MAGIC3	equ 0xdd28bf64			; Tail signature
+
+ADV_LEN		equ 500				; Data bytes
+
+adv_retries	equ 6				; Disk retries
+
+		section .adv
+		; Introduce the ADVs to valid but blank
+adv0:
+.head		resd 1
+.csum		resd 1
+.data		resb ADV_LEN
+.tail		resd 1
+.end		equ $
+adv1:
+.head		resd 1
+.csum		resd 1
+.data		resb ADV_LEN
+.tail		resd 1
+.end		equ $
+		section .text16
+
+		;
+		; This is called after config file parsing, so we know
+		; the intended location of the ADV
+		;
+adv_init:
+		cmp byte [ADVDrive],-1
+		jne adv_read
+
+%if IS_SYSLINUX || IS_EXTLINUX
+		cmp word [ADVSectors],2		; Not present?
+		jb adv_verify
+
+		mov eax,[Hidden]
+		mov edx,[Hidden+4]
+		add [ADVSec0],eax
+		adc [ADVSec0+4],edx
+		add [ADVSec1],eax
+		adc [ADVSec1+4],edx
+		mov al,[DriveNumber]
+		mov [ADVDrive],al
+		jmp adv_read
+%endif
+
+		;
+		; Initialize the ADV data structure in memory
+		;
+adv_verify:
+		cmp byte [ADVDrive],-1		; No ADV configured, still?
+		je .reset			; Then unconditionally reset
+
+		mov si,adv0
+		call .check_adv
+		jz .ok				; Primary ADV okay
+		mov si,adv1
+		call .check_adv
+		jz .adv1ok
+
+		; Neither ADV is usable; initialize to blank
+.reset:
+		mov di,adv0
+		mov eax,ADV_MAGIC1
+		stosd
+		mov eax,ADV_MAGIC2
+		stosd
+		xor eax,eax
+		mov cx,ADV_LEN/4
+		rep stosd
+		mov eax,ADV_MAGIC3
+		stosd
+
+.ok:
+		ret
+
+		; The primary ADV is bad, but the backup is OK
+.adv1ok:
+		mov di,adv0
+		mov cx,512/4
+		rep movsd
+		ret
+
+
+		; SI points to the putative ADV; unchanged by routine
+		; ZF=1 on return if good
+.check_adv:
+		push si
+		lodsd
+		cmp eax,ADV_MAGIC1
+		jne .done			; ZF=0, i.e. bad
+		xor edx,edx
+		mov cx,ADV_LEN/4+1		; Remaining dwords
+.csum:
+		lodsd
+		add edx,eax
+		loop .csum
+		cmp edx,ADV_MAGIC2
+		jne .done
+		lodsd
+		cmp eax,ADV_MAGIC3
+.done:
+		pop si
+		ret
+
+;
+; adv_get: find an ADV string if present
+;
+; Input:	DL	= ADV ID
+; Output:	CX	= byte count (zero on not found)
+;		SI	= pointer to data
+;		DL	= unchanged
+;
+; Assumes CS == DS.
+;
+
+adv_get:
+		push ax
+		mov si,adv0.data
+		xor ax,ax			; Keep AH=0 at all times
+.loop:
+		lodsb				; Read ID
+		cmp al,dl
+		je .found
+		and al,al
+		jz .end
+		lodsb				; Read length
+		add si,ax
+		cmp si,adv0.tail
+		jb .loop
+		jmp .end
+
+.found:
+		lodsb
+		mov cx,ax
+		add ax,si			; Make sure it fits
+		cmp ax,adv0.tail
+		jbe .ok
+.end:
+		xor cx,cx
+.ok:
+		pop ax
+		ret
+
+;
+; adv_set: insert a string into the ADV in memory
+;
+; Input:	DL	= ADV ID
+;		FS:BX	= input buffer
+;		CX	= byte count (max = 255!)
+; Output:	CF=1 on error
+;		CX	clobbered
+;
+; Assumes CS == DS == ES.
+;
+adv_set:
+		push ax
+		push si
+		push di
+		and ch,ch
+		jnz .overflow
+
+		push cx
+		mov si,adv0.data
+		xor ax,ax
+.loop:
+		lodsb
+		cmp al,dl
+		je .found
+		and al,al
+		jz .endz
+		lodsb
+		add si,ax
+		cmp si,adv0.tail
+		jb .loop
+		jmp .end
+
+.found:		; Found, need to delete old copy
+		lodsb
+		lea di,[si-2]
+		push di
+		add si,ax
+		mov cx,adv0.tail
+		sub cx,si
+		jb .nukeit
+		rep movsb			; Remove the old one
+		mov [di],ah			; Termination zero
+		pop si
+		jmp .loop
+.nukeit:
+		pop si
+		jmp .end
+.endz:
+		dec si
+.end:
+		; Now SI points to where we want to put our data
+		pop cx
+		mov di,si
+		jcxz .empty
+		add si,cx
+		cmp si,adv0.tail-2
+		jae .overflow			; CF=0
+
+		mov si,bx
+		mov al,dl
+		stosb
+		mov al,cl
+		stosb
+		fs rep movsb
+
+.empty:
+		mov cx,adv0.tail
+		sub cx,di
+		xor ax,ax
+		rep stosb			; Zero-fill remainder
+
+		clc
+.done:
+		pop di
+		pop si
+		pop ax
+		ret
+.overflow:
+		stc
+		jmp .done
+
+;
+; adv_cleanup:	checksum adv0 and copy to adv1
+;		Assumes CS == DS == ES.
+;
+adv_cleanup:
+		pushad
+		mov si,adv0.data
+		mov cx,ADV_LEN/4
+		xor edx,edx
+.loop:
+		lodsd
+		add edx,eax
+		loop .loop
+		mov eax,ADV_MAGIC2
+		sub eax,edx
+		lea di,[si+4]			; adv1
+		mov si,adv0
+		mov [si+4],eax			; Store checksum
+		mov cx,(ADV_LEN+12)/4
+		rep movsd
+		popad
+		ret
+
+;
+; adv_write:	write the ADV to disk.
+;
+;		Location is in memory variables.
+;		Assumes CS == DS == ES.
+;
+;		Returns CF=1 if the ADV cannot be written.
+;
+adv_write:
+		push eax
+		mov eax,[ADVSec0]
+		or eax,[ADVSec0+4]
+		je .bad
+		mov eax,[ADVSec1]
+		or eax,[ADVSec1+4]
+		je .bad
+		cmp byte [ADVDrive],-1
+		je .bad
+
+		call adv_cleanup
+		mov ah,3			; Write
+		call adv_read_write
+
+		clc
+		pop eax
+		ret
+.bad:						; No location for ADV set
+		stc
+		pop eax
+		ret
+
+;
+; adv_read:	read the ADV from disk
+;
+;		Location is in memory variables.
+;		Assumes CS == DS == ES.
+;
+adv_read:
+		push ax
+		mov ah,2			; Read
+		call adv_read_write
+		call adv_verify
+		pop ax
+		ret
+
+;
+; adv_read_write: disk I/O for the ADV
+;
+;		On input, AH=2 for read, AH=3 for write.
+;		Assumes CS == DS == ES.
+;
+adv_read_write:
+		mov [ADVOp],ah
+		pushad
+
+		; Check for EDD
+		mov bx,55AAh
+		mov ah,41h			; EDD existence query
+		mov dl,[ADVDrive]
+		int 13h
+		mov si,.cbios
+		jc .noedd
+		cmp bx,0AA55h
+		jne .noedd
+		test cl,1
+		jz .noedd
+		mov si,.ebios
+.noedd:
+
+		mov eax,[ADVSec0]
+		mov edx,[ADVSec0+4]
+		mov bx,adv0
+		call .doone
+
+		mov eax,[ADVSec1]
+		mov edx,[ADVSec1+4]
+		mov bx,adv1
+		call .doone
+
+		popad
+		ret
+
+.doone:
+		push si
+		jmp si
+
+.ebios:
+		mov cx,adv_retries
+.eb_retry:
+		; Form DAPA on stack
+		push edx
+		push eax
+		push es
+		push bx
+		push word 1			; Sector count
+		push word 16			; DAPA size
+		mov si,sp
+		pushad
+		mov dl,[ADVDrive]
+		mov ax,4000h
+		or ah,[ADVOp]
+		push ds
+		push ss
+		pop ds
+		int 13h
+		pop ds
+		popad
+		lea sp,[si+16]			; Remove DAPA
+		jc .eb_error
+		pop si
+		ret
+.eb_error:
+		loop .eb_retry
+		stc
+		pop si
+		ret
+
+.cbios:
+		push edx
+		push eax
+		push bp
+
+		and edx,edx			; > 2 TiB not possible
+		jnz .cb_overflow
+
+		mov dl,[ADVDrive]
+		and dl,dl
+		; Floppies: can't trust INT 13h 08h, we better know
+		; the geometry a priori, which means it better be our
+		; boot device...
+		jns .noparm			; Floppy drive... urk
+
+		mov ah,08h			; Get disk parameters
+		int 13h
+		jc .noparm
+		and ah,ah
+		jnz .noparm
+		shr dx,8
+		inc dx
+		movzx edi,dx			; EDI = heads
+		and cx,3fh
+		movzx esi,cx			; ESI = sectors/track
+		jmp .parmok
+
+.noparm:
+		; No CHS info... this better be our boot drive, then
+%if IS_SYSLINUX || IS_EXTLINUX
+		cmp dl,[DriveNumber]
+		jne .cb_overflow		; Fatal error!
+		movzx esi,word [bsSecPerTrack]
+		movzx edi,word [bsHeads]
+%else
+		; Not a disk-based derivative... there is no hope
+		jmp .cb_overflow
+%endif
+
+.parmok:
+                ;
+                ; Dividing by sectors to get (track,sector): we may have
+                ; up to 2^18 tracks, so we need to use 32-bit arithmetric.
+                ;
+		xor edx,edx
+                div esi
+                xor cx,cx
+                xchg cx,dx              ; CX <- sector index (0-based)
+                                        ; EDX <- 0
+                ; eax = track #
+                div edi                 ; Convert track to head/cyl
+
+		; Watch out for overflow, we might be writing!
+		cmp eax,1023
+                ja .cb_overflow
+
+                ;
+                ; Now we have AX = cyl, DX = head, CX = sector (0-based),
+                ; BP = sectors to transfer, SI = bsSecPerTrack,
+                ; ES:BX = data target
+                ;
+
+                shl ah,6                ; Because IBM was STOOPID
+                                        ; and thought 8 bits were enough
+                                        ; then thought 10 bits were enough...
+                inc cx                  ; Sector numbers are 1-based, sigh
+                or cl,ah
+                mov ch,al
+                mov dh,dl
+                mov dl,[ADVDrive]
+		mov al,01h		; Transfer one sector
+                mov ah,[ADVOp]		; Operation
+
+		mov bp,adv_retries
+.cb_retry:
+                pushad
+                int 13h
+                popad
+                jc .cb_error
+
+.cb_done:
+                pop bp
+                pop eax
+                pop edx
+		pop si
+                ret
+
+.cb_error:
+                dec bp
+                jnz .cb_retry
+.cb_overflow:
+		stc
+		jmp .cb_done
+
+		section .data16
+		alignz 8
+ADVSec0		dq 0			; Not specified
+ADVSec1		dq 0			; Not specified
+ADVDrive	db -1			; No ADV defined
+ADVCHSInfo	db -1			; We have CHS info for this drive
+
+		section .bss16
+ADVOp		resb 1
+
+		section .text16
diff --git a/contrib/syslinux-4.02/core/bcopy32.inc b/contrib/syslinux-4.02/core/bcopy32.inc
new file mode 100644
index 0000000..6537546
--- /dev/null
+++ b/contrib/syslinux-4.02/core/bcopy32.inc
@@ -0,0 +1,75 @@
+;; -----------------------------------------------------------------------
+;;
+;;   Copyright 1994-2009 H. Peter Anvin - All Rights Reserved
+;;   Copyright 2009 Intel Corporation; author: H. Peter Anvin
+;;
+;;   This program is free software; you can redistribute it and/or modify
+;;   it under the terms of the GNU General Public License as published by
+;;   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
+;;   Boston MA 02111-1307, USA; either version 2 of the License, or
+;;   (at your option) any later version; incorporated herein by reference.
+;;
+;; -----------------------------------------------------------------------
+
+;;
+;; bcopy32.inc
+;;
+;; 32-bit bcopy routine for real mode
+;;
+
+;
+; 32-bit bcopy routine for real mode
+;
+; We enter protected mode, set up a flat 32-bit environment, run rep movsd
+; and then exit.  IMPORTANT: This code assumes cs == 0.
+;
+; This code is probably excessively anal-retentive in its handling of
+; segments, but this stuff is painful enough as it is without having to rely
+; on everything happening "as it ought to."
+;
+
+		bits 16
+		section .text16
+
+;
+; bcopy:
+;	32-bit copy, overlap safe
+;
+; Inputs:
+;	ESI	- source pointer (-1 means do bzero rather than bcopy)
+;	EDI	- target pointer
+;	ECX	- byte count
+;
+; Outputs:
+;	ESI	- first byte after source (garbage if ESI == -1 on entry)
+;	EDI	- first byte after target
+;
+bcopy:		jecxz .ret
+		pm_call pm_bcopy
+		add edi,ecx
+		add esi,ecx
+.ret:		ret
+
+;
+; shuffle_and_boot_raw:
+;	The new version of shuffle and boot.
+; Inputs:
+;	ESI		-> Pointer to list of (dst, src, len) pairs(*)
+;	EDI		-> Pointer to safe area for list + shuffler
+;			   (must not overlap this code nor the RM stack)
+;	ECX		-> Byte count of list area (for initial copy)
+;
+;     If src == -1: then the memory pointed to by (dst, len) is bzeroed;
+;		    this is handled inside the bcopy routine.
+;
+;     If len == 0:  this marks the end of the list; dst indicates
+;		    the entry point and src the mode (0 = pm, 1 = rm)
+;
+shuffle_and_boot_raw:
+		mov bx,pm_shuffle
+		jmp enter_pm
+
+;
+; The 32-bit copy and shuffle code is "special", so it is in its own file
+;
+%include "bcopyxx.inc"
diff --git a/contrib/syslinux-4.02/core/bcopyxx.inc b/contrib/syslinux-4.02/core/bcopyxx.inc
new file mode 100644
index 0000000..c669b7a
--- /dev/null
+++ b/contrib/syslinux-4.02/core/bcopyxx.inc
@@ -0,0 +1,318 @@
+;; -----------------------------------------------------------------------
+;;
+;;   Copyright 1994-2009 H. Peter Anvin - All Rights Reserved
+;;   Copyright 2009-2010 Intel Corporation; author: H. Peter Anvin
+;;
+;;   This program is free software; you can redistribute it and/or modify
+;;   it under the terms of the GNU General Public License as published by
+;;   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
+;;   Boston MA 02111-1307, USA; either version 2 of the License, or
+;;   (at your option) any later version; incorporated herein by reference.
+;;
+;; -----------------------------------------------------------------------
+
+;;
+;; bcopy32xx.inc
+;;
+
+
+;
+; 32-bit bcopy routine
+;
+; This is the actual 32-bit portion of the bcopy and shuffle and boot
+; routines.  ALL THIS CODE NEEDS TO BE POSITION-INDEPENDENT, with the
+; sole exception being the actual relocation code at the beginning of
+; pm_shuffle_boot.
+;
+; It also really needs to live all in a single segment, for the
+; address calculcations to actually work.
+;
+
+		bits 32
+		section .bcopyxx.text
+		align 16
+;
+; pm_bcopy:
+;
+;	This is the protected-mode core of the "bcopy" routine.
+;	Try to do aligned transfers; if the src and dst are relatively
+;	misaligned, align the dst.
+;
+;	ECX is guaranteed to not be zero on entry.
+;
+;	Clobbers ESI, EDI, ECX.
+;
+
+pm_bcopy:
+		push ebx
+		push edx
+		push eax
+
+		cmp esi,-1
+		je .bzero
+
+		cmp esi,edi		; If source < destination, we might
+		jb .reverse		; have to copy backwards
+
+.forward:
+		; Initial alignment
+		mov edx,edi
+		shr edx,1
+		jnc .faa1
+		movsb
+		dec ecx
+.faa1:
+		mov al,cl
+		cmp ecx,2
+		jb .f_tiny
+
+		shr edx,1
+		jnc .faa2
+		movsw
+		sub ecx,2
+.faa2:
+
+		; Bulk transfer
+		mov al,cl		; Save low bits
+		shr ecx,2		; Convert to dwords
+		rep movsd		; Do our business
+		; At this point ecx == 0
+
+		test al,2
+		jz .fab2
+		movsw
+.fab2:
+.f_tiny:
+		test al,1
+		jz .fab1
+		movsb
+.fab1:
+.done:
+		pop eax
+		pop edx
+		pop ebx
+		ret
+
+.reverse:
+		lea eax,[esi+ecx-1]	; Point to final byte
+		cmp edi,eax
+		ja .forward		; No overlap, do forward copy
+
+		std			; Reverse copy
+		lea edi,[edi+ecx-1]
+		mov esi,eax
+
+		; Initial alignment
+		mov edx,edi
+		shr edx,1
+		jc .raa1
+		movsb
+		dec ecx
+.raa1:
+
+		dec esi
+		dec edi
+		mov al,cl
+		cmp ecx,2
+		jb .r_tiny
+		shr edx,1
+		jc .raa2
+		movsw
+		sub ecx,2
+.raa2:
+
+		; Bulk copy
+		sub esi,2
+		sub edi,2
+		mov al,cl		; Save low bits
+		shr ecx,2
+		rep movsd
+
+		; Final alignment
+.r_final:
+		add esi,2
+		add edi,2
+		test al,2
+		jz .rab2
+		movsw
+.rab2:
+.r_tiny:
+		inc esi
+		inc edi
+		test al,1
+		jz .rab1
+		movsb
+.rab1:
+		cld
+		jmp short .done
+
+.bzero:
+		xor eax,eax
+
+		; Initial alignment
+		mov edx,edi
+		shr edx,1
+		jnc .zaa1
+		stosb
+		dec ecx
+.zaa1:
+
+		mov bl,cl
+		cmp ecx,2
+		jb .z_tiny
+		shr edx,1
+		jnc .zaa2
+		stosw
+		sub ecx,2
+.zaa2:
+
+		; Bulk
+		mov bl,cl		; Save low bits
+		shr ecx,2
+		rep stosd
+
+		test bl,2
+		jz .zab2
+		stosw
+.zab2:
+.z_tiny:
+		test bl,1
+		jz .zab1
+		stosb
+.zab1:
+		jmp short .done
+
+;
+; shuffle_and_boot:
+;
+; This routine is used to shuffle memory around, followed by
+; invoking an entry point somewhere in low memory.  This routine
+; can clobber any memory outside the bcopy special area.
+;
+; IMPORTANT: This routine does not set up any registers.
+; It is the responsibility of the caller to generate an appropriate entry
+; stub; *especially* when going to real mode.
+;
+; Inputs:
+;	ESI		-> Pointer to list of (dst, src, len) pairs(*)
+;	EDI		-> Pointer to safe area for list + shuffler
+;			   (must not overlap this code nor the RM stack)
+;	ECX		-> Byte count of list area (for initial copy)
+;
+;     If src == -1: then the memory pointed to by (dst, len) is bzeroed;
+;		    this is handled inside the bcopy routine.
+;
+;     If len == 0:  this marks the end of the list; dst indicates
+;		    the entry point and src the mode (0 = pm, 1 = rm)
+;
+pm_shuffle:
+		cli			; End interrupt service (for good)
+		mov ebx,edi		; EBX <- descriptor list
+		lea edx,[edi+ecx+15]	; EDX <- where to relocate our code to
+		and edx,~15		; Align 16 to benefit the GDT
+		call pm_bcopy
+		mov esi,__bcopyxx_start	; Absolute source address
+		mov edi,edx		; Absolute target address
+		sub edx,esi		; EDX <- address delta
+		mov ecx,__bcopyxx_dwords
+		lea eax,[edx+.safe]	; Resume point
+		; Relocate this code
+		rep movsd
+		jmp eax			; Jump to safe location
+.safe:
+		; Give ourselves a safe stack
+		lea esp,[edx+bcopyxx_stack+__bcopyxx_end]
+		add edx,bcopy_gdt	; EDX <- new GDT
+		mov [edx+2],edx		; GDT self-pointer
+		lgdt [edx]		; Switch to local GDT
+
+		; Now for the actual shuffling...
+.loop:
+		mov edi,[ebx]
+		mov esi,[ebx+4]
+		mov ecx,[ebx+8]
+		add ebx,12
+		jecxz .done
+		call pm_bcopy
+		jmp .loop
+.done:
+		lidt [edx+RM_IDT_ptr-bcopy_gdt]	; RM-like IDT
+		push ecx		; == 0, for cleaning the flags register
+		and esi,esi
+		jz pm_shuffle_16
+		popfd			; Clean the flags
+		jmp edi			; Protected mode entry
+
+		; We have a 16-bit entry point, so we need to return
+		; to 16-bit mode.  Note: EDX already points to the GDT.
+pm_shuffle_16:
+		mov eax,edi
+		mov [edx+PM_CS16+2],ax
+		mov [edx+PM_DS16+2],ax
+		shr eax,16
+		mov [edx+PM_CS16+4],al
+		mov [edx+PM_CS16+7],ah
+		mov [edx+PM_DS16+4],al
+		mov [edx+PM_DS16+7],ah
+		mov eax,cr0
+		and al,~1
+		popfd			; Clean the flags
+		; No flag-changing instructions below...
+		mov dx,PM_DS16
+		mov ds,edx
+		mov es,edx
+		mov fs,edx
+		mov gs,edx
+		mov ss,edx
+		jmp PM_CS16:0
+
+		section	.bcopyxx.data
+
+		alignz 16
+; GDT descriptor entry
+%macro desc 1
+bcopy_gdt.%1:
+PM_%1		equ bcopy_gdt.%1-bcopy_gdt
+%endmacro
+
+bcopy_gdt:
+		dw bcopy_gdt_size-1	; Null descriptor - contains GDT
+		dd bcopy_gdt		; pointer for LGDT instruction
+		dw 0
+
+		; TSS segment to keep Intel VT happy.  Intel VT is
+		; unhappy about anything that doesn't smell like a
+		; full-blown 32-bit OS.
+	desc TSS
+		dw 104-1, DummyTSS	; 08h 32-bit task state segment
+		dd 00008900h		; present, dpl 0, 104 bytes @DummyTSS
+
+	desc CS16
+		dd 0000ffffh		; 10h Code segment, use16, readable,
+		dd 00009b00h		; present, dpl 0, cover 64K
+	desc DS16
+		dd 0000ffffh		; 18h Data segment, use16, read/write,
+		dd 00009300h		; present, dpl 0, cover 64K
+	desc CS32
+		dd 0000ffffh		; 20h Code segment, use32, readable,
+		dd 00cf9b00h		; present, dpl 0, cover all 4G
+	desc DS32
+		dd 0000ffffh		; 28h Data segment, use32, read/write,
+		dd 00cf9300h		; present, dpl 0, cover all 4G
+
+bcopy_gdt_size:	equ $-bcopy_gdt
+;
+; Space for a dummy task state segment.  It should never be actually
+; accessed, but just in case it is, point to a chunk of memory that
+; has a chance to not be used for anything real...
+;
+DummyTSS	equ 0x580
+
+		align 4
+RM_IDT_ptr:	dw 0FFFFh		; Length (nonsense, but matches CPU)
+		dd 0			; Offset
+
+bcopyxx_stack	equ 128			; We want this much stack
+
+		bits 16
+		section .text16
diff --git a/contrib/syslinux-4.02/core/bios.inc b/contrib/syslinux-4.02/core/bios.inc
new file mode 100644
index 0000000..33a3cd4
--- /dev/null
+++ b/contrib/syslinux-4.02/core/bios.inc
@@ -0,0 +1,45 @@
+;; -----------------------------------------------------------------------
+;;
+;;   Copyright 1994-2008 H. Peter Anvin - All Rights Reserved
+;;
+;;   This program is free software; you can redistribute it and/or modify
+;;   it under the terms of the GNU General Public License as published by
+;;   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
+;;   Boston MA 02111-1307, USA; either version 2 of the License, or
+;;   (at your option) any later version; incorporated herein by reference.
+;;
+;; -----------------------------------------------------------------------
+
+;;
+;; bios.inc
+;;
+;; Header file for the BIOS data structures etc.
+;;
+
+%ifndef _BIOS_INC
+%define _BIOS_INC
+                global BIOS_fbm, BIOS_timer
+
+		; Interrupt vectors
+		absolute 4*1Ch
+BIOS_timer_hook	resd 1
+
+		absolute 4*1Eh
+fdctab		equ $
+fdctab1		resw 1
+fdctab2		resw 1
+
+		absolute 0400h
+serial_base	resw 4			; Base addresses for 4 serial ports
+		absolute 0413h
+BIOS_fbm	resw 1			; Free Base Memory (kilobytes)
+		absolute 0462h
+BIOS_page	resb 1			; Current video page
+		absolute 046Ch
+BIOS_timer	resw 1			; Timer ticks
+		absolute 0472h
+BIOS_magic	resw 1			; BIOS reset magic
+                absolute 0484h
+BIOS_vidrows    resb 1			; Number of screen rows
+
+%endif ; _BIOS_INC
diff --git a/contrib/syslinux-4.02/core/bootsect.inc b/contrib/syslinux-4.02/core/bootsect.inc
new file mode 100644
index 0000000..b4402f1
--- /dev/null
+++ b/contrib/syslinux-4.02/core/bootsect.inc
@@ -0,0 +1,237 @@
+;; -----------------------------------------------------------------------
+;;
+;;   Copyright 1994-2009 H. Peter Anvin - All Rights Reserved
+;;   Copyright 2009 Intel Corporation; author: H. Peter Anvin
+;;
+;;   This program is free software; you can redistribute it and/or modify
+;;   it under the terms of the GNU General Public License as published by
+;;   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
+;;   Boston MA 02111-1307, USA; either version 2 of the License, or
+;;   (at your option) any later version; incorporated herein by reference.
+;;
+;; -----------------------------------------------------------------------
+
+;;
+;; bootsect.inc
+;;
+;; Load a boot sector (or other bootstrap program.)
+;;
+;; Unlike previous versions of this software, this doesn't require that
+;; the length is 512 bytes.  This allows PXE bootstraps and WinNT
+;; "CD boot sectors" to be invoked.
+;;
+
+;
+; Load a boot sector
+;
+is_bootsector:
+%if IS_SYSLINUX
+		; Transfer zero bytes
+		push word 0
+		jmp short load_bootsec
+
+is_bss_sector:
+		; Transfer the superblock
+SuperSize	equ $+1
+		push word superblock_len_fat16
+%endif
+load_bootsec:
+		mov edi,free_high_memory
+		mov [trackbuf+4],edi	; Copy from this address
+		xor dx,dx		; No padding
+		mov bx,abort_check	; Don't print dots, but allow abort
+		call load_high
+
+		sub edi,free_high_memory
+		mov [trackbuf+8],edi	; Save length
+
+		mov eax,7C00h		; Entry point
+		mov [trackbuf],eax	; Copy to this address
+
+%if IS_SYSLINUX
+		xor ecx,ecx
+		pop cx
+
+		; For a BSS boot sector we have to patch.
+		mov esi,superblock
+		mov edi,free_high_memory+(superblock-bootsec)
+		call bcopy
+%endif
+		push eax		; Save entry point
+
+		xor edx,edx
+		xor esi,esi
+%if IS_SYSLINUX || IS_EXTLINUX
+		; Restore original FDC table
+		mov eax,[OrigFDCTabPtr]
+		mov [fdctab],eax
+
+		mov dl,[DriveNumber]
+		mov si,PartInfo		; Partition info buffer
+		mov di,800h-18		; Put partition info here
+		push di
+		mov cx,8		; 16 bytes
+		xor ax,ax
+		rep movsw
+		pop si			; DS:SI points to partition info
+		xor bx,bx
+%elif IS_ISOLINUX
+		mov dl,[DriveNumber]
+		xor bx,bx
+%elif IS_PXELINUX
+		mov byte [KeepPXE],03h	; Chainloading + keep PXE
+		pm_call reset_pxe
+		lfs si,[InitStack]
+		; Put restore DS, EDX and ESI to the true initial values
+		mov bx,[fs:si+6]
+		mov edx,[fs:si+28]
+		mov esi,[fs:si+12]
+%endif
+
+;
+; replace_bootstrap for the special case where we have exactly one
+; descriptor, based in low memory.  We will generate a second descriptor
+; to clear remaining FBM.
+;
+
+replace_bootstrap_one:
+		mov eax,[trackbuf]		; Base address
+		add eax,[trackbuf+8]		; Length
+		movzx ecx,word [BIOS_fbm]
+		shl ecx,10			; Free Base Memory
+		sub ecx,eax
+		mov [trackbuf+12],eax
+		or dword [trackbuf+16],-1	; Zero memory
+		mov [trackbuf+20],ecx
+		push word 2			; Length of descriptor list
+		; Fall through
+
+;
+; Entrypoint for "shut down and replace bootstrap" -- also invoked by
+; the COMBOOT API.  This routine expects the entry point (CS, IP) and the
+; count of the descriptor sequence on the stack; the shuffle
+; descriptors start at the first byte of the trackbuf.
+;
+; The registers EDX and ESI are passed on to the called program,
+; and BX is passed on as DS.
+;
+replace_bootstrap:
+		;
+		; Prepare for shutting down
+		;
+		call vgaclearmode
+
+;
+; We jump here when loading a kernel image, so that we don't reset
+; the screen mode in "quiet" mode
+;
+replace_bootstrap_noclearmode:
+		call cleanup_hardware
+
+		;
+		; Set up initial stack frame (not used by PXE if keeppxe is
+		; set - we use the PXE stack then.)
+		;
+		xor ax,ax
+		mov ds,ax
+		mov es,ax
+
+%if IS_PXELINUX
+		cmp byte [KeepPXE],0
+		je .stdstack
+		les di,[InitStack]	; Reset stack to PXE original
+		jmp .stackok
+%endif
+.stdstack:
+		; StackBuf is guaranteed to have 44 bytes free immediately
+		; above it, and it will not interfere with our existing stack.
+		mov di,StackBuf
+		push di
+		mov cx,22		; 44 bytes
+		rep stosw
+		pop di
+.stackok:
+
+		mov [es:di+28],edx	; New EDX
+		mov [es:di+12],esi	; New ESI
+		mov [es:di+6],bx	; New DS
+
+%if IS_PXELINUX == 0
+		; DON'T DO THIS FOR PXELINUX...
+		; For PXE, ES:BX -> PXENV+, and this would corrupt
+		; that use.
+
+		; Restore ES:DI -> $PnP (if we were ourselves called
+		; that way...)
+		mov ax,[OrigESDI]
+		mov bx,[OrigESDI+2]
+
+		mov [es:di+8],ax	; New DI
+		mov [es:di+4],bx	; New ES
+%endif
+		pop ax			; List length
+
+		push di
+		push es
+
+		push ds
+		pop es
+
+		mov ebx,trackbuf
+		imul di,ax,12
+		add di,bx		; DI <- end of list
+		push di
+
+		; Terminating entry...
+		lea eax,[replace_stub]	; Entrypoint
+		push ax
+		stosd
+		xor ax,ax		; EAX[31:16] == 0 already
+		stosd			; 16-bit mode
+		stosd			; End of list
+
+		; Copy the stub
+		pop di
+		mov si,__replacestub_lma
+		mov cx,__replacestub_dwords
+		rep movsd
+
+		xor ecx,ecx
+		pop cx			; ECX <- length of list
+
+		pop word [replace_stub.ss]
+		pop word [replace_stub.esp]
+		pop dword [replace_stub.csip]
+
+		cli
+		mov ss,[replace_stub.ss]
+		mov esp,[replace_stub.esp]
+
+		mov edi,trackbuf
+		mov esi,edi
+
+		jmp shuffle_and_boot_raw
+
+		; This stub gets run after the shuffle.  It is copied
+		; below 0x7c00 in order to properly handle the case
+		; of bootstrap replacement.
+		section .replacestub
+replace_stub:
+		mov cr0,eax
+		jmp 0:.next
+.next:
+		mov ax,strict word 0
+.ss		equ $-2
+		mov ss,ax
+		mov esp,strict dword 0
+.esp		equ $-4
+		pop gs
+		pop fs
+		pop es
+		pop ds
+		popad
+		popfd
+		jmp 0:0
+.csip		equ $-4
+
+		section .text16
diff --git a/contrib/syslinux-4.02/core/call16.c b/contrib/syslinux-4.02/core/call16.c
new file mode 100644
index 0000000..095f814
--- /dev/null
+++ b/contrib/syslinux-4.02/core/call16.c
@@ -0,0 +1,41 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 2009-2010 Intel Corporation; author: H. Peter Anvin
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+ *   Boston MA 02110-1301, USA; either version 2 of the License, or
+ *   (at your option) any later version; incorporated herein by reference.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * call16.c
+ *
+ * Simple wrapper to call 16-bit core functions from 32-bit code
+ */
+
+#include <stddef.h>
+#include <stdio.h>
+#include "core.h"
+
+const com32sys_t zero_regs;	/* Common all-zero register set */
+
+static inline uint32_t eflags(void)
+{
+    uint32_t v;
+
+    asm volatile("pushfl ; popl %0" : "=rm" (v));
+    return v;
+}
+
+void call16(void (*func)(void), const com32sys_t *ireg, com32sys_t *oreg)
+{
+    com32sys_t xreg = *ireg;
+
+    /* Enable interrupts if and only if they are enabled in the caller */
+    xreg.eflags.l = (xreg.eflags.l & ~EFLAGS_IF) | (eflags() & EFLAGS_IF);
+
+    core_farcall((size_t)func, &xreg, oreg);
+}
diff --git a/contrib/syslinux-4.02/core/callback.inc b/contrib/syslinux-4.02/core/callback.inc
new file mode 100644
index 0000000..d98d800
--- /dev/null
+++ b/contrib/syslinux-4.02/core/callback.inc
@@ -0,0 +1,215 @@
+;; -----------------------------------------------------------------------
+;;
+;;   Copyright 1994-2009 H. Peter Anvin - All Rights Reserved
+;;   Copyright 2009 Intel Corporation; author: H. Peter Anvin
+;;
+;;   This program is free software; you can redistribute it and/or modify
+;;   it under the terms of the GNU General Public License as published by
+;;   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
+;;   Boston MA 02111-1307, USA; either version 2 of the License, or
+;;   (at your option) any later version; incorporated herein by reference.
+;;
+;; -----------------------------------------------------------------------
+
+;;
+;; callback.inc
+;;
+;; Callbacks from 32-bit mode to 16-bit mode
+;;
+
+;
+; 16-bit intcall/farcall handling code
+;
+
+;
+; 32-bit support code
+;
+		bits 32
+		section .text
+
+;
+; Intcall/farcall invocation.  We manifest a structure on the real-mode stack,
+; containing the com32sys_t structure from <com32.h> as well as
+; the following entries (from low to high address):
+; - Target offset
+; - Target segment
+; - Return offset
+; - Return segment (== real mode cs == 0)
+; - Return flags
+;
+		global core_farcall
+core_farcall:
+		mov eax,[esp+1*4]		; CS:IP
+		jmp core_syscall
+
+		global core_intcall
+core_intcall:
+		movzx eax,byte [esp+1*4]	; INT number
+		mov eax,[eax*4]			; Get CS:IP from low memory
+
+core_syscall:
+		pushfd				; Save IF among other things...
+		push ebx
+		push ebp
+		push esi
+		push edi
+		push dword [CallbackSP]
+
+		cld
+
+		movzx edi,word [word RealModeSSSP]
+		movzx ebx,word [word RealModeSSSP+2]
+		sub edi,54		; Allocate 54 bytes
+		mov [word RealModeSSSP],di
+		shl ebx,4
+		add edi,ebx		; Create linear address
+
+		mov esi,[esp+8*4]	; Source regs
+		xor ecx,ecx
+		mov cl,11		; 44 bytes to copy
+		rep movsd
+
+		; EAX is already set up to be CS:IP
+		stosd			; Save in stack frame
+		mov eax,.rm_return	; Return seg:offs
+		stosd			; Save in stack frame
+		mov eax,[edi-12]	; Return flags
+		and eax,0x200ed7	; Mask (potentially) unsafe flags
+		mov [edi-12],eax	; Primary flags entry
+		stosw			; Return flags
+
+		mov bx,.rm
+		jmp enter_rm	; Go to real mode
+
+		bits 16
+		section .text16
+.rm:
+		mov ax,sp
+		add ax,9*4+4*2
+		mov [CallbackSP],ax
+		pop gs
+		pop fs
+		pop es
+		pop ds
+		popad
+		popfd
+		retf				; Invoke routine
+
+.rm_return:
+		; We clean up SP here because we don't know if the
+		; routine returned with RET, RETF or IRET
+		mov sp,[cs:CallbackSP]
+		pushfd
+		pushad
+		push ds
+		push es
+		push fs
+		push gs
+		mov ebx,.pm_return
+		jmp enter_pm
+
+		; On return, the 44-byte return structure is on the
+		; real-mode stack, plus the 10 additional bytes used
+		; by the target address (see above.)
+		bits 32
+		section .text
+.pm_return:
+		movzx esi,word [word RealModeSSSP]
+		movzx eax,word [word RealModeSSSP+2]
+		mov edi,[esp+9*4]	; Dest regs
+		shl eax,4
+		add esi,eax		; Create linear address
+		and edi,edi		; NULL pointer?
+		jnz .do_copy
+.no_copy:	mov edi,esi		; Do a dummy copy-to-self
+.do_copy:	xor ecx,ecx
+		mov cl,11		; 44 bytes
+		rep movsd		; Copy register block
+
+		add dword [word RealModeSSSP],54
+					; Remove from stack
+
+		pop dword [CallbackSP]
+		pop edi
+		pop esi
+		pop ebp
+		pop ebx
+		popfd
+		ret			; Return to 32-bit program
+
+;
+; Cfarcall invocation.  We copy the stack frame to the real-mode stack,
+; followed by the return CS:IP and the CS:IP of the target function.
+; The value of IF is copied from the calling routine.
+;
+		global core_cfarcall
+core_cfarcall:
+		pushfd				; Save IF among other things...
+		push ebx
+		push ebp
+		push esi
+		push edi
+		push dword [CallbackSP]
+
+		cld
+		mov ecx,[esp+9*4]		; Size of stack frame
+
+		movzx edi,word [word RealModeSSSP]
+		movzx ebx,word [word RealModeSSSP+2]
+		mov [word CallbackSP],di
+		sub edi,ecx		; Allocate space for stack frame
+		and edi,~3		; Round
+		sub edi,4*3		; Return pointer, return value, EFLAGS
+		mov [word RealModeSSSP],di
+		shl ebx,4
+		add edi,ebx		; Create linear address
+
+		mov eax,[esp+5*4]	; EFLAGS from entry
+		and eax,0x202		; IF only
+		stosd
+		mov eax,[esp+7*4]	; CS:IP
+		stosd			; Save to stack frame
+		mov eax,.rm_return	; Return seg:off
+		stosd
+		mov esi,[esp+8*4]	; Stack frame
+		mov eax,ecx		; Copy the stack frame
+		shr ecx,2
+		rep movsd
+		mov ecx,eax
+		and ecx,3
+		rep movsb
+
+		mov bx,.rm
+		jmp enter_rm
+
+		bits 16
+		section .text16
+.rm:
+		popfd
+		retf
+.rm_return:
+		mov sp,[cs:CallbackSP]
+		mov esi,eax
+		mov ebx,.pm_return
+		jmp enter_pm
+
+		bits 32
+		section .text
+.pm_return:
+		mov eax,esi
+		; EDX already set up to be the RM return value
+		pop dword [CallbackSP]
+		pop ebx
+		pop ebp
+		pop esi
+		pop edi
+		popfd
+		ret
+
+		bits 16
+		section .bss16
+		alignb 4
+CallbackSP	resd 1			; SP saved during callback
+
+		bits 16
+		section .text16
diff --git a/contrib/syslinux-4.02/core/cleanup.inc b/contrib/syslinux-4.02/core/cleanup.inc
new file mode 100644
index 0000000..300584c
--- /dev/null
+++ b/contrib/syslinux-4.02/core/cleanup.inc
@@ -0,0 +1,60 @@
+;; -----------------------------------------------------------------------
+;;
+;;   Copyright 2007-2008 H. Peter Anvin - All Rights Reserved
+;;
+;;   This program is free software; you can redistribute it and/or modify
+;;   it under the terms of the GNU General Public License as published by
+;;   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
+;;   Boston MA 02111-1307, USA; either version 2 of the License, or
+;;   (at your option) any later version; incorporated herein by reference.
+;;
+;; -----------------------------------------------------------------------
+
+;;
+;; cleanup.inc
+;;
+;; Some final tidying before jumping to a kernel or bootsector
+;;
+
+		section .text16
+;
+; cleanup_hardware:
+;
+;	Shut down anything transient.  *No segment assumptions*.
+;	Preserves all registers.
+;
+cleanup_hardware:
+		pushad
+;
+; Linux wants the floppy motor shut off before starting the kernel,
+; at least bootsect.S seems to imply so.  If we don't load the floppy
+; driver, this is *definitely* so!
+;
+		xor ax,ax
+		xor dx,dx
+		int 13h
+
+%if 0		; This bug report has not been substantiated!
+; Vmware crashes if we scroll in the decompressor!  Try to detect vmware
+; and if it is Vmware, clear the screen...
+		mov eax,'VMXh'
+		xor ebx, ebx
+		mov ecx, 10		; Get version
+		mov dx, 'VX'
+		in eax, dx
+		cmp ebx, 'VMXh'
+		jne .no_vmware
+
+		mov ax,0x0003		; Set mode (clear screen/home cursor)
+		int 10h
+.no_vmware:
+%endif
+
+		call comboot_cleanup_api
+
+		call timer_cleanup
+
+		popad
+
+		; If we enabled serial port interrupts, clean them up now
+		jmp sirq_cleanup
diff --git a/contrib/syslinux-4.02/core/cmdline.inc b/contrib/syslinux-4.02/core/cmdline.inc
new file mode 100644
index 0000000..3e63f9a
--- /dev/null
+++ b/contrib/syslinux-4.02/core/cmdline.inc
@@ -0,0 +1,101 @@
+;; -----------------------------------------------------------------------
+;;
+;;   Copyright 2003-2009 H. Peter Anvin - All Rights Reserved
+;;   Copyright 2009 Intel Corporation; author: H. Peter Anvin
+;;
+;;   This program is free software; you can redistribute it and/or modify
+;;   it under the terms of the GNU General Public License as published by
+;;   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
+;;   Boston MA 02111-1307, USA; either version 2 of the License, or
+;;   (at your option) any later version; incorporated herein by reference.
+;;
+;; -----------------------------------------------------------------------
+
+;;
+;; cmdline.inc
+;;
+;; Common routine to assemble [null-terminated] command line into
+;; real_mode_seg:cmd_line_here.
+;; Not used by plain kernel due to BOOT_IMAGE= etc.
+;;
+
+		section .text16
+
+;
+; Assumes DS == CS
+;
+make_plain_cmdline:
+		push es
+		; ui.inc has already copied any APPEND options
+		mov ax,real_mode_seg
+		mov es,ax
+
+		mov di,[CmdLinePtr]
+		call do_ip_append
+
+		mov si,[CmdOptPtr]
+
+		call strcpy
+
+		dec di
+		mov [CmdLinePtr],di
+		mov byte [es:di],0		; Null-terminate
+
+		pop es
+		ret
+
+;
+; Actual IPAppend strings...
+;
+%if IS_PXELINUX
+		extern IPOption, BOOTIFStr, SYSUUIDStr
+		global IPAppends, numIPAppends
+
+		section .data16
+		alignz 2
+IPAppends	dw IPOption
+		dw BOOTIFStr
+		dw SYSUUIDStr
+numIPAppends	equ ($-IPAppends)/2
+%else
+IPAppends	equ 0
+numIPAppends	equ 0
+%endif
+
+;
+; Handle "ipappend" strings, if applicable
+;
+; Assumes DS == CS; pushes output to ES:DI
+;
+		section .text16
+
+do_ip_append:
+%ifndef DEPEND
+ %if numIPAppends > 0
+		push cx
+		push bx
+		push si
+
+		mov bx,IPAppends
+		mov cx,[IPAppend]
+		and cx,(1 << numIPAppends)-1
+.loop:
+		jcxz .done
+		mov si,[bx]
+		inc bx
+		inc bx
+		test cl,1
+		jz .not_this
+
+		call strcpy
+		mov byte [es:di-1],' '	; Replace final null with space
+.not_this:
+		shr cx,1
+		jmp .loop
+.done:
+		pop si
+		pop bx
+		pop cx
+ %endif
+%endif
+		ret
diff --git a/contrib/syslinux-4.02/core/codepage.S b/contrib/syslinux-4.02/core/codepage.S
new file mode 100644
index 0000000..4f1d483
--- /dev/null
+++ b/contrib/syslinux-4.02/core/codepage.S
@@ -0,0 +1,5 @@
+	.section ".rodata","a"
+	.globl	codepage
+codepage:
+	.incbin "codepage.cp"
+	.size	codepage, .-codepage
diff --git a/contrib/syslinux-4.02/core/com32.inc b/contrib/syslinux-4.02/core/com32.inc
new file mode 100644
index 0000000..111590c
--- /dev/null
+++ b/contrib/syslinux-4.02/core/com32.inc
@@ -0,0 +1,145 @@
+;; -----------------------------------------------------------------------
+;;
+;;   Copyright 1994-2009 H. Peter Anvin - All Rights Reserved
+;;   Copyright 2009-2010 Intel Corporation; author: H. Peter Anvin
+;;
+;;   This program is free software; you can redistribute it and/or modify
+;;   it under the terms of the GNU General Public License as published by
+;;   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
+;;   Boston MA 02111-1307, USA; either version 2 of the License, or
+;;   (at your option) any later version; incorporated herein by reference.
+;;
+;; -----------------------------------------------------------------------
+
+;;
+;; com32.inc
+;;
+;; Common code for running a COM32 image
+;;
+
+		extern pm_api_vector
+
+;
+; Load a COM32 image.  A COM32 image is the 32-bit analogue to a DOS
+; .com file.  A COM32 image is loaded at address 0x101000, with %esp
+; set to the high end of usable memory.
+;
+; A COM32 image should begin with the magic bytes:
+; B8 FF 4C CD 21, which is "mov eax,0x21cd4cff" in 32-bit mode and
+; "mov ax,0x4cff; int 0x21" in 16-bit mode.  This will abort the
+; program with an error if run in 16-bit mode.
+;
+com32_entry	equ	free_high_memory
+
+		section .text16
+is_com32_image:
+		push si			; Save file handle
+		push eax		; Save file length
+
+		call make_plain_cmdline
+		; Copy the command line into the low cmdline buffer
+		mov ax,real_mode_seg
+		mov fs,ax
+		mov si,cmd_line_here
+		mov di,command_line
+		mov cx,[CmdLinePtr]
+		inc cx			; Include final null
+		sub cx,si
+		fs rep movsb
+
+		mov si,KernelName
+		mov di,Com32Name
+		call strcpy
+
+		call comboot_setup_api	; Set up the COMBOOT-style API
+
+		mov edi,com32_entry	; Load address
+		pop eax			; File length
+		pop si			; File handle
+		xor dx,dx		; No padding
+		mov bx,abort_check	; Don't print dots, but allow abort
+		call load_high
+
+		mov esi,com32_entry
+		mov edi,trackbuf
+		mov ecx,5
+		call bcopy
+		cmp dword [trackbuf],0xcd4cfeb8
+		jne not_com32r
+		cmp byte [trackbuf+4],0x21
+		jne not_com32r
+
+com32_start:
+		;
+		; Point the stack to the end of (permitted) high memory
+		;
+		mov eax,[HighMemRsvd]
+		xor ax,ax			; Align to a 64K boundary
+		mov [PMESP],eax
+		mov ebx,.pm			; Where to go in PM
+		jmp enter_pm
+
+;
+; This is invoked right before the actually starting the COM32
+; progam, in 32-bit mode...
+;
+		bits 32
+		section .text
+.pm:
+		; Set up the calling stack frame
+
+		push dword pm_api_vector
+		push dword Com32Name		; Module filename
+		push dword [HighMemSize]	; Memory managed by Syslinux
+		push dword core_cfarcall	; Cfarcall entry point
+		push dword core_farcall		; Farcall entry point
+		push dword (1 << 16)		; 64K bounce buffer
+		push dword core_real_mode	; Bounce buffer address
+		push dword core_intcall		; Intcall entry point
+		push dword command_line		; Command line pointer
+		push dword 9			; Argument count
+		sti				; Interrupts OK now
+		call com32_entry		; Run the program...
+		; ... on return, fall through to com32_exit ...
+com32_exit:
+		mov bx,comboot_return
+		jmp enter_rm
+
+		bits 16
+		section .text16
+not_com32r:
+		mov si,KernelName
+		call writestr
+		mov si,not_com32r_msg
+		call writestr
+		jmp enter_command
+
+		section .data16
+not_com32r_msg	db ': not a COM32R image', CR, LF, 0
+
+		; Ersatz com32 invocation structure, to make libcom32
+		; code run the same if linked to the core.  This is in
+		; the .data16 segment so HighMemSize can live here.
+		;
+		; Danger, Will Robinson: it's not clear the use of
+		; core_xfer_buf is safe here.
+		global __entry_esp, __com32
+		alignz 4
+__entry_esp:
+		dd 0				; Dummy to avoid _exit issues
+__com32:
+		dd 9				; Argument count
+		dd 0				; No command line
+		dd core_intcall			; Intcall entry point
+		dd 0				; Bounce buffer address
+		dd 0				; 64K bounce buffer
+		dd core_farcall			; Farcall entry point
+		dd core_cfarcall		; Cfarcall entry point
+HighMemSize	dd 0				; End of memory pointer (bytes)
+		dd 0				; No module name
+		dd pm_api_vector		; Protected mode functions
+
+		section .uibss
+Com32Name	resb FILENAME_MAX
+
+		section .text16
diff --git a/contrib/syslinux-4.02/core/comboot.inc b/contrib/syslinux-4.02/core/comboot.inc
new file mode 100644
index 0000000..59db7ec
--- /dev/null
+++ b/contrib/syslinux-4.02/core/comboot.inc
@@ -0,0 +1,1010 @@
+;; -----------------------------------------------------------------------
+;;
+;;   Copyright 1994-2009 H. Peter Anvin - All Rights Reserved
+;;   Copyright 2009-2010 Intel Corporation; author: H. Peter Anvin
+;;
+;;   This program is free software; you can redistribute it and/or modify
+;;   it under the terms of the GNU General Public License as published by
+;;   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
+;;   Boston MA 02111-1307, USA; either version 2 of the License, or
+;;   (at your option) any later version; incorporated herein by reference.
+;;
+;; -----------------------------------------------------------------------
+
+;;
+;; comboot.inc
+;;
+;; Common code for running a COMBOOT image
+;;
+
+		section .text16
+
+; Parameter registers definition; this is the definition
+; of the stack frame used by INT 21h and INT 22h.
+%define		P_FLAGS		word [bp+44]
+%define		P_FLAGSL	byte [bp+44]
+%define		P_FLAGSH	byte [bp+45]
+%define		P_CS		word [bp+42]
+%define		P_IP		word [bp+40]
+%define		P_CSIP		dword [bp+40]
+%define		P_DS		word [bp+38]
+%define		P_ES		word [bp+36]
+%define		P_FS		word [bp+34]
+%define		P_GS		word [bp+32]
+%define		P_EAX		dword [bp+28]
+%define		P_AX		word [bp+28]
+%define		P_HAX		word [bp+30]
+%define		P_AL		byte [bp+28]
+%define		P_AH		byte [bp+29]
+%define		P_ECX		dword [bp+24]
+%define		P_CX		word [bp+24]
+%define		P_HCX		word [bp+26]
+%define		P_CL		byte [bp+24]
+%define		P_CH		byte [bp+25]
+%define		P_EDX		dword [bp+20]
+%define		P_DX		word [bp+20]
+%define		P_HDX		word [bp+22]
+%define		P_DL		byte [bp+20]
+%define		P_DH		byte [bp+21]
+%define		P_EBX		dword [bp+16]
+%define		P_BX		word [bp+16]
+%define		P_HBX		word [bp+18]
+%define		P_BL		byte [bp+16]
+%define		P_BH		byte [bp+17]
+%define		P_EBP		dword [bp+8]
+%define		P_BP		word [bp+8]
+%define		P_HBP		word [bp+10]
+%define		P_ESI		dword [bp+4]
+%define		P_SI		word [bp+4]
+%define		P_HSI		word [bp+6]
+%define		P_EDI		dword [bp]
+%define		P_DI		word [bp]
+%define		P_HDI		word [bp+2]
+
+; Looks like a COMBOOT image but too large
+comboot_too_large:
+		pm_call pm_close_file
+		mov si,err_comlarge
+		call writestr
+		jmp enter_command
+
+;
+; Load a COMBOOT image.  A COMBOOT image is basically a DOS .COM file,
+; except that it may, of course, not contain any DOS system calls.  We
+; do, however, allow the execution of INT 20h to return to SYSLINUX.
+;
+is_comboot_image:
+		push si			; Save file handle
+
+		call make_plain_cmdline
+
+		call comboot_setup_api
+
+		mov cx,comboot_seg
+		mov es,cx
+
+		xor di,di
+		mov cx,64		; 256 bytes (size of PSP)
+		xor eax,eax		; Clear PSP
+		rep stosd
+
+		mov word [es:0], 020CDh	; INT 20h instruction
+		; First non-free paragraph
+		; This is valid because comboot_seg == real_mode_seg
+		; == the highest segment used by all derivatives
+		int 12h			; Get DOS memory size
+		shl ax,6		; Kilobytes -> paragraphs
+		mov word [es:02h],ax
+
+%ifndef DEPEND
+%if real_mode_seg != comboot_seg
+%error "This code assumes real_mode_seg == comboot_seg"
+%endif
+%endif
+		; Copy the command line from high memory
+		mov si,cmd_line_here
+		mov cx,125		; Max cmdline len (minus space and CR)
+		mov di,081h		; Offset in PSP for command line
+		mov al,' '		; DOS command lines begin with a space
+		stosb
+
+.loop:		es lodsb
+		and al,al
+		jz .done
+		stosb
+		loop .loop
+.done:
+
+		mov al,0Dh		; CR after last character
+		stosb
+		mov ax,di
+		sub al,82h		; Include space but not CR
+		mov [es:80h],al		; Store command line length
+
+		; Now actually load the file...
+		pop si			; File handle
+		mov bx,100h		; Load at <seg>:0100h
+		mov cx,0FF00h		; Maximum number of bytes
+		pm_call getfsbytes
+		cmp ecx,65536-256-2	; Maximum size
+		ja comboot_too_large
+
+		; And invoke the program...
+		mov ax,es
+		mov ds,ax
+		mov ss,ax
+		xor sp,sp
+		push word 0		; Return to address 0 -> exit
+
+		jmp comboot_seg:100h	; Run it
+
+;
+; Set up the COMBOOT API interrupt vectors.  This is now done at
+; initialization time.
+;
+comboot_setup_api:
+		mov di,DOSErrTramp	; Error trampolines
+		mov cx,32
+		push cx
+		mov eax,02EB206Ah	; push 20h; jmp $+4
+.loop1:		stosd
+		inc ah
+		loop .loop1
+		dec di
+		mov byte [di-1],0E9h
+		mov ax,comboot_bogus-2
+		sub ax,di
+		stosw
+
+		pop cx			; CX <- 32
+		mov si,4*20h		; DOS interrupt vectors
+		mov bx,comboot_vectors
+		mov di,DOSSaveVectors
+.loop2:
+		movsd
+		movzx eax,word [bx]
+		inc bx
+		inc bx
+		mov [si-4],eax
+		loop .loop2
+		ret
+
+;
+; Restore the original state of the COMBOOT API vectors, and free
+; any low memory allocated by the comboot module.
+;
+comboot_cleanup_api:
+		pusha
+		mov si,DOSSaveVectors
+		mov di,4*20h
+		mov cx,20h
+		rep movsd		; Restore DOS-range vectors
+		popa
+		ret
+
+		section .bss16
+		alignb 4
+DOSSaveVectors	resd 32
+
+		section .data16
+%define comboot_err(x) (DOSErrTramp+4*((x)-20h))
+
+comboot_vectors:
+		dw comboot_return	; INT 20 = exit
+		dw comboot_int21	; INT 21 = DOS-compatible system calls
+		dw comboot_int22	; INT 22 = native system calls
+		dw comboot_err(23h)	; INT 23 = DOS Ctrl-C handler
+		dw comboot_err(24h)	; INT 24 = DOS critical error handler
+		dw comboot_err(25h)	; INT 25 = DOS absolute disk read
+		dw comboot_err(26h)	; INT 26 = DOS absolute disk write
+		dw comboot_err(27h)	; INT 27 = DOS TSR
+		dw comboot_int28	; INT 28 = DOS idle interrupt
+		dw comboot_int29	; INT 29 = DOS fast console output
+		dw comboot_err(2Ah)	; INT 2A = DOS network API (NetBIOS)
+		dw comboot_err(2Bh)	; INT 2B = DOS reserved
+		dw comboot_err(2Ch)	; INT 2C = DOS reserved
+		dw comboot_iret		; INT 2D = DOS reserved, AMIS
+		dw comboot_err(2Eh)	; INT 2E = DOS run command
+		dw comboot_iret		; INT 2F = DOS multiplex interrupt
+		dw comboot_err(30h)	; INT 30 = DOS CP/M system calls
+		dw comboot_err(31h)	; INT 31 = DPMI
+		dw comboot_err(32h)	; INT 32 = DOS reserved
+		dw comboot_iret		; INT 33 = DOS mouse API
+		dw comboot_err(34h)	; INT 34 = DOS FPU emulation
+		dw comboot_err(35h)	; INT 35 = DOS FPU emulation
+		dw comboot_err(36h)	; INT 36 = DOS FPU emulation
+		dw comboot_err(37h)	; INT 37 = DOS FPU emulation
+		dw comboot_err(38h)	; INT 38 = DOS FPU emulation
+		dw comboot_err(39h)	; INT 39 = DOS FPU emulation
+		dw comboot_err(3Ah)	; INT 3A = DOS FPU emulation
+		dw comboot_err(3Bh)	; INT 3B = DOS FPU emulation
+		dw comboot_err(3Ch)	; INT 3C = DOS FPU emulation
+		dw comboot_err(3Dh)	; INT 3D = DOS FPU emulation
+		dw comboot_err(3Eh)	; INT 3E = DOS FPU emulation
+		dw comboot_err(3Fh)	; INT 3F = DOS overlay manager
+
+		section .text16
+
+; INT 21h: generic DOS system call
+comboot_int21:	sti
+		push ds
+		push es
+		push fs
+		push gs
+		pushad
+		cld
+		mov bp,cs
+		mov ds,bp
+		mov es,bp
+		mov bp,sp			; Set up stack frame
+
+		call adjust_screen		; The COMBOOT program might have changed the screen
+
+		mov cx,int21_count
+		mov si,int21_table
+.again:		lodsb
+		cmp al,P_AH
+		lodsw
+		loopne .again
+		; The last function in the list is the
+		; "no such function" function
+		clc
+		call ax			; Call the invoked function
+comboot_resume:
+		mov bp,sp		; In case the function clobbers BP
+		setc P_FLAGSL		; Propagate CF->error
+		popad
+		pop gs
+		pop fs
+		pop es
+		pop ds
+comboot_iret:
+		iret
+
+comboot_bad_int21:
+		mov ax,P_AX
+		push P_CSIP
+		push 21h
+		; Fall through
+
+; Attempted to execute invalid DOS system call
+; The interrupt number is on the stack.
+comboot_bogus:	pop dx			; Interrupt number
+		pop edi			; CS:IP
+		mov cx,err_notdos
+		push comboot_bogus_tail
+		jmp comboot_exit_msg
+comboot_bogus_tail:
+		xchg ax,dx
+		call writehex2		; Interrupt number
+		mov al,' '
+		call writechr
+		xchg ax,dx
+		call writehex4		; Function number (AX)
+		mov al,' '
+		call writechr
+		mov eax,edi
+		call writehex8		; CS:IP of the origin
+		call crlf
+		jmp enter_command
+
+; Proper return vector
+; Note: this gets invoked both via INT 21h and directly via INT 20h.
+; We don't need to cld explicitly here, because comboot_exit does that
+; when invoking RESET_STACK_AND_SEGS.
+comboot_return:
+		cli			; May not have a safe stack
+		push enter_command	; Normal return to command prompt
+		; jmp comboot_exit
+
+;
+; Generic COMBOOT return to command line code
+;  stack -> where to go next
+;     CX -> message (for _msg version)
+;
+		extern comboot_cleanup_lowmem
+comboot_exit:
+		xor cx,cx
+comboot_exit_msg:
+		pop bx			; Return address
+		RESET_STACK_AND_SEGS si	; Contains sti, cld
+		pm_call comboot_cleanup_lowmem
+		call adjust_screen	; The COMBOOT program might have changed the screen
+		jcxz .nomsg
+		mov si,KernelName
+		call writestr
+		mov si,cx
+		call writestr
+.nomsg:
+		jmp bx
+
+;
+; INT 21h system calls
+;
+comboot_getkey:				; 01 = get key with echo
+		call vgashowcursor
+		call comboot_getchar
+		call vgahidecursor
+		call writechr
+		clc
+		ret
+
+comboot_writechr:			; 02 = writechr
+		mov al,P_DL
+		call writechr
+		clc
+		ret
+
+comboot_writeserial:			; 04 = write serial port
+		mov al,P_DL
+		call write_serial
+		clc
+		ret
+
+comboot_getkeynoecho:			; 08 = get key w/o echo
+		call comboot_getchar
+		clc
+		ret
+
+comboot_writestr:			; 09 = write DOS string
+		mov es,P_DS
+		mov si,P_DX
+.loop:		es lodsb
+		cmp al,'$'		; End string with $ - bizarre
+		je .done
+		call writechr
+		jmp short .loop
+.done:		clc
+		ret
+
+comboot_checkkey:			; 0B = check keyboard status
+		cmp byte [APIKeyFlag],00h
+		jnz .waiting
+		call pollchar
+.waiting:	setz al
+		dec al			; AL = 0FFh if present, 0 if not
+		mov P_AL,al
+		clc
+		ret
+
+comboot_checkver:			; 30 = check DOS version
+		; We return 0 in all DOS-compatible version registers,
+		; but the high part of eax-ebx-ecx-edx spell "SYSLINUX"
+		mov P_EAX,'SY' << 16
+		mov P_EBX,'SL' << 16
+		mov P_ECX,'IN' << 16
+		mov P_EDX,'UX' << 16
+		ret
+
+comboot_getchar:
+		cmp byte [APIKeyFlag],00h
+		jne .queued
+		call getchar		; If not queued get input
+		and al,al		; Function key?  (CF <- 0)
+		jnz .done
+		mov [APIKeyWait],ah	; High part of key
+		inc byte [APIKeyFlag]	; Set flag
+.done:		mov P_AL,al
+		ret
+.queued:	mov al,[APIKeyWait]
+		dec byte [APIKeyFlag]
+		jmp .done
+
+;
+; INT 28h - DOS idle
+;
+comboot_int28:
+		sti
+		cld
+		call do_idle
+		iret
+
+;
+; INT 29h - DOS fast write character
+;
+comboot_int29:
+		sti
+		cld
+		call writechr			; Preserves registers!
+		iret
+
+;
+; INT 22h - SYSLINUX-specific system calls
+;           System call number in ax
+;
+comboot_int22:
+		sti
+		push ds
+		push es
+		push fs
+		push gs
+		pushad
+		cld
+		mov bp,cs
+		mov ds,bp
+		mov es,bp
+		mov bp,sp			; Set up stack frame
+
+		call adjust_screen		; The COMBOOT program might have changed the screen
+
+		cmp ax,int22_count
+		jb .ok
+		xor ax,ax			; Function 0 -> unimplemented
+.ok:
+		xchg ax,bx
+		add bx,bx			; CF <- 0
+		call [bx+int22_table]
+		jmp comboot_resume		; On return
+
+;
+; INT 22h AX=0000h	Unimplemented call
+;
+comapi_err:
+		stc
+		ret
+
+;
+; INT 22h AX=0001h	Get SYSLINUX version
+;
+comapi_get_version:
+		; Number of API functions supported
+		mov P_AX,int22_count
+		; SYSLINUX version
+		mov P_CX,(VERSION_MAJOR << 8)+VERSION_MINOR
+		; SYSLINUX derivative ID byte
+		mov P_DX,my_id
+		; For future use
+		mov P_BX,cs	; cs == 0
+
+		mov P_ES,ds
+		; ES:SI -> version banner
+		mov P_SI,syslinux_banner + 2	; Skip leading CR LF
+		; ES:DI -> copyright string
+		mov P_DI,copyright_str + 1	; Skip leading space
+
+comapi_nop:
+		clc
+		ret
+
+;
+; INT 22h AX=0002h	Write string
+;
+; Write null-terminated string in ES:BX
+;
+comapi_writestr:
+		mov ds,P_ES
+		mov si,P_BX
+		call writestr
+		clc
+		ret
+
+;
+; INT 22h AX=0003h	Run command
+;
+; Terminates the COMBOOT program and executes the command line in
+; ES:BX as if it had been entered by the user.
+;
+comapi_run:
+		mov ds,P_ES
+		mov si,P_BX
+		mov di,command_line
+		call strcpy
+		push load_kernel		; Run a new kernel
+		jmp comboot_exit		; Terminate task, clean up
+
+;
+; INT 22h AX=0004h	Run default command
+;
+; Terminates the COMBOOT program and executes the default command line
+; as if a timeout had happened or the user pressed <Enter>.
+;
+comapi_run_default:
+		push auto_boot
+		jmp comboot_exit
+
+;
+; INT 22h AX=0005h	Force text mode
+;
+; Puts the video in standard text mode
+;
+comapi_textmode:
+		call vgaclearmode
+		clc
+		ret
+
+;
+; INT 22h AX=0006h	Open file
+;
+comapi_open:
+		mov es,P_ES
+		mov si,P_SI
+		pm_call pm_open_file
+		mov P_EAX,eax
+		mov P_CX,cx
+		mov P_SI,si
+		ret
+
+;
+; INT 22h AX=0007h	Read file
+;
+comapi_read:
+		mov es,P_ES
+		mov bx,P_BX
+		mov si,P_SI
+		mov cx,P_CX
+		pm_call getfssec
+		jnc .noteof
+		xor si,si		; SI <- 0 on EOF, CF <- 0
+.noteof:	mov P_SI,si
+		mov P_ECX,ecx
+		ret
+
+;
+; INT 22h AX=0008h	Close file
+;
+comapi_close:
+		mov si,P_SI
+		pm_call pm_close_file
+		clc
+		ret
+
+;
+; INT 22h AX=0009h	Call PXE stack
+;
+%if IS_PXELINUX
+comapi_pxecall:
+		mov bx,P_BX
+		mov es,P_ES
+		mov di,P_DI
+		call pxenv
+		mov ax,[PXEStatus]
+		mov P_AX,ax
+		ret
+%else
+comapi_pxecall	equ comapi_err			; Not available
+%endif
+
+;
+; INT 22h AX=000Ah	Get Derivative-Specific Info
+;
+comapi_derinfo:
+		mov P_AL,my_id
+%if IS_PXELINUX
+		mov ax,[APIVer]
+		mov P_DX,ax
+		mov ax,[StrucPtr]
+		mov P_BX,ax
+		mov ax,[StrucPtr+2]
+		mov P_ES,ax
+		mov ax,[InitStack]
+		mov P_SI,ax
+		mov ax,[InitStack+2]
+		mov P_FS,ax
+		mov eax,[IPInfo.MyIP]
+		mov P_ECX,eax
+		mov P_GS,0
+		mov P_DI,IPInfo
+%else
+		; Physical medium...
+
+		mov al,[SectorShift]
+		mov P_CL,al
+		mov al,[DriveNumber]
+		mov P_DL,al
+		mov P_FS,cs
+		mov P_SI,OrigESDI
+		mov P_GS,cs
+		mov P_DI,Hidden
+%if IS_SYSLINUX || IS_EXTLINUX
+		mov P_ES,cs
+		mov P_BX,PartInfo
+%elif IS_ISOLINUX
+		mov P_ES,cs
+		mov P_BX,spec_packet
+		mov ax,[BIOSType]
+		sub ax,bios_cdrom
+		shr ax,2
+		mov P_CH,al		; Mode (el torito/cbios/ebios)
+%endif
+%endif
+		clc
+		ret
+
+;
+; INT 22h AX=000Bh	Get Serial Console Configuration
+;
+comapi_serialcfg:
+		mov ax,[SerialPort]
+		mov P_DX,ax
+		mov ax,[BaudDivisor]
+		mov P_CX,ax
+		mov ax,[FlowControl]
+		or al,ah
+		mov ah,[FlowIgnore]
+		shr ah,4
+		test byte [DisplayCon],01h
+		jnz .normalconsole
+		or ah,80h
+.normalconsole:
+		mov P_BX,ax
+		clc
+		ret
+
+;
+; INT 22h AX=000Ch	Perform final cleanup
+;
+comapi_cleanup:
+%if IS_PXELINUX
+		; Unload PXE if requested
+		test dl,3
+		setnz [KeepPXE]
+		sub bp,sp		; unload_pxe may move the stack around
+		pm_call unload_pxe
+		add bp,sp		; restore frame pointer...
+%elif IS_SYSLINUX || IS_EXTLINUX
+		; Restore original FDC table
+		mov eax,[OrigFDCTabPtr]
+		mov [fdctab],eax
+%endif
+		call cleanup_hardware
+		clc
+		ret
+
+;
+; INT 22h AX=000Dh	Clean up then replace bootstrap
+;
+comapi_chainboot:
+		call comapi_cleanup
+		mov eax,P_EDI
+		mov [trackbuf+4],eax		; Copy from
+		mov eax,P_ECX
+		mov [trackbuf+8],eax		; Total bytes
+		mov eax,7C00h
+		mov [trackbuf],eax		; Copy to
+		push eax			; Entry point on stack
+		mov esi,P_ESI
+		mov edx,P_EBX
+		mov bx,P_DS
+		jmp replace_bootstrap_one
+
+;
+; INT 22h AX=000Eh	Get configuration file name
+;
+comapi_configfile:
+		mov P_ES,cs
+		mov P_BX,ConfigName
+		clc
+		ret
+
+;
+; INT 22h AX=000Fh	Get IPAPPEND strings
+;
+comapi_ipappend:
+		mov P_ES,cs
+		mov P_CX,numIPAppends
+		mov P_BX,IPAppends
+		clc
+		ret
+
+;
+; INT 22h AX=0010h	Resolve hostname
+;
+%if IS_PXELINUX
+                extern pxe_dns_resolv
+comapi_dnsresolv:
+		mov ds,P_ES
+		mov si,P_BX
+		pm_call pxe_dns_resolv
+		mov P_EAX,eax
+		clc
+		ret
+%else
+comapi_dnsresolv equ comapi_err
+%endif
+
+		section .text16
+
+;
+; INT 22h AX=0011h	Obsolete
+;
+
+;
+; INT 22h AX=0012h	Obsolete
+;
+
+;
+; INT 22h AX=0013h	Idle call
+;
+comapi_idle:
+		call do_idle
+		clc
+		ret
+
+;
+; INT 22h AX=0014h	Local boot
+;
+%if HAS_LOCALBOOT
+comapi_localboot:
+		mov ax,P_DX
+		jmp local_boot
+%else
+comapi_localboot equ comapi_err
+%endif ; HAS_LOCALBOOT
+
+;
+; INT 22h AX=0015h	Feature flags
+;
+comapi_features:
+		mov P_ES,cs
+		mov P_BX,feature_flags
+		mov P_CX,feature_flags_len
+		clc
+		ret
+
+;
+; INT 22h AX=0016h	Run kernel image
+;
+comapi_runkernel:
+		mov al,P_DL
+		cmp al,VK_TYPES-1
+		ja .error
+		mov [KernelType],al
+
+		; It's not just possible, but quite likely, that ES:BX
+		; points into real_mode_seg or xfer_buf_seg, so we
+		; need to exercise some special care here... use
+		; VKernelBuf for temporary storage.
+		push ds
+		mov ds,P_ES
+		mov si,P_BX
+		mov di,VKernelBuf
+		call strcpy
+		pop ds
+
+		push ds
+		mov ds,P_DS
+		mov si,P_SI
+		mov di,KernelName
+		pm_call pm_mangle_name
+		pop ds
+		pm_call pm_searchdir
+		jz comapi_err
+
+		; The kernel image was found, so we can load it...
+		mov [Kernel_SI],si
+		mov [Kernel_EAX],eax
+
+%if IS_PXELINUX
+		mov al,P_CL
+		mov [IPAppend],al
+%endif
+
+		call comboot_exit
+
+.finish:
+		; Copy the command line into its proper place
+		push es
+		mov dx,real_mode_seg
+		mov es,dx
+		mov si,VKernelBuf
+		mov di,cmd_line_here
+		call strcpy
+		mov word [es:di-1],' '	; Simulate APPEND: space plus null
+		pop es
+		mov [CmdLinePtr],di
+		mov word [CmdOptPtr],zero_string
+		jmp kernel_good_saved
+
+.error		equ comapi_usingvga.error
+
+;
+; INT 22h AX=0017h  Report video mode change
+;
+comapi_usingvga:
+		mov ax,P_BX
+		cmp ax,0Fh		; Unknown flags = failure
+		ja .error
+		mov [UsingVGA],al
+		mov cx,P_CX
+		mov dx,P_DX
+		mov [GXPixCols],cx
+		mov [GXPixRows],dx
+		test al,08h
+		jnz .notext
+		call adjust_screen
+.notext:
+		clc
+		ret
+.error:
+		stc
+		ret
+
+;
+; INT 22h AX=0018h  Query custom font
+;
+comapi_userfont:
+		mov al,[UserFont]
+		and al,al
+		jz .done
+		mov al,[VGAFontSize]
+		mov P_ES,aux_seg
+		mov P_BX,aux.fontbuf
+
+.done:		; CF=0 here
+		mov P_AL,al
+		ret
+
+;
+; INT 22h AX=0019h  Read disk
+;
+%if IS_SYSLINUX || IS_ISOLINUX || IS_EXTLINUX
+comapi_readdisk:
+		cmp P_EDI,0		; Reserved for future expansion
+		jnz .err
+		mov eax,P_EDX
+		mov edx,P_ESI
+		mov es,P_ES
+		mov bx,P_BX
+		mov bp,P_CX		; WE CANNOT use P_* after touching bp!
+		call getlinsec
+		clc
+		ret
+.err:
+		stc
+		ret
+%else
+comapi_readdisk	equ comapi_err
+%endif
+
+;
+; INT 22h AX=001Ah	Obsolete
+;
+
+;
+; INT 22h AX=001Bh	Obsolete
+;
+
+;
+; INT 22h AX=001Ch	Get pointer to auxillary data vector
+;
+comapi_getadv:
+		mov P_ES,ds
+		mov P_BX,adv0.data
+		mov P_CX,ADV_LEN
+		ret
+
+;
+; INT 22h AX=001Dh	Write auxillary data vector
+;
+comapi_writeadv	equ adv_write
+
+;
+; INT 22h AX=001Eh	Keyboard remapping table
+comapi_kbdtable:
+		cmp P_DX,0
+		jne .err
+		mov P_AX,1			; Version
+		mov P_CX,256			; Length
+		mov P_ES,cs
+		mov P_BX,KbdMap
+		ret
+.err:
+		stc
+		ret
+
+;
+; INT 22h AX=001Fh	Get current working directory
+;
+comapi_getcwd:
+		mov P_ES,cs
+		mov P_BX,CurrentDirName
+		clc
+		ret
+
+;
+; INT 22h AX=0023h	Query shuffler size
+;
+comapi_shufsize:
+		; +15 is padding to guarantee alignment
+		mov P_CX,__bcopyxx_len + 15
+		ret
+
+;
+; INT 22h AX=0024h	Cleanup, shuffle and boot raw
+;
+comapi_shufraw:
+		call comapi_cleanup
+		mov edi,P_EDI
+		mov esi,P_ESI
+		mov ecx,P_ECX
+		jmp shuffle_and_boot_raw
+
+		section .data16
+
+%macro		int21 2
+		db %1
+		dw %2
+%endmacro
+
+int21_table:
+		int21	00h, comboot_return
+		int21	01h, comboot_getkey
+		int21	02h, comboot_writechr
+		int21	04h, comboot_writeserial
+		int21	08h, comboot_getkeynoecho
+		int21	09h, comboot_writestr
+		int21	0Bh, comboot_checkkey
+		int21	30h, comboot_checkver
+		int21	4Ch, comboot_return
+		int21	 -1, comboot_bad_int21
+int21_count	equ ($-int21_table)/3
+
+		alignz 2
+int22_table:
+		dw comapi_err		; 0000 unimplemented syscall
+		dw comapi_get_version	; 0001 get SYSLINUX version
+		dw comapi_writestr	; 0002 write string
+		dw comapi_run		; 0003 run specified command
+		dw comapi_run_default	; 0004 run default command
+		dw comapi_textmode	; 0005 force text mode
+		dw comapi_open		; 0006 open file
+		dw comapi_read		; 0007 read file
+		dw comapi_close		; 0008 close file
+		dw comapi_pxecall	; 0009 call PXE stack
+		dw comapi_derinfo	; 000A derivative-specific info
+		dw comapi_serialcfg	; 000B get serial port config
+		dw comapi_cleanup	; 000C perform final cleanup
+		dw comapi_err		; 000D clean up then bootstrap
+		dw comapi_configfile	; 000E get name of config file
+		dw comapi_ipappend	; 000F get ipappend strings
+		dw comapi_dnsresolv	; 0010 resolve hostname
+		dw comapi_err		; 0011 maximum shuffle descriptors
+		dw comapi_err		; 0012 cleanup, shuffle and boot
+		dw comapi_idle		; 0013 idle call
+		dw comapi_localboot	; 0014 local boot
+		dw comapi_features	; 0015 feature flags
+		dw comapi_runkernel	; 0016 run kernel image
+		dw comapi_usingvga	; 0017 report video mode change
+		dw comapi_userfont	; 0018 query custom font
+		dw comapi_readdisk	; 0019 read disk
+		dw comapi_err		; 001A cleanup, shuffle and boot to pm
+		dw comapi_err		; 001B cleanup, shuffle and boot to rm
+		dw comapi_getadv	; 001C get pointer to ADV
+		dw comapi_writeadv	; 001D write ADV to disk
+		dw comapi_kbdtable	; 001E keyboard remapping table
+		dw comapi_getcwd	; 001F get current working directory
+		dw comapi_err		; 0020 open directory
+		dw comapi_err		; 0021 read directory
+		dw comapi_err		; 0022 close directory
+		dw comapi_shufsize	; 0023 query shuffler size
+		dw comapi_shufraw	; 0024 cleanup, shuffle and boot raw
+int22_count	equ ($-int22_table)/2
+
+APIKeyWait	db 0
+APIKeyFlag	db 0
+
+zero_string	db 0			; Empty, null-terminated string
+
+;
+; This is the feature flag array for INT 22h AX=0015h
+;
+; Note: PXELINUX clears the idle is noop flag if appropriate
+; in pxe_detect_nic_type
+;
+feature_flags:
+		db 1			; Have local boot, idle is not noop
+feature_flags_len equ ($-feature_flags)
+
+err_notdos	db ': attempted DOS system call INT ',0
+err_comlarge	db 'COMBOOT image too large.', CR, LF, 0
+
+		section .bss16
+		alignb 4
+DOSErrTramp	resd	33		; Error trampolines
+
+		global ConfigName
+ConfigName	resb	FILENAME_MAX
+%ifndef HAVE_CURRENTDIRNAME
+		global CurrentDirName
+CurrentDirName	resb	FILENAME_MAX
+%endif
diff --git a/contrib/syslinux-4.02/core/common.inc b/contrib/syslinux-4.02/core/common.inc
new file mode 100644
index 0000000..7078011
--- /dev/null
+++ b/contrib/syslinux-4.02/core/common.inc
@@ -0,0 +1,25 @@
+;
+; Modules common to all derivatives.  Do not include modules in this list
+; which have special section requirements (i.e. need to be in .init for
+; some derivatives.)
+;
+
+%include "getc.inc"		; getc et al
+%include "conio.inc"		; Console I/O
+%include "configinit.inc"	; Initialize configuration
+%include "parseconfig.inc"	; High-level config file handling
+%include "parsecmd.inc"		; Low-level config file handling
+%include "pm.inc"		; Protected mode
+%include "bcopy32.inc"		; 32-bit bcopy
+%include "loadhigh.inc"		; Load a file into high memory
+%include "font.inc"		; VGA font stuff
+%include "graphics.inc"		; VGA graphics
+%include "highmem.inc"		; High memory sizing
+%include "strcpy.inc"           ; strcpy()
+%include "idle.inc"		; Idle handling
+%include "adv.inc"		; Auxillary Data Vector
+%include "timer.inc"		; Timer handling
+
+; Note: the prefix section is included late, to avoid problems with some
+; versions of NASM that had issues with forward references to EQU symbols.
+%include "prefix.inc"		; Prefix section for prepcore
diff --git a/contrib/syslinux-4.02/core/config.inc b/contrib/syslinux-4.02/core/config.inc
new file mode 100644
index 0000000..269e13e
--- /dev/null
+++ b/contrib/syslinux-4.02/core/config.inc
@@ -0,0 +1,45 @@
+;; -----------------------------------------------------------------------
+;;
+;;   Copyright 2002-2009 H. Peter Anvin - All Rights Reserved
+;;   Copyright 2009 Intel Corporation; author: H. Peter Anvin
+;;
+;;   This program is free software; you can redistribute it and/or modify
+;;   it under the terms of the GNU General Public License as published by
+;;   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
+;;   Boston MA 02111-1307, USA; either version 2 of the License, or
+;;   (at your option) any later version; incorporated herein by reference.
+;;
+;; -----------------------------------------------------------------------
+
+;;
+;; config.inc
+;;
+;; Common configuration options.  Some of these are imposed by the kernel.
+;;
+
+%ifndef _CONFIG_INC
+%define _CONFIG_INC
+
+max_cmd_len	equ 2047		; Must be &3; 2047 is the kernel limit
+HIGHMEM_MAX	equ 037FFFFFFh		; DEFAULT highest address for an initrd
+DEFAULT_BAUD	equ 9600		; Default baud rate for serial port
+BAUD_DIVISOR	equ 115200		; Serial port parameter
+MAX_FKEYS	equ 12			; Number of F-key help files
+
+;
+; Local boot supported
+;
+%assign	HAS_LOCALBOOT 1
+
+;
+; log2(Max filename size Including final null)
+;
+FILENAME_MAX_LG2 equ 8
+FILENAME_MAX	 equ (1 << FILENAME_MAX_LG2)	; Max mangled filename size
+
+;
+; Version number definitinons
+;
+%include "../version.gen"
+
+%endif ; _CONFIG_INC
diff --git a/contrib/syslinux-4.02/core/configinit.inc b/contrib/syslinux-4.02/core/configinit.inc
new file mode 100644
index 0000000..915e77f
--- /dev/null
+++ b/contrib/syslinux-4.02/core/configinit.inc
@@ -0,0 +1,51 @@
+;; -----------------------------------------------------------------------
+;;
+;;   Copyright 1994-2008 H. Peter Anvin - All Rights Reserved
+;;   Copyright 2009-2010 Intel Corporation; author: H. Peter Anvin
+;;
+;;   This program is free software; you can redistribute it and/or modify
+;;   it under the terms of the GNU General Public License as published by
+;;   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
+;;   Boston MA 02111-1307, USA; either version 2 of the License, or
+;;   (at your option) any later version; incorporated herein by reference.
+;;
+;; -----------------------------------------------------------------------
+
+;;
+;; configinit.inc
+;;
+;; Initialize the configuration section
+;;
+
+		section .text16
+
+reset_config:
+		call highmemsize
+
+		; Initialize the .config section
+		xor eax,eax
+		mov si,__config_lma
+		mov di,__config_start
+		mov cx,__config_dwords
+		rep movsd
+
+%ifndef DEPEND
+%if NULLFILE != 0
+		mov al,NULLFILE
+		mov di,FKeyName
+		mov cx,MAX_FKEYS*(1 << FILENAME_MAX_LG2)
+		rep stosb
+%endif
+%endif
+
+		mov di,KbdMap			; Default keymap 1:1
+		xor al,al
+		inc ch				; CX <- 256
+mkkeymap:	stosb
+		inc al
+		loop mkkeymap
+
+		mov eax,[HighMemSize]
+		mov [VKernelEnd],eax
+
+		ret
diff --git a/contrib/syslinux-4.02/core/conio.inc b/contrib/syslinux-4.02/core/conio.inc
new file mode 100644
index 0000000..b450502
--- /dev/null
+++ b/contrib/syslinux-4.02/core/conio.inc
@@ -0,0 +1,431 @@
+;; -----------------------------------------------------------------------
+;;
+;;   Copyright 1994-2008 H. Peter Anvin - All Rights Reserved
+;;   Copyright 2009 Intel Corporation; author: H. Peter Anvin
+;;
+;;   This program is free software; you can redistribute it and/or modify
+;;   it under the terms of the GNU General Public License as published by
+;;   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
+;;   Boston MA 02111-1307, USA; either version 2 of the License, or
+;;   (at your option) any later version; incorporated herein by reference.
+;;
+;; -----------------------------------------------------------------------
+
+;;
+;; conio.inc
+;;
+;; Console I/O code, except:
+;;   writechr, writestr_early	- module-dependent
+;;   writestr, crlf		- writestr.inc
+;;   writehex*			- writehex.inc
+;;
+
+;
+; loadkeys:	Load a LILO-style keymap; file is open on the top of the
+;		getc stack.
+;
+		section .text16
+
+loadkeys:
+		mov cx,256
+		mov di,trackbuf
+		call readc
+		jc .done				; EOF already?
+
+		; Make sure we are at EOF now...
+		call getc
+		jnc .done			; We should be at EOF now!
+
+		; It was okay, we can now move it into the KbdMap
+		mov si,trackbuf
+		mov di,KbdMap
+		mov cx,256 >> 2
+		rep movsd
+
+.done:
+		call close
+		ret
+
+;
+; get_msg_file: Load a text file and write its contents to the screen,
+;               interpreting color codes.  Call with the file already
+;		on the top of the open/getc stack.
+;
+;		Assumes CS == DS == ES.
+;
+get_msg_file:
+                mov byte [TextAttribute],07h	; Default grey on white
+		mov byte [DisplayMask],07h	; Display text in all modes
+		call msg_initvars
+
+print_msg_file:
+.getc:
+		call getc
+		jc .done
+                cmp al,1Ah                      ; DOS EOF?
+		je .done
+		movzx cx,byte [UsingVGA]
+		and cl,01h
+		inc cx				; CL <- 01h = text mode,
+						;       02h = graphics mode
+                call [NextCharJump]		; Do what shall be done
+		jmp .getc
+.done:
+		jmp close			; Tailcall!
+
+msg_putchar:                                    ; Normal character
+                cmp al,0Fh                      ; ^O = color code follows
+                je msg_ctrl_o
+                cmp al,0Dh                      ; Ignore <CR>
+                je msg_ignore
+                cmp al,0Ah                      ; <LF> = newline
+                je msg_newline
+                cmp al,0Ch                      ; <FF> = clear screen
+                je msg_formfeed
+		cmp al,07h			; <BEL> = beep
+		je msg_beep
+		cmp al,19h			; <EM> = return to text mode
+		je msg_novga
+		cmp al,18h			; <CAN> = VGA filename follows
+		je msg_vga
+		jnb .not_modectl
+		cmp al,10h			; 10h to 17h are mode controls
+		jae msg_modectl
+.not_modectl:
+
+msg_normal:	call write_serial_displaymask	; Write to serial port
+		test [DisplayMask],cl
+		jz msg_ignore			; Not screen
+		test byte [DisplayCon],01h
+		jz msg_ignore
+                mov bl,[TextAttribute]
+		mov bh,[BIOS_page]
+                mov ah,09h                      ; Write character/attribute
+                mov cx,1                        ; One character only
+                int 10h                         ; Write to screen
+                mov al,[CursorCol]
+                inc ax
+                cmp al,[VidCols]
+                ja msg_line_wrap		; Screen wraparound
+                mov [CursorCol],al
+
+msg_gotoxy:     mov bh,[BIOS_page]
+                mov dx,[CursorDX]
+                mov ah,02h                      ; Set cursor position
+                int 10h
+msg_ignore:     ret
+
+msg_beep:	mov ax,0E07h			; Beep
+		xor bx,bx
+		int 10h
+		ret
+
+msg_ctrl_o:                                     ; ^O = color code follows
+                mov word [NextCharJump],msg_setbg
+                ret
+msg_newline:                                    ; Newline char or end of line
+		mov si,crlf_msg
+		call write_serial_str_displaymask
+msg_line_wrap:					; Screen wraparound
+		test [DisplayMask],cl
+		jz msg_ignore
+                mov byte [CursorCol],0
+                mov al,[CursorRow]
+                inc ax
+                cmp al,[VidRows]
+                ja msg_scroll
+                mov [CursorRow],al
+                jmp short msg_gotoxy
+msg_scroll:     xor cx,cx                       ; Upper left hand corner
+                mov dx,[ScreenSize]
+                mov [CursorRow],dh		; New cursor at the bottom
+                mov bh,[ScrollAttribute]
+                mov ax,0601h                    ; Scroll up one line
+                int 10h
+                jmp short msg_gotoxy
+msg_formfeed:                                   ; Form feed character
+		mov si,crff_msg
+		call write_serial_str_displaymask
+		test [DisplayMask],cl
+		jz msg_ignore
+                xor cx,cx
+                mov [CursorDX],cx		; Upper lefthand corner
+                mov dx,[ScreenSize]
+                mov bh,[TextAttribute]
+                mov ax,0600h                    ; Clear screen region
+                int 10h
+                jmp msg_gotoxy
+msg_setbg:                                      ; Color background character
+                call unhexchar
+                jc msg_color_bad
+                shl al,4
+		test [DisplayMask],cl
+		jz .dontset
+                mov [TextAttribute],al
+.dontset:
+                mov word [NextCharJump],msg_setfg
+                ret
+msg_setfg:                                      ; Color foreground character
+                call unhexchar
+                jc msg_color_bad
+		test [DisplayMask],cl
+		jz .dontset
+                or [TextAttribute],al		; setbg set foreground to 0
+.dontset:
+		jmp short msg_putcharnext
+msg_vga:
+		mov word [NextCharJump],msg_filename
+		mov di, VGAFileBuf
+		jmp short msg_setvgafileptr
+
+msg_color_bad:
+                mov byte [TextAttribute],07h	; Default attribute
+msg_putcharnext:
+                mov word [NextCharJump],msg_putchar
+		ret
+
+msg_filename:					; Getting VGA filename
+		cmp al,0Ah			; <LF> = end of filename
+		je msg_viewimage
+		cmp al,' '
+		jbe msg_ret			; Ignore space/control char
+		mov di,[VGAFilePtr]
+		cmp di,VGAFileBufEnd
+		jnb msg_ret
+		mov [di],al			; Can't use stosb (DS:)
+		inc di
+msg_setvgafileptr:
+		mov [VGAFilePtr],di
+msg_ret:	ret
+
+msg_novga:
+		call vgaclearmode
+		jmp short msg_initvars
+
+msg_viewimage:
+		mov si,[VGAFilePtr]
+		mov byte [si],0			; Zero-terminate filename
+		mov si,VGAFileBuf
+		mov di,VGAFileMBuf
+		pm_call pm_mangle_name
+		call core_open
+		jz msg_putcharnext		; Not there
+		call vgadisplayfile
+		; Fall through
+
+		; Subroutine to initialize variables, also needed
+		; after loading a graphics file
+msg_initvars:
+                pusha
+                mov bh,[BIOS_page]
+                mov ah,03h                      ; Read cursor position
+                int 10h
+                mov [CursorDX],dx
+                popa
+		jmp short msg_putcharnext	; Initialize state machine
+
+msg_modectl:
+		and al,07h
+		mov [DisplayMask],al
+		jmp short msg_putcharnext
+
+;
+; write_serial:	If serial output is enabled, write character on serial port
+; write_serial_displaymask: d:o, but ignore if DisplayMask & 04h == 0
+;
+write_serial_displaymask:
+		test byte [DisplayMask], 04h
+		jz write_serial.end
+write_serial:
+		pushfd
+		pushad
+		mov bx,[SerialPort]
+		and bx,bx
+		je .noserial
+		push ax
+		mov ah,[FlowInput]
+.waitspace:
+		; Wait for space in transmit register
+		lea dx,[bx+5]			; DX -> LSR
+		in al,dx
+		test al,20h
+		jz .waitspace
+
+		; Wait for input flow control
+		inc dx				; DX -> MSR
+		in al,dx
+		and al,ah
+		cmp al,ah
+		jne .waitspace
+.no_flow:
+
+		xchg dx,bx			; DX -> THR
+		pop ax
+		slow_out dx,al			; Send data
+.noserial:	popad
+		popfd
+.end:		ret
+
+;
+; write_serial_str: write_serial for strings
+; write_serial_str_displaymask: d:o, but ignore if DisplayMask & 04h == 0
+;
+write_serial_str_displaymask:
+		test byte [DisplayMask], 04h
+		jz write_serial_str.end
+
+write_serial_str:
+.loop		lodsb
+		and al,al
+		jz .end
+		call write_serial
+		jmp short .loop
+.end:		ret
+
+;
+; pollchar: check if we have an input character pending (ZF = 0)
+;
+pollchar:
+		pushad
+		mov ah,11h		; Poll keyboard
+		int 16h
+		jnz .done		; Keyboard response
+		mov dx,[SerialPort]
+		and dx,dx
+		jz .done		; No serial port -> no input
+		mov ax,[SerialTail]	; Already-queued input?
+		cli
+		cmp ax,[SerialHead]
+		jne .done_sti		; If so, return ZF = 0
+		add dx,5		; DX -> LSR
+		in al,dx
+		test al,1		; ZF = 0 if data pending
+		jz .done_sti
+		inc dx			; DX -> MSR
+		mov ah,[FlowIgnore]	; Required status bits
+		in al,dx
+		and al,ah
+		cmp al,ah
+		setne al
+		dec al			; Set ZF = 0 if equal
+.done_sti:	sti
+.done:		popad
+		ret
+
+;
+; getchar: Read a character from keyboard or serial port
+;
+getchar.sti_again:
+		sti
+getchar:
+.again:
+		call do_idle
+		mov ah,11h		; Poll keyboard
+		int 16h
+		jnz .kbd		; Keyboard input?
+		mov bx,[SerialPort]
+		and bx,bx
+		jz .again
+		mov ax,[SerialTail]
+		cli
+		cmp ax,[SerialHead]
+		jne .serial_queued
+		lea dx,[bx+5]		; DX -> LSR
+		in al,dx
+		test al,1
+		jz .sti_again
+		inc dx			; DX -> MSR
+		mov ah,[FlowIgnore]
+		in al,dx
+		and al,ah
+		cmp al,ah
+		jne .sti_again
+.serial:	xor ah,ah		; Avoid confusion
+		mov dx,bx		; Data port
+		in al,dx		; Read data
+		sti
+		jmp .done
+.serial_queued:
+		sti			; We already know we'll consume data
+		xchg bx,ax
+		push ds
+		mov ax,aux_seg + (aux.serial >> 4)
+		mov ds,ax
+		mov al,[bx]
+		pop ds
+		inc bx
+		and bx,serial_buf_size-1
+		mov [SerialTail],bx
+		jmp .done
+
+.kbd:		mov ah,10h		; Get keyboard input
+		int 16h
+		cmp al,0E0h
+		jnz .not_ext
+		xor al,al
+.not_ext:
+		and al,al
+		jz .func_key
+		mov bx,KbdMap		; Convert character sets
+		xlatb
+.func_key:
+.done:
+		jmp reset_idle		; Character received
+
+%ifdef DEBUG_TRACERS
+;
+; debug hack to print a character with minimal code impact
+;
+debug_tracer:	pushad
+		pushfd
+		mov bp,sp
+		mov bx,[bp+9*4]		; Get return address
+		mov al,[cs:bx]		; Get data byte
+		inc word [bp+9*4]	; Return to after data byte
+		call writechr
+		popfd
+		popad
+		ret
+%endif	; DEBUG_TRACERS
+
+		section .data16
+%if IS_ISOLINUX == 0			; Defined elsewhere for ISOLINUX
+crlf_msg	db CR, LF
+null_msg	db 0
+%endif
+crff_msg	db CR, FF, 0
+
+		section .config
+		; This is a word to pc_setint16 can set it
+DisplayCon	dw 01h			; Console display enabled
+
+ScrollAttribute	db 07h			; Grey on white (normal text color)
+
+		section .bss16
+		alignb 2
+NextCharJump    resw 1			; Routine to interpret next print char
+CursorDX        equ $
+CursorCol       resb 1			; Cursor column for message file
+CursorRow       resb 1			; Cursor row for message file
+ScreenSize      equ $
+VidCols         resb 1			; Columns on screen-1
+VidRows         resb 1			; Rows on screen-1
+
+; Serial console stuff; don't put this in .config becasue we don't want
+; loading a new config file to undo this setting.
+		section .data16
+		alignz 4
+SerialPort	dw 0			; Serial port base (or 0 for no serial port)
+BaudDivisor	dw 115200/9600		; Baud rate divisor
+FlowControl	equ $
+FlowOutput	db 0			; Outputs to assert for serial flow
+FlowInput	db 0			; Input bits for serial flow
+FlowIgnore	db 0			; Ignore input unless these bits set
+FlowDummy	db 0			; Unused
+
+		section .bss16
+TextAttribute   resb 1			; Text attribute for message file
+DisplayMask	resb 1			; Display modes mask
+
+		section .text16
+%include "serirq.inc"
diff --git a/contrib/syslinux-4.02/core/console.c b/contrib/syslinux-4.02/core/console.c
new file mode 100644
index 0000000..282c57f
--- /dev/null
+++ b/contrib/syslinux-4.02/core/console.c
@@ -0,0 +1,22 @@
+#include <stddef.h>
+#include <com32.h>
+#include <stdio.h>
+#include <string.h>
+
+void myputchar(int c)
+{
+    static com32sys_t ireg;
+
+    if (c == '\n')
+	myputchar('\r');
+
+    ireg.eax.b[1] = 0x02;
+    ireg.edx.b[0] = c;
+    __intcall(0x21, &ireg, NULL);
+}
+
+void myputs(const char *str)
+{
+    while (*str)
+	myputchar(*str++);
+}
diff --git a/contrib/syslinux-4.02/core/diskfs.inc b/contrib/syslinux-4.02/core/diskfs.inc
new file mode 100644
index 0000000..9f18c76
--- /dev/null
+++ b/contrib/syslinux-4.02/core/diskfs.inc
@@ -0,0 +1,173 @@
+; -*- fundamental -*- (asm-mode sucks)
+; -----------------------------------------------------------------------
+;   
+;   Copyright 1994-2009 H. Peter Anvin - All Rights Reserved
+;   Copyright 2009 Intel Corporation; author: H. Peter Anvin
+;
+;   This program is free software; you can redistribute it and/or modify
+;   it under the terms of the GNU General Public License as published by
+;   the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+;   Boston MA 02110-1301, USA; either version 2 of the License, or
+;   (at your option) any later version; incorporated herein by reference.
+;
+; -----------------------------------------------------------------------
+
+;
+; diskfs.inc
+;
+; Common code for conventional disk-based filesystems
+;
+
+;
+; Some semi-configurable constants... change on your own risk.
+;
+NULLFILE	equ 0			; Null character == empty filename
+NULLOFFSET	equ 0			; Position in which to look
+retry_count	equ 16			; How patient are we with the disk?
+%assign HIGHMEM_SLOP 0			; Avoid this much memory near the top
+LDLINUX_MAGIC	equ 0x3eb202fe		; A random number to identify ourselves with
+
+SECTOR_SHIFT	equ 9
+SECTOR_SIZE	equ (1 << SECTOR_SHIFT)
+
+;
+; The following structure is used for "virtual kernels"; i.e. LILO-style
+; option labels.  The options we permit here are `kernel' and `append
+; Since there is no room in the bottom 64K for all of these, we
+; stick them in high memory and copy them down before we need them.
+;
+		struc vkernel
+vk_vname:	resb FILENAME_MAX	; Virtual name **MUST BE FIRST!**
+vk_rname:	resb FILENAME_MAX	; Real name
+vk_appendlen:	resw 1
+vk_type:	resb 1			; Type of file
+		alignb 4
+vk_append:	resb max_cmd_len+1	; Command line
+		alignb 4
+vk_end:		equ $			; Should be <= vk_size
+		endstruc
+
+
+
+; ---------------------------------------------------------------------------
+;   BEGIN CODE
+; ---------------------------------------------------------------------------
+
+;
+; Memory below this point is reserved for the BIOS and the MBR
+;
+		section .earlybss
+		global trackbuf
+trackbufsize	equ 8192
+trackbuf	resb trackbufsize	; Track buffer goes here
+		; ends at 2800h
+
+;
+; Common bootstrap code for disk-based derivatives
+;
+%include "diskstart.inc"
+
+
+;
+; Now, everything is "up and running"... patch kaboom for more
+; verbosity and using the full screen system
+;
+		; E9 = JMP NEAR
+		mov di,kaboom.patch
+		mov al,0e9h
+		stosb
+		mov ax,kaboom2-2
+		sub ax,di
+		stosw
+
+;
+; Now we're all set to start with our *real* business.	First load the
+; configuration file (if any) and parse it.
+;
+; In previous versions I avoided using 32-bit registers because of a
+; rumour some BIOSes clobbered the upper half of 32-bit registers at
+; random.  I figure, though, that if there are any of those still left
+; they probably won't be trying to install Linux on them...
+;
+; The code is still ripe with 16-bitisms, though.  Not worth the hassle
+; to take'm out.  In fact, we may want to put them back if we're going
+; to boot ELKS at some point.
+;
+
+;
+; Load configuration file
+;
+		pm_call load_config
+		jz no_config_file
+
+;
+; Now we have the config file open.  Parse the config file and
+; run the user interface.
+;
+%include "ui.inc"
+
+;
+;
+; kaboom2: once everything is loaded, replace the part of kaboom
+;	   starting with "kaboom.patch" with this part
+
+kaboom2:
+		mov si,err_bootfailed
+		call writestr
+		cmp byte [kaboom.again+1],18h	; INT 18h version?
+		je .int18
+		call getchar
+		call vgaclearmode
+		int 19h			; And try once more to boot...
+.norge:		jmp short .norge	; If int 19h returned; this is the end
+.int18:
+		call vgaclearmode
+		int 18h
+.noreg:		jmp short .noreg	; Nynorsk
+
+; -----------------------------------------------------------------------------
+;  Common modules
+; -----------------------------------------------------------------------------
+
+%include "common.inc"		; Universal modules
+%include "plaincon.inc"		; writechr
+%include "writestr.inc"		; String output
+%include "writehex.inc"		; Hexadecimal output
+%include "localboot.inc"	; Disk-based local boot
+
+; -----------------------------------------------------------------------------
+;  Begin data section
+; -----------------------------------------------------------------------------
+
+		section .data16
+copyright_str   db ' Copyright (C) 1994-'
+		asciidec YEAR
+		db ' H. Peter Anvin et al', CR, LF, 0
+err_bootfailed	db CR, LF, 'Boot failed: please change disks and press '
+		db 'a key to continue.', CR, LF, 0
+
+;
+; Config file keyword table
+;
+%include "keywords.inc"
+
+;
+; Extensions to search for (in *forward* order).
+;
+		alignz 4
+exten_table:	db '.cbt'		; COMBOOT (specific)
+%if IS_SYSLINUX
+		db '.bss'		; Boot sector (add superblock)
+%endif
+		db '.bs', 0		; Boot sector
+		db '.com'		; COMBOOT (same as DOS)
+		db '.c32'		; COM32
+exten_table_end:
+		dd 0, 0			; Need 8 null bytes here
+
+;
+; Misc initialized (data) variables
+;
+%ifdef debug				; This code for debugging only
+debug_magic	dw 0D00Dh		; Debug code sentinel
+%endif
diff --git a/contrib/syslinux-4.02/core/diskstart.inc b/contrib/syslinux-4.02/core/diskstart.inc
new file mode 100644
index 0000000..c0ba52a
--- /dev/null
+++ b/contrib/syslinux-4.02/core/diskstart.inc
@@ -0,0 +1,874 @@
+; -----------------------------------------------------------------------
+;
+;   Copyright 1994-2009 H. Peter Anvin - All Rights Reserved
+;   Copyright 2009-2010 Intel Corporation; author: H. Peter Anvin
+;
+;   This program is free software; you can redistribute it and/or modify
+;   it under the terms of the GNU General Public License as published by
+;   the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+;   Boston MA 02110-1301, USA; either version 2 of the License, or
+;   (at your option) any later version; incorporated herein by reference.
+;
+; -----------------------------------------------------------------------
+
+;
+; diskstart.inc
+;
+; Common early-bootstrap code for harddisk-based Syslinux derivatives.
+;
+
+		section .init
+;
+; Some of the things that have to be saved very early are saved
+; "close" to the initial stack pointer offset, in order to
+; reduce the code size...
+;
+
+StackBuf	equ STACK_TOP-44-92	; Start the stack here (grow down - 4K)
+PartInfo	equ StackBuf
+.mbr		equ PartInfo
+.gptlen		equ PartInfo+16
+.gpt		equ PartInfo+20
+FloppyTable	equ PartInfo+76
+; Total size of PartInfo + FloppyTable == 76+16 = 92 bytes
+Hidden		equ StackBuf-20		; Partition offset
+OrigFDCTabPtr	equ StackBuf-12		; The 2nd high dword on the stack
+OrigESDI	equ StackBuf-8		; The high dword on the stack
+DriveNumber	equ StackBuf-4		; Drive number
+StackHome	equ Hidden		; The start of the canonical stack
+
+;
+; Primary entry point.  Tempting as though it may be, we can't put the
+; initial "cli" here; the jmp opcode in the first byte is part of the
+; "magic number" (using the term very loosely) for the DOS superblock.
+;
+bootsec		equ $
+_start:		jmp short start		; 2 bytes
+		nop			; 1 byte
+;
+; "Superblock" follows -- it's in the boot sector, so it's already
+; loaded and ready for us
+;
+bsOemName	db MY_NAME		; The SYS command sets this, so...
+		zb 8-($-bsOemName)
+
+;
+; These are the fields we actually care about.  We end up expanding them
+; all to dword size early in the code, so generate labels for both
+; the expanded and unexpanded versions.
+;
+%macro		superb 1
+bx %+ %1	equ SuperInfo+($-superblock)*8+4
+bs %+ %1	equ $
+		zb 1
+%endmacro
+%macro		superw 1
+bx %+ %1	equ SuperInfo+($-superblock)*8
+bs %+ %1	equ $
+		zw 1
+%endmacro
+%macro		superd 1
+bx %+ %1	equ $			; no expansion for dwords
+bs %+ %1	equ $
+		zd 1
+%endmacro
+superblock	equ $
+		superw BytesPerSec
+		superb SecPerClust
+		superw ResSectors
+		superb FATs
+		superw RootDirEnts
+		superw Sectors
+		superb Media
+		superw FATsecs
+		superw SecPerTrack
+		superw Heads
+superinfo_size	equ ($-superblock)-1	; How much to expand
+		superd Hidden
+		superd HugeSectors
+		;
+		; This is as far as FAT12/16 and FAT32 are consistent
+		;
+		; FAT12/16 need 26 more bytes,
+		; FAT32 need 54 more bytes
+		;
+superblock_len_fat16	equ $-superblock+26
+superblock_len_fat32	equ $-superblock+54
+		zb 54			; Maximum needed size
+superblock_max	equ $-superblock
+
+		global SecPerClust
+SecPerClust	equ bxSecPerClust
+
+;
+; Note we don't check the constraints above now; we did that at install
+; time (we hope!)
+;
+start:
+		cli			; No interrupts yet, please
+		cld			; Copy upwards
+;
+; Set up the stack
+;
+		xor cx,cx
+		mov ss,cx
+		mov sp,StackBuf-2	; Just below BSS (-2 for alignment)
+		push dx			; Save drive number (in DL)
+		push es			; Save initial ES:DI -> $PnP pointer
+		push di
+		mov es,cx
+
+;
+; DS:SI may contain a partition table entry and possibly a GPT entry.
+; Preserve it for us.  This saves 56 bytes of the GPT entry, which is
+; currently the maximum we care about.  Total is 76 bytes.
+;
+		mov cl,(16+4+56)/2	; Save partition info
+		mov di,PartInfo
+		rep movsw		; This puts CX back to zero
+
+		mov ds,cx		; Now we can initialize DS...
+
+;
+; Now sautee the BIOS floppy info block to that it will support decent-
+; size transfers; the floppy block is 11 bytes and is stored in the
+; INT 1Eh vector (brilliant waste of resources, eh?)
+;
+; Of course, if BIOSes had been properly programmed, we wouldn't have
+; had to waste precious space with this code.
+;
+		mov bx,fdctab
+		lfs si,[bx]		; FS:SI -> original fdctab
+		push fs			; Save on stack in case we need to bail
+		push si
+
+		; Save the old fdctab even if hard disk so the stack layout
+		; is the same.  The instructions above do not change the flags
+		and dl,dl		; If floppy disk (00-7F), assume no
+					; partition table
+		js harddisk
+
+floppy:
+		xor ax,ax
+		mov cl,6		; 12 bytes (CX == 0)
+		; es:di -> FloppyTable already
+		; This should be safe to do now, interrupts are off...
+		mov [bx],di		; FloppyTable
+		mov [bx+2],ax		; Segment 0
+		fs rep movsw		; Faster to move words
+		mov cl,[bsSecPerTrack]  ; Patch the sector count
+		mov [di-76+8],cl
+
+		push ax			; Partition offset == 0
+		push ax
+		push ax
+		push ax
+
+		int 13h			; Some BIOSes need this
+		jmp short not_harddisk
+;
+; The drive number and possibly partition information was passed to us
+; by the BIOS or previous boot loader (MBR).  Current "best practice" is to
+; trust that rather than what the superblock contains.
+;
+; Note: di points to beyond the end of PartInfo
+;
+harddisk:
+		test byte [di-76],7Fh	; Sanity check: "active flag" should
+		jnz .no_partition	; be 00 or 80
+		cmp [di-76+4],cl	; Sanity check: partition type != 0
+		je .no_partition
+		cmp eax,'!GPT'		; !GPT signature?
+		jne .mbr
+		cmp byte [di-76+4],0EDh	; Synthetic GPT partition entry?
+		jne .mbr
+.gpt:					; GPT-style partition info
+		push dword [di-76+20+36]
+		push dword [di-76+20+32]
+		jmp .gotoffs
+.mbr:					; MBR-style partition info
+		push cx			; Upper half partition offset == 0
+		push cx
+		push dword [di-76+8]	; Partition offset (dword)
+		jmp .gotoffs
+.no_partition:
+;
+; No partition table given... assume that the Hidden field in the boot sector
+; tells the truth (in particular, is zero if this is an unpartitioned disk.)
+;
+		push cx
+		push cx
+		push dword [bsHidden]
+.gotoffs:
+;
+; Get disk drive parameters (don't trust the superblock.)  Don't do this for
+; floppy drives -- INT 13:08 on floppy drives will (may?) return info about
+; what the *drive* supports, not about the *media*.  Fortunately floppy disks
+; tend to have a fixed, well-defined geometry which is stored in the superblock.
+;
+		; DL == drive # still
+		mov ah,08h
+		int 13h
+		jc no_driveparm
+		and ah,ah
+		jnz no_driveparm
+		shr dx,8
+		inc dx			; Contains # of heads - 1
+		mov [bsHeads],dx
+		and cx,3fh
+		mov [bsSecPerTrack],cx
+no_driveparm:
+not_harddisk:
+;
+; Ready to enable interrupts, captain
+;
+		sti
+
+;
+; Do we have EBIOS (EDD)?
+;
+eddcheck:
+		mov bx,55AAh
+		mov ah,41h		; EDD existence query
+		mov dl,[DriveNumber]
+		int 13h
+		jc .noedd
+		cmp bx,0AA55h
+		jne .noedd
+		test cl,1		; Extended disk access functionality set
+		jz .noedd
+		;
+		; We have EDD support...
+		;
+		mov byte [getonesec.jmp+1],(getonesec_ebios-(getonesec.jmp+2))
+.noedd:
+
+;
+; Load the first sector of LDLINUX.SYS; this used to be all proper
+; with parsing the superblock and root directory; it doesn't fit
+; together with EBIOS support, unfortunately.
+;
+		mov eax,strict dword 0xdeadbeef
+Sect1Ptr0	equ $-4
+		mov edx,strict dword 0xfeedface
+Sect1Ptr1	equ $-4
+		mov bx,ldlinux_sys	; Where to load it
+		call getonesec
+
+		; Some modicum of integrity checking
+		cmp dword [ldlinux_magic+4],LDLINUX_MAGIC^HEXDATE
+		jne kaboom
+
+		; Go for it...
+		jmp 0:ldlinux_ent
+
+
+;
+; getonesec: load a single disk linear sector EDX:EAX into the buffer
+;	     at ES:BX.
+;
+;            This routine assumes CS == DS == SS, and trashes most registers.
+;
+; Stylistic note: use "xchg" instead of "mov" when the source is a register
+; that is dead from that point; this saves space.  However, please keep
+; the order to dst,src to keep things sane.
+;
+getonesec:
+		add eax,[Hidden]		; Add partition offset
+		adc edx,[Hidden+4]
+		mov cx,retry_count
+.jmp:		jmp strict short getonesec_cbios
+
+;
+; getonesec_ebios:
+;
+; getonesec implementation for EBIOS (EDD)
+;
+getonesec_ebios:
+.retry:
+		; Form DAPA on stack
+		push edx
+		push eax
+		push es
+		push bx
+		push word 1
+		push word 16
+		mov si,sp
+		pushad
+                mov ah,42h                      ; Extended Read
+		call xint13
+		popad
+		lea sp,[si+16]			; Remove DAPA
+		jc .error
+                ret
+
+.error:
+		; Some systems seem to get "stuck" in an error state when
+		; using EBIOS.  Doesn't happen when using CBIOS, which is
+		; good, since some other systems get timeout failures
+		; waiting for the floppy disk to spin up.
+
+		pushad				; Try resetting the device
+		xor ax,ax
+		call xint13
+		popad
+		loop .retry			; CX-- and jump if not zero
+
+		; Total failure.  Try falling back to CBIOS.
+		mov byte [getonesec.jmp+1],(getonesec_cbios-(getonesec.jmp+2))
+
+;
+; getonesec_cbios:
+;
+; getlinsec implementation for legacy CBIOS
+;
+getonesec_cbios:
+.retry:
+		pushad
+
+		movzx esi,word [bsSecPerTrack]
+		movzx edi,word [bsHeads]
+		;
+		; Dividing by sectors to get (track,sector): we may have
+		; up to 2^18 tracks, so we need to use 32-bit arithmetric.
+		;
+		div esi
+		xor cx,cx
+		xchg cx,dx		; CX <- sector index (0-based)
+					; EDX <- 0
+		; eax = track #
+		div edi			; Convert track to head/cyl
+
+		cmp eax,1023		; Outside the CHS range?
+		ja kaboom
+
+		;
+		; Now we have AX = cyl, DX = head, CX = sector (0-based),
+		; SI = bsSecPerTrack, ES:BX = data target
+		;
+		shl ah,6		; Because IBM was STOOPID
+					; and thought 8 bits were enough
+					; then thought 10 bits were enough...
+		inc cx			; Sector numbers are 1-based, sigh
+		or cl,ah
+		mov ch,al
+		mov dh,dl
+		mov ax,0201h		; Read one sector
+		call xint13
+		popad
+		jc .error
+		ret
+
+.error:
+		loop .retry
+		; Fall through to disk_error
+
+;
+; kaboom: write a message and bail out.
+;
+		global kaboom
+disk_error:
+kaboom:
+		xor si,si
+		mov ss,si
+		mov sp,OrigFDCTabPtr	; Reset stack
+		mov ds,si		; Reset data segment
+		pop dword [fdctab]	; Restore FDC table
+.patch:					; When we have full code, intercept here
+		mov si,bailmsg
+		call writestr_early
+
+		xor ax,ax
+.again:		int 16h			; Wait for keypress
+					; NB: replaced by int 18h if
+					; chosen at install time..
+		int 19h			; And try once more to boot...
+.norge:		hlt			; If int 19h returned; this is the end
+		jmp short .norge
+
+;
+;
+; writestr_early: write a null-terminated string to the console
+;	    This assumes we're on page 0.  This is only used for early
+;           messages, so it should be OK.
+;
+writestr_early:
+		pushad
+.loop:		lodsb
+		and al,al
+                jz .return
+		mov ah,0Eh		; Write to screen as TTY
+		mov bx,0007h		; Attribute
+		int 10h
+		jmp short .loop
+.return:	popad
+		ret
+
+;
+; INT 13h wrapper function
+;
+xint13:
+                mov dl,[DriveNumber]
+		int 13h
+		ret
+
+;
+; Error message on failure
+;
+bailmsg:	db 'Boot error', 0Dh, 0Ah, 0
+
+		; This fails if the boot sector overflowsg
+		zb 1FEh-($-$$)
+
+bootsignature	dw 0xAA55
+
+;
+; ===========================================================================
+;  End of boot sector
+; ===========================================================================
+;  Start of LDLINUX.SYS
+; ===========================================================================
+
+LDLINUX_SYS	equ ($-$$)+TEXT_START
+ldlinux_sys:
+
+syslinux_banner	db CR, LF, MY_NAME, ' ', VERSION_STR, ' ', DATE_STR, ' ', 0
+		db CR, LF, 1Ah	; EOF if we "type" this in DOS
+
+		alignz 8
+ldlinux_magic	dd LDLINUX_MAGIC
+		dd LDLINUX_MAGIC^HEXDATE
+
+;
+; This area is patched by the installer.  It is found by looking for
+; LDLINUX_MAGIC, plus 8 bytes.
+;
+SUBVOL_MAX	equ 256
+CURRENTDIR_MAX	equ FILENAME_MAX
+
+patch_area:
+DataSectors	dw 0		; Number of sectors (not including bootsec)
+ADVSectors	dw 0		; Additional sectors for ADVs
+LDLDwords	dd 0		; Total dwords starting at ldlinux_sys,
+CheckSum	dd 0		; Checksum starting at ldlinux_sys
+				; value = LDLINUX_MAGIC - [sum of dwords]
+MaxTransfer	dw 127		; Max sectors to transfer
+EPAPtr		dw EPA - LDLINUX_SYS	; Pointer to the extended patch area
+
+;
+; Extended patch area -- this is in .data16 so it doesn't occupy space in
+; the first sector.  Use this structure for anything that isn't used by
+; the first sector itself.
+;
+		section .data16
+		alignz 2
+EPA:
+ADVSecPtr	dw ADVSec0 - LDLINUX_SYS
+CurrentDirPtr	dw CurrentDirName-LDLINUX_SYS	; Current directory name string
+CurrentDirLen	dw CURRENTDIR_MAX
+SubvolPtr	dw SubvolName-LDLINUX_SYS
+SubvolLen	dw SUBVOL_MAX
+SecPtrOffset	dw SectorPtrs-LDLINUX_SYS
+SecPtrCnt	dw (SectorPtrsEnd - SectorPtrs)/10
+
+;
+; Boot sector patch pointers
+;
+Sect1Ptr0Ptr	dw Sect1Ptr0 - bootsec		; Pointers to Sector 1 location
+Sect1Ptr1Ptr	dw Sect1Ptr1 - bootsec
+RAIDPatchPtr	dw kaboom.again - bootsec	; Patch to INT 18h in RAID mode
+
+;
+; Base directory name and subvolume, if applicable.
+;
+%define HAVE_CURRENTDIRNAME
+		global CurrentDirName, SubvolName
+CurrentDirName	times CURRENTDIR_MAX db 0
+SubvolName	times SUBVOL_MAX db 0
+
+		section .init
+ldlinux_ent:
+;
+; Note that some BIOSes are buggy and run the boot sector at 07C0:0000
+; instead of 0000:7C00 and the like.  We don't want to add anything
+; more to the boot sector, so it is written to not assume a fixed
+; value in CS, but we don't want to deal with that anymore from now
+; on.
+;
+		sti		; In case of broken INT 13h BIOSes
+
+;
+; Tell the user we got this far
+;
+		mov si,syslinux_banner
+		call writestr_early
+
+;
+; Checksum data thus far
+;
+		mov si,ldlinux_sys
+		mov cx,SECTOR_SIZE >> 2
+		mov edx,-LDLINUX_MAGIC
+.checksum:
+		lodsd
+		add edx,eax
+		loop .checksum
+		mov [CheckSum],edx		; Save intermediate result
+
+;
+; Tell the user if we're using EBIOS or CBIOS
+;
+print_bios:
+		mov si,cbios_name
+		cmp byte [getonesec.jmp+1],(getonesec_ebios-(getonesec.jmp+2))
+		jne .cbios
+		mov si,ebios_name
+		mov byte [getlinsec.jmp+1],(getlinsec_ebios-(getlinsec.jmp+2))
+.cbios:
+		mov [BIOSName],si
+		call writestr_early
+
+		section .earlybss
+%define	HAVE_BIOSNAME 1
+BIOSName	resw 1
+
+		section .init
+;
+; Now we read the rest of LDLINUX.SYS.
+;
+load_rest:
+		lea esi,[SectorPtrs]
+		mov ebx,TEXT_START+2*SECTOR_SIZE ; Where we start loading
+		mov cx,[DataSectors]
+		dec cx				; Minus this sector
+
+.get_chunk:
+		jcxz .done
+		mov eax,[si]
+		mov edx,[si+4]
+		movzx ebp,word [si+8]
+		sub cx,bp
+		push ebx
+		shr ebx,4			; Convert to a segment
+		mov es,bx
+		xor bx,bx
+		call getlinsec
+		pop ebx
+		shl ebp,SECTOR_SHIFT
+		add ebx,ebp
+		add si,10
+		jmp .get_chunk
+
+.done:
+
+;
+; All loaded up, verify that we got what we needed.
+; Note: the checksum field is embedded in the checksum region, so
+; by the time we get to the end it should all cancel out.
+;
+verify_checksum:
+		mov si,ldlinux_sys + SECTOR_SIZE
+		mov ecx,[LDLDwords]
+		sub ecx,SECTOR_SIZE >> 2
+		mov eax,[CheckSum]
+.checksum:
+		add eax,[si]
+		add si,4
+		jnz .nowrap
+		; Handle segment wrap
+		mov dx,ds
+		add dx,1000h
+		mov ds,dx
+.nowrap:
+		dec ecx
+		jnz .checksum
+
+		and eax,eax			; Should be zero
+		jz all_read			; We're cool, go for it!
+
+;
+; Uh-oh, something went bad...
+;
+		mov si,checksumerr_msg
+		call writestr_early
+		jmp kaboom
+
+;
+; -----------------------------------------------------------------------------
+; Subroutines that have to be in the first sector
+; -----------------------------------------------------------------------------
+
+
+
+;
+; getlinsec: load a sequence of BP floppy sector given by the linear sector
+;	     number in EAX into the buffer at ES:BX.  We try to optimize
+;	     by loading up to a whole track at a time, but the user
+;	     is responsible for not crossing a 64K boundary.
+;	     (Yes, BP is weird for a count, but it was available...)
+;
+;	     On return, BX points to the first byte after the transferred
+;	     block.
+;
+;            This routine assumes CS == DS.
+;
+		global getlinsec
+getlinsec:
+		pushad
+		add eax,[Hidden]		; Add partition offset
+		adc edx,[Hidden+4]
+.jmp:		jmp strict short getlinsec_cbios
+
+;
+; getlinsec_ebios:
+;
+; getlinsec implementation for EBIOS (EDD)
+;
+getlinsec_ebios:
+.loop:
+                push bp                         ; Sectors left
+.retry2:
+		call maxtrans			; Enforce maximum transfer size
+		movzx edi,bp			; Sectors we are about to read
+		mov cx,retry_count
+.retry:
+
+		; Form DAPA on stack
+		push edx
+		push eax
+		push es
+		push bx
+		push di
+		push word 16
+		mov si,sp
+		pushad
+                mov ah,42h                      ; Extended Read
+		push ds
+		push ss
+		pop ds
+		call xint13
+		pop ds
+		popad
+		lea sp,[si+16]			; Remove DAPA
+		jc .error
+		pop bp
+		add eax,edi			; Advance sector pointer
+		adc edx,0
+		sub bp,di			; Sectors left
+                shl di,SECTOR_SHIFT		; 512-byte sectors
+                add bx,di			; Advance buffer pointer
+                and bp,bp
+                jnz .loop
+
+		popad
+                ret
+
+.error:
+		; Some systems seem to get "stuck" in an error state when
+		; using EBIOS.  Doesn't happen when using CBIOS, which is
+		; good, since some other systems get timeout failures
+		; waiting for the floppy disk to spin up.
+
+		pushad				; Try resetting the device
+		xor ax,ax
+		mov dl,[DriveNumber]
+		int 13h
+		popad
+		loop .retry			; CX-- and jump if not zero
+
+		;shr word [MaxTransfer],1	; Reduce the transfer size
+		;jnz .retry2
+
+		; Total failure.  Try falling back to CBIOS.
+		mov byte [getlinsec.jmp+1],(getlinsec_cbios-(getlinsec.jmp+2))
+		;mov byte [MaxTransfer],63	; Max possibe CBIOS transfer
+
+		pop bp
+		; ... fall through ...
+
+;
+; getlinsec_cbios:
+;
+; getlinsec implementation for legacy CBIOS
+;
+getlinsec_cbios:
+.loop:
+		push edx
+		push eax
+		push bp
+		push bx
+
+		movzx esi,word [bsSecPerTrack]
+		movzx edi,word [bsHeads]
+		;
+		; Dividing by sectors to get (track,sector): we may have
+		; up to 2^18 tracks, so we need to use 32-bit arithmetric.
+		;
+		div esi
+		xor cx,cx
+		xchg cx,dx		; CX <- sector index (0-based)
+					; EDX <- 0
+		; eax = track #
+		div edi			; Convert track to head/cyl
+
+		cmp eax,1023		; Outside the CHS range?
+		ja kaboom
+
+		;
+		; Now we have AX = cyl, DX = head, CX = sector (0-based),
+		; BP = sectors to transfer, SI = bsSecPerTrack,
+		; ES:BX = data target
+		;
+
+		call maxtrans			; Enforce maximum transfer size
+
+		; Must not cross track boundaries, so BP <= SI-CX
+		sub si,cx
+		cmp bp,si
+		jna .bp_ok
+		mov bp,si
+.bp_ok:
+
+		shl ah,6		; Because IBM was STOOPID
+					; and thought 8 bits were enough
+					; then thought 10 bits were enough...
+		inc cx			; Sector numbers are 1-based, sigh
+		or cl,ah
+		mov ch,al
+		mov dh,dl
+		xchg ax,bp		; Sector to transfer count
+		mov ah,02h		; Read sectors
+		mov bp,retry_count
+.retry:
+		pushad
+		call xint13
+		popad
+		jc .error
+.resume:
+		movzx ecx,al		; ECX <- sectors transferred
+		shl ax,SECTOR_SHIFT	; Convert sectors in AL to bytes in AX
+		pop bx
+		add bx,ax
+		pop bp
+		pop eax
+		pop edx
+		add eax,ecx
+		sub bp,cx
+		jnz .loop
+		popad
+		ret
+
+.error:
+		dec bp
+		jnz .retry
+
+		xchg ax,bp		; Sectors transferred <- 0
+		shr word [MaxTransfer],1
+		jnz .resume
+		jmp kaboom
+
+maxtrans:
+		cmp bp,[MaxTransfer]
+		jna .ok
+		mov bp,[MaxTransfer]
+.ok:		ret
+
+;
+; Checksum error message
+;
+checksumerr_msg	db ' Load error - ', 0	; Boot failed appended
+
+;
+; BIOS type string
+;
+cbios_name	db 'CHS', 0			; CHS/CBIOS
+ebios_name	db 'EDD', 0			; EDD/EBIOS
+
+;
+; Debug routine
+;
+%ifdef debug
+safedumpregs:
+		cmp word [Debug_Magic],0D00Dh
+		jnz nc_return
+		jmp dumpregs
+%endif
+
+rl_checkpt	equ $				; Must be <= 8000h
+
+rl_checkpt_off	equ ($-$$)
+%ifndef DEPEND
+ %if rl_checkpt_off > 3F6h			; Need one extent
+  %assign rl_checkpt_overflow rl_checkpt_off - 3F6h
+  %error Sector 1 overflow by rl_checkpt_overflow bytes
+ %endif
+%endif
+
+;
+; Extent pointers... each extent contains an 8-byte LBA and an 2-byte
+; sector count.  In most cases, we will only ever need a handful of
+; extents, but we have to assume a maximally fragmented system where each
+; extent contains only one sector.
+;
+		alignz 2
+MaxInitDataSize	equ 96 << 10
+MaxLMA		equ TEXT_START+SECTOR_SIZE+MaxInitDataSize
+SectorPtrs	zb 10*(MaxInitDataSize >> SECTOR_SHIFT)
+SectorPtrsEnd	equ $
+
+; ----------------------------------------------------------------------------
+;  End of code and data that have to be in the first sector
+; ----------------------------------------------------------------------------
+
+		section .text16
+all_read:
+		; We enter here with both DS and ES scrambled...
+		xor ax,ax
+		mov ds,ax
+		mov es,ax
+;
+; Let the user (and programmer!) know we got this far.  This used to be
+; in Sector 1, but makes a lot more sense here.
+;
+		mov si,copyright_str
+		call writestr_early
+
+
+;
+; Insane hack to expand the DOS superblock to dwords
+;
+expand_super:
+		xor eax,eax
+		mov si,superblock
+		mov di,SuperInfo
+		mov cx,superinfo_size
+.loop:
+		lodsw
+		dec si
+		stosd				; Store expanded word
+		xor ah,ah
+		stosd				; Store expanded byte
+		loop .loop
+
+
+;
+; Common initialization code
+;
+%include "init.inc"
+		
+		pushad
+		mov eax,ROOT_FS_OPS
+		movzx dx,byte [DriveNumber]
+		; DH = 0: we are boot from disk not CDROM
+		mov ecx,[Hidden]
+		mov ebx,[Hidden+4]
+		mov si,[bsHeads]
+		mov di,[bsSecPerTrack]
+		movzx ebp,word [MaxTransfer]
+		pm_call fs_init
+		popad
+
+		section .bss16
+SuperInfo	resq 16			; The first 16 bytes expanded 8 times
+
+		section .text16
diff --git a/contrib/syslinux-4.02/core/extern.inc b/contrib/syslinux-4.02/core/extern.inc
new file mode 100644
index 0000000..64edea6
--- /dev/null
+++ b/contrib/syslinux-4.02/core/extern.inc
@@ -0,0 +1,32 @@
+;
+; extern.inc
+;
+; Prototypes for external functions
+
+%ifndef EXTERN_INC
+%define EXTERN_INC
+
+	; rllpack.c
+	extern rllpack, rllunpack
+
+	; fs.c
+	extern fs_init, pm_searchdir, getfssec, getfsbytes
+	extern pm_mangle_name, load_config
+        extern pm_open_file, pm_close_file
+	extern SectorSize, SectorShift
+
+	; chdir.c
+	extern pm_realpath
+
+        ; readdir.c
+        extern opendir, readdir, closedir
+
+	; newconfig.c
+	extern pm_is_config_file
+
+%if IS_PXELINUX
+	; pxe.c
+	extern unload_pxe, reset_pxe
+%endif
+
+%endif ; EXTERN_INC
diff --git a/contrib/syslinux-4.02/core/font.inc b/contrib/syslinux-4.02/core/font.inc
new file mode 100644
index 0000000..1223635
--- /dev/null
+++ b/contrib/syslinux-4.02/core/font.inc
@@ -0,0 +1,152 @@
+;; -----------------------------------------------------------------------
+;;
+;;   Copyright 1994-2008 H. Peter Anvin - All Rights Reserved
+;;
+;;   This program is free software; you can redistribute it and/or modify
+;;   it under the terms of the GNU General Public License as published by
+;;   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
+;;   Boston MA 02111-1307, USA; either version 2 of the License, or
+;;   (at your option) any later version; incorporated herein by reference.
+;;
+;; -----------------------------------------------------------------------
+
+;;
+;; font.inc
+;;
+;; VGA font handling code
+;;
+
+		section .text16
+
+;
+; loadfont:	Load a .psf font file and install it onto the VGA console
+;		(if we're not on a VGA screen then ignore.)
+;		The font is on top of the getc stack.
+;
+loadfont.err:	jmp close			; Tailcall the close routine
+
+loadfont:
+		mov di,trackbuf
+		mov cx,4
+		call readc			; Read header
+		jc .err
+
+		mov ax,[trackbuf]		; Magic number
+		cmp ax,0436h
+		jne .err
+
+		mov al,[trackbuf+2]		; File mode
+		cmp al,5			; Font modes 0-5 supported
+		ja .err
+
+		xor bx,bx
+		mov bh,[trackbuf+3]		; Height of font
+		cmp bh,2			; VGA minimum
+		jb .err
+		cmp bh,32			; VGA maximum
+		ja .err
+
+		; Load the actual font
+		mov di,trackbuf
+		mov cx,bx			; Bytes = font height * 256
+		call readc
+		jc .err
+
+		call close
+
+		; Copy to font buffer
+		mov si,trackbuf			; Start of font data
+		mov [VGAFontSize],bh
+		push es
+		mov cx,aux_seg
+		mov es,cx
+		mov di,aux.fontbuf
+		mov cx,bx
+		shr cx,2
+		rep movsd
+		pop es
+
+		mov [UserFont], byte 1		; Set font flag
+
+;
+; use_font:
+;	This routine activates whatever font happens to be in the
+;	vgafontbuf, and updates the adjust_screen data.
+;       Must be called with CS = DS
+;
+use_font:
+		test byte [UsingVGA], ~03h	; Nonstandard mode?
+		jz .modeok
+		call vgaclearmode
+
+.modeok:
+		test [UserFont], byte 1		; Are we using a user-specified font?
+		jz adjust_screen		; If not, just do the normal stuff
+
+		push es
+		mov bp,aux_seg
+		mov es,bp
+
+		mov bp,aux.fontbuf		; ES:BP -> font
+		mov bh,[VGAFontSize]
+		xor bl,bl			; Needed by both INT 10h calls
+
+		test byte [UsingVGA], 01h	; Are we in graphics mode?
+		jz .text
+
+.graphics:
+		xor cx,cx
+		mov cl,bh			; CX = bytes/character
+		mov ax,[GXPixRows]
+		div cl				; Compute char rows per screen
+		mov dl,al
+		dec ax
+		mov [VidRows],al
+		mov ax,1121h			; Set user character table
+		int 10h
+		mov ax,[GXPixCols]
+		shr ax,3			; 8 pixels/character
+		dec ax
+		mov [VidCols],al
+		pop es
+		ret				; No need to call adjust_screen
+
+.text:
+		mov cx,256
+		xor dx,dx
+		mov ax,1110h
+		int 10h				; Load into VGA RAM
+		pop es
+
+		xor bl,bl
+		mov ax,1103h			; Select page 0
+		int 10h
+
+;
+; adjust_screen: Set the internal variables associated with the screen size.
+;		This is a subroutine in case we're loading a custom font.
+;
+adjust_screen:
+		pusha
+                mov al,[BIOS_vidrows]
+                and al,al
+                jnz vidrows_ok
+                mov al,24                       ; No vidrows in BIOS, assume 25
+						; (Remember: vidrows == rows-1)
+vidrows_ok:	mov [VidRows],al
+                mov ah,0fh
+                int 10h                         ; Read video state
+                dec ah                          ; Store count-1 (same as rows)
+                mov [VidCols],ah
+		popa
+		ret
+
+		section .data16
+		alignz 2
+VGAFontSize	dw 16			; Defaults to 16 byte font
+UserFont	db 0			; Using a user-specified font
+
+		section .bss16
+		alignb 4
+GXPixCols	resw 1			; Graphics mode pixel columns
+GXPixRows	resw 1			; Graphics mode pixel rows
diff --git a/contrib/syslinux-4.02/core/fs/btrfs/btrfs.c b/contrib/syslinux-4.02/core/fs/btrfs/btrfs.c
new file mode 100644
index 0000000..b6a14e3
--- /dev/null
+++ b/contrib/syslinux-4.02/core/fs/btrfs/btrfs.c
@@ -0,0 +1,674 @@
+/*
+ * btrfs.c -- readonly btrfs support for syslinux
+ * Some data structures are derivated from btrfs-tools-0.19 ctree.h
+ * Copyright 2009 Intel Corporation; author: alek.du@intel.com
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, Inc., 53 Temple Place Ste 330,
+ * Boston MA 02111-1307, USA; either version 2 of the License, or
+ * (at your option) any later version; incorporated herein by reference.
+ *
+ */
+
+#include <dprintf.h>
+#include <stdio.h>
+#include <string.h>
+#include <cache.h>
+#include <core.h>
+#include <disk.h>
+#include <fs.h>
+#include <dirent.h>
+#include "btrfs.h"
+
+/* compare function used for bin_search */
+typedef int (*cmp_func)(void *ptr1, void *ptr2);
+
+/* simple but useful bin search, used for chunk search and btree search */
+static int bin_search(void *ptr, int item_size, void *cmp_item, cmp_func func,
+			      int min, int max, int *slot)
+{
+	int low = min;
+	int high = max;
+	int mid;
+	int ret;
+	unsigned long offset;
+	void *item;
+
+	while (low < high) {
+		mid = (low + high) / 2;
+		offset = mid * item_size;
+
+		item = ptr + offset;
+		ret = func(item, cmp_item);
+
+		if (ret < 0)
+			low = mid + 1;
+		else if (ret > 0)
+			high = mid;
+		else {
+			*slot = mid;
+			return 0;
+		}
+	}
+	*slot = low;
+	return 1;
+}
+
+/* XXX: these should go into the filesystem instance structure */
+static struct btrfs_chunk_map chunk_map;
+static struct btrfs_super_block sb;
+static u64 fs_tree;
+
+static int btrfs_comp_chunk_map(struct btrfs_chunk_map_item *m1,
+				struct btrfs_chunk_map_item *m2)
+{
+	if (m1->logical > m2->logical)
+		return 1;
+	if (m1->logical < m2->logical)
+		return -1;
+	return 0;
+}
+
+/* insert a new chunk mapping item */
+static void insert_map(struct btrfs_chunk_map_item *item)
+{
+	int ret;
+	int slot;
+	int i;
+
+	if (chunk_map.map == NULL) { /* first item */
+		chunk_map.map_length = BTRFS_MAX_CHUNK_ENTRIES;
+		chunk_map.map = (struct btrfs_chunk_map_item *)
+			malloc(chunk_map.map_length * sizeof(*chunk_map.map));
+		chunk_map.map[0] = *item;
+		chunk_map.cur_length = 1;
+		return;
+	}
+	ret = bin_search(chunk_map.map, sizeof(*item), item,
+			(cmp_func)btrfs_comp_chunk_map, 0,
+			chunk_map.cur_length, &slot);
+	if (ret == 0)/* already in map */
+		return;
+	if (chunk_map.cur_length == BTRFS_MAX_CHUNK_ENTRIES) {
+		/* should be impossible */
+		printf("too many chunk items\n");
+		return;
+	}
+	for (i = chunk_map.cur_length; i > slot; i--)
+		chunk_map.map[i] = chunk_map.map[i-1];
+	chunk_map.map[slot] = *item;
+	chunk_map.cur_length++;
+}
+
+/*
+ * from sys_chunk_array or chunk_tree, we can convert a logical address to
+ * a physical address we can not support multi device case yet
+ */
+static u64 logical_physical(u64 logical)
+{
+	struct btrfs_chunk_map_item item;
+	int slot, ret;
+
+	item.logical = logical;
+	ret = bin_search(chunk_map.map, sizeof(*chunk_map.map), &item,
+			(cmp_func)btrfs_comp_chunk_map, 0,
+			chunk_map.cur_length, &slot);
+	if (ret == 0)
+		slot++;
+	else if (slot == 0)
+		return -1;
+	if (logical >=
+		chunk_map.map[slot-1].logical + chunk_map.map[slot-1].length)
+		return -1;
+	return chunk_map.map[slot-1].physical + logical -
+			chunk_map.map[slot-1].logical;
+}
+
+/* cache read from disk, offset and count are bytes */
+static int btrfs_read(struct fs_info *fs, char *buf, u64 offset, u64 count)
+{
+	const char *cd;
+	size_t block_size = fs->fs_dev->cache_block_size;
+	size_t off, cnt, total;
+	block_t block;
+
+	total = count;
+	while (count > 0) {
+		block = offset / block_size;
+		off = offset % block_size;
+		cd = get_cache(fs->fs_dev, block);
+		if (!cd)
+			break;
+		cnt = block_size - off;
+		if (cnt > count)
+			cnt = count;
+		memcpy(buf, cd + off, cnt);
+		count -= cnt;
+		buf += cnt;
+		offset += cnt;
+	}
+	return total - count;
+}
+
+/* btrfs has several super block mirrors, need to calculate their location */
+static inline u64 btrfs_sb_offset(int mirror)
+{
+	u64 start = 16 * 1024;
+	if (mirror)
+		return start << (BTRFS_SUPER_MIRROR_SHIFT * mirror);
+	return BTRFS_SUPER_INFO_OFFSET;
+}
+
+/* find the most recent super block */
+static void btrfs_read_super_block(struct fs_info *fs)
+{
+	int i;
+	int ret;
+	u8 fsid[BTRFS_FSID_SIZE];
+	u64 offset;
+	u64 transid = 0;
+	struct btrfs_super_block buf;
+
+	sb.total_bytes = ~0;	/* Unknown as of yet */
+
+	/* find most recent super block */
+	for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) {
+		offset = btrfs_sb_offset(i);
+		dprintf("btrfs super: %llu max %llu\n",
+			offset, sb.total_bytes);
+		if (offset >= sb.total_bytes)
+			break;
+
+		ret = btrfs_read(fs, (char *)&buf, offset, sizeof(buf));
+		if (ret < sizeof(buf))
+			break;
+
+		if (buf.bytenr != offset ||
+		    strncmp((char *)(&buf.magic), BTRFS_MAGIC,
+			    sizeof(buf.magic)))
+			continue;
+
+		if (i == 0)
+			memcpy(fsid, buf.fsid, sizeof(fsid));
+		else if (memcmp(fsid, buf.fsid, sizeof(fsid)))
+			continue;
+
+		if (buf.generation > transid) {
+			memcpy(&sb, &buf, sizeof(sb));
+			transid = buf.generation;
+		}
+	}
+}
+
+static inline unsigned long btrfs_chunk_item_size(int num_stripes)
+{
+	return sizeof(struct btrfs_chunk) +
+		sizeof(struct btrfs_stripe) * (num_stripes - 1);
+}
+
+static void clear_path(struct btrfs_path *path)
+{
+	memset(path, 0, sizeof(*path));
+}
+
+static int btrfs_comp_keys(struct btrfs_disk_key *k1, struct btrfs_disk_key *k2)
+{
+	if (k1->objectid > k2->objectid)
+		return 1;
+	if (k1->objectid < k2->objectid)
+		return -1;
+	if (k1->type > k2->type)
+		return 1;
+	if (k1->type < k2->type)
+		return -1;
+	if (k1->offset > k2->offset)
+		return 1;
+	if (k1->offset < k2->offset)
+		return -1;
+	return 0;
+}
+
+/* compare keys but ignore offset, is useful to enumerate all same kind keys */
+static int btrfs_comp_keys_type(struct btrfs_disk_key *k1,
+					struct btrfs_disk_key *k2)
+{
+	if (k1->objectid > k2->objectid)
+		return 1;
+	if (k1->objectid < k2->objectid)
+		return -1;
+	if (k1->type > k2->type)
+		return 1;
+	if (k1->type < k2->type)
+		return -1;
+	return 0;
+}
+
+/* seach tree directly on disk ... */
+static int search_tree(struct fs_info *fs, u64 loffset,
+		struct btrfs_disk_key *key, struct btrfs_path *path)
+{
+	u8 buf[BTRFS_MAX_LEAF_SIZE];
+	struct btrfs_header *header = (struct btrfs_header *)buf;
+	struct btrfs_node *node = (struct btrfs_node *)buf;
+	struct btrfs_leaf *leaf = (struct btrfs_leaf *)buf;
+	int slot, ret;
+	u64 offset;
+
+	offset = logical_physical(loffset);
+	btrfs_read(fs, (char *)header, offset, sizeof(*header));
+	if (header->level) {/*node*/
+		btrfs_read(fs, (char *)&node->ptrs[0], offset + sizeof(*header),
+			sb.nodesize - sizeof(*header));
+		path->itemsnr[header->level] = header->nritems;
+		path->offsets[header->level] = loffset;
+		ret = bin_search(&node->ptrs[0], sizeof(struct btrfs_key_ptr),
+			key, (cmp_func)btrfs_comp_keys,
+			path->slots[header->level], header->nritems, &slot);
+		if (ret && slot > path->slots[header->level])
+			slot--;
+		path->slots[header->level] = slot;
+		ret = search_tree(fs, node->ptrs[slot].blockptr, key, path);
+	} else {/*leaf*/
+		btrfs_read(fs, (char *)&leaf->items, offset + sizeof(*header),
+			sb.leafsize - sizeof(*header));
+		path->itemsnr[header->level] = header->nritems;
+		path->offsets[0] = loffset;
+		ret = bin_search(&leaf->items[0], sizeof(struct btrfs_item),
+			key, (cmp_func)btrfs_comp_keys, path->slots[0],
+			header->nritems, &slot);
+		if (ret && slot > path->slots[header->level])
+			slot--;
+		path->slots[0] = slot;
+		path->item = leaf->items[slot];
+		btrfs_read(fs, (char *)&path->data,
+			offset + sizeof(*header) + leaf->items[slot].offset,
+			leaf->items[slot].size);
+	}
+	return ret;
+}
+
+/* return 0 if leaf found */
+static int next_leaf(struct fs_info *fs, struct btrfs_disk_key *key, struct btrfs_path *path)
+{
+	int slot;
+	int level = 1;
+
+	while (level < BTRFS_MAX_LEVEL) {
+		if (!path->itemsnr[level]) /* no more nodes */
+			return 1;
+		slot = path->slots[level] + 1;
+		if (slot >= path->itemsnr[level]) {
+			level++;
+			continue;;
+		}
+		path->slots[level] = slot;
+		path->slots[level-1] = 0; /* reset low level slots info */
+		search_tree(fs, path->offsets[level], key, path);
+		break;
+	}
+	if (level == BTRFS_MAX_LEVEL)
+		return 1;
+	return 0;
+}
+
+/* return 0 if slot found */
+static int next_slot(struct fs_info *fs, struct btrfs_disk_key *key, struct btrfs_path *path)
+{
+	int slot;
+
+	if (!path->itemsnr[0])
+		return 1;
+	slot = path->slots[0] + 1;
+	if (slot >= path->itemsnr[0])
+		return 1;
+	path->slots[0] = slot;
+	search_tree(fs, path->offsets[0], key, path);
+	return 0;
+}
+
+/*
+ * read chunk_array in super block
+ */
+static void btrfs_read_sys_chunk_array(void)
+{
+	struct btrfs_chunk_map_item item;
+	struct btrfs_disk_key *key;
+	struct btrfs_chunk *chunk;
+	int cur;
+
+	/* read chunk array in superblock */
+	cur = 0;
+	while (cur < sb.sys_chunk_array_size) {
+		key = (struct btrfs_disk_key *)(sb.sys_chunk_array + cur);
+		cur += sizeof(*key);
+		chunk = (struct btrfs_chunk *)(sb.sys_chunk_array + cur);
+		cur += btrfs_chunk_item_size(chunk->num_stripes);
+		/* insert to mapping table, ignore multi stripes */
+		item.logical = key->offset;
+		item.length = chunk->length;
+		item.devid = chunk->stripe.devid;
+		item.physical = chunk->stripe.offset;/*ignore other stripes */
+		insert_map(&item);
+	}
+}
+
+/* read chunk items from chunk_tree and insert them to chunk map */
+static void btrfs_read_chunk_tree(struct fs_info *fs)
+{
+	struct btrfs_disk_key search_key;
+	struct btrfs_chunk *chunk;
+	struct btrfs_chunk_map_item item;
+	struct btrfs_path path;
+
+	if (!(sb.flags & BTRFS_SUPER_FLAG_METADUMP)) {
+		if (sb.num_devices > 1)
+			printf("warning: only support single device btrfs\n");
+		/* read chunk from chunk_tree */
+		search_key.objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID;
+		search_key.type = BTRFS_CHUNK_ITEM_KEY;
+		search_key.offset = 0;
+		clear_path(&path);
+		search_tree(fs, sb.chunk_root, &search_key, &path);
+		do {
+			do {
+				if (btrfs_comp_keys_type(&search_key,
+							&path.item.key))
+					break;
+				chunk = (struct btrfs_chunk *)(path.data);
+				/* insert to mapping table, ignore stripes */
+				item.logical = path.item.key.offset;
+				item.length = chunk->length;
+				item.devid = chunk->stripe.devid;
+				item.physical = chunk->stripe.offset;
+				insert_map(&item);
+			} while (!next_slot(fs, &search_key, &path));
+			if (btrfs_comp_keys_type(&search_key, &path.item.key))
+				break;
+		} while (!next_leaf(fs, &search_key, &path));
+	}
+}
+
+static inline u64 btrfs_name_hash(const char *name, int len)
+{
+	return btrfs_crc32c((u32)~1, name, len);
+}
+
+static struct inode *btrfs_iget_by_inr(struct fs_info *fs, u64 inr)
+{
+	struct inode *inode;
+	struct btrfs_inode_item inode_item;
+	struct btrfs_disk_key search_key;
+	struct btrfs_path path;
+	int ret;
+
+	/* FIXME: some BTRFS inode member are u64, while our logical inode
+           is u32, we may need change them to u64 later */
+	search_key.objectid = inr;
+	search_key.type = BTRFS_INODE_ITEM_KEY;
+	search_key.offset = 0;
+	clear_path(&path);
+	ret = search_tree(fs, fs_tree, &search_key, &path);
+	if (ret)
+		return NULL;
+	inode_item = *(struct btrfs_inode_item *)path.data;
+	if (!(inode = alloc_inode(fs, inr, sizeof(struct btrfs_pvt_inode))))
+		return NULL;
+	inode->ino = inr;
+	inode->size = inode_item.size;
+	inode->mode = IFTODT(inode_item.mode);
+
+	if (inode->mode == DT_REG || inode->mode == DT_LNK) {
+		struct btrfs_file_extent_item extent_item;
+		u64 offset;
+
+		/* get file_extent_item */
+		search_key.type = BTRFS_EXTENT_DATA_KEY;
+		search_key.offset = 0;
+		clear_path(&path);
+		ret = search_tree(fs, fs_tree, &search_key, &path);
+		if (ret)
+			return NULL; /* impossible */
+		extent_item = *(struct btrfs_file_extent_item *)path.data;
+		if (extent_item.type == BTRFS_FILE_EXTENT_INLINE)/* inline file */
+			offset = path.offsets[0] + sizeof(struct btrfs_header)
+				+ path.item.offset
+				+ offsetof(struct btrfs_file_extent_item, disk_bytenr);
+		else
+			offset = extent_item.disk_bytenr;
+		PVT(inode)->offset = offset;
+	}
+	return inode;
+}
+
+static struct inode *btrfs_iget_root(struct fs_info *fs)
+{
+	/* BTRFS_FIRST_CHUNK_TREE_OBJECTID(256) actually is first OBJECTID for FS_TREE */
+	return btrfs_iget_by_inr(fs, BTRFS_FIRST_CHUNK_TREE_OBJECTID);
+}
+
+static struct inode *btrfs_iget(const char *name, struct inode *parent)
+{
+	struct fs_info *fs = parent->fs;
+	struct btrfs_disk_key search_key;
+	struct btrfs_path path;
+	struct btrfs_dir_item dir_item;
+	int ret;
+
+	search_key.objectid = parent->ino;
+	search_key.type = BTRFS_DIR_ITEM_KEY;
+	search_key.offset = btrfs_name_hash(name, strlen(name));
+	clear_path(&path);
+	ret = search_tree(fs, fs_tree, &search_key, &path);
+	if (ret)
+		return NULL;
+	dir_item = *(struct btrfs_dir_item *)path.data;
+
+	return btrfs_iget_by_inr(fs, dir_item.location.objectid);
+}
+
+static int btrfs_readlink(struct inode *inode, char *buf)
+{
+	btrfs_read(inode->fs, buf, logical_physical(PVT(inode)->offset), inode->size);
+	buf[inode->size] = '\0';
+	return inode->size;
+}
+
+static int btrfs_readdir(struct file *file, struct dirent *dirent)
+{
+	struct fs_info *fs = file->fs;
+	struct inode *inode = file->inode;
+	struct btrfs_disk_key search_key;
+	struct btrfs_path path;
+	struct btrfs_dir_item *dir_item;
+	int ret;
+
+	/*
+	 * we use file->offset to store last search key.offset, will will search
+	 * key that lower that offset, 0 means first search and we will search
+         * -1UL, which is the biggest possible key
+         */
+	search_key.objectid = inode->ino;
+	search_key.type = BTRFS_DIR_ITEM_KEY;
+	search_key.offset = file->offset - 1;
+	clear_path(&path);
+	ret = search_tree(fs, fs_tree, &search_key, &path);
+
+	if (ret) {
+		if (btrfs_comp_keys_type(&search_key, &path.item.key))
+			return -1;
+	}
+
+	dir_item = (struct btrfs_dir_item *)path.data;
+	file->offset = path.item.key.offset;
+	dirent->d_ino = dir_item->location.objectid;
+	dirent->d_off = file->offset;
+	dirent->d_reclen = offsetof(struct dirent, d_name)
+		+ dir_item->name_len + 1;
+	dirent->d_type = IFTODT(dir_item->type);
+	memcpy(dirent->d_name, dir_item + 1, dir_item->name_len);
+	dirent->d_name[dir_item->name_len] = '\0';
+
+	return 0;
+}
+
+static int btrfs_next_extent(struct inode *inode, uint32_t lstart)
+{
+	struct btrfs_disk_key search_key;
+	struct btrfs_file_extent_item extent_item;
+	struct btrfs_path path;
+	int ret;
+	u64 offset;
+	struct fs_info *fs = inode->fs;
+	u32 sec_shift = SECTOR_SHIFT(fs);
+	u32 sec_size = SECTOR_SIZE(fs);
+
+	search_key.objectid = inode->ino;
+	search_key.type = BTRFS_EXTENT_DATA_KEY;
+	search_key.offset = lstart << sec_shift;
+	clear_path(&path);
+	ret = search_tree(fs, fs_tree, &search_key, &path);
+	if (ret) { /* impossible */
+		printf("btrfs: search extent data error!\n");
+		return -1;
+	}
+	extent_item = *(struct btrfs_file_extent_item *)path.data;
+
+	if (extent_item.encryption) {
+	    printf("btrfs: found encrypted data, cannot continue!\n");
+	    return -1;
+	}
+	if (extent_item.compression) {
+	    printf("btrfs: found compressed data, cannot continue!\n");
+	    return -1;
+	}
+
+	if (extent_item.type == BTRFS_FILE_EXTENT_INLINE) {/* inline file */
+		/* we fake a extent here, and PVT of inode will tell us */
+		offset = path.offsets[0] + sizeof(struct btrfs_header)
+			+ path.item.offset
+			+ offsetof(struct btrfs_file_extent_item, disk_bytenr);
+		inode->next_extent.len =
+			(inode->size + sec_size -1) >> sec_shift;
+	} else {
+		offset = extent_item.disk_bytenr + extent_item.offset;
+		inode->next_extent.len =
+			(extent_item.num_bytes + sec_size - 1) >> sec_shift;
+	}
+	inode->next_extent.pstart =
+		logical_physical(offset) >> sec_shift;
+	PVT(inode)->offset = offset;
+	return 0;
+}
+
+static uint32_t btrfs_getfssec(struct file *file, char *buf, int sectors,
+					bool *have_more)
+{
+	u32 ret;
+	struct fs_info *fs = file->fs;
+	u32 off = PVT(file->inode)->offset % SECTOR_SIZE(fs);
+	bool handle_inline = false;
+
+	if (off && !file->offset) {/* inline file first read patch */
+		file->inode->size += off;
+		handle_inline = true;
+	}
+	ret = generic_getfssec(file, buf, sectors, have_more);
+	if (!ret)
+		return ret;
+	off = PVT(file->inode)->offset % SECTOR_SIZE(fs);
+	if (handle_inline) {/* inline file patch */
+		ret -= off;
+		memcpy(buf, buf + off, ret);
+	}
+	return ret;
+}
+
+static void btrfs_get_fs_tree(struct fs_info *fs)
+{
+	struct btrfs_disk_key search_key;
+	struct btrfs_path path;
+	struct btrfs_root_item *tree;
+	bool subvol_ok = false;
+
+	/* check if subvol is filled by installer */
+	if (*SubvolName) {
+		search_key.objectid = BTRFS_FS_TREE_OBJECTID;
+		search_key.type = BTRFS_ROOT_REF_KEY;
+		search_key.offset = 0;
+		clear_path(&path);
+		if (search_tree(fs, sb.root, &search_key, &path))
+			next_slot(fs, &search_key, &path);
+		do {
+			do {
+				struct btrfs_root_ref *ref;
+
+				if (btrfs_comp_keys_type(&search_key,
+							&path.item.key))
+					break;
+				ref = (struct btrfs_root_ref *)path.data;
+				if (!strcmp((char*)(ref + 1), SubvolName)) {
+					subvol_ok = true;
+					break;
+				}
+			} while (!next_slot(fs, &search_key, &path));
+			if (subvol_ok)
+				break;
+			if (btrfs_comp_keys_type(&search_key, &path.item.key))
+				break;
+		} while (!next_leaf(fs, &search_key, &path));
+		if (!subvol_ok) /* should be impossible */
+			printf("no subvol found!\n");
+	}
+	/* find fs_tree from tree_root */
+	if (subvol_ok)
+		search_key.objectid = path.item.key.offset;
+	else /* "default" volume */
+		search_key.objectid = BTRFS_FS_TREE_OBJECTID;
+	search_key.type = BTRFS_ROOT_ITEM_KEY;
+	search_key.offset = -1;
+	clear_path(&path);
+	search_tree(fs, sb.root, &search_key, &path);
+	tree = (struct btrfs_root_item *)path.data;
+	fs_tree = tree->bytenr;
+}
+
+/* init. the fs meta data, return the block size shift bits. */
+static int btrfs_fs_init(struct fs_info *fs)
+{
+	struct disk *disk = fs->fs_dev->disk;
+    
+	btrfs_init_crc32c();
+
+	fs->sector_shift = disk->sector_shift;
+	fs->sector_size  = 1 << fs->sector_shift;
+	fs->block_shift  = BTRFS_BLOCK_SHIFT;
+	fs->block_size   = 1 << fs->block_shift;
+
+	/* Initialize the block cache */
+	cache_init(fs->fs_dev, fs->block_shift);
+
+	btrfs_read_super_block(fs);
+	if (strncmp((char *)(&sb.magic), BTRFS_MAGIC, sizeof(sb.magic)))
+		return -1;
+	btrfs_read_sys_chunk_array();
+	btrfs_read_chunk_tree(fs);
+	btrfs_get_fs_tree(fs);
+
+	return fs->block_shift;
+}
+
+const struct fs_ops btrfs_fs_ops = {
+    .fs_name       = "btrfs",
+    .fs_flags      = 0,
+    .fs_init       = btrfs_fs_init,
+    .iget_root     = btrfs_iget_root,
+    .iget          = btrfs_iget,
+    .readlink      = btrfs_readlink,
+    .getfssec      = btrfs_getfssec,
+    .close_file    = generic_close_file,
+    .mangle_name   = generic_mangle_name,
+    .next_extent   = btrfs_next_extent,
+    .readdir       = btrfs_readdir,
+    .load_config   = generic_load_config
+};
diff --git a/contrib/syslinux-4.02/core/fs/btrfs/btrfs.h b/contrib/syslinux-4.02/core/fs/btrfs/btrfs.h
new file mode 100644
index 0000000..aa1245b
--- /dev/null
+++ b/contrib/syslinux-4.02/core/fs/btrfs/btrfs.h
@@ -0,0 +1,292 @@
+#ifndef _BTRFS_H_
+#define _BTRFS_H_
+
+#include <stdint.h>
+#include <zconf.h>
+
+typedef uint8_t u8;
+typedef uint16_t u16;
+typedef uint32_t u32;
+typedef uint64_t u64;
+/* type that store on disk, but it is same as cpu type for i386 arch */
+typedef u16 __le16;
+typedef u32 __le32;
+typedef u64 __le64;
+
+#include "crc32c.h"
+#define btrfs_crc32c crc32c_le
+
+#define BTRFS_SUPER_INFO_OFFSET (64 * 1024)
+#define BTRFS_SUPER_INFO_SIZE 4096
+#define BTRFS_MAX_LEAF_SIZE 4096
+#define BTRFS_BLOCK_SHIFT 12
+
+#define BTRFS_SUPER_MIRROR_MAX   3
+#define BTRFS_SUPER_MIRROR_SHIFT 12
+#define BTRFS_CSUM_SIZE 32
+#define BTRFS_FSID_SIZE 16
+#define BTRFS_LABEL_SIZE 256
+#define BTRFS_SYSTEM_CHUNK_ARRAY_SIZE 2048
+#define BTRFS_UUID_SIZE 16
+
+#define BTRFS_MAGIC "_BHRfS_M"
+
+#define BTRFS_SUPER_FLAG_METADUMP	(1ULL << 33)
+
+#define BTRFS_DEV_ITEM_KEY	216
+#define BTRFS_CHUNK_ITEM_KEY	228
+#define BTRFS_ROOT_REF_KEY	156
+#define BTRFS_ROOT_ITEM_KEY	132
+#define BTRFS_EXTENT_DATA_KEY	108
+#define BTRFS_DIR_ITEM_KEY	84
+#define BTRFS_INODE_ITEM_KEY	1
+
+#define BTRFS_EXTENT_TREE_OBJECTID 2ULL
+#define BTRFS_FS_TREE_OBJECTID 5ULL
+
+#define BTRFS_FIRST_CHUNK_TREE_OBJECTID 256ULL
+
+#define BTRFS_FILE_EXTENT_INLINE 0
+#define BTRFS_FILE_EXTENT_REG 1
+#define BTRFS_FILE_EXTENT_PREALLOC 2
+
+#define BTRFS_MAX_LEVEL 8
+#define BTRFS_MAX_CHUNK_ENTRIES 256
+
+#define BTRFS_FT_REG_FILE	1
+#define BTRFS_FT_DIR		2
+#define BTRFS_FT_SYMLINK	7
+
+#define ROOT_DIR_WORD 0x002f
+
+struct btrfs_dev_item {
+	__le64 devid;
+	__le64 total_bytes;
+	__le64 bytes_used;
+	__le32 io_align;
+	__le32 io_width;
+	__le32 sector_size;
+	__le64 type;
+	__le64 generation;
+	__le64 start_offset;
+	__le32 dev_group;
+	u8 seek_speed;
+	u8 bandwidth;
+	u8 uuid[BTRFS_UUID_SIZE];
+	u8 fsid[BTRFS_UUID_SIZE];
+} __attribute__ ((__packed__));
+
+struct btrfs_super_block {
+	u8 csum[BTRFS_CSUM_SIZE];
+	/* the first 3 fields must match struct btrfs_header */
+	u8 fsid[BTRFS_FSID_SIZE];    /* FS specific uuid */
+	__le64 bytenr; /* this block number */
+	__le64 flags;
+
+	/* allowed to be different from the btrfs_header from here own down */
+	__le64 magic;
+	__le64 generation;
+	__le64 root;
+	__le64 chunk_root;
+	__le64 log_root;
+
+	/* this will help find the new super based on the log root */
+	__le64 log_root_transid;
+	__le64 total_bytes;
+	__le64 bytes_used;
+	__le64 root_dir_objectid;
+	__le64 num_devices;
+	__le32 sectorsize;
+	__le32 nodesize;
+	__le32 leafsize;
+	__le32 stripesize;
+	__le32 sys_chunk_array_size;
+	__le64 chunk_root_generation;
+	__le64 compat_flags;
+	__le64 compat_ro_flags;
+	__le64 incompat_flags;
+	__le16 csum_type;
+	u8 root_level;
+	u8 chunk_root_level;
+	u8 log_root_level;
+	struct btrfs_dev_item dev_item;
+
+	char label[BTRFS_LABEL_SIZE];
+
+	/* future expansion */
+	__le64 reserved[32];
+	u8 sys_chunk_array[BTRFS_SYSTEM_CHUNK_ARRAY_SIZE];
+} __attribute__ ((__packed__));
+
+struct btrfs_disk_key {
+	__le64 objectid;
+	u8 type;
+	__le64 offset;
+} __attribute__ ((__packed__));
+
+struct btrfs_stripe {
+	__le64 devid;
+	__le64 offset;
+	u8 dev_uuid[BTRFS_UUID_SIZE];
+} __attribute__ ((__packed__));
+
+struct btrfs_chunk {
+	__le64 length;
+	__le64 owner;
+	__le64 stripe_len;
+	__le64 type;
+	__le32 io_align;
+	__le32 io_width;
+	__le32 sector_size;
+	__le16 num_stripes;
+	__le16 sub_stripes;
+	struct btrfs_stripe stripe;
+} __attribute__ ((__packed__));
+
+struct btrfs_header {
+	/* these first four must match the super block */
+	u8 csum[BTRFS_CSUM_SIZE];
+	u8 fsid[BTRFS_FSID_SIZE]; /* FS specific uuid */
+	__le64 bytenr; /* which block this node is supposed to live in */
+	__le64 flags;
+
+	/* allowed to be different from the super from here on down */
+	u8 chunk_tree_uuid[BTRFS_UUID_SIZE];
+	__le64 generation;
+	__le64 owner;
+	__le32 nritems;
+	u8 level;
+} __attribute__ ((__packed__));
+
+struct btrfs_item {
+	struct btrfs_disk_key key;
+	__le32 offset;
+	__le32 size;
+} __attribute__ ((__packed__));
+
+struct btrfs_leaf {
+	struct btrfs_header header;
+	struct btrfs_item items[];
+} __attribute__ ((__packed__));
+
+struct btrfs_key_ptr {
+	struct btrfs_disk_key key;
+	__le64 blockptr;
+	__le64 generation;
+} __attribute__ ((__packed__));
+
+struct btrfs_node {
+	struct btrfs_header header;
+	struct btrfs_key_ptr ptrs[];
+} __attribute__ ((__packed__));
+
+/* remember how we get to a node/leaf */
+struct btrfs_path {
+	u64 offsets[BTRFS_MAX_LEVEL];
+	int itemsnr[BTRFS_MAX_LEVEL];
+	int slots[BTRFS_MAX_LEVEL];
+	/* remember last slot's item and data */
+	struct btrfs_item item;
+	u8 data[BTRFS_MAX_LEAF_SIZE];
+};
+
+/* store logical offset to physical offset mapping */
+struct btrfs_chunk_map_item {
+	u64 logical;
+	u64 length;
+	u64 devid;
+	u64 physical;
+};
+
+struct btrfs_chunk_map {
+	struct btrfs_chunk_map_item *map;
+	u32 map_length;
+	u32 cur_length;
+};
+
+struct btrfs_timespec {
+	__le64 sec;
+	__le32 nsec;
+} __attribute__ ((__packed__));
+
+struct btrfs_inode_item {
+	/* nfs style generation number */
+	__le64 generation;
+	/* transid that last touched this inode */
+	__le64 transid;
+	__le64 size;
+	__le64 nbytes;
+	__le64 block_group;
+	__le32 nlink;
+	__le32 uid;
+	__le32 gid;
+	__le32 mode;
+	__le64 rdev;
+	__le64 flags;
+
+	/* modification sequence number for NFS */
+	__le64 sequence;
+
+	/*
+	 * a little future expansion, for more than this we can
+	 * just grow the inode item and version it
+	 */
+	__le64 reserved[4];
+	struct btrfs_timespec atime;
+	struct btrfs_timespec ctime;
+	struct btrfs_timespec mtime;
+	struct btrfs_timespec otime;
+} __attribute__ ((__packed__));
+
+struct btrfs_root_item {
+	struct btrfs_inode_item inode;
+	__le64 generation;
+	__le64 root_dirid;
+	__le64 bytenr;
+	__le64 byte_limit;
+	__le64 bytes_used;
+	__le64 last_snapshot;
+	__le64 flags;
+	__le32 refs;
+	struct btrfs_disk_key drop_progress;
+	u8 drop_level;
+	u8 level;
+} __attribute__ ((__packed__));
+
+struct btrfs_dir_item {
+	struct btrfs_disk_key location;
+	__le64 transid;
+	__le16 data_len;
+	__le16 name_len;
+	u8 type;
+} __attribute__ ((__packed__));
+
+struct btrfs_file_extent_item {
+	__le64 generation;
+	__le64 ram_bytes;
+	u8 compression;
+	u8 encryption;
+	__le16 other_encoding; /* spare for later use */
+	u8 type;
+	__le64 disk_bytenr;
+	__le64 disk_num_bytes;
+	__le64 offset;
+	__le64 num_bytes;
+} __attribute__ ((__packed__));
+
+struct btrfs_root_ref {
+	__le64 dirid;
+	__le64 sequence;
+	__le16 name_len;
+} __attribute__ ((__packed__));
+
+/*
+ * btrfs private inode information
+ */
+struct btrfs_pvt_inode {
+    uint64_t offset;
+};
+
+#define PVT(i) ((struct btrfs_pvt_inode *)((i)->pvt))
+
+#endif
diff --git a/contrib/syslinux-4.02/core/fs/btrfs/crc32c.h b/contrib/syslinux-4.02/core/fs/btrfs/crc32c.h
new file mode 100644
index 0000000..2c31738
--- /dev/null
+++ b/contrib/syslinux-4.02/core/fs/btrfs/crc32c.h
@@ -0,0 +1,50 @@
+/*
+ * Copied from Linux kernel crypto/crc32c.c
+ * Copyright (c) 2004 Cisco Systems, Inc.
+ * Copyright (c) 2008 Herbert Xu <herbert@gondor.apana.org.au>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ */
+
+/*
+ * This is the CRC-32C table
+ * Generated with:
+ * width = 32 bits
+ * poly = 0x1EDC6F41
+ * reflect input bytes = true
+ * reflect output bytes = true
+ */
+
+static u32 crc32c_table[256];
+
+/*
+ * Steps through buffer one byte at at time, calculates reflected
+ * crc using table.
+ */
+
+static inline u32 crc32c_le(u32 crc, const char *data, size_t length)
+{
+	while (length--)
+		crc = crc32c_table[(u8)(crc ^ *data++)] ^ (crc >> 8);
+
+	return crc;
+}
+
+static inline void btrfs_init_crc32c(void)
+{
+	int i, j;
+	u32 v;
+	const u32 poly = 0x82F63B78; /* Bit-reflected CRC32C polynomial */
+
+	for (i = 0; i < 256; i++) {
+		v = i;
+		for (j = 0; j < 8; j++) {
+			v = (v >> 1) ^ ((v & 1) ? poly : 0);
+		}
+		crc32c_table[i] = v;
+	}
+}
diff --git a/contrib/syslinux-4.02/core/fs/cache.c b/contrib/syslinux-4.02/core/fs/cache.c
new file mode 100644
index 0000000..0d7891b
--- /dev/null
+++ b/contrib/syslinux-4.02/core/fs/cache.c
@@ -0,0 +1,125 @@
+/*
+ * core/cache.c: A simple LRU-based cache implementation.
+ *
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <dprintf.h>
+#include "core.h"
+#include "cache.h"
+
+
+/*
+ * Initialize the cache data structres. the _block_size_shift_ specify
+ * the block size, which is 512 byte for FAT fs of the current 
+ * implementation since the block(cluster) size in FAT is a bit big.
+ *
+ */
+void cache_init(struct device *dev, int block_size_shift)
+{
+    struct cache *prev, *cur;
+    char *data = dev->cache_data;
+    struct cache *head, *cache;
+    int i;
+
+    dev->cache_block_size = 1 << block_size_shift;
+
+    if (dev->cache_size < dev->cache_block_size + 2*sizeof(struct cache)) {
+	dev->cache_head = NULL;
+	return;			/* Cache unusably small */
+    }
+
+    /* We need one struct cache for the headnode plus one for each block */
+    dev->cache_entries =
+	(dev->cache_size - sizeof(struct cache))/
+	(dev->cache_block_size + sizeof(struct cache));
+
+    dev->cache_head = head = (struct cache *)
+	(data + (dev->cache_entries << block_size_shift));
+    cache = dev->cache_head + 1; /* First cache descriptor */
+
+    head->prev  = &cache[dev->cache_entries-1];
+    head->next->prev = dev->cache_head;
+    head->block = -1;
+    head->data  = NULL;
+
+    prev = head;
+    
+    for (i = 0; i < dev->cache_entries; i++) {
+        cur = &cache[i];
+        cur->data  = data;
+        cur->block = -1;
+        cur->prev  = prev;
+        prev->next = cur;
+        data += dev->cache_block_size;
+        prev = cur++;
+    }
+}
+
+/*
+ * Lock a block permanently in the cache
+ */
+void cache_lock_block(struct cache *cs)
+{
+    cs->prev->next = cs->next;
+    cs->next->prev = cs->prev;
+
+    cs->next = cs->prev = NULL;
+}
+
+/*
+ * Check for a particular BLOCK in the block cache, 
+ * and if it is already there, just do nothing and return;
+ * otherwise pick a victim block and update the LRU link.
+ */
+struct cache *_get_cache_block(struct device *dev, block_t block)
+{
+    struct cache *head = dev->cache_head;
+    struct cache *cs;
+    int i;
+
+    cs = dev->cache_head + 1;
+
+    for (i = 0; i < dev->cache_entries; i++) {
+	if (cs->block == block)
+	    goto found;
+	cs++;
+    }
+    
+    /* Not found, pick a victim */
+    cs = head->next;
+
+found:
+    /* Move to the end of the LRU chain, unless the block is already locked */
+    if (cs->next) {
+	cs->prev->next = cs->next;
+	cs->next->prev = cs->prev;
+	
+	cs->prev = head->prev;
+	head->prev->next = cs;
+	cs->next = head;
+	head->prev = cs;
+    }
+
+    return cs;
+}    
+
+/*
+ * Check for a particular BLOCK in the block cache, 
+ * and if it is already there, just do nothing and return;
+ * otherwise load it from disk and update the LRU link.
+ * Return the data pointer.
+ */
+const void *get_cache(struct device *dev, block_t block)
+{
+    struct cache *cs;
+
+    cs = _get_cache_block(dev, block);
+    if (cs->block != block) {
+	cs->block = block;
+        getoneblk(dev->disk, cs->data, block, dev->cache_block_size);
+    }
+
+    return cs->data;
+}
diff --git a/contrib/syslinux-4.02/core/fs/chdir.c b/contrib/syslinux-4.02/core/fs/chdir.c
new file mode 100644
index 0000000..9e8dfd2
--- /dev/null
+++ b/contrib/syslinux-4.02/core/fs/chdir.c
@@ -0,0 +1,103 @@
+#include <stdio.h>
+#include <stdbool.h>
+#include <string.h>
+#include "fs.h"
+#include "cache.h"
+
+/*
+ * Convert a relative pathname to an absolute pathname
+ * In the future this might also resolve symlinks...
+ */
+void pm_realpath(com32sys_t *regs)
+{
+    const char *src = MK_PTR(regs->ds, regs->esi.w[0]);
+    char       *dst = MK_PTR(regs->es, regs->edi.w[0]);
+
+    realpath(dst, src, FILENAME_MAX);
+}
+
+#define EMIT(x)		     		\
+do {		     			\
+    if (++n < bufsize)	 		\
+    	*q++ = (x);			\
+} while (0)
+
+static size_t join_paths(char *dst, size_t bufsize,
+			 const char *s1, const char *s2)
+{
+    const char *list[2];
+    int i;
+    char c;
+    const char *p;
+    char *q  = dst;
+    size_t n = 0;
+    bool slash = false;
+    
+    list[0] = s1;
+    list[1] = s2;
+
+    for (i = 0; i < 2; i++) {
+	p = list[i];
+
+	while ((c = *p++)) {
+	    if (c == '/') {
+		if (!slash)
+		    EMIT(c);
+		slash = true;
+	    } else {
+		EMIT(c);
+		slash = false;
+	    }
+	}
+    }
+
+    if (bufsize)
+	*q = '\0';
+
+    return n;
+}
+
+size_t realpath(char *dst, const char *src, size_t bufsize)
+{
+    if (this_fs->fs_ops->realpath) {
+	return this_fs->fs_ops->realpath(this_fs, dst, src, bufsize);
+    } else {
+	/* Filesystems with "common" pathname resolution */
+	return join_paths(dst, bufsize, 
+			  src[0] == '/' ? "" : this_fs->cwd_name,
+			  src);
+    }
+}
+
+int chdir(const char *src)
+{
+    int rv;
+    struct file *file;
+    char cwd_buf[CURRENTDIR_MAX];
+
+    if (this_fs->fs_ops->chdir)
+	return this_fs->fs_ops->chdir(this_fs, src);
+
+    /* Otherwise it is a "conventional filesystem" */
+    rv = searchdir(src);
+    if (rv < 0)
+	return rv;
+
+    file = handle_to_file(rv);
+    if (file->inode->mode != DT_DIR) {
+	_close_file(file);
+	return -1;
+    }
+
+    put_inode(this_fs->cwd);
+    this_fs->cwd = get_inode(file->inode);
+    _close_file(file);
+
+    /* Save the current working directory */
+    realpath(cwd_buf, src, CURRENTDIR_MAX);
+
+    /* Make sure the cwd_name ends in a slash, it's supposed to be a prefix */
+    join_paths(this_fs->cwd_name, CURRENTDIR_MAX, cwd_buf, "/");
+
+    return 0;
+}
diff --git a/contrib/syslinux-4.02/core/fs/diskio.c b/contrib/syslinux-4.02/core/fs/diskio.c
new file mode 100644
index 0000000..481b59b
--- /dev/null
+++ b/contrib/syslinux-4.02/core/fs/diskio.c
@@ -0,0 +1,418 @@
+#include <dprintf.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdbool.h>
+#include <klibc/compiler.h>
+#include <core.h>
+#include <fs.h>
+#include <disk.h>
+#include <ilog2.h>
+
+#define RETRY_COUNT 6
+
+static inline sector_t chs_max(const struct disk *disk)
+{
+    return (sector_t)disk->secpercyl << 10;
+}
+
+static int chs_rdwr_sectors(struct disk *disk, void *buf,
+			    sector_t lba, size_t count, bool is_write)
+{
+    char *ptr = buf;
+    char *tptr;
+    size_t chunk, freeseg;
+    int sector_shift = disk->sector_shift;
+    uint32_t xlba = lba + disk->part_start; /* Truncated LBA (CHS is << 2 TB) */
+    uint32_t t;
+    uint32_t c, h, s;
+    com32sys_t ireg, oreg;
+    size_t done = 0;
+    size_t bytes;
+    int retry;
+    uint32_t maxtransfer = disk->maxtransfer;
+
+    if (lba + disk->part_start >= chs_max(disk))
+	return 0;		/* Impossible CHS request */
+
+    memset(&ireg, 0, sizeof ireg);
+
+    ireg.eax.b[1] = 0x02 + is_write;
+    ireg.edx.b[0] = disk->disk_number;
+
+    while (count) {
+	chunk = count;
+	if (chunk > maxtransfer)
+	    chunk = maxtransfer;
+
+	freeseg = (0x10000 - ((size_t)ptr & 0xffff)) >> sector_shift;
+
+	if ((size_t)buf <= 0xf0000 && freeseg) {
+	    /* Can do a direct load */
+	    tptr = ptr;
+	} else {
+	    /* Either accessing high memory or we're crossing a 64K line */
+	    tptr = core_xfer_buf;
+	    freeseg = (0x10000 - ((size_t)tptr & 0xffff)) >> sector_shift;
+	}
+	if (chunk > freeseg)
+	    chunk = freeseg;
+
+	s = xlba % disk->s;
+	t = xlba / disk->s;
+	h = t % disk->h;
+	c = t / disk->h;
+
+	if (chunk > (disk->s - s))
+	    chunk = disk->s - s;
+
+	bytes = chunk << sector_shift;
+
+	if (tptr != ptr && is_write)
+	    memcpy(tptr, ptr, bytes);
+
+	ireg.eax.b[0] = chunk;
+	ireg.ecx.b[1] = c;
+	ireg.ecx.b[0] = ((c & 0x300) >> 2) | (s+1);
+	ireg.edx.b[1] = h;
+	ireg.ebx.w[0] = OFFS(tptr);
+	ireg.es       = SEG(tptr);
+
+	retry = RETRY_COUNT;
+
+        for (;;) {
+	    if (c < 1024) {
+		dprintf("CHS[%02x]: %u @ %llu (%u/%u/%u) %04x:%04x %s %p\n",
+			ireg.edx.b[0], chunk, xlba, c, h, s+1,
+			ireg.es, ireg.ebx.w[0],
+			(ireg.eax.b[1] & 1) ? "<-" : "->",
+			ptr);
+
+		__intcall(0x13, &ireg, &oreg);
+		if (!(oreg.eflags.l & EFLAGS_CF))
+		    break;
+
+		dprintf("CHS: error AX = %04x\n", oreg.eax.w[0]);
+
+		if (retry--)
+		    continue;
+
+		/*
+		 * For any starting value, this will always end with
+		 * ..., 1, 0
+		 */
+		chunk >>= 1;
+		if (chunk) {
+		    maxtransfer = chunk;
+		    retry = RETRY_COUNT;
+		    ireg.eax.b[0] = chunk;
+		    continue;
+		}
+	    }
+
+	    printf("CHS: Error %04x %s sector %llu (%u/%u/%u)\n",
+		   oreg.eax.w[0],
+		   is_write ? "writing" : "reading",
+		   lba, c, h, s+1);
+	    return done;	/* Failure */
+	}
+
+	bytes = chunk << sector_shift;
+
+	if (tptr != ptr && !is_write)
+	    memcpy(ptr, tptr, bytes);
+
+	/* If we dropped maxtransfer, it eventually worked, so remember it */
+	disk->maxtransfer = maxtransfer;
+
+	ptr   += bytes;
+	xlba  += chunk;
+	count -= chunk;
+	done  += chunk;
+    }
+
+    return done;
+}
+
+struct edd_rdwr_packet {
+    uint16_t size;
+    uint16_t blocks;
+    far_ptr_t buf;
+    uint64_t lba;
+};
+
+static int edd_rdwr_sectors(struct disk *disk, void *buf,
+			    sector_t lba, size_t count, bool is_write)
+{
+    static __lowmem struct edd_rdwr_packet pkt;
+    char *ptr = buf;
+    char *tptr;
+    size_t chunk, freeseg;
+    int sector_shift = disk->sector_shift;
+    com32sys_t ireg, oreg, reset;
+    size_t done = 0;
+    size_t bytes;
+    int retry;
+    uint32_t maxtransfer = disk->maxtransfer;
+
+    memset(&ireg, 0, sizeof ireg);
+
+    ireg.eax.b[1] = 0x42 + is_write;
+    ireg.edx.b[0] = disk->disk_number;
+    ireg.ds       = SEG(&pkt);
+    ireg.esi.w[0] = OFFS(&pkt);
+
+    memset(&reset, 0, sizeof reset);
+
+    ireg.edx.b[0] = disk->disk_number;
+
+    lba += disk->part_start;
+    while (count) {
+	chunk = count;
+	if (chunk > maxtransfer)
+	    chunk = maxtransfer;
+
+	freeseg = (0x10000 - ((size_t)ptr & 0xffff)) >> sector_shift;
+
+	if ((size_t)ptr <= 0xf0000 && freeseg) {
+	    /* Can do a direct load */
+	    tptr = ptr;
+	} else {
+	    /* Either accessing high memory or we're crossing a 64K line */
+	    tptr = core_xfer_buf;
+	    freeseg = (0x10000 - ((size_t)tptr & 0xffff)) >> sector_shift;
+	}
+	if (chunk > freeseg)
+	    chunk = freeseg;
+
+	bytes = chunk << sector_shift;
+
+	if (tptr != ptr && is_write)
+	    memcpy(tptr, ptr, bytes);
+
+	retry = RETRY_COUNT;
+
+	for (;;) {
+	    pkt.size   = sizeof pkt;
+	    pkt.blocks = chunk;
+	    pkt.buf    = FAR_PTR(tptr);
+	    pkt.lba    = lba;
+
+	    dprintf("EDD[%02x]: %u @ %llu %04x:%04x %s %p\n",
+		    ireg.edx.b[0], pkt.blocks, pkt.lba,
+		    pkt.buf.seg, pkt.buf.offs,
+		    (ireg.eax.b[1] & 1) ? "<-" : "->",
+		    ptr);
+
+	    __intcall(0x13, &ireg, &oreg);
+	    if (!(oreg.eflags.l & EFLAGS_CF))
+		break;
+
+	    dprintf("EDD: error AX = %04x\n", oreg.eax.w[0]);
+
+	    if (retry--)
+		continue;
+
+	    /*
+	     * Some systems seem to get "stuck" in an error state when
+	     * using EBIOS.  Doesn't happen when using CBIOS, which is
+	     * good, since some other systems get timeout failures
+	     * waiting for the floppy disk to spin up.
+	     */
+	    __intcall(0x13, &reset, NULL);
+
+	    /* For any starting value, this will always end with ..., 1, 0 */
+	    chunk >>= 1;
+	    if (chunk) {
+		maxtransfer = chunk;
+		retry = RETRY_COUNT;
+		continue;
+	    }
+
+	    /*
+	     * Total failure.  There are systems which identify as
+	     * EDD-capable but aren't; the known such systems return
+	     * error code AH=1 (invalid function), but let's not
+	     * assume that for now.
+	     *
+	     * Try to fall back to CHS.  If the LBA is absurd, the
+	     * chs_max() test in chs_rdwr_sectors() will catch it.
+	     */
+	    done = chs_rdwr_sectors(disk, buf, lba - disk->part_start,
+				    count, is_write);
+	    if (done == (count << sector_shift)) {
+		/* Successful, assume this is a CHS disk */
+		disk->rdwr_sectors = chs_rdwr_sectors;
+		return done;
+	    }
+	    printf("EDD: Error %04x %s sector %llu\n",
+		   oreg.eax.w[0],
+		   is_write ? "writing" : "reading",
+		   lba);
+	    return done;	/* Failure */
+	}
+
+	bytes = chunk << sector_shift;
+
+	if (tptr != ptr && !is_write)
+	    memcpy(ptr, tptr, bytes);
+
+	/* If we dropped maxtransfer, it eventually worked, so remember it */
+	disk->maxtransfer = maxtransfer;
+
+	ptr   += bytes;
+	lba   += chunk;
+	count -= chunk;
+	done  += chunk;
+    }
+    return done;
+}
+
+struct edd_disk_params {
+    uint16_t  len;
+    uint16_t  flags;
+    uint32_t  phys_c;
+    uint32_t  phys_h;
+    uint32_t  phys_s;
+    uint64_t  sectors;
+    uint16_t  sector_size;
+    far_ptr_t dpte;
+    uint16_t  devpath_key;
+    uint8_t   devpath_len;
+    uint8_t   _pad1[3];
+    char      bus_type[4];
+    char      if_type[8];
+    uint8_t   if_path[8];
+    uint8_t   dev_path[8];
+    uint8_t   _pad2;
+    uint8_t   devpath_csum;
+} __attribute__((packed));
+
+static inline bool is_power_of_2(uint32_t x)
+{
+    return !(x & (x-1));
+}
+
+void getoneblk(struct disk *disk, char *buf, block_t block, int block_size)
+{
+    int sec_per_block = block_size / disk->sector_size;
+
+    disk->rdwr_sectors(disk, buf, block * sec_per_block, sec_per_block, 0);
+}
+
+
+struct disk *disk_init(uint8_t devno, bool cdrom, sector_t part_start,
+                       uint16_t bsHeads, uint16_t bsSecPerTrack,
+		       uint32_t MaxTransfer)
+{
+    static struct disk disk;
+    static __lowmem struct edd_disk_params edd_params;
+    com32sys_t ireg, oreg;
+    bool ebios;
+    int sector_size;
+    unsigned int hard_max_transfer;
+
+    memset(&ireg, 0, sizeof ireg);
+    ireg.edx.b[0] = devno;
+
+    if (cdrom) {
+	/*
+	 * The query functions don't work right on some CD-ROM stacks.
+	 * Known affected systems: ThinkPad T22, T23.
+	 */
+	sector_size = 2048;
+	ebios = true;
+	hard_max_transfer = 32;
+    } else {
+	sector_size = 512;
+	ebios = false;
+	hard_max_transfer = 63;
+
+	/* CBIOS parameters */
+	disk.h = bsHeads;
+	disk.s = bsSecPerTrack;
+
+	if ((int8_t)devno < 0) {
+	    /* Get hard disk geometry from BIOS */
+	    
+	    ireg.eax.b[1] = 0x08;
+	    __intcall(0x13, &ireg, &oreg);
+	    
+	    if (!(oreg.eflags.l & EFLAGS_CF)) {
+		disk.h = oreg.edx.b[1] + 1;
+		disk.s = oreg.ecx.b[0] & 63;
+	    }
+	}
+
+	/* Get EBIOS support */
+	ireg.eax.b[1] = 0x41;
+	ireg.ebx.w[0] = 0x55aa;
+	ireg.eflags.b[0] = 0x3;	/* CF set */
+
+	__intcall(0x13, &ireg, &oreg);
+	
+	if (!(oreg.eflags.l & EFLAGS_CF) &&
+	    oreg.ebx.w[0] == 0xaa55 && (oreg.ecx.b[0] & 1)) {
+	    ebios = true;
+	    hard_max_transfer = 127;
+
+	    /* Query EBIOS parameters */
+	    edd_params.len = sizeof edd_params;
+
+	    ireg.eax.b[1] = 0x48;
+	    ireg.ds = SEG(&edd_params);
+	    ireg.esi.w[0] = OFFS(&edd_params);
+	    __intcall(0x13, &ireg, &oreg);
+
+	    if (!(oreg.eflags.l & EFLAGS_CF) && oreg.eax.b[1] == 0) {
+		if (edd_params.len < sizeof edd_params)
+		    memset((char *)&edd_params + edd_params.len, 0,
+			   sizeof edd_params - edd_params.len);
+
+		if (edd_params.sector_size >= 512 &&
+		    is_power_of_2(edd_params.sector_size))
+		    sector_size = edd_params.sector_size;
+	    }
+	}
+
+    }
+
+    disk.disk_number   = devno;
+    disk.sector_size   = sector_size;
+    disk.sector_shift  = ilog2(sector_size);
+    disk.part_start    = part_start;
+    disk.secpercyl     = disk.h * disk.s;
+    disk.rdwr_sectors  = ebios ? edd_rdwr_sectors : chs_rdwr_sectors;
+
+    if (!MaxTransfer || MaxTransfer > hard_max_transfer)
+	MaxTransfer = hard_max_transfer;
+
+    disk.maxtransfer   = MaxTransfer;
+
+    dprintf("disk %02x cdrom %d type %d sector %u/%u offset %llu limit %u\n",
+	    devno, cdrom, ebios, sector_size, disk.sector_shift,
+	    part_start, disk.maxtransfer);
+
+    return &disk;
+}
+
+
+/*
+ * Initialize the device structure.
+ *
+ * NOTE: the disk cache needs to be revamped to support multiple devices...
+ */
+struct device * device_init(uint8_t devno, bool cdrom, sector_t part_start,
+                            uint16_t bsHeads, uint16_t bsSecPerTrack,
+			    uint32_t MaxTransfer)
+{
+    static struct device dev;
+    static __hugebss char diskcache[128*1024];
+
+    dev.disk = disk_init(devno, cdrom, part_start,
+			 bsHeads, bsSecPerTrack, MaxTransfer);
+
+    dev.cache_data = diskcache;
+    dev.cache_size = sizeof diskcache;
+
+    return &dev;
+}
diff --git a/contrib/syslinux-4.02/core/fs/ext2/bmap.c b/contrib/syslinux-4.02/core/fs/ext2/bmap.c
new file mode 100644
index 0000000..ef2bf64
--- /dev/null
+++ b/contrib/syslinux-4.02/core/fs/ext2/bmap.c
@@ -0,0 +1,228 @@
+/*
+ * The logical block -> physical block routine.
+ *
+ * Copyright (C) 2009 Liu Aleaxander -- All rights reserved. This file
+ * may be redistributed under the terms of the GNU Public License.
+ */
+
+#include <stdio.h>
+#include <dprintf.h>
+#include <fs.h>
+#include <disk.h>
+#include <cache.h>
+#include "ext2_fs.h"
+
+static const struct ext4_extent_header *
+ext4_find_leaf(struct fs_info *fs, const struct ext4_extent_header *eh,
+	       block_t block)
+{
+    struct ext4_extent_idx *index;
+    block_t blk;
+    int i;
+
+    while (1) {
+	if (eh->eh_magic != EXT4_EXT_MAGIC)
+	    return NULL;
+	if (eh->eh_depth == 0)
+	    return eh;
+
+	index = EXT4_FIRST_INDEX(eh);
+	for (i = 0; i < (int)eh->eh_entries; i++) {
+	    if (block < index[i].ei_block)
+		break;
+	}
+	if (--i < 0)
+	    return NULL;
+
+	blk = index[i].ei_leaf_hi;
+	blk = (blk << 32) + index[i].ei_leaf_lo;
+	eh = get_cache(fs->fs_dev, blk);
+    }
+}
+
+/* handle the ext4 extents to get the phsical block number */
+/* XXX: still need to handle sparse files with extents */
+static block_t
+bmap_extent(struct inode *inode, uint32_t block, size_t *nblocks)
+{
+    struct fs_info *fs = inode->fs;
+    const struct ext4_extent_header *leaf;
+    const struct ext4_extent *ext;
+    int i;
+    block_t start;
+
+    leaf = ext4_find_leaf(fs, &PVT(inode)->i_extent_hdr, block);
+    if (!leaf) {
+	printf("ERROR, extent leaf not found\n");
+	return 0;
+    }
+
+    ext = EXT4_FIRST_EXTENT(leaf);
+    for (i = 0; i < leaf->eh_entries; i++) {
+	if (block < ext[i].ee_block)
+	    break;
+    }
+    if (--i < 0) {
+	printf("ERROR, not find the right block\n");
+	return 0;
+    }
+
+    /* got it */
+    block -= ext[i].ee_block;
+    if (block >= ext[i].ee_len)
+	return 0;
+    start = ((block_t)ext[i].ee_start_hi << 32) + ext[i].ee_start_lo;
+
+    if (nblocks)
+	*nblocks = ext[i].ee_len - block;
+
+    return start + block;
+}
+
+/*
+ * Scan forward in a range of blocks to see if they are contiguous,
+ * then return the initial value.
+ */
+static uint32_t
+scan_set_nblocks(const uint32_t *map, unsigned int count, size_t *nblocks)
+{
+    uint32_t blk = *map;
+
+    if (nblocks) {
+	uint32_t skip = blk ? 1 : 0;
+	uint32_t next = blk + skip;
+	size_t   cnt = 1;
+
+	while (--count) {
+	    map++;
+	    if (*map == next) {
+		cnt++;
+		next += skip;
+	    } else {
+		break;
+	    }
+	}
+
+	*nblocks = cnt;
+    }
+
+    return blk;
+}
+
+/*
+ * The actual indirect block map handling - the block passed in should
+ * be relative to the beginning of the particular block hierarchy.
+ */
+static block_t
+bmap_indirect(struct fs_info *fs, uint32_t start, uint32_t block,
+	      int levels, size_t *nblocks)
+{
+    int addr_shift = BLOCK_SHIFT(fs) - 2;
+    uint32_t addr_count = 1 << addr_shift;
+    const uint32_t *blk = NULL;
+    uint32_t index = 0;
+
+    while (levels--) {
+	if (!start) {
+	    if (nblocks)
+		*nblocks = addr_count << (levels * addr_shift);
+	    return 0;
+	}
+	blk = get_cache(fs->fs_dev, start);
+	index = (block >> (levels * addr_shift)) & (addr_count - 1);
+	start = blk[index];
+    }
+
+    return scan_set_nblocks(blk + index, addr_count - index, nblocks);
+}
+
+/*
+ * Handle the traditional block map, like indirect, double indirect
+ * and triple indirect
+ */
+static block_t
+bmap_traditional(struct inode *inode, block_t block, size_t *nblocks)
+{
+    struct fs_info *fs = inode->fs;
+    const uint32_t addr_per_block = BLOCK_SIZE(fs) >> 2;
+    const int shft_per_block      = BLOCK_SHIFT(fs) - 2;
+    const uint32_t direct_blocks   = EXT2_NDIR_BLOCKS;
+    const uint32_t indirect_blocks = addr_per_block;
+    const uint32_t double_blocks   = addr_per_block << shft_per_block;
+    const uint32_t triple_blocks   = double_blocks  << shft_per_block;
+
+    /* direct blocks */
+    if (block < direct_blocks)
+	return scan_set_nblocks(&PVT(inode)->i_block[block],
+				direct_blocks - block, nblocks);
+
+    /* indirect blocks */
+    block -= direct_blocks;
+    if (block < indirect_blocks)
+	return bmap_indirect(fs, PVT(inode)->i_block[EXT2_IND_BLOCK],
+			     block, 1, nblocks);
+
+    /* double indirect blocks */
+    block -= indirect_blocks;
+    if (block < double_blocks)
+	return bmap_indirect(fs, PVT(inode)->i_block[EXT2_DIND_BLOCK],
+			     block, 2, nblocks);
+
+    /* triple indirect block */
+    block -= double_blocks;
+    if (block < triple_blocks)
+	return bmap_indirect(fs, PVT(inode)->i_block[EXT2_TIND_BLOCK],
+			     block, 3, nblocks);
+
+    /* This can't happen... */
+    return 0;
+}
+
+
+/**
+ * Map the logical block to physic block where the file data stores.
+ * In EXT4, there are two ways to handle the map process, extents and indirect.
+ * EXT4 uses a inode flag to mark extent file and indirect block file.
+ *
+ * @fs:      the fs_info structure.
+ * @inode:   the inode structure.
+ * @block:   the logical block to be mapped.
+ * @nblocks: optional pointer to number of contiguous blocks (low estimate)
+ * @retrun:  the physical block number.
+ *
+ */
+block_t ext2_bmap(struct inode *inode, block_t block, size_t *nblocks)
+{
+    block_t ret;
+
+    if (inode->flags & EXT4_EXTENTS_FLAG)
+	ret = bmap_extent(inode, block, nblocks);
+    else
+	ret = bmap_traditional(inode, block, nblocks);
+
+    return ret;
+}
+
+
+/*
+ * Next extent for getfssec
+ */
+int ext2_next_extent(struct inode *inode, uint32_t lstart)
+{
+    struct fs_info *fs = inode->fs;
+    int blktosec =  BLOCK_SHIFT(fs) - SECTOR_SHIFT(fs);
+    int blkmask = (1 << blktosec) - 1;
+    block_t block;
+    size_t nblocks = 0;
+
+    block = ext2_bmap(inode, lstart >> blktosec, &nblocks);
+
+    if (!block)
+	inode->next_extent.pstart = EXTENT_ZERO;
+    else
+	inode->next_extent.pstart =
+	    ((sector_t)block << blktosec) | (lstart & blkmask);
+
+    inode->next_extent.len = (nblocks << blktosec) - (lstart & blkmask);
+    return 0;
+}
diff --git a/contrib/syslinux-4.02/core/fs/ext2/ext2.c b/contrib/syslinux-4.02/core/fs/ext2/ext2.c
new file mode 100644
index 0000000..716670c
--- /dev/null
+++ b/contrib/syslinux-4.02/core/fs/ext2/ext2.c
@@ -0,0 +1,335 @@
+#include <dprintf.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/dirent.h>
+#include <minmax.h>
+#include "cache.h"
+#include "core.h"
+#include "disk.h"
+#include "fs.h"
+#include "ext2_fs.h"
+
+/*
+ * Convert an ext2 file type to the global values
+ */
+static enum dirent_type ext2_cvt_type(unsigned int d_file_type)
+{
+    static const enum dirent_type inode_type[] = {
+	DT_UNKNOWN, DT_REG, DT_DIR, DT_CHR,
+	DT_BLK, DT_FIFO, DT_SOCK, DT_LNK,
+    };
+
+    if (d_file_type > sizeof inode_type / sizeof *inode_type)
+	return DT_UNKNOWN;
+    else
+	return inode_type[d_file_type];
+}
+
+/*
+ * get the group's descriptor of group_num
+ */
+static const struct ext2_group_desc *
+ext2_get_group_desc(struct fs_info *fs, uint32_t group_num)
+{
+    struct ext2_sb_info *sbi = EXT2_SB(fs);
+    uint32_t desc_block, desc_index;
+    const struct ext2_group_desc *desc_data_block;
+
+    if (group_num >= sbi->s_groups_count) {
+	printf ("ext2_get_group_desc"
+		"block_group >= groups_count - "
+		"block_group = %d, groups_count = %d",
+		group_num, sbi->s_groups_count);
+
+	return NULL;
+    }
+
+    desc_block = group_num / sbi->s_desc_per_block;
+    desc_index = group_num % sbi->s_desc_per_block;
+
+    desc_block += sbi->s_first_data_block + 1;
+
+    desc_data_block = get_cache(fs->fs_dev, desc_block);
+    return &desc_data_block[desc_index];
+}
+
+/*
+ * Unlike strncmp, ext2_match_entry returns 1 for success, 0 for failure.
+ */
+static inline bool ext2_match_entry(const char *name, size_t len,
+                                    const struct ext2_dir_entry * de)
+{
+    if (!de->d_inode)
+        return false;
+    if (len != de->d_name_len)
+	return false;
+    return !memcmp(name, de->d_name, len);
+}
+
+
+/*
+ * p is at least 6 bytes before the end of page
+ */
+static inline struct ext2_dir_entry *ext2_next_entry(struct ext2_dir_entry *p)
+{
+    return (struct ext2_dir_entry *)((char*)p + p->d_rec_len);
+}
+
+/*
+ * Map a logical sector and load it into the cache
+ */
+static const void *
+ext2_get_cache(struct inode *inode, block_t lblock)
+{
+    block_t pblock = ext2_bmap(inode, lblock, NULL);
+    return get_cache(inode->fs->fs_dev, pblock);
+}
+
+/*
+ * find a dir entry, return it if found, or return NULL.
+ */
+static const struct ext2_dir_entry *
+ext2_find_entry(struct fs_info *fs, struct inode *inode, const char *dname)
+{
+    block_t index = 0;
+    uint32_t i = 0, offset, maxoffset;
+    const struct ext2_dir_entry *de;
+    const char *data;
+    size_t dname_len = strlen(dname);
+
+    while (i < inode->size) {
+	data = ext2_get_cache(inode, index++);
+	offset = 0;
+	maxoffset =  min(BLOCK_SIZE(fs), i-inode->size);
+
+	/* The smallest possible size is 9 bytes */
+	while (offset < maxoffset-8) {
+	    de = (const struct ext2_dir_entry *)(data + offset);
+	    if (de->d_rec_len > maxoffset - offset)
+		break;
+
+	    if (ext2_match_entry(dname, dname_len, de))
+		return de;
+
+	    offset += de->d_rec_len;
+	}
+	i += BLOCK_SIZE(fs);
+    }
+
+    return NULL;
+}
+
+static const struct ext2_inode *
+ext2_get_inode(struct fs_info *fs, int inr)
+{
+    const struct ext2_group_desc *desc;
+    const char *data;
+    uint32_t inode_group, inode_offset;
+    uint32_t block_num, block_off;
+
+    inr--;
+    inode_group  = inr / EXT2_INODES_PER_GROUP(fs);
+    inode_offset = inr % EXT2_INODES_PER_GROUP(fs);
+    desc = ext2_get_group_desc(fs, inode_group);
+    if (!desc)
+	return NULL;
+
+    block_num = desc->bg_inode_table +
+	inode_offset / EXT2_INODES_PER_BLOCK(fs);
+    block_off = inode_offset % EXT2_INODES_PER_BLOCK(fs);
+
+    data = get_cache(fs->fs_dev, block_num);
+
+    return (const struct ext2_inode *)
+	(data + block_off * EXT2_SB(fs)->s_inode_size);
+}
+
+static void fill_inode(struct inode *inode, const struct ext2_inode *e_inode)
+{
+    inode->mode    = IFTODT(e_inode->i_mode);
+    inode->size    = e_inode->i_size;
+    inode->atime   = e_inode->i_atime;
+    inode->ctime   = e_inode->i_ctime;
+    inode->mtime   = e_inode->i_mtime;
+    inode->dtime   = e_inode->i_dtime;
+    inode->blocks  = e_inode->i_blocks;
+    inode->flags   = e_inode->i_flags;
+    inode->file_acl = e_inode->i_file_acl;
+    memcpy(PVT(inode)->i_block, e_inode->i_block, sizeof PVT(inode)->i_block);
+}
+
+static struct inode *ext2_iget_by_inr(struct fs_info *fs, uint32_t inr)
+{
+    const struct ext2_inode *e_inode;
+    struct inode *inode;
+
+    e_inode = ext2_get_inode(fs, inr);
+    if (!(inode = alloc_inode(fs, inr, sizeof(struct ext2_pvt_inode))))
+	return NULL;
+    fill_inode(inode, e_inode);
+
+    return inode;
+}
+
+static struct inode *ext2_iget_root(struct fs_info *fs)
+{
+    return ext2_iget_by_inr(fs, EXT2_ROOT_INO);
+}
+
+static struct inode *ext2_iget(const char *dname, struct inode *parent)
+{
+    const struct ext2_dir_entry *de;
+    struct fs_info *fs = parent->fs;
+
+    de = ext2_find_entry(fs, parent, dname);
+    if (!de)
+	return NULL;
+    
+    return ext2_iget_by_inr(fs, de->d_inode);
+}
+
+/*
+ * Read the entire contents of an inode into a memory buffer
+ */
+static int cache_get_file(struct inode *inode, void *buf, size_t bytes)
+{
+    struct fs_info *fs = inode->fs;
+    size_t block_size = BLOCK_SIZE(fs);
+    uint32_t index = 0;		/* Logical block number */
+    size_t chunk;
+    const char *data;
+    char *p = buf;
+
+    if (inode->size > bytes)
+	bytes = inode->size;
+
+    while (bytes) {
+	chunk = min(bytes, block_size);
+	data = ext2_get_cache(inode, index++);
+	memcpy(p, data, chunk);
+
+	bytes -= chunk;
+	p += chunk;
+    }
+
+    return 0;
+}
+	
+static int ext2_readlink(struct inode *inode, char *buf)
+{
+    struct fs_info *fs = inode->fs;
+    int sec_per_block = 1 << (fs->block_shift - fs->sector_shift);
+    bool fast_symlink;
+
+    if (inode->size > BLOCK_SIZE(fs))
+	return -1;		/* Error! */
+
+    fast_symlink = (inode->file_acl ? sec_per_block : 0) == inode->blocks;
+    if (fast_symlink)
+	memcpy(buf, PVT(inode)->i_block, inode->size);
+    else
+	cache_get_file(inode, buf, inode->size);
+
+    return inode->size;
+}
+
+/*
+ * Read one directory entry at a time
+ */
+static int ext2_readdir(struct file *file, struct dirent *dirent)
+{
+    struct fs_info *fs = file->fs;
+    struct inode *inode = file->inode;
+    const struct ext2_dir_entry *de;
+    const char *data;
+    block_t index = file->offset >> fs->block_shift;
+
+    if (file->offset >= inode->size)
+	return -1;		/* End of file */
+
+    data = ext2_get_cache(inode, index);
+    de = (const struct ext2_dir_entry *)
+	(data + (file->offset & (BLOCK_SIZE(fs) - 1)));
+
+    dirent->d_ino = de->d_inode;
+    dirent->d_off = file->offset;
+    dirent->d_reclen = offsetof(struct dirent, d_name) + de->d_name_len + 1;
+    dirent->d_type = ext2_cvt_type(de->d_file_type);
+    memcpy(dirent->d_name, de->d_name, de->d_name_len);
+    dirent->d_name[de->d_name_len] = '\0';
+
+    file->offset += de->d_rec_len;  /* Update for next reading */
+
+    return 0;
+}
+
+/*
+ * init. the fs meta data, return the block size bits.
+ */
+static int ext2_fs_init(struct fs_info *fs)
+{
+    struct disk *disk = fs->fs_dev->disk;
+    struct ext2_sb_info *sbi;
+    struct ext2_super_block sb;
+    struct cache *cs;
+
+    /* read the super block */
+    disk->rdwr_sectors(disk, &sb, 2, 2, 0);
+
+    /* check if it is ext2, since we also support btrfs now */
+    if (sb.s_magic != EXT2_SUPER_MAGIC)
+	return -1;
+
+    sbi = malloc(sizeof(*sbi));
+    if (!sbi) {
+	malloc_error("ext2_sb_info structure");
+	return -1;
+    }
+    fs->fs_info = sbi;
+
+    if (sb.s_magic != EXT2_SUPER_MAGIC) {
+	printf("ext2 mount error: it's not a EXT2/3/4 file system!\n");
+	return 0;
+    }
+
+    fs->sector_shift = disk->sector_shift;
+    fs->block_shift  = sb.s_log_block_size + 10;
+    fs->sector_size  = 1 << fs->sector_shift;
+    fs->block_size   = 1 << fs->block_shift;
+
+    sbi->s_inodes_per_group = sb.s_inodes_per_group;
+    sbi->s_blocks_per_group = sb.s_blocks_per_group;
+    sbi->s_inodes_per_block = BLOCK_SIZE(fs) / sb.s_inode_size;
+    if (sb.s_desc_size < sizeof(struct ext2_group_desc))
+	sb.s_desc_size = sizeof(struct ext2_group_desc);
+    sbi->s_desc_per_block   = BLOCK_SIZE(fs) / sb.s_desc_size;
+    sbi->s_groups_count     = (sb.s_blocks_count - sb.s_first_data_block
+			       + EXT2_BLOCKS_PER_GROUP(fs) - 1)
+	                      / EXT2_BLOCKS_PER_GROUP(fs);
+    sbi->s_first_data_block = sb.s_first_data_block;
+    sbi->s_inode_size = sb.s_inode_size;
+
+    /* Initialize the cache, and force block zero to all zero */
+    cache_init(fs->fs_dev, fs->block_shift);
+    cs = _get_cache_block(fs->fs_dev, 0);
+    memset(cs->data, 0, fs->block_size);
+    cache_lock_block(cs);
+
+    return fs->block_shift;
+}
+
+const struct fs_ops ext2_fs_ops = {
+    .fs_name       = "ext2",
+    .fs_flags      = FS_THISIND | FS_USEMEM,
+    .fs_init       = ext2_fs_init,
+    .searchdir     = NULL,
+    .getfssec      = generic_getfssec,
+    .close_file    = generic_close_file,
+    .mangle_name   = generic_mangle_name,
+    .load_config   = generic_load_config,
+    .iget_root     = ext2_iget_root,
+    .iget          = ext2_iget,
+    .readlink      = ext2_readlink,
+    .readdir       = ext2_readdir,
+    .next_extent   = ext2_next_extent,
+};
diff --git a/contrib/syslinux-4.02/core/fs/ext2/ext2_fs.h b/contrib/syslinux-4.02/core/fs/ext2/ext2_fs.h
new file mode 100644
index 0000000..8adc9bb
--- /dev/null
+++ b/contrib/syslinux-4.02/core/fs/ext2/ext2_fs.h
@@ -0,0 +1,310 @@
+#ifndef __EXT2_FS_H
+#define __EXT2_FS_H
+
+#include <stdint.h>
+
+#define	EXT2_SUPER_MAGIC	0xEF53
+
+#define EXT2_GOOD_OLD_REV       0       // The good old (original) format
+#define EXT2_DYNAMIC_REV        1       // V2 format w/ dynamic inode sizes
+#define EXT2_GOOD_OLD_INODE_SIZE 128
+
+// Special inode numbers
+#define	EXT2_BAD_INO		 1	// Bad blocks inode
+#define EXT2_ROOT_INO		 2	// Root inode
+#define EXT2_BOOT_LOADER_INO	 5	// Boot loader inode
+#define EXT2_UNDEL_DIR_INO	 6	// Undelete directory inode
+#define EXT3_RESIZE_INO		 7	// Reserved group descriptors inode
+#define EXT3_JOURNAL_INO	 8	// Journal inode
+
+// We're readonly, so we only care about incompat features.
+#define EXT2_FEATURE_INCOMPAT_COMPRESSION	0x0001
+#define EXT2_FEATURE_INCOMPAT_FILETYPE		0x0002
+#define EXT3_FEATURE_INCOMPAT_RECOVER		0x0004
+#define EXT3_FEATURE_INCOMPAT_JOURNAL_DEV	0x0008
+#define EXT2_FEATURE_INCOMPAT_META_BG		0x0010
+#define EXT2_FEATURE_INCOMPAT_ANY		0xffffffff
+
+#define EXT2_NDIR_BLOCKS	12
+#define	EXT2_IND_BLOCK		EXT2_NDIR_BLOCKS
+#define EXT2_DIND_BLOCK		(EXT2_IND_BLOCK+1)
+#define	EXT2_TIND_BLOCK		(EXT2_DIND_BLOCK+1)
+#define	EXT2_N_BLOCKS		(EXT2_TIND_BLOCK+1)
+
+
+/* for EXT4 extent */
+#define EXT4_EXT_MAGIC     0xf30a
+#define EXT4_EXTENTS_FLAG  0x00080000
+
+/*
+ * File types and file modes
+ */
+#define S_IFDIR		0040000	        // Directory
+#define S_IFCHR		0020000	        // Character device
+#define S_IFBLK		0060000		// Block device
+#define S_IFREG		0100000	        // Regular file
+#define S_IFIFO		0010000	        // FIFO
+#define S_IFLNK		0120000		// Symbolic link
+#define S_IFSOCK	0140000		// Socket
+
+#define S_IFSHIFT	12
+
+#define T_IFDIR		(S_IFDIR >> S_IFSHIFT)
+#define T_IFCHR		(S_IFCHR >> S_IFSHIFT)
+#define T_IFBLK		(S_IFBLK >> S_IFSHIFT)
+#define T_IFREG		(S_IFREG >> S_IFSHIFT)
+#define T_IFIFO		(S_IFIFO >> S_IFSHIFT)
+#define T_IFLNK		(S_IFLNK >> S_IFSHIFT)
+#define T_IFSOCK	(S_IFSOCK >> S_IFSHIFT)
+
+
+#define ext2_group_desc_lg2size 5
+
+
+
+/*
+ * super block structure:
+ * include/linux/ext2_fs.h
+ */
+struct ext2_super_block {
+    uint32_t s_inodes_count;	        /* Inodes count */
+    uint32_t s_blocks_count;	        /* Blocks count */
+    uint32_t s_r_blocks_count;	        /* Reserved blocks count */
+    uint32_t s_free_blocks_count;	/* Free blocks count */
+    uint32_t s_free_inodes_count;	/* Free inodes count */
+    uint32_t s_first_data_block;	/* First Data Block */
+    uint32_t s_log_block_size;	        /* Block size */
+    uint32_t s_log_frag_size;	        /* Fragment size */
+    uint32_t s_blocks_per_group;	/* # Blocks per group */
+    uint32_t s_frags_per_group;	        /* # Fragments per group */
+    uint32_t s_inodes_per_group;	/* # Inodes per group */
+    uint32_t s_mtime;		        /* Mount time */
+    uint32_t s_wtime;		        /* Write time */
+    uint16_t s_mnt_count;		/* Mount count */
+    int16_t  s_max_mnt_count;	        /* Maximal mount count */
+    uint16_t s_magic;		        /* Magic signature */
+    uint16_t s_state;		        /* File system state */
+    uint16_t s_errors;		        /* Behaviour when detecting errors */
+    uint16_t s_minor_rev_level;
+    uint32_t s_lastcheck;		/* time of last check */
+    uint32_t s_checkinterval;	        /* max. time between checks */
+    uint32_t s_creator_os;		/* OS */
+    uint32_t s_rev_level;		/* Revision level */
+    uint16_t s_def_resuid;		/* Default uid for reserved blocks */
+    uint16_t s_def_resgid;		/* Default gid for reserved blocks */
+
+    uint32_t s_first_ino;		/* First non-reserved inode */
+    uint16_t s_inode_size;		/* size of inode structure */
+    uint16_t s_block_group_nr;	        /* block group # of this superblock */
+    uint32_t s_feature_compat;	        /* compatible feature set */
+    uint32_t s_feature_incompat;	/* incompatible feature set */
+    uint32_t s_feature_ro_compat;	/* readonly-compatible feature set */
+    uint8_t  s_uuid[16];		/* 128-bit uuid for volume */
+    char  s_volume_name[16];	        /* volume name */
+    char  s_last_mounted[64];	        /* directory where last mounted */
+    uint32_t s_algorithm_usage_bitmap;  /* For compression */
+    uint8_t  s_prealloc_blocks;	        /* Nr of blocks to try to preallocate*/
+    uint8_t  s_prealloc_dir_blocks;
+    uint16_t s_reserved_gdt_blocks;	/* Per group desc for online growth */
+    /*
+     * Journaling support valid if EXT4_FEATURE_COMPAT_HAS_JOURNAL set.
+     */
+    uint8_t  s_journal_uuid[16];	/* uuid of journal superblock */
+    uint32_t s_journal_inum;	/* inode number of journal file */
+    uint32_t s_journal_dev;		/* device number of journal file */
+    uint32_t s_last_orphan;		/* start of list of inodes to delete */
+    uint32_t s_hash_seed[4];	/* HTREE hash seed */
+    uint8_t  s_def_hash_version;	/* Default hash version to use */
+    uint8_t  s_reserved_char_pad;
+    uint16_t s_desc_size;		/* size of group descriptor */
+    uint32_t s_default_mount_opts;
+    uint32_t s_first_meta_bg;	/* First metablock block group */
+    uint32_t s_mkfs_time;		/* When the filesystem was created */
+    uint32_t s_jnl_blocks[17];	/* Backup of the journal inode */
+    /* 64bit support valid if EXT4_FEATURE_COMPAT_64BIT */
+    uint32_t s_blocks_count_hi;	/* Blocks count */
+    uint32_t s_r_blocks_count_hi;	/* Reserved blocks count */
+    uint32_t s_free_blocks_count_hi;/* Free blocks count */
+    uint16_t s_min_extra_isize;	/* All inodes have at least # bytes */
+    uint16_t s_want_extra_isize;	/* New inodes should reserve # bytes */
+    uint32_t s_flags;		/* Miscellaneous flags */
+    uint16_t s_raid_stride;		/* RAID stride */
+    uint16_t s_mmp_interval;        /* # seconds to wait in MMP checking */
+    uint64_t s_mmp_block;           /* Block for multi-mount protection */
+    uint32_t s_raid_stripe_width;   /* blocks on all data disks (N*stride)*/
+    uint8_t  s_log_groups_per_flex; /* FLEX_BG group size */
+    uint8_t  s_reserved_char_pad2;
+    uint16_t s_reserved_pad;
+    uint32_t s_reserved[162];        /* Padding to the end of the block */
+};
+
+/*******************************************************************************
+#ifndef DEPEND
+#if ext2_super_block_size != 1024
+#error ext2_super_block definition bogus
+#endif
+#endif
+*******************************************************************************/
+
+/*
+ *  ext2 group desc structure:
+ */
+struct ext2_group_desc {
+    uint32_t bg_block_bitmap;	/* Blocks bitmap block */
+    uint32_t bg_inode_bitmap;	/* Inodes bitmap block */
+    uint32_t bg_inode_table;	/* Inodes table block */
+    uint16_t bg_free_blocks_count;	/* Free blocks count */
+    uint16_t bg_free_inodes_count;	/* Free inodes count */
+    uint16_t bg_used_dirs_count;	/* Directories count */
+    uint16_t bg_pad;
+    uint32_t bg_reserved[3];
+};
+
+/*******************************************************************************
+#ifndef DEPEND
+#if ext2_group_desc_size != 32
+#error ext2_group_desc definition bogus
+#endif
+#endif
+*******************************************************************************/
+
+
+/*
+ * ext2 inode structure:
+ */
+struct ext2_inode {
+    uint16_t i_mode;		/* File mode */
+    uint16_t i_uid;		/* Owner Uid */
+    uint32_t i_size;		/* 4: Size in bytes */
+    uint32_t i_atime;		/* Access time */
+    uint32_t i_ctime;		/* 12: Creation time */
+    uint32_t i_mtime;		/* Modification time */
+    uint32_t i_dtime;		/* 20: Deletion Time */
+    uint16_t i_gid;		/* Group Id */
+    uint16_t i_links_count;	/* 24: Links count */
+    uint32_t i_blocks;		/* Blocks count */
+    uint32_t i_flags;		/* 32: File flags */
+    uint32_t l_i_reserved1;
+    uint32_t i_block[EXT2_N_BLOCKS];	/* 40: Pointers to blocks */
+    uint32_t i_version;		/* File version (for NFS) */
+    uint32_t i_file_acl;	/* File ACL */
+    uint32_t i_dir_acl;		/* Directory ACL */
+    uint32_t i_faddr;		/* Fragment address */
+    uint8_t  l_i_frag;	        /* Fragment number */
+    uint8_t  l_i_fsize;	        /* Fragment size */
+    uint16_t i_pad1;
+    uint32_t l_i_reserved2[2];
+};
+
+/*******************************************************************************
+#ifndef DEPEND
+#if ext2_inode_size != 128
+#error ext2_inode definition bogus
+#endif
+#endif
+*******************************************************************************/
+
+
+#define EXT2_NAME_LEN 255
+struct ext2_dir_entry {
+    unsigned int	d_inode;		/* Inode number */
+    unsigned short	d_rec_len;		/* Directory entry length */
+    unsigned char	d_name_len;		/* Name length */
+    unsigned char	d_file_type;
+    char	d_name[EXT2_NAME_LEN];	        /* File name */
+};
+
+/*******************************************************************************
+#define EXT2_DIR_PAD	 4
+#define EXT2_DIR_ROUND	(EXT2_DIR_PAD - 1)
+#define EXT2_DIR_REC_LEN(name_len)	(((name_len) + 8 + EXT2_DIR_ROUND) & \
+					 ~EXT2_DIR_ROUND)
+*******************************************************************************/
+
+
+
+
+
+
+/*
+ * This is the extent on-disk structure.
+ * It's used at the bottom of the tree.
+ */
+struct ext4_extent {
+    uint32_t ee_block;	        /* first logical block extent covers */
+    uint16_t ee_len;	        /* number of blocks covered by extent */
+    uint16_t ee_start_hi;	/* high 16 bits of physical block */
+    uint32_t ee_start_lo;	/* low 32 bits of physical block */
+};
+
+/*
+ * This is index on-disk structure.
+ * It's used at all the levels except the bottom.
+ */
+struct ext4_extent_idx {
+    uint32_t ei_block;	        /* index covers logical blocks from 'block' */
+    uint32_t ei_leaf_lo;	/* pointer to the physical block of the next *
+				 * level. leaf or next index could be there */
+    uint16_t ei_leaf_hi;	/* high 16 bits of physical block */
+    uint16_t ei_unused;
+};
+
+/*
+ * Each block (leaves and indexes), even inode-stored has header.
+ */
+struct ext4_extent_header {
+    uint16_t eh_magic;	        /* probably will support different formats */
+    uint16_t eh_entries;	/* number of valid entries */
+    uint16_t eh_max;	        /* capacity of store in entries */
+    uint16_t eh_depth;	        /* has tree real underlying blocks? */
+    uint32_t eh_generation;	/* generation of the tree */
+};
+
+
+
+#define EXT4_FIRST_EXTENT(header) ( (struct ext4_extent *)(header + 1) )
+#define EXT4_FIRST_INDEX(header)  ( (struct ext4_extent_idx *) (header + 1) )
+
+
+/*
+ * The ext2 super block information in memory
+ */
+struct ext2_sb_info {
+    uint32_t s_inodes_per_block;/* Number of inodes per block */
+    uint32_t s_inodes_per_group;/* Number of inodes in a group */
+    uint32_t s_blocks_per_group;/* Number of blocks in a group */
+    uint32_t s_desc_per_block;  /* Number of group descriptors per block */
+    uint32_t s_groups_count;    /* Number of groups in the fs */
+    uint32_t s_first_data_block;	/* First Data Block */
+    int      s_inode_size;
+};
+
+static inline struct ext2_sb_info *EXT2_SB(struct fs_info *fs)
+{
+    return fs->fs_info;
+}
+
+#define EXT2_BLOCKS_PER_GROUP(fs)      (EXT2_SB(fs)->s_blocks_per_group)
+#define EXT2_INODES_PER_GROUP(fs)      (EXT2_SB(fs)->s_inodes_per_group)
+#define EXT2_INODES_PER_BLOCK(fs)      (EXT2_SB(fs)->s_inodes_per_block)
+#define EXT2_DESC_PER_BLOCK(fs)        (EXT2_SB(fs)->s_desc_per_block)
+
+/*
+ * ext2 private inode information
+ */
+struct ext2_pvt_inode {
+    union {
+	uint32_t i_block[EXT2_N_BLOCKS];
+	struct ext4_extent_header i_extent_hdr;
+    };
+};
+
+#define PVT(i) ((struct ext2_pvt_inode *)((i)->pvt))
+
+/*
+ * functions
+ */
+block_t ext2_bmap(struct inode *, block_t, size_t *);
+int ext2_next_extent(struct inode *, uint32_t);
+
+#endif /* ext2_fs.h */
diff --git a/contrib/syslinux-4.02/core/fs/fat/fat.c b/contrib/syslinux-4.02/core/fs/fat/fat.c
new file mode 100644
index 0000000..5902f48
--- /dev/null
+++ b/contrib/syslinux-4.02/core/fs/fat/fat.c
@@ -0,0 +1,795 @@
+#include <dprintf.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/dirent.h>
+#include <cache.h>
+#include <core.h>
+#include <disk.h>
+#include <fs.h>
+#include <ilog2.h>
+#include <klibc/compiler.h>
+#include "codepage.h"
+#include "fat_fs.h"
+
+static struct inode * new_fat_inode(struct fs_info *fs)
+{
+    struct inode *inode = alloc_inode(fs, 0, sizeof(struct fat_pvt_inode));
+    if (!inode)
+	malloc_error("inode structure");
+
+    return inode;
+}
+
+/*
+ * Check for a particular sector in the FAT cache
+ */
+static const void *get_fat_sector(struct fs_info *fs, sector_t sector)
+{
+    return get_cache(fs->fs_dev, FAT_SB(fs)->fat + sector);
+}
+
+static uint32_t get_next_cluster(struct fs_info *fs, uint32_t clust_num)
+{
+    uint32_t next_cluster = 0;
+    sector_t fat_sector;
+    uint32_t offset;
+    uint32_t sector_mask = SECTOR_SIZE(fs) - 1;
+    const uint8_t *data;
+
+    switch(FAT_SB(fs)->fat_type) {
+    case FAT12:
+	offset = clust_num + (clust_num >> 1);
+	fat_sector = offset >> SECTOR_SHIFT(fs);
+	offset &= sector_mask;
+	data = get_fat_sector(fs, fat_sector);
+	if (offset == sector_mask) {
+	    /*
+	     * we got the end of the one fat sector,
+	     * but we have just one byte and we need two,
+	     * so store the low part, then read the next fat
+	     * sector, read the high part, then combine it.
+	     */
+	    next_cluster = data[offset];
+	    data = get_fat_sector(fs, fat_sector + 1);
+	    next_cluster += data[0] << 8;
+	} else {
+	    next_cluster = *(const uint16_t *)(data + offset);
+	}
+
+	if (clust_num & 0x0001)
+	    next_cluster >>= 4;         /* cluster number is ODD */
+	else
+	    next_cluster &= 0x0fff;     /* cluster number is EVEN */
+	break;
+
+    case FAT16:
+	offset = clust_num << 1;
+	fat_sector = offset >> SECTOR_SHIFT(fs);
+	offset &= sector_mask;
+	data = get_fat_sector(fs, fat_sector);
+	next_cluster = *(const uint16_t *)(data + offset);
+	break;
+
+    case FAT32:
+	offset = clust_num << 2;
+	fat_sector = offset >> SECTOR_SHIFT(fs);
+	offset &= sector_mask;
+	data = get_fat_sector(fs, fat_sector);
+	next_cluster = *(const uint32_t *)(data + offset);
+	next_cluster &= 0x0fffffff;
+	break;
+    }
+
+    return next_cluster;
+}
+
+static int fat_next_extent(struct inode *inode, uint32_t lstart)
+{
+    struct fs_info *fs = inode->fs;
+    struct fat_sb_info *sbi = FAT_SB(fs);
+    uint32_t mcluster = lstart >> sbi->clust_shift;
+    uint32_t lcluster;
+    uint32_t pcluster;
+    uint32_t tcluster;
+    uint32_t xcluster;
+    const uint32_t cluster_bytes = UINT32_C(1) << sbi->clust_byte_shift;
+    const uint32_t cluster_secs  = UINT32_C(1) << sbi->clust_shift;
+    sector_t data_area = sbi->data;
+
+    tcluster = (inode->size + cluster_bytes - 1) >> sbi->clust_byte_shift;
+    if (mcluster >= tcluster)
+	goto err;		/* Requested cluster beyond end of file */
+
+    lcluster = PVT(inode)->offset >> sbi->clust_shift;
+    pcluster = ((PVT(inode)->here - data_area) >> sbi->clust_shift) + 2;
+
+    if (lcluster > mcluster || PVT(inode)->here < data_area) {
+	lcluster = 0;
+	pcluster = PVT(inode)->start_cluster;
+    }
+
+    for (;;) {
+	if (pcluster-2 >= sbi->clusters) {
+	    inode->size = lcluster << sbi->clust_shift;
+	    goto err;
+	}
+
+	if (lcluster >= mcluster)
+	    break;
+
+	lcluster++;
+	pcluster = get_next_cluster(fs, pcluster);
+    }
+
+    inode->next_extent.pstart =
+	((sector_t)(pcluster-2) << sbi->clust_shift) + data_area;
+    inode->next_extent.len = cluster_secs;
+    xcluster = 0;		/* Nonsense */
+
+    while (++lcluster < tcluster) {
+	xcluster = get_next_cluster(fs, pcluster);
+	if (xcluster != ++pcluster)
+	    break;		/* Not contiguous */
+	inode->next_extent.len += cluster_secs;
+    }
+
+    /* Note: ->here is bogus if ->offset >= EOF, but that's okay */
+    PVT(inode)->offset = lcluster << sbi->clust_shift;
+    PVT(inode)->here   = ((xcluster-2) << sbi->clust_shift) + data_area;
+
+    return 0;
+
+err:
+    return -1;
+}
+
+static sector_t get_next_sector(struct fs_info* fs, uint32_t sector)
+{
+    struct fat_sb_info *sbi = FAT_SB(fs);
+    sector_t data_area = sbi->data;
+    sector_t data_sector;
+    uint32_t cluster;
+    int clust_shift = sbi->clust_shift;
+
+    if (sector < data_area) {
+	/* Root directory sector... */
+	sector++;
+	if (sector >= data_area)
+	    sector = 0; /* Ran out of root directory, return EOF */
+	return sector;
+    }
+
+    data_sector = sector - data_area;
+    if ((data_sector + 1) & sbi->clust_mask)  /* Still in the same cluster */
+	return sector + 1;		      /* Next sector inside cluster */
+
+    /* get a new cluster */
+    cluster = data_sector >> clust_shift;
+    cluster = get_next_cluster(fs, cluster + 2) - 2;
+
+    if (cluster >= sbi->clusters)
+	return 0;
+
+    /* return the start of the new cluster */
+    sector = (cluster << clust_shift) + data_area;
+    return sector;
+}
+
+/*
+ * The FAT is a single-linked list.  We remember the last place we
+ * were, so for a forward seek we can move forward from there, but
+ * for a reverse seek we have to start over...
+ */
+static sector_t get_the_right_sector(struct file *file)
+{
+    struct inode *inode = file->inode;
+    uint32_t sector_pos  = file->offset >> SECTOR_SHIFT(file->fs);
+    uint32_t where;
+    sector_t sector;
+
+    if (sector_pos < PVT(inode)->offset) {
+	/* Reverse seek */
+	where = 0;
+	sector = PVT(inode)->start;
+    } else {
+	where = PVT(inode)->offset;
+	sector = PVT(inode)->here;
+    }
+
+    while (where < sector_pos) {
+	sector = get_next_sector(file->fs, sector);
+	where++;
+    }
+
+    PVT(inode)->offset = sector_pos;
+    PVT(inode)->here   = sector;
+
+    return sector;
+}
+
+/*
+ * Get the next sector in sequence
+ */
+static sector_t next_sector(struct file *file)
+{
+    struct inode *inode = file->inode;
+    sector_t sector = get_next_sector(file->fs, PVT(inode)->here);
+    PVT(inode)->offset++;
+    PVT(inode)->here = sector;
+
+    return sector;
+}
+
+/*
+ * Mangle a filename pointed to by src into a buffer pointed to by dst;
+ * ends on encountering any whitespace.
+ *
+ */
+static void vfat_mangle_name(char *dst, const char *src)
+{
+    char *p = dst;
+    char c;
+    int i = FILENAME_MAX -1;
+
+    /*
+     * Copy the filename, converting backslash to slash and
+     * collapsing duplicate separators.
+     */
+    while (not_whitespace(c = *src)) {
+        if (c == '\\')
+            c = '/';
+
+        if (c == '/') {
+            if (src[1] == '/' || src[1] == '\\') {
+                src++;
+                i--;
+                continue;
+            }
+        }
+        i--;
+        *dst++ = *src++;
+    }
+
+    /* Strip terminal slashes or whitespace */
+    while (1) {
+        if (dst == p)
+            break;
+		if (*(dst-1) == '/' && dst-1 == p) /* it's the '/' case */
+			break;
+        if ((*(dst-1) != '/') && (*(dst-1) != '.'))
+            break;
+
+        dst--;
+        i++;
+    }
+
+    i++;
+    for (; i > 0; i --)
+        *dst++ = '\0';
+}
+
+/*
+ * Mangle a normal style string to DOS style string.
+ */
+static void mangle_dos_name(char *mangle_buf, const char *src)
+{
+    int i;
+    unsigned char c;
+
+    if (src[0] == '.' && (!src[1] || (src[1] == '.' && !src[2]))) {
+	/* . and .. mangle to their respective zero-padded version */
+	i = stpcpy(mangle_buf, src) - mangle_buf;
+    } else {
+	i = 0;
+	while (i < 11) {
+	    c = *src++;
+	    
+	if ((c <= ' ') || (c == '/'))
+	    break;
+	
+	if (c == '.') {
+	    while (i < 8)
+		mangle_buf[i++] = ' ';
+	    i = 8;
+	    continue;
+	}
+	
+	c = codepage.upper[c];
+	if (i == 0 && c == 0xe5)
+	    c = 0x05;		/* Special hack for the first byte only! */
+	
+	mangle_buf[i++] = c;
+	}
+    }
+
+    while (i < 11)
+	mangle_buf[i++] = ' ';
+
+    mangle_buf[i] = '\0';
+}
+
+/*
+ * Match a string name against a longname.  "len" is the number of
+ * codepoints in the input; including padding.
+ *
+ * Returns true on match.
+ */
+static bool vfat_match_longname(const char *str, const uint16_t *match,
+				int len)
+{
+    unsigned char c = -1;	/* Nonzero: we have not yet seen NUL */
+    uint16_t cp;
+
+    dprintf("Matching: %s\n", str);
+
+    while (len) {
+	cp = *match++;
+	len--;
+	if (!cp)
+	    break;
+	c = *str++;
+	if (cp != codepage.uni[0][c] && cp != codepage.uni[1][c])
+	    return false;	/* Also handles c == '\0' */
+    }
+
+    /* This should have been the end of the matching string */
+    if (*str)
+	return false;
+
+    /* Any padding entries must be FFFF */
+    while (len--)
+	if (*match++ != 0xffff)
+	    return false;
+
+    return true;
+}
+
+/*
+ * Convert an UTF-16 longname to the system codepage; return
+ * the length on success or -1 on failure.
+ */
+static int vfat_cvt_longname(char *entry_name, const uint16_t *long_name)
+{
+    struct unicache {
+	uint16_t utf16;
+	uint8_t cp;
+    };
+    static struct unicache unicache[256];
+    struct unicache *uc;
+    uint16_t cp;
+    unsigned int c;
+    char *p = entry_name;
+
+    do {
+	cp = *long_name++;
+	uc = &unicache[cp % 256];
+
+	if (__likely(uc->utf16 == cp)) {
+	    *p++ = uc->cp;
+	} else {
+	    for (c = 0; c < 512; c++) {
+		/* This is a bit hacky... */
+		if (codepage.uni[0][c] == cp) {
+		    uc->utf16 = cp;
+		    *p++ = uc->cp = (uint8_t)c;
+		    goto found;
+		}
+	    }
+	    return -1;		/* Impossible character */
+	found:
+	    ;
+	}
+    } while (cp);
+
+    return (p-entry_name)-1;
+}
+
+static void copy_long_chunk(uint16_t *buf, const struct fat_dir_entry *de)
+{
+    const struct fat_long_name_entry *le =
+	(const struct fat_long_name_entry *)de;
+
+    memcpy(buf,      le->name1, 5 * 2);
+    memcpy(buf + 5,  le->name2, 6 * 2);
+    memcpy(buf + 11, le->name3, 2 * 2);
+}
+
+static uint8_t get_checksum(const char *dir_name)
+{
+    int  i;
+    uint8_t sum = 0;
+
+    for (i = 11; i; i--)
+	sum = ((sum & 1) << 7) + (sum >> 1) + (uint8_t)*dir_name++;
+    return sum;
+}
+
+
+/* compute the first sector number of one dir where the data stores */
+static inline sector_t first_sector(struct fs_info *fs,
+				    const struct fat_dir_entry *dir)
+{
+    const struct fat_sb_info *sbi = FAT_SB(fs);
+    sector_t first_clust;
+    sector_t sector;
+
+    first_clust = (dir->first_cluster_high << 16) + dir->first_cluster_low;
+    if (first_clust == 0)
+	sector = sbi->root;	/* first_clust == 0 means root directory */
+    else
+	sector = ((first_clust - 2) << sbi->clust_shift) + sbi->data;
+
+    return sector;
+}
+
+static inline enum dirent_type get_inode_mode(uint8_t attr)
+{
+    return (attr & FAT_ATTR_DIRECTORY) ? DT_DIR : DT_REG;
+}
+
+
+static struct inode *vfat_find_entry(const char *dname, struct inode *dir)
+{
+    struct fs_info *fs = dir->fs;
+    struct inode *inode;
+    const struct fat_dir_entry *de;
+    struct fat_long_name_entry *long_de;
+
+    char mangled_name[12];
+    uint16_t long_name[260];	/* == 20*13 */
+    int long_len;
+
+    sector_t dir_sector = PVT(dir)->start;
+    uint8_t vfat_init, vfat_next, vfat_csum = 0;
+    uint8_t id;
+    int slots;
+    int entries;
+    int checksum;
+    int long_match = 0;
+
+    slots = (strlen(dname) + 12) / 13;
+    if (slots > 20)
+	return NULL;		/* Name too long */
+
+    slots |= 0x40;
+    vfat_init = vfat_next = slots;
+    long_len = slots*13;
+
+    /* Produce the shortname version, in case we need it. */
+    mangle_dos_name(mangled_name, dname);
+
+    while (dir_sector) {
+	de = get_cache(fs->fs_dev, dir_sector);
+	entries = 1 << (fs->sector_shift - 5);
+
+	while (entries--) {
+	    if (de->name[0] == 0)
+		return NULL;
+
+	    if (de->attr == 0x0f) {
+		/*
+		 * It's a long name entry.
+		 */
+		long_de = (struct fat_long_name_entry *)de;
+		id = long_de->id;
+		if (id != vfat_next)
+		    goto not_match;
+
+		if (id & 0x40) {
+		    /* get the initial checksum value */
+		    vfat_csum = long_de->checksum;
+		    id &= 0x3f;
+		    long_len = id * 13;
+
+		    /* ZERO the long_name buffer */
+		    memset(long_name, 0, sizeof long_name);
+		} else {
+		    if (long_de->checksum != vfat_csum)
+			goto not_match;
+		}
+
+		vfat_next = --id;
+
+		/* got the long entry name */
+		copy_long_chunk(long_name + id*13, de);
+
+		/*
+		 * If we got the last entry, check it.
+		 * Or, go on with the next entry.
+		 */
+		if (id == 0) {
+		    if (!vfat_match_longname(dname, long_name, long_len))
+			goto not_match;
+		    long_match = 1;
+		}
+		de++;
+		continue;     /* Try the next entry */
+	    } else {
+		/*
+		 * It's a short entry
+		 */
+		if (de->attr & 0x08) /* ignore volume labels */
+		    goto not_match;
+
+		if (long_match) {
+		    /*
+		     * We already have a VFAT long name match. However, the
+		     * match is only valid if the checksum matches.
+		     */
+		    checksum = get_checksum(de->name);
+		    if (checksum == vfat_csum)
+			goto found;  /* Got it */
+		} else {
+		    if (!memcmp(mangled_name, de->name, 11))
+			goto found;
+		}
+	    }
+
+	not_match:
+	    vfat_next = vfat_init;
+	    long_match = 0;
+
+	    de++;
+	}
+
+	/* Try with the next sector */
+	dir_sector = get_next_sector(fs, dir_sector);
+    }
+    return NULL;		/* Nothing found... */
+
+found:
+    inode = new_fat_inode(fs);
+    inode->size = de->file_size;
+    PVT(inode)->start_cluster = 
+	(de->first_cluster_high << 16) + de->first_cluster_low;
+    if (PVT(inode)->start_cluster == 0) {
+	/* Root directory */
+	int root_size = FAT_SB(fs)->root_size;
+
+	PVT(inode)->start_cluster = FAT_SB(fs)->root_cluster;
+	inode->size = root_size ? root_size << fs->sector_shift : ~0;
+	PVT(inode)->start = PVT(inode)->here = FAT_SB(fs)->root;
+    } else {
+	PVT(inode)->start = PVT(inode)->here = first_sector(fs, de);
+    }
+    inode->mode = get_inode_mode(de->attr);
+
+    return inode;
+}
+
+static struct inode *vfat_iget_root(struct fs_info *fs)
+{
+    struct inode *inode = new_fat_inode(fs);
+    int root_size = FAT_SB(fs)->root_size;
+
+    /*
+     * For FAT32, the only way to get the root directory size is to
+     * follow the entire FAT chain to the end... which seems pointless.
+     */
+    PVT(inode)->start_cluster = FAT_SB(fs)->root_cluster;
+    inode->size = root_size ? root_size << fs->sector_shift : ~0;
+    PVT(inode)->start = PVT(inode)->here = FAT_SB(fs)->root;
+    inode->mode = DT_DIR;
+
+    return inode;
+}
+
+static struct inode *vfat_iget(const char *dname, struct inode *parent)
+{
+    return vfat_find_entry(dname, parent);
+}
+
+static int vfat_readdir(struct file *file, struct dirent *dirent)
+{
+    struct fs_info *fs = file->fs;
+    const struct fat_dir_entry *de;
+    const char *data;
+    const struct fat_long_name_entry *long_de;
+
+    sector_t sector = get_the_right_sector(file);
+
+    uint16_t long_name[261];	/* == 20*13 + 1 (to guarantee null) */
+    char filename[261];
+    int name_len = 0;
+
+    uint8_t vfat_init, vfat_next, vfat_csum;
+    uint8_t id;
+    int entries_left;
+    bool long_entry = false;
+    int sec_off = file->offset & ((1 << fs->sector_shift) - 1);
+
+    data = get_cache(fs->fs_dev, sector);
+    de = (const struct fat_dir_entry *)(data + sec_off);
+    entries_left = ((1 << fs->sector_shift) - sec_off) >> 5;
+
+    vfat_next = vfat_csum = 0xff;
+
+    while (1) {
+	while (entries_left--) {
+	    if (de->name[0] == 0)
+		return -1;	/* End of directory */
+	    if ((uint8_t)de->name[0] == 0xe5)
+		goto invalid;
+
+	    if (de->attr == 0x0f) {
+		/*
+		 * It's a long name entry.
+		 */
+		long_de = (struct fat_long_name_entry *)de;
+		id = long_de->id;
+
+		if (id & 0x40) {
+		    /* init vfat_csum and vfat_init */
+		    vfat_csum = long_de->checksum;
+		    id &= 0x3f;
+		    if (id >= 20)
+			goto invalid; /* Too long! */
+
+		    vfat_init = id;
+
+		    /* ZERO the long_name buffer */
+		    memset(long_name, 0, sizeof long_name);
+		} else {
+		    if (long_de->checksum != vfat_csum || id != vfat_next)
+			goto invalid;
+		}
+
+		vfat_next = --id;
+
+		/* got the long entry name */
+		copy_long_chunk(long_name + id*13, de);
+
+		if (id == 0) {
+		    name_len = vfat_cvt_longname(filename, long_name);
+		    if (name_len > 0 && name_len < sizeof(dirent->d_name))
+			long_entry = true;
+		}
+
+		goto next;
+	    } else {
+		/*
+		 * It's a short entry
+		 */
+		if (de->attr & 0x08) /* ignore volume labels */
+		    goto invalid;
+
+		if (long_entry && get_checksum(de->name) == vfat_csum) {
+		   /* Got a long entry */
+		} else {
+		    /* Use the shortname */
+		    int i;
+		    uint8_t c;
+		    char *p = filename;
+
+		    for (i = 0; i < 8; i++) {
+			c = de->name[i];
+			if (c == ' ')
+			    break;
+			if (de->lcase & LCASE_BASE)
+			    c = codepage.lower[c];
+			*p++ = c;
+		    }
+		    if (de->name[8] != ' ') {
+			*p++ = '.';
+			for (i = 8; i < 11; i++) {
+			    c = de->name[i];
+			    if (c == ' ')
+				break;
+			    if (de->lcase & LCASE_EXT)
+				c = codepage.lower[c];
+			    *p++ = c;
+			}
+		    }
+		    *p = '\0';
+		    name_len = p - filename;
+		}
+		goto got;	/* Got something one way or the other */
+	    }
+
+	invalid:
+	    long_entry = false;
+	next:
+	    de++;
+	    file->offset += sizeof(struct fat_dir_entry);
+	}
+
+	/* Try with the next sector */
+	sector = next_sector(file);
+	if (!sector)
+	    return -1;
+	de = get_cache(fs->fs_dev, sector);
+	entries_left = 1 << (fs->sector_shift - 5);
+    }
+
+got:
+    name_len++;			/* Include final null */
+    dirent->d_ino = de->first_cluster_low | (de->first_cluster_high << 16);
+    dirent->d_off = file->offset;
+    dirent->d_reclen = offsetof(struct dirent, d_name) + name_len;
+    dirent->d_type = get_inode_mode(de->attr);
+    memcpy(dirent->d_name, filename, name_len);
+
+    file->offset += sizeof(*de);  /* Update for next reading */
+
+    return 0;
+}
+
+/* init. the fs meta data, return the block size in bits */
+static int vfat_fs_init(struct fs_info *fs)
+{
+    struct fat_bpb fat;
+    struct fat_sb_info *sbi;
+    struct disk *disk = fs->fs_dev->disk;
+    int sectors_per_fat;
+    uint32_t clusters;
+    sector_t total_sectors;
+
+    fs->sector_shift = fs->block_shift = disk->sector_shift;
+    fs->sector_size  = 1 << fs->sector_shift;
+    fs->block_size   = 1 << fs->block_shift;
+
+    disk->rdwr_sectors(disk, &fat, 0, 1, 0);
+
+    /* XXX: Find better sanity checks... */
+    if (!fat.bxResSectors || !fat.bxFATs)
+	return -1;
+    sbi = malloc(sizeof(*sbi));
+    if (!sbi)
+	malloc_error("fat_sb_info structure");
+    fs->fs_info = sbi;
+
+    sectors_per_fat = fat.bxFATsecs ? : fat.fat32.bxFATsecs_32;
+    total_sectors   = fat.bxSectors ? : fat.bsHugeSectors;
+
+    sbi->fat       = fat.bxResSectors;
+    sbi->root      = sbi->fat + sectors_per_fat * fat.bxFATs;
+    sbi->root_size = root_dir_size(fs, &fat);
+    sbi->data      = sbi->root + sbi->root_size;
+
+    sbi->clust_shift      = ilog2(fat.bxSecPerClust);
+    sbi->clust_byte_shift = sbi->clust_shift + fs->sector_shift;
+    sbi->clust_mask       = fat.bxSecPerClust - 1;
+    sbi->clust_size       = fat.bxSecPerClust << fs->sector_shift;
+
+    clusters = (total_sectors - sbi->data) >> sbi->clust_shift;
+    if (clusters <= 0xff4) {
+	sbi->fat_type = FAT12;
+    } else if (clusters <= 0xfff4) {
+	sbi->fat_type = FAT16;
+    } else {
+	sbi->fat_type = FAT32;
+
+	if (clusters > 0x0ffffff4)
+	    clusters = 0x0ffffff4; /* Maximum possible */
+
+	if (fat.fat32.extended_flags & 0x80) {
+	    /* Non-mirrored FATs, we need to read the active one */
+	    sbi->fat += (fat.fat32.extended_flags & 0x0f) * sectors_per_fat;
+	}
+
+	/* FAT32: root directory is a cluster chain */
+	sbi->root = sbi->data
+	    + ((fat.fat32.root_cluster-2) << sbi->clust_shift);
+    }
+    sbi->clusters = clusters;
+
+    /* Initialize the cache */
+    cache_init(fs->fs_dev, fs->block_shift);
+
+    return fs->block_shift;
+}
+
+const struct fs_ops vfat_fs_ops = {
+    .fs_name       = "vfat",
+    .fs_flags      = FS_USEMEM | FS_THISIND,
+    .fs_init       = vfat_fs_init,
+    .searchdir     = NULL,
+    .getfssec      = generic_getfssec,
+    .close_file    = generic_close_file,
+    .mangle_name   = vfat_mangle_name,
+    .load_config   = generic_load_config,
+    .readdir       = vfat_readdir,
+    .iget_root     = vfat_iget_root,
+    .iget          = vfat_iget,
+    .next_extent   = fat_next_extent,
+};
diff --git a/contrib/syslinux-4.02/core/fs/fat/fat_fs.h b/contrib/syslinux-4.02/core/fs/fat/fat_fs.h
new file mode 100644
index 0000000..7ea3db8
--- /dev/null
+++ b/contrib/syslinux-4.02/core/fs/fat/fat_fs.h
@@ -0,0 +1,158 @@
+#ifndef FAT_FS_H
+#define FAT_FS_H
+
+#include <stdint.h>
+
+#define FAT_DIR_ENTRY_SIZE 32
+#define DIRENT_SHIFT 5
+
+#define FAT_ATTR_READ_ONLY 0x01
+#define FAT_ATTR_HIDDEN	   0x02
+#define FAT_ATTR_SYSTEM	   0x04
+#define FAT_ATTR_VOLUME_ID 0x08
+#define FAT_ATTR_DIRECTORY 0x10
+#define FAT_ATTR_ARCHIVE   0x20
+
+#define FAT_MAXFILE	   256
+
+#define FAT_ATTR_LONG_NAME (FAT_ATTR_READ_ONLY             \
+                            | FAT_ATTR_HIDDEN              \
+                            | FAT_ATTR_SYSTEM              \
+                            | FAT_ATTR_VOLUME_ID)
+
+#define FAT_ATTR_VALID	   (FAT_ATTR_READ_ONLY             \
+                            | FAT_ATTR_HIDDEN              \
+                            | FAT_ATTR_SYSTEM              \
+                            | FAT_ATTR_DIRECTORY           \
+                            | FAT_ATTR_ARCHIVE)
+
+enum fat_type{ FAT12, FAT16, FAT32 };
+
+/*
+ * The fat file system structures 
+ */
+
+struct fat_bpb {
+        uint8_t  jmp_boot[3];
+        uint8_t  oem_name[8];
+        uint16_t sector_size;
+        uint8_t  bxSecPerClust;
+        uint16_t bxResSectors;
+        uint8_t  bxFATs;
+        uint16_t bxRootDirEnts;
+        uint16_t bxSectors;
+        uint8_t  media;
+        uint16_t bxFATsecs;
+        uint16_t sectors_per_track;
+        uint16_t num_heads;
+        uint32_t num_hidden_sectors;
+        uint32_t bsHugeSectors;
+       
+        union {
+                struct {
+                        uint8_t  num_ph_drive;
+                        uint8_t  reserved;
+                        uint8_t  boot_sig;
+                        uint32_t num_serial;
+                        uint8_t  label[11];
+                        uint8_t  fstype[8];
+                } __attribute__ ((packed)) fat12_16;
+
+                struct {
+                        uint32_t bxFATsecs_32;
+                        uint16_t extended_flags;
+                        uint16_t fs_version;
+                        uint32_t root_cluster;
+                        uint16_t fs_info;
+                        uint16_t backup_boot_sector;
+                        uint8_t  reserved[12];
+                        uint8_t  num_ph_drive;
+                        uint8_t  reserved1;
+                        uint8_t  boot_sig;
+                        uint32_t num_serial;
+                        uint8_t  label[11];
+                        uint8_t  fstype[8];
+                } __attribute__ ((packed)) fat32;
+
+        } __attribute__ ((packed));
+
+        uint8_t pad[422];  /* padding to 512 Bytes (one sector) */
+
+} __attribute__ ((packed));
+
+/*
+ * The fat file system info in memory 
+ */
+struct fat_sb_info {
+	sector_t fat;             /* The FAT region */
+	sector_t root;            /* The root dir region */
+	sector_t data;            /* The data region */
+
+	uint32_t clusters;	  /* Total number of clusters */
+	uint32_t root_cluster;	  /* Cluster number for (FAT32) root dir */
+	int      root_size;       /* The root dir size in sectors */
+	
+	int      clust_shift;      /* based on sectors */
+	int      clust_byte_shift; /* based on bytes   */
+	int      clust_mask;	   /* sectors per cluster mask */
+	int      clust_size;
+
+	int      fat_type;
+} __attribute__ ((packed));
+
+struct fat_dir_entry {
+        char     name[11];
+        uint8_t  attr;
+        uint8_t  lcase;
+        uint8_t  c_time_tenth;
+        uint16_t c_time;
+        uint16_t c_date;
+        uint16_t a_date;
+        uint16_t first_cluster_high;
+        uint16_t w_time;
+        uint16_t w_date;
+        uint16_t first_cluster_low;
+        uint32_t file_size;
+} __attribute__ ((packed));
+
+#define LCASE_BASE 8       /* basename is lower case */
+#define LCASE_EXT  16      /* extension is lower case */
+
+struct fat_long_name_entry {
+        uint8_t  id;
+        uint16_t name1[5];
+        uint8_t  attr;
+        uint8_t  reserved;
+        uint8_t  checksum;
+        uint16_t name2[6];
+        uint16_t first_cluster;
+        uint16_t name3[2];
+} __attribute__ ((packed));
+
+static inline struct fat_sb_info *FAT_SB(struct fs_info *fs)
+{
+        return fs->fs_info;
+}
+
+/* 
+ * Count the root dir size in sectors
+ */
+static inline int root_dir_size(struct fs_info *fs, struct fat_bpb *fat)
+{
+    return (fat->bxRootDirEnts + SECTOR_SIZE(fs)/32 - 1)
+	>> (SECTOR_SHIFT(fs) - 5);
+}
+
+/*
+ * FAT private inode information
+ */
+struct fat_pvt_inode {
+    uint32_t start_cluster;	/* Starting cluster address */
+    sector_t start;		/* Starting sector */
+    sector_t offset;		/* Current sector offset */
+    sector_t here;		/* Sector corresponding to offset */
+};
+
+#define PVT(i) ((struct fat_pvt_inode *)((i)->pvt))
+
+#endif /* fat_fs.h */
diff --git a/contrib/syslinux-4.02/core/fs/fs.c b/contrib/syslinux-4.02/core/fs/fs.c
new file mode 100644
index 0000000..48856c9
--- /dev/null
+++ b/contrib/syslinux-4.02/core/fs/fs.c
@@ -0,0 +1,475 @@
+#include <stdio.h>
+#include <stdbool.h>
+#include <string.h>
+#include <dprintf.h>
+#include "fs.h"
+#include "cache.h"
+
+/* The currently mounted filesystem */
+struct fs_info *this_fs = NULL;		/* Root filesystem */
+
+/* Actual file structures (we don't have malloc yet...) */
+struct file files[MAX_OPEN];
+
+/* Symlink hard limits */
+#define MAX_SYMLINK_CNT	20
+#define MAX_SYMLINK_BUF 4096
+
+/*
+ * Get a new inode structure
+ */
+struct inode *alloc_inode(struct fs_info *fs, uint32_t ino, size_t data)
+{
+    struct inode *inode = zalloc(sizeof(struct inode) + data);
+    if (inode) {
+	inode->fs = fs;
+	inode->ino = ino;
+	inode->refcnt = 1;
+    }
+    return inode;
+}
+
+/*
+ * Free a refcounted inode
+ */
+void put_inode(struct inode *inode)
+{
+    while (inode && --inode->refcnt == 0) {
+	struct inode *dead = inode;
+	inode = inode->parent;
+	free(dead);
+    }
+}
+
+/*
+ * Get an empty file structure
+ */
+static struct file *alloc_file(void)
+{
+    int i;
+    struct file *file = files;
+
+    for (i = 0; i < MAX_OPEN; i++) {
+	if (!file->fs)
+	    return file;
+	file++;
+    }
+
+    return NULL;
+}
+
+/*
+ * Close and free a file structure
+ */
+static inline void free_file(struct file *file)
+{
+    memset(file, 0, sizeof *file);
+}
+
+void _close_file(struct file *file)
+{
+    if (file->fs)
+	file->fs->fs_ops->close_file(file);
+    free_file(file);
+}
+
+/*
+ * Convert between a 16-bit file handle and a file structure
+ */
+
+void load_config(void)
+{
+    int err;
+
+    err = this_fs->fs_ops->load_config();
+
+    if (err)
+	printf("ERROR: No configuration file found\n");
+}
+
+void pm_mangle_name(com32sys_t *regs)
+{
+    const char *src = MK_PTR(regs->ds, regs->esi.w[0]);
+    char       *dst = MK_PTR(regs->es, regs->edi.w[0]);
+
+    mangle_name(dst, src);
+}
+
+void mangle_name(char *dst, const char *src)
+{
+    this_fs->fs_ops->mangle_name(dst, src);
+}
+
+void getfssec(com32sys_t *regs)
+{
+    int sectors;
+    bool have_more;
+    uint32_t bytes_read;
+    char *buf;
+    struct file *file;
+    uint16_t handle;
+
+    sectors = regs->ecx.w[0];
+
+    handle = regs->esi.w[0];
+    file = handle_to_file(handle);
+
+    buf = MK_PTR(regs->es, regs->ebx.w[0]);
+    bytes_read = file->fs->fs_ops->getfssec(file, buf, sectors, &have_more);
+
+    /*
+     * If we reach EOF, the filesystem driver will have already closed
+     * the underlying file... this really should be cleaner.
+     */
+    if (!have_more) {
+	_close_file(file);
+        regs->esi.w[0] = 0;
+    }
+
+    regs->ecx.l = bytes_read;
+}
+
+void getfsbytes(com32sys_t *regs)
+{
+    int sectors;
+    bool have_more;
+    uint32_t bytes_read;
+    char *buf;
+    struct file *file;
+    uint16_t handle;
+
+    handle = regs->esi.w[0];
+    file = handle_to_file(handle);
+
+    sectors = regs->ecx.w[0] >> SECTOR_SHIFT(file->fs);
+
+    buf = MK_PTR(regs->es, regs->ebx.w[0]);
+    bytes_read = file->fs->fs_ops->getfssec(file, buf, sectors, &have_more);
+
+    /*
+     * If we reach EOF, the filesystem driver will have already closed
+     * the underlying file... this really should be cleaner.
+     */
+    if (!have_more) {
+	_close_file(file);
+        regs->esi.w[0] = 0;
+    }
+
+    regs->ecx.l = bytes_read;
+}
+
+size_t pmapi_read_file(uint16_t *handle, void *buf, size_t sectors)
+{
+    bool have_more;
+    size_t bytes_read;
+    struct file *file;
+
+    file = handle_to_file(*handle);
+    bytes_read = file->fs->fs_ops->getfssec(file, buf, sectors, &have_more);
+
+    /*
+     * If we reach EOF, the filesystem driver will have already closed
+     * the underlying file... this really should be cleaner.
+     */
+    if (!have_more) {
+	_close_file(file);
+	*handle = 0;
+    }
+
+    return bytes_read;
+}
+
+void pm_searchdir(com32sys_t *regs)
+{
+    char *name = MK_PTR(regs->ds, regs->edi.w[0]);
+    int rv;
+
+    rv = searchdir(name);
+    if (rv < 0) {
+	regs->esi.w[0]  = 0;
+	regs->eax.l     = 0;
+	regs->eflags.l |= EFLAGS_ZF;
+    } else {
+	regs->esi.w[0]  = rv;
+	regs->eax.l     = handle_to_file(rv)->inode->size;
+	regs->eflags.l &= ~EFLAGS_ZF;
+    }
+}
+
+int searchdir(const char *name)
+{
+    struct inode *inode = NULL;
+    struct inode *parent = NULL;
+    struct file *file;
+    char *pathbuf = NULL;
+    char *part, *p, echar;
+    int symlink_count = MAX_SYMLINK_CNT;
+
+    if (!(file = alloc_file()))
+	goto err_no_close;
+    file->fs = this_fs;
+
+    /* if we have ->searchdir method, call it */
+    if (file->fs->fs_ops->searchdir) {
+	file->fs->fs_ops->searchdir(name, file);
+
+	if (file->inode)
+	    return file_to_handle(file);
+	else
+	    goto err;
+    }
+
+    /* else, try the generic-path-lookup method */
+
+    parent = get_inode(this_fs->cwd);
+    p = pathbuf = strdup(name);
+    if (!pathbuf)
+	goto err;
+
+    do {
+    got_link:
+	if (*p == '/') {
+	    put_inode(parent);
+	    parent = get_inode(this_fs->root);
+	}
+
+	do {
+	    inode = get_inode(parent);
+
+	    while (*p == '/')
+		p++;
+
+	    if (!*p)
+		break;
+
+	    part = p;
+	    while ((echar = *p) && echar != '/')
+		p++;
+	    *p++ = '\0';
+
+	    if (part[0] == '.' && part[1] == '.' && part[2] == '\0') {
+		if (inode->parent) {
+		    put_inode(parent);
+		    parent = get_inode(inode->parent);
+		    put_inode(inode);
+		    inode = NULL;
+		    if (!echar) {
+			/* Terminal double dots */
+			inode = parent;
+			parent = inode->parent ?
+			    get_inode(inode->parent) : NULL;
+		    }
+		}
+	    } else if (part[0] != '.' || part[1] != '\0') {
+		inode = this_fs->fs_ops->iget(part, parent);
+		if (!inode)
+		    goto err;
+		if (inode->mode == DT_LNK) {
+		    char *linkbuf, *q;
+		    int name_len = echar ? strlen(p) : 0;
+		    int total_len = inode->size + name_len + 2;
+		    int link_len;
+
+		    if (!this_fs->fs_ops->readlink ||
+			--symlink_count == 0       ||      /* limit check */
+			total_len > MAX_SYMLINK_BUF)
+			goto err;
+
+		    linkbuf = malloc(total_len);
+		    if (!linkbuf)
+			goto err;
+
+		    link_len = this_fs->fs_ops->readlink(inode, linkbuf);
+		    if (link_len <= 0) {
+			free(linkbuf);
+			goto err;
+		    }
+
+		    q = linkbuf + link_len;
+
+		    if (echar) {
+			if (link_len > 0 && q[-1] != '/')
+			    *q++ = '/';
+
+			memcpy(q, p, name_len+1);
+		    } else {
+			*q = '\0';
+		    }
+
+		    free(pathbuf);
+		    p = pathbuf = linkbuf;
+		    put_inode(inode);
+		    inode = NULL;
+		    goto got_link;
+		}
+
+		inode->parent = parent;
+		parent = NULL;
+
+		if (!echar)
+		    break;
+
+		if (inode->mode != DT_DIR)
+		    goto err;
+
+		parent = inode;
+		inode = NULL;
+	    }
+	} while (echar);
+    } while (0);
+
+    free(pathbuf);
+    pathbuf = NULL;
+    put_inode(parent);
+    parent = NULL;
+
+    if (!inode)
+	goto err;
+
+    file->inode  = inode;
+    file->offset = 0;
+
+    return file_to_handle(file);
+
+err:
+    put_inode(inode);
+    put_inode(parent);
+    if (pathbuf)
+	free(pathbuf);
+    _close_file(file);
+err_no_close:
+    return -1;
+}
+
+int open_file(const char *name, struct com32_filedata *filedata)
+{
+    int rv;
+    struct file *file;
+    char mangled_name[FILENAME_MAX];
+
+    mangle_name(mangled_name, name);
+    rv = searchdir(mangled_name);
+
+    if (rv < 0)
+	return rv;
+
+    file = handle_to_file(rv);
+
+    if (file->inode->mode != DT_REG) {
+	_close_file(file);
+	return -1;
+    }
+
+    filedata->size	= file->inode->size;
+    filedata->blocklg2	= SECTOR_SHIFT(file->fs);
+    filedata->handle	= rv;
+
+    return rv;
+}
+
+void pm_open_file(com32sys_t *regs)
+{
+    int rv;
+    struct file *file;
+    const char *name = MK_PTR(regs->es, regs->esi.w[0]);
+    char mangled_name[FILENAME_MAX];
+
+    mangle_name(mangled_name, name);
+    rv = searchdir(mangled_name);
+    if (rv < 0) {
+	regs->eflags.l |= EFLAGS_CF;
+    } else {
+	file = handle_to_file(rv);
+	regs->eflags.l &= ~EFLAGS_CF;
+	regs->eax.l = file->inode->size;
+	regs->ecx.w[0] = SECTOR_SIZE(file->fs);
+	regs->esi.w[0] = rv;
+    }
+}
+
+void close_file(uint16_t handle)
+{
+    struct file *file;
+
+    if (handle) {
+	file = handle_to_file(handle);
+	_close_file(file);
+    }
+}
+
+void pm_close_file(com32sys_t *regs)
+{
+    close_file(regs->esi.w[0]);
+}
+
+/*
+ * it will do:
+ *    initialize the memory management function;
+ *    set up the vfs fs structure;
+ *    initialize the device structure;
+ *    invoke the fs-specific init function;
+ *    initialize the cache if we need one;
+ *    finally, get the current inode for relative path looking.
+ */
+__bss16 uint16_t SectorSize, SectorShift;
+
+void fs_init(com32sys_t *regs)
+{
+    static struct fs_info fs;	/* The actual filesystem buffer */
+    uint8_t disk_devno = regs->edx.b[0];
+    uint8_t disk_cdrom = regs->edx.b[1];
+    sector_t disk_offset = regs->ecx.l | ((sector_t)regs->ebx.l << 32);
+    uint16_t disk_heads = regs->esi.w[0];
+    uint16_t disk_sectors = regs->edi.w[0];
+    uint32_t maxtransfer = regs->ebp.l;
+    int blk_shift = -1;
+    struct device *dev = NULL;
+    /* ops is a ptr list for several fs_ops */
+    const struct fs_ops **ops = (const struct fs_ops **)regs->eax.l;
+
+    /* Initialize malloc() */
+    mem_init();
+
+    /* Default name for the root directory */
+    fs.cwd_name[0] = '/';
+
+    while ((blk_shift < 0) && *ops) {
+	/* set up the fs stucture */
+	fs.fs_ops = *ops;
+
+	/*
+	 * This boldly assumes that we don't mix FS_NODEV filesystems
+	 * with FS_DEV filesystems...
+	 */
+	if (fs.fs_ops->fs_flags & FS_NODEV) {
+	    fs.fs_dev = NULL;
+	} else {
+	    if (!dev)
+		dev = device_init(disk_devno, disk_cdrom, disk_offset,
+				  disk_heads, disk_sectors, maxtransfer);
+	    fs.fs_dev = dev;
+	}
+	/* invoke the fs-specific init code */
+	blk_shift = fs.fs_ops->fs_init(&fs);
+	ops++;
+    }
+    if (blk_shift < 0) {
+	printf("No valid file system found!\n");
+	while (1)
+		;
+    }
+    this_fs = &fs;
+
+    /* initialize the cache */
+    if (fs.fs_dev && fs.fs_dev->cache_data)
+        cache_init(fs.fs_dev, blk_shift);
+
+    /* start out in the root directory */
+    if (fs.fs_ops->iget_root) {
+	fs.root = fs.fs_ops->iget_root(&fs);
+	fs.cwd = get_inode(fs.root);
+    }
+
+    SectorShift = fs.sector_shift;
+    SectorSize  = fs.sector_size;
+}
diff --git a/contrib/syslinux-4.02/core/fs/getcwd.c b/contrib/syslinux-4.02/core/fs/getcwd.c
new file mode 100644
index 0000000..a7b6c7a
--- /dev/null
+++ b/contrib/syslinux-4.02/core/fs/getcwd.c
@@ -0,0 +1,13 @@
+#include <string.h>
+#include "fs.h"
+
+char *getcwd(char *buf, size_t size)
+{
+    char *ret = NULL;
+
+    if((buf != NULL) && (strlen(this_fs->cwd_name) < size)) {
+        strcpy(buf, this_fs->cwd_name);
+        ret = buf;
+    }
+    return ret;
+}
diff --git a/contrib/syslinux-4.02/core/fs/getfssec.c b/contrib/syslinux-4.02/core/fs/getfssec.c
new file mode 100644
index 0000000..e099b64
--- /dev/null
+++ b/contrib/syslinux-4.02/core/fs/getfssec.c
@@ -0,0 +1,194 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 2010 Intel Corporation; author: H. Peter Anvin
+ *
+ *   Permission is hereby granted, free of charge, to any person
+ *   obtaining a copy of this software and associated documentation
+ *   files (the "Software"), to deal in the Software without
+ *   restriction, including without limitation the rights to use,
+ *   copy, modify, merge, publish, distribute, sublicense, and/or
+ *   sell copies of the Software, and to permit persons to whom
+ *   the Software is furnished to do so, subject to the following
+ *   conditions:
+ *
+ *   The above copyright notice and this permission notice shall
+ *   be included in all copies or substantial portions of the Software.
+ *
+ *   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ *   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ *   OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ *   NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ *   HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ *   WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ *   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ *   OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * getfssec.c
+ *
+ * Generic getfssec implementation for disk-based filesystems, which
+ * support the next_extent() method.
+ *
+ * The expected semantics of next_extent are as follows:
+ *
+ * The second argument will contain the initial sector number to be
+ * mapped.  The routine is expected to populate
+ * inode->next_extent.pstart and inode->next_extent.len (the caller
+ * will store the initial sector number into inode->next_extent.lstart
+ * on return.)
+ *
+ * If inode->next_extent.len != 0 on entry then the routine is allowed
+ * to assume inode->next_extent contains valid data from the previous
+ * usage, which can be used for optimization purposes.
+ *
+ * If the filesystem can map the entire file as a single extent
+ * (e.g. iso9660), then the filesystem can simply insert the extent
+ * information into inode->next_extent at searchdir/iget time, and leave
+ * next_extent() as NULL.
+ *
+ * Note: the filesystem driver is not required to do extent coalescing,
+ * if that is difficult to do; this routine will perform extent lookahead
+ * and coalescing.
+ */
+
+#include <dprintf.h>
+#include <minmax.h>
+#include "fs.h"
+
+static inline sector_t next_psector(sector_t psector, uint32_t skip)
+{
+    if (EXTENT_SPECIAL(psector))
+	return psector;
+    else
+	return psector + skip;
+}
+
+static inline sector_t next_pstart(const struct extent *e)
+{
+    return next_psector(e->pstart, e->len);
+}
+
+
+static void get_next_extent(struct inode *inode)
+{
+    /* The logical start address that we care about... */
+    uint32_t lstart = inode->this_extent.lstart + inode->this_extent.len;
+
+    if (inode->fs->fs_ops->next_extent(inode, lstart))
+	inode->next_extent.len = 0; /* ERROR */
+    inode->next_extent.lstart = lstart;
+
+    dprintf("Extent: inode %p @ %u start %llu len %u\n",
+	    inode, inode->next_extent.lstart,
+	    inode->next_extent.pstart, inode->next_extent.len);
+}
+
+uint32_t generic_getfssec(struct file *file, char *buf,
+			  int sectors, bool *have_more)
+{
+    struct inode *inode = file->inode;
+    struct fs_info *fs = file->fs;
+    struct disk *disk = fs->fs_dev->disk;
+    uint32_t bytes_read = 0;
+    uint32_t bytes_left = inode->size - file->offset;
+    uint32_t sectors_left =
+	(bytes_left + SECTOR_SIZE(fs) - 1) >> SECTOR_SHIFT(fs);
+    uint32_t lsector;
+
+    if (sectors > sectors_left)
+	sectors = sectors_left;
+
+    if (!sectors)
+	return 0;
+
+    lsector = file->offset >> SECTOR_SHIFT(fs);
+    dprintf("Offset: %u  lsector: %u\n", file->offset, lsector);
+
+    if (lsector < inode->this_extent.lstart ||
+	lsector >= inode->this_extent.lstart + inode->this_extent.len) {
+	/* inode->this_extent unusable, maybe next_extent is... */
+	inode->this_extent = inode->next_extent;
+    }
+
+    if (lsector < inode->this_extent.lstart ||
+	lsector >= inode->this_extent.lstart + inode->this_extent.len) {
+	/* Still nothing useful... */
+	inode->this_extent.lstart = lsector;
+	inode->this_extent.len = 0;
+    } else {
+	/* We have some usable information */
+	uint32_t delta = lsector - inode->this_extent.lstart;
+	inode->this_extent.lstart = lsector;
+	inode->this_extent.len -= delta;
+	inode->this_extent.pstart
+	    = next_psector(inode->this_extent.pstart, delta);
+    }
+
+    dprintf("this_extent: lstart %u pstart %llu len %u\n",
+	    inode->this_extent.lstart,
+	    inode->this_extent.pstart,
+	    inode->this_extent.len);
+
+    while (sectors) {
+	uint32_t chunk;
+	size_t len;
+
+	while (sectors > inode->this_extent.len) {
+	    if (!inode->next_extent.len ||
+		inode->next_extent.lstart !=
+		inode->this_extent.lstart + inode->this_extent.len)
+		get_next_extent(inode);
+
+	    if (!inode->this_extent.len) {
+		/* Doesn't matter if it's contiguous... */
+		inode->this_extent = inode->next_extent;
+		if (!inode->next_extent.len) {
+		    sectors = 0; /* Failed to get anything... we're dead */
+		    break;
+		}
+	    } else if (inode->next_extent.len &&
+		inode->next_extent.pstart == next_pstart(&inode->this_extent)) {
+		/* Coalesce extents and loop */
+		inode->this_extent.len += inode->next_extent.len;
+	    } else {
+		/* Discontiguous extents */
+		break;
+	    }
+	}
+
+	dprintf("this_extent: lstart %u pstart %llu len %u\n",
+		inode->this_extent.lstart,
+		inode->this_extent.pstart,
+		inode->this_extent.len);
+
+	chunk = min(sectors, inode->this_extent.len);
+	len = chunk << SECTOR_SHIFT(fs);
+
+	dprintf("   I/O: inode %p @ %u start %llu len %u\n",
+		inode, inode->this_extent.lstart,
+		inode->this_extent.pstart, chunk);
+
+	if (inode->this_extent.pstart == EXTENT_ZERO) {
+	    memset(buf, 0, len);
+	} else {
+	    disk->rdwr_sectors(disk, buf, inode->this_extent.pstart, chunk, 0);
+	    inode->this_extent.pstart += chunk;
+	}
+
+	buf += len;
+	sectors -= chunk;
+	bytes_read += len;
+	inode->this_extent.lstart += chunk;
+	inode->this_extent.len -= chunk;
+    }
+
+    bytes_read = min(bytes_read, bytes_left);
+    file->offset += bytes_read;
+
+    if (have_more)
+	*have_more = bytes_read < bytes_left;
+
+    return bytes_read;
+}
diff --git a/contrib/syslinux-4.02/core/fs/iso9660/iso9660.c b/contrib/syslinux-4.02/core/fs/iso9660/iso9660.c
new file mode 100644
index 0000000..62137d0
--- /dev/null
+++ b/contrib/syslinux-4.02/core/fs/iso9660/iso9660.c
@@ -0,0 +1,346 @@
+#include <dprintf.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/dirent.h>
+#include <core.h>
+#include <cache.h>
+#include <disk.h>
+#include <fs.h>
+#include "iso9660_fs.h"
+
+/* Convert to lower case string */
+static inline char iso_tolower(char c)
+{
+    if (c >= 'A' && c <= 'Z')
+	c += 0x20;
+
+    return c;
+}
+
+static struct inode *new_iso_inode(struct fs_info *fs)
+{
+    return alloc_inode(fs, 0, sizeof(struct iso9660_pvt_inode));
+}
+
+static inline struct iso_sb_info *ISO_SB(struct fs_info *fs)
+{
+    return fs->fs_info;
+}
+
+/*
+ * Mangle a filename pointed to by src into a buffer pointed
+ * to by dst; ends on encountering any whitespace.
+ * dst is preserved.
+ *
+ * This verifies that a filename is < FilENAME_MAX characters,
+ * doesn't contain whitespace, zero-pads the output buffer,
+ * and removes trailing dots and redumndant slashes, so "repe
+ * cmpsb" can do a compare, and the path-searching routine gets
+ * a bit of an easier job.
+ *
+ */
+static void iso_mangle_name(char *dst, const char *src)
+{
+    char *p = dst;
+    int i = FILENAME_MAX - 1;
+
+    while (not_whitespace(*src)) {
+        if ( *src == '/' ) {
+            if ( *(src+1) == '/' ) {
+                i--;
+                src++;
+                continue;
+            }
+        }
+
+        *dst++ = *src ++;
+        i--;
+    }
+
+    while ( 1 ) {
+        if ( dst == p )
+            break;
+
+        if ( (*(dst-1) != '.') && (*(dst-1) != '/') )
+            break;
+
+        dst --;
+        i ++;
+    }
+
+    i ++;
+    for (; i > 0; i -- )
+        *dst++ = '\0';
+}
+
+static size_t iso_convert_name(char *dst, const char *src, int len)
+{
+    char *p = dst;
+    char c;
+    
+    if (len == 1) {
+	switch (*src) {
+	case 1:
+	    *p++ = '.';
+	    /* fall through */
+	case 0:
+	    *p++ = '.';
+	    goto done;
+	default:
+	    /* nothing special */
+	    break;
+	}
+    }
+
+    while (len-- && (c = *src++)) {
+	if (c == ';')	/* Remove any filename version suffix */
+	    break;
+	*p++ = iso_tolower(c);
+    }
+    
+    /* Then remove any terminal dots */
+    while (p > dst+1 && p[-1] == '.')
+	p--;
+
+done:
+    *p = '\0';
+    return p - dst;
+}
+
+/* 
+ * Unlike strcmp, it does return 1 on match, or reutrn 0 if not match.
+ */
+static bool iso_compare_name(const char *de_name, size_t len,
+			     const char *file_name)
+{
+    char iso_file_name[256];
+    char *p = iso_file_name;
+    char c1, c2;
+    size_t i;
+    
+    i = iso_convert_name(iso_file_name, de_name, len);
+    dprintf("Compare: \"%s\" to \"%s\" (len %zu)\n",
+	    file_name, iso_file_name, i);
+
+    do {
+	c1 = *p++;
+	c2 = iso_tolower(*file_name++);
+
+	/* compare equal except for case? */
+	if (c1 != c2)
+	    return false;
+    } while (c1);
+
+    return true;
+}
+
+/*
+ * Find a entry in the specified dir with name _dname_.
+ */
+static const struct iso_dir_entry *
+iso_find_entry(const char *dname, struct inode *inode)
+{
+    struct fs_info *fs = inode->fs;
+    block_t dir_block = PVT(inode)->lba;
+    int i = 0, offset = 0;
+    const char *de_name;
+    int de_name_len, de_len;
+    const struct iso_dir_entry *de;
+    const char *data = NULL;
+
+    dprintf("iso_find_entry: \"%s\"\n", dname);
+    
+    while (1) {
+	if (!data) {
+	    dprintf("Getting block %d from block %llu\n", i, dir_block);
+	    if (++i > inode->blocks)
+		return NULL;	/* End of directory */
+	    data = get_cache(fs->fs_dev, dir_block++);
+	    offset = 0;
+	}
+
+	de = (const struct iso_dir_entry *)(data + offset);
+	de_len = de->length;
+	offset += de_len;
+	
+	/* Make sure we have a full directory entry */
+	if (de_len < 33 || offset > BLOCK_SIZE(fs)) {
+	    /*
+	     * Zero = end of sector, or corrupt directory entry
+	     *
+	     * ECMA-119:1987 6.8.1.1: "Each Directory Record shall end
+	     * in the Logical Sector in which it begins.
+	     */
+	    data = NULL;
+	    continue;
+	}
+	
+	de_name_len = de->name_len;
+	de_name = de->name;
+	if (iso_compare_name(de_name, de_name_len, dname)) {
+	    dprintf("Found.\n");
+	    return de;
+	}
+    }
+}
+
+static inline enum dirent_type get_inode_mode(uint8_t flags)
+{
+    return (flags & 0x02) ? DT_DIR : DT_REG;
+}
+
+static struct inode *iso_get_inode(struct fs_info *fs,
+				   const struct iso_dir_entry *de)
+{
+    struct inode *inode = new_iso_inode(fs);
+    int blktosec = BLOCK_SHIFT(fs) - SECTOR_SHIFT(fs);
+
+    if (!inode)
+	return NULL;
+
+    dprintf("Getting inode for: %.*s\n", de->name_len, de->name);
+
+    inode->mode   = get_inode_mode(de->flags);
+    inode->size   = de->size_le;
+    PVT(inode)->lba = de->extent_le;
+    inode->blocks = (inode->size + BLOCK_SIZE(fs) - 1) >> BLOCK_SHIFT(fs);
+
+    /* We have a single extent for all data */
+    inode->next_extent.pstart = (sector_t)de->extent_le << blktosec;
+    inode->next_extent.len    = (sector_t)inode->blocks << blktosec;
+
+    return inode;
+}
+
+static struct inode *iso_iget_root(struct fs_info *fs)
+{
+    const struct iso_dir_entry *root = &ISO_SB(fs)->root;
+
+    return iso_get_inode(fs, root);
+}
+
+static struct inode *iso_iget(const char *dname, struct inode *parent)
+{
+    const struct iso_dir_entry *de;
+    
+    dprintf("iso_iget %p %s\n", parent, dname);
+
+    de = iso_find_entry(dname, parent);
+    if (!de)
+	return NULL;
+    
+    return iso_get_inode(parent->fs, de);
+}
+
+static int iso_readdir(struct file *file, struct dirent *dirent)
+{
+    struct fs_info *fs = file->fs;
+    struct inode *inode = file->inode;
+    const struct iso_dir_entry *de;
+    const char *data = NULL;
+    
+    while (1) {
+	size_t offset = file->offset & (BLOCK_SIZE(fs) - 1);
+
+	if (!data) {
+	    uint32_t i = file->offset >> BLOCK_SHIFT(fs);
+	    if (i >= inode->blocks)
+		return -1;
+	    data = get_cache(fs->fs_dev, PVT(inode)->lba + i);
+	}
+	de = (const struct iso_dir_entry *)(data + offset);
+	
+	if (de->length < 33 || offset + de->length > BLOCK_SIZE(fs)) {
+	    file->offset = (file->offset + BLOCK_SIZE(fs))
+		& ~(BLOCK_SIZE(fs) - 1); /* Start of the next block */
+	    data = NULL;
+	    continue;
+	}
+	break;
+    }
+    
+    dirent->d_ino = 0;           /* Inode number is invalid to ISO fs */
+    dirent->d_off = file->offset;
+    dirent->d_type = get_inode_mode(de->flags);
+    dirent->d_reclen = offsetof(struct dirent, d_name) + 1 +
+	iso_convert_name(dirent->d_name, de->name, de->name_len);
+
+    file->offset += de->length;  /* Update for next reading */
+    
+    return 0;
+}
+
+/* Load the config file, return 1 if failed, or 0 */
+static int iso_load_config(void)
+{
+    static const char *search_directories[] = {
+	"/boot/isolinux", 
+	"/isolinux",
+	"/boot/syslinux", 
+	"/syslinux", 
+	"/",
+	NULL
+    };
+    static const char *filenames[] = {
+	"isolinux.cfg",
+	"syslinux.cfg",
+	NULL
+    };
+
+    return search_config(search_directories, filenames);
+}
+
+static int iso_fs_init(struct fs_info *fs)
+{
+    struct iso_sb_info *sbi;
+    char pvd[2048];		/* Primary Volume Descriptor */
+    uint32_t pvd_lba;
+    struct disk *disk = fs->fs_dev->disk;
+    int blktosec;
+
+    sbi = malloc(sizeof(*sbi));
+    if (!sbi) {
+	malloc_error("iso_sb_info structure");
+	return 1;
+    }
+    fs->fs_info = sbi;
+
+    /* 
+     * XXX: handling iso9660 in hybrid mode on top of a 4K-logical disk
+     * will really, really hurt...
+     */
+    fs->sector_shift = fs->fs_dev->disk->sector_shift;
+    fs->block_shift  = 11;	/* A CD-ROM block is always 2K */
+    fs->sector_size  = 1 << fs->sector_shift;
+    fs->block_size   = 1 << fs->block_shift;
+    blktosec = fs->block_shift - fs->sector_shift;
+
+    pvd_lba = iso_boot_info.pvd;
+    if (!pvd_lba)
+	pvd_lba = 16;		/* Default if not otherwise defined */
+
+    disk->rdwr_sectors(disk, pvd, (sector_t)pvd_lba << blktosec,
+		       1 << blktosec, false);
+    memcpy(&sbi->root, pvd + ROOT_DIR_OFFSET, sizeof(sbi->root));
+
+    /* Initialize the cache */
+    cache_init(fs->fs_dev, fs->block_shift);
+
+    return fs->block_shift;
+}
+
+
+const struct fs_ops iso_fs_ops = {
+    .fs_name       = "iso",
+    .fs_flags      = FS_USEMEM | FS_THISIND,
+    .fs_init       = iso_fs_init,
+    .searchdir     = NULL, 
+    .getfssec      = generic_getfssec,
+    .close_file    = generic_close_file,
+    .mangle_name   = iso_mangle_name,
+    .load_config   = iso_load_config,
+    .iget_root     = iso_iget_root,
+    .iget          = iso_iget,
+    .readdir       = iso_readdir,
+    .next_extent   = no_next_extent,
+};
diff --git a/contrib/syslinux-4.02/core/fs/iso9660/iso9660_fs.h b/contrib/syslinux-4.02/core/fs/iso9660/iso9660_fs.h
new file mode 100644
index 0000000..a365fa1
--- /dev/null
+++ b/contrib/syslinux-4.02/core/fs/iso9660/iso9660_fs.h
@@ -0,0 +1,51 @@
+#ifndef ISO9660_FS_H
+#define ISO9660_FS_H
+
+#include <klibc/compiler.h>
+#include <stdint.h>
+
+/* Boot info table */
+struct iso_boot_info {
+    uint32_t pvd;		/* LBA of primary volume descriptor */
+    uint32_t file;		/* LBA of boot file */
+    uint32_t length;		/* Length of boot file */
+    uint32_t csum;		/* Checksum of boot file */
+    uint32_t reserved[10];	/* Currently unused */
+};
+
+extern struct iso_boot_info iso_boot_info; /* In isolinux.asm */
+
+/* The root dir entry offset in the primary volume descriptor */
+#define ROOT_DIR_OFFSET   156
+
+struct iso_dir_entry {
+    uint8_t length;                         /* 00 */
+    uint8_t ext_attr_length;                /* 01 */    
+    uint32_t extent_le;			    /* 02 */
+    uint32_t extent_be;			    /* 06 */
+    uint32_t size_le;			    /* 0a */  
+    uint32_t size_be;			    /* 0e */
+    uint8_t date[7];                        /* 12 */
+    uint8_t flags;                          /* 19 */
+    uint8_t file_unit_size;                 /* 1a */
+    uint8_t interleave;                     /* 1b */
+    uint16_t volume_sequence_number_le;	    /* 1c */
+    uint16_t volume_sequence_number_be;	    /* 1e */
+    uint8_t name_len;                       /* 20 */
+    char    name[0];                        /* 21 */
+} __packed;
+
+struct iso_sb_info {
+    struct iso_dir_entry root;
+};
+
+/*
+ * iso9660 private inode information
+ */
+struct iso9660_pvt_inode {
+    uint32_t lba;		/* Starting LBA of file data area*/
+};
+
+#define PVT(i) ((struct iso9660_pvt_inode *)((i)->pvt))
+
+#endif /* iso9660_fs.h */
diff --git a/contrib/syslinux-4.02/core/fs/lib/close.c b/contrib/syslinux-4.02/core/fs/lib/close.c
new file mode 100644
index 0000000..279598b
--- /dev/null
+++ b/contrib/syslinux-4.02/core/fs/lib/close.c
@@ -0,0 +1,9 @@
+#include "fs.h"
+
+void generic_close_file(struct file *file)
+{
+    if (file->inode) {
+	file->offset = 0;
+	put_inode(file->inode);
+    }
+}
diff --git a/contrib/syslinux-4.02/core/fs/lib/loadconfig.c b/contrib/syslinux-4.02/core/fs/lib/loadconfig.c
new file mode 100644
index 0000000..c9652b6
--- /dev/null
+++ b/contrib/syslinux-4.02/core/fs/lib/loadconfig.c
@@ -0,0 +1,34 @@
+#include <dprintf.h>
+#include <stdio.h>
+#include <string.h>
+#include <core.h>
+#include <fs.h>
+
+/*
+ * Standard version of load_config for extlinux/syslinux filesystems.
+ *
+ * This searches for extlinux.conf and syslinux.cfg in the install
+ * directory, followed by a set of fallback directories.  If found,
+ * set the current working directory to match.
+ */
+int generic_load_config(void)
+{
+    static const char *search_directories[] = {
+	NULL,			/* CurrentDirName */
+	"/boot/syslinux",
+	"/syslinux",
+	"/",
+	NULL
+    };
+    static const char *filenames[] = {
+	"extlinux.conf",
+	"syslinux.cfg",
+	NULL
+    };
+
+    search_directories[0] = CurrentDirName;
+
+    dprintf("CurrentDirName: \"%s\"\n", CurrentDirName);
+
+    return search_config(search_directories, filenames);
+}
diff --git a/contrib/syslinux-4.02/core/fs/lib/mangle.c b/contrib/syslinux-4.02/core/fs/lib/mangle.c
new file mode 100644
index 0000000..813099f
--- /dev/null
+++ b/contrib/syslinux-4.02/core/fs/lib/mangle.c
@@ -0,0 +1,47 @@
+/**
+ * mangle_name:
+ *
+ * Mangle a filename pointed to by src into a buffer pointed
+ * to by dst; ends on encountering any whitespace.
+ * dst is preserved.
+ *
+ * This verifies that a filename is < FILENAME_MAX characters,
+ * doesn't contain whitespace, zero-pads the output buffer,
+ * and removes redundant slashes.
+ *
+ */
+
+#include <string.h>
+#include "fs.h"
+
+void generic_mangle_name(char *dst, const char *src)
+{
+    char *p = dst;
+    int i = FILENAME_MAX-1;
+
+    while (not_whitespace(*src)) {
+        if (*src == '/') {
+            if (src[1] == '/') {
+                src++;
+                i--;
+                continue;
+            }
+        }
+        i--;
+        *dst++ = *src++;
+    }
+
+    while (1) {
+        if (dst == p)
+            break;
+        if (dst[-1] != '/')
+            break;
+
+        dst--;
+        i++;
+    }
+
+    i++;
+    for (; i > 0; i --)
+        *dst++ = '\0';
+}
diff --git a/contrib/syslinux-4.02/core/fs/lib/searchconfig.c b/contrib/syslinux-4.02/core/fs/lib/searchconfig.c
new file mode 100644
index 0000000..24bfde3
--- /dev/null
+++ b/contrib/syslinux-4.02/core/fs/lib/searchconfig.c
@@ -0,0 +1,40 @@
+#include <dprintf.h>
+#include <stdio.h>
+#include <string.h>
+#include <core.h>
+#include <fs.h>
+
+/*
+ * Common implementation of load_config
+ *
+ * This searches for a specified set of filenames in a specified set
+ * of directories.  If found, set the current working directory to
+ * match.
+ */
+int search_config(const char *search_directories[], const char *filenames[])
+{
+    char confignamebuf[FILENAME_MAX];
+    com32sys_t regs;
+    const char *sd, **sdp;
+    const char *sf, **sfp;
+
+    for (sdp = search_directories; (sd = *sdp); sdp++) {
+	for (sfp = filenames; (sf = *sfp); sfp++) {
+	    memset(&regs, 0, sizeof regs);
+	    snprintf(confignamebuf, sizeof confignamebuf,
+		     "%s%s%s",
+		     sd, (*sd && sd[strlen(sd)-1] == '/') ? "" : "/",
+		     sf);
+	    realpath(ConfigName, confignamebuf, FILENAME_MAX);
+	    regs.edi.w[0] = OFFS_WRT(ConfigName, 0);
+	    dprintf("Config search: %s\n", ConfigName);
+	    call16(core_open, &regs, &regs);
+	    if (!(regs.eflags.l & EFLAGS_ZF)) {
+		chdir(sd);
+		return 0;	/* Got it */
+	    }
+	}
+    }
+
+    return -1;
+}
diff --git a/contrib/syslinux-4.02/core/fs/loadhigh.c b/contrib/syslinux-4.02/core/fs/loadhigh.c
new file mode 100644
index 0000000..e365b1a
--- /dev/null
+++ b/contrib/syslinux-4.02/core/fs/loadhigh.c
@@ -0,0 +1,113 @@
+/*
+ * -----------------------------------------------------------------------
+ *
+ *   Copyright 1994-2009 H. Peter Anvin - All Rights Reserved
+ *   Copyright 2009-2010 Intel Corporation; author: H. Peter Anvin
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
+ *   Boston MA 02111-1307, USA; either version 2 of the License, or
+ *   (at your option) any later version; incorporated herein by reference.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * loadhigh.c
+ *
+ * An alternate interface to getfssec.
+ *
+ * Inputs:	SI  = file handle/cluster pointer
+ *		EDI = target address in high memory
+ *		EAX = maximum number of bytes to load
+ *		DX  = zero-padding mask (e.g. 0003h for pad to dword)
+ *		BX  = 16-bit subroutine to call at the top of each loop
+ *                    (to print status and check for abort)
+ *		EBP = maximum load address
+ *
+ * Outputs:	SI  = file handle/cluster pointer
+ *		EBX = first untouched address (not including padding)
+ *		EDI = first untouched address (including padding)
+ *		CF  = reached EOF
+ *		OF  = ran out of high memory
+ */
+
+#include <com32.h>
+#include <minmax.h>
+#include "core.h"
+#include "fs.h"
+
+#define MAX_CHUNK	(1 << 20) /* 1 MB */
+
+void pm_load_high(com32sys_t *regs)
+{
+    struct fs_info *fs;
+    uint32_t bytes;
+    uint32_t zero_mask;
+    bool have_more;
+    uint32_t bytes_read;
+    char *buf, *limit;
+    struct file *file;
+    uint32_t sector_mask;
+    size_t pad;
+
+    bytes     = regs->eax.l;
+    zero_mask = regs->edx.w[0];
+    buf       = (char *)regs->edi.l;
+    limit     = (char *)(regs->ebp.l & ~zero_mask);
+    file      = handle_to_file(regs->esi.w[0]);
+    fs        = file->fs;
+
+    regs->eflags.l &= ~(EFLAGS_CF|EFLAGS_OF|EFLAGS_AF|
+			EFLAGS_PF|EFLAGS_ZF|EFLAGS_SF);
+
+    sector_mask = SECTOR_SIZE(fs) - 1;
+
+    while (bytes) {
+	uint32_t sectors;
+	uint32_t chunk;
+
+	if (buf + SECTOR_SIZE(fs) > limit) {
+	    /* Can't fit even one more sector in... */
+	    regs->eflags.l |= EFLAGS_OF;
+	    break;
+	}
+
+	chunk = bytes;
+
+	if (regs->ebx.w[0]) {
+	    call16((void (*)(void))(size_t)regs->ebx.w[0], &zero_regs, NULL);
+	    chunk = min(chunk, MAX_CHUNK);
+	}
+
+	if (chunk > (((char *)limit - buf) & ~sector_mask))
+	    chunk = ((char *)limit - buf) & ~sector_mask;
+
+	sectors = (chunk + sector_mask) >> SECTOR_SHIFT(fs);
+	bytes_read = fs->fs_ops->getfssec(file, buf, sectors, &have_more);
+
+	if (bytes_read > chunk)
+	    bytes_read = chunk;
+
+	buf += bytes_read;
+	bytes -= bytes_read;
+
+	if (!have_more) {
+	    /*
+	     * If we reach EOF, the filesystem driver will have already closed
+	     * the underlying file... this really should be cleaner.
+	     */
+	    _close_file(file);
+	    regs->esi.w[0] = 0;
+	    regs->eflags.l |= EFLAGS_CF;
+	    break;
+	}
+    }
+
+    pad = (size_t)buf & zero_mask;
+    if (pad)
+	memset(buf, 0, pad);
+
+    regs->ebx.l = (size_t)buf;
+    regs->edi.l = (size_t)buf + pad;
+}
diff --git a/contrib/syslinux-4.02/core/fs/newconfig.c b/contrib/syslinux-4.02/core/fs/newconfig.c
new file mode 100644
index 0000000..58c47a5
--- /dev/null
+++ b/contrib/syslinux-4.02/core/fs/newconfig.c
@@ -0,0 +1,41 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 2010 Intel Corporation; author: H. Peter Anvin
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+ *   Boston MA 02110-1301, USA; either version 2 of the License, or
+ *   (at your option) any later version; incorporated herein by reference.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * newconfig.c
+ *
+ * Load a new configuration file
+ */
+
+#include "core.h"
+#include "fs.h"
+
+void pm_is_config_file(com32sys_t *regs)
+{
+    char target_cwd[FILENAME_MAX];
+    const char *p;
+
+    (void)regs;
+
+    /* Save configuration file as an absolute path for posterity */
+    realpath(ConfigName, KernelName, FILENAME_MAX);
+
+    /* If we got anything on the command line, do a chdir */
+    p = cmd_line;
+    while (*p && !not_whitespace(*p))
+	p++;
+
+    if (*p) {
+	mangle_name(target_cwd, p);
+	chdir(target_cwd);
+    }
+}
diff --git a/contrib/syslinux-4.02/core/fs/nonextextent.c b/contrib/syslinux-4.02/core/fs/nonextextent.c
new file mode 100644
index 0000000..0c1ce2c
--- /dev/null
+++ b/contrib/syslinux-4.02/core/fs/nonextextent.c
@@ -0,0 +1,13 @@
+#include "fs.h"
+
+/*
+ * Use this routine for the next_extent() pointer when we never should
+ * be calling next_extent(), e.g. iso9660.
+ */
+int no_next_extent(struct inode *inode, uint32_t lstart)
+{
+    (void)inode;
+    (void)lstart;
+
+    return -1;
+}
diff --git a/contrib/syslinux-4.02/core/fs/pxe/dhcp_option.c b/contrib/syslinux-4.02/core/fs/pxe/dhcp_option.c
new file mode 100644
index 0000000..50f2de0
--- /dev/null
+++ b/contrib/syslinux-4.02/core/fs/pxe/dhcp_option.c
@@ -0,0 +1,258 @@
+#include <stdio.h>
+#include <string.h>
+#include <core.h>
+#include <sys/cpu.h>
+#include "pxe.h"
+
+char LocalDomain[256];
+
+int over_load;
+uint8_t uuid_type;
+uint8_t uuid[16];
+
+static void parse_dhcp_options(const void *, int, uint8_t);
+
+static void subnet_mask(const void *data, int opt_len)
+{
+    if (opt_len != 4)
+	return;
+    IPInfo.netmask = *(const uint32_t *)data;
+}
+
+static void router(const void *data, int opt_len)
+{
+    if (opt_len != 4)
+	return;
+    IPInfo.gateway = *(const uint32_t *)data;
+}
+
+static void dns_servers(const void *data, int opt_len)
+{
+    const uint32_t *dp = data;
+    int num = 0;
+
+    while (num < DNS_MAX_SERVERS) {
+	uint32_t ip;
+
+	if (opt_len < 4)
+	    break;
+
+	opt_len -= 4;
+	ip = *dp++;
+	if (ip_ok(ip))
+	    dns_server[num++] = ip;
+    }
+    while (num < DNS_MAX_SERVERS)
+	dns_server[num++] = 0;
+}
+
+static void local_domain(const void *data, int opt_len)
+{
+    char buffer[256];
+    char *ld = LocalDomain;
+
+    memcpy(buffer, data, opt_len);
+    buffer[opt_len] = 0;
+
+    dns_mangle(&ld, buffer);
+}
+
+static void vendor_encaps(const void *data, int opt_len)
+{
+    /* Only recognize PXELINUX options */
+    parse_dhcp_options(data, opt_len, 208);
+}
+
+static void option_overload(const void *data, int opt_len)
+{
+    if (opt_len != 1)
+	return;
+    over_load = *(uint8_t *)data;
+}
+
+static void server(const void *data, int opt_len)
+{
+    uint32_t ip;
+
+    if (opt_len != 4)
+	return;
+
+    if (IPInfo.serverip)
+        return;
+
+    ip = *(uint32_t *)data;
+    if (ip_ok(ip))
+        IPInfo.serverip = ip;
+}
+
+static void client_identifier(const void *data, int opt_len)
+{
+    if (opt_len > MAC_MAX || opt_len < 2 ||
+        MAC_len != (opt_len >> 8) ||
+        *(uint8_t *)data != MAC_type)
+        return;
+
+    opt_len --;
+    MAC_len = opt_len & 0xff;
+    memcpy(MAC, data+1, opt_len);
+    MAC[opt_len] = 0;
+}
+
+static void bootfile_name(const void *data, int opt_len)
+{
+    memcpy(boot_file, data, opt_len);
+    boot_file[opt_len] = 0;
+}
+
+static void uuid_client_identifier(const void *data, int opt_len)
+{
+    int type = *(const uint8_t *)data;
+    if (opt_len != 17 || type != 0 || have_uuid)
+        return;
+
+    have_uuid = true;
+    uuid_type = type;
+    memcpy(uuid, data+1, 16);
+}
+
+static void pxelinux_configfile(const void *data, int opt_len)
+{
+    DHCPMagic |= 2;
+    memcpy(ConfigName, data, opt_len);
+    ConfigName[opt_len] = 0;
+}
+
+static void pxelinux_pathprefix(const void *data, int opt_len)
+{
+    DHCPMagic |= 4;
+    memcpy(path_prefix, data, opt_len);
+    path_prefix[opt_len] = 0;
+}
+
+static void pxelinux_reboottime(const void *data, int opt_len)
+{
+    if (opt_len != 4)
+        return;
+
+    RebootTime = ntohl(*(const uint32_t *)data);
+    DHCPMagic |= 8;     /* Got reboot time */
+}
+
+
+struct dhcp_options {
+    int opt_num;
+    void (*fun)(const void *, int);
+};
+
+static const struct dhcp_options dhcp_opts[] = {
+    {1,   subnet_mask},
+    {3,   router},
+    {6,   dns_servers},
+    {15,  local_domain},
+    {43,  vendor_encaps},
+    {52,  option_overload},
+    {54,  server},
+    {61,  client_identifier},
+    {67,  bootfile_name},
+    {97,  uuid_client_identifier},
+    {209, pxelinux_configfile},
+    {210, pxelinux_pathprefix},
+    {211, pxelinux_reboottime}
+};
+
+/*
+ * Parse a sequence of DHCP options, pointed to by _option_;
+ * -- some DHCP servers leave option fields unterminated
+ * in violation of the spec.
+ *
+ * filter  contains the minimum value for the option to recognize
+ * -- this is used to restrict parsing to PXELINUX-specific options only.
+ */
+static void parse_dhcp_options(const void *option, int size, uint8_t opt_filter)
+{
+    int opt_num;
+    int opt_len;
+    const int opt_entries = sizeof(dhcp_opts) / sizeof(dhcp_opts[0]);
+    int i = 0;
+    const uint8_t *p = option;
+    const struct dhcp_options *opt;
+
+    /* The only 1-byte options are 00 and FF, neither of which matter */
+    while (size >= 2) {
+        opt_num = *p++;
+	size--;
+
+        if (opt_num == 0)
+            continue;
+        if (opt_num == 0xff)
+            break;
+
+        /* Anything else will have a length field */
+        opt_len = *p++; /* c  <- option lenght */
+        size -= opt_len + 1;
+        if (size < 0)
+            break;
+
+	if (opt_num >= opt_filter) {
+	    opt = dhcp_opts;
+	    for (i = 0; i < opt_entries; i++) {
+		if (opt_num == opt->opt_num) {
+		    opt->fun(p, opt_len);
+		    break;
+		}
+		opt++;
+	    }
+	}
+
+        /* parse next */
+        p += opt_len;
+    }
+}
+
+/*
+ * parse_dhcp
+ *
+ * Parse a DHCP packet.  This includes dealing with "overloaded"
+ * option fields (see RFC 2132, section 9.3)
+ *
+ * This should fill in the following global variables, if the
+ * information is present:
+ *
+ * MyIP		- client IP address
+ * server_ip	- boot server IP address
+ * net_mask	- network mask
+ * gate_way	- default gateway router IP
+ * boot_file	- boot file name
+ * DNSServers	- DNS server IPs
+ * LocalDomain	- Local domain name
+ * MAC_len, MAC	- Client identifier, if MAC_len == 0
+ *
+ * This assumes the DHCP packet is in "trackbuf".
+ *
+ */
+void parse_dhcp(int pkt_len)
+{
+    struct bootp_t *dhcp = (struct bootp_t *)trackbuf;
+    int opt_len;
+
+    IPInfo.ipv4 = 4;		/* This is IPv4 only for now... */
+
+    over_load = 0;
+    if (ip_ok(dhcp->yip))
+        IPInfo.myip = dhcp->yip;
+
+    if (ip_ok(dhcp->sip))
+        IPInfo.serverip = dhcp->sip;
+
+    opt_len = (char *)dhcp + pkt_len - (char *)&dhcp->options;
+    if (opt_len && (dhcp->option_magic == BOOTP_OPTION_MAGIC))
+        parse_dhcp_options(&dhcp->options, opt_len, 0);
+
+    if (over_load & 1)
+        parse_dhcp_options(&dhcp->bootfile, 128, 0);
+    else if (dhcp->bootfile[0])
+	strcpy(boot_file, dhcp->bootfile);
+
+    if (over_load & 2)
+        parse_dhcp_options(dhcp->sname, 64, 0);
+}
diff --git a/contrib/syslinux-4.02/core/fs/pxe/dnsresolv.c b/contrib/syslinux-4.02/core/fs/pxe/dnsresolv.c
new file mode 100644
index 0000000..2b263fa
--- /dev/null
+++ b/contrib/syslinux-4.02/core/fs/pxe/dnsresolv.c
@@ -0,0 +1,349 @@
+#include <stdio.h>
+#include <string.h>
+#include <core.h>
+#include "pxe.h"
+
+/* DNS CLASS values we care about */
+#define CLASS_IN	1
+
+/* DNS TYPE values we care about */
+#define TYPE_A		1
+#define TYPE_CNAME	5
+
+/*
+ * The DNS header structure
+ */
+struct dnshdr {
+    uint16_t id;
+    uint16_t flags;
+    /* number of entries in the question section */
+    uint16_t qdcount;
+    /* number of resource records in the answer section */
+    uint16_t ancount;
+    /* number of name server resource records in the authority records section*/
+    uint16_t nscount;
+    /* number of resource records in the additional records section */
+    uint16_t arcount;
+} __attribute__ ((packed));
+
+/*
+ * The DNS query structure
+ */
+struct dnsquery {
+    uint16_t qtype;
+    uint16_t qclass;
+} __attribute__ ((packed));
+
+/*
+ * The DNS Resource recodes structure
+ */
+struct dnsrr {
+    uint16_t type;
+    uint16_t class;
+    uint32_t ttl;
+    uint16_t rdlength;   /* The lenght of this rr data */
+    char     rdata[];
+} __attribute__ ((packed));
+
+
+uint32_t dns_server[DNS_MAX_SERVERS] = {0, };
+
+
+/*
+ * Turn a string in _src_ into a DNS "label set" in _dst_; returns the
+ * number of dots encountered. On return, *dst is updated.
+ */
+int dns_mangle(char **dst, const char *p)
+{
+    char *q = *dst;
+    char *count_ptr;
+    char c;
+    int dots = 0;
+
+    count_ptr = q;
+    *q++ = 0;
+
+    while (1) {
+        c = *p++;
+        if (c == 0 || c == ':' || c == '/')
+            break;
+        if (c == '.') {
+            dots++;
+            count_ptr = q;
+            *q++ = 0;
+            continue;
+        }
+
+        *count_ptr += 1;
+        *q++ = c;
+    }
+
+    if (*count_ptr)
+        *q++ = 0;
+
+    /* update the strings */
+    *dst = q;
+    return dots;
+}
+
+
+/*
+ * Compare two sets of DNS labels, in _s1_ and _s2_; the one in _s2_
+ * is allowed pointers relative to a packet in buf.
+ *
+ */
+static bool dns_compare(const void *s1, const void *s2, const void *buf)
+{
+    const uint8_t *q = s1;
+    const uint8_t *p = s2;
+    unsigned int c0, c1;
+
+    while (1) {
+	c0 = p[0];
+        if (c0 >= 0xc0) {
+	    /* Follow pointer */
+	    c1 = p[1];
+	    p = (const uint8_t *)buf + ((c0 - 0xc0) << 8) + c1;
+	} else if (c0) {
+	    c0++;		/* Include the length byte */
+	    if (memcmp(q, p, c0))
+		return false;
+	    q += c0;
+	    p += c0;
+	} else {
+	    return *q == 0;
+	}
+    }
+}
+
+/*
+ * Copy a DNS label into a buffer, considering the possibility that we might
+ * have to follow pointers relative to "buf".
+ * Returns a pointer to the first free byte *after* the terminal null.
+ */
+static void *dns_copylabel(void *dst, const void *src, const void *buf)
+{
+    uint8_t *q = dst;
+    const uint8_t *p = src;
+    unsigned int c0, c1;
+
+    while (1) {
+	c0 = p[0];
+        if (c0 >= 0xc0) {
+	    /* Follow pointer */
+	    c1 = p[1];
+	    p = (const uint8_t *)buf + ((c0 - 0xc0) << 8) + c1;
+	} else if (c0) {
+	    c0++;		/* Include the length byte */
+	    memcpy(q, p, c0);
+	    p += c0;
+	    q += c0;
+	} else {
+	    *q++ = 0;
+	    return q;
+	}
+    }
+}
+
+/*
+ * Skip past a DNS label set in DS:SI
+ */
+static char *dns_skiplabel(char *label)
+{
+    uint8_t c;
+
+    while (1) {
+        c = *label++;
+        if (c >= 0xc0)
+            return ++label; /* pointer is two bytes */
+        if (c == 0)
+            return label;
+        label += c;
+    }
+}
+
+/*
+ * Actual resolver function
+ * Points to a null-terminated or :-terminated string in _name_
+ * and returns the ip addr in _ip_ if it exists and can be found.
+ * If _ip_ = 0 on exit, the lookup failed. _name_ will be updated
+ *
+ * XXX: probably need some caching here.
+ */
+uint32_t dns_resolv(const char *name)
+{
+    static char __lowmem DNSSendBuf[PKTBUF_SIZE];
+    static char __lowmem DNSRecvBuf[PKTBUF_SIZE];
+    char *p;
+    int err;
+    int dots;
+    int same;
+    int rd_len;
+    int ques, reps;    /* number of questions and replies */
+    uint8_t timeout;
+    const uint8_t *timeout_ptr = TimeoutTable;
+    uint32_t oldtime;
+    uint32_t srv;
+    uint32_t *srv_ptr;
+    struct dnshdr *hd1 = (struct dnshdr *)DNSSendBuf;
+    struct dnshdr *hd2 = (struct dnshdr *)DNSRecvBuf;
+    struct dnsquery *query;
+    struct dnsrr *rr;
+    static __lowmem struct s_PXENV_UDP_WRITE udp_write;
+    static __lowmem struct s_PXENV_UDP_READ  udp_read;
+    uint16_t local_port;
+    uint32_t result = 0;
+
+    /* Make sure we have at least one valid DNS server */
+    if (!dns_server[0])
+	return 0;
+
+    /* Get a local port number */
+    local_port = get_port();
+
+    /* First, fill the DNS header struct */
+    hd1->id++;                      /* New query ID */
+    hd1->flags   = htons(0x0100);   /* Recursion requested */
+    hd1->qdcount = htons(1);        /* One question */
+    hd1->ancount = 0;               /* No answers */
+    hd1->nscount = 0;               /* No NS */
+    hd1->arcount = 0;               /* No AR */
+
+    p = DNSSendBuf + sizeof(struct dnshdr);
+    dots = dns_mangle(&p, name);   /* store the CNAME */
+
+    if (!dots) {
+        p--; /* Remove final null */
+        /* Uncompressed DNS label set so it ends in null */
+        strcpy(p, LocalDomain);
+    }
+
+    /* Fill the DNS query packet */
+    query = (struct dnsquery *)p;
+    query->qtype  = htons(TYPE_A);
+    query->qclass = htons(CLASS_IN);
+    p += sizeof(struct dnsquery);
+
+    /* Now send it to name server */
+    timeout_ptr = TimeoutTable;
+    timeout = *timeout_ptr++;
+    srv_ptr = dns_server;
+    while (timeout) {
+	srv = *srv_ptr++;
+	if (!srv) {
+	    srv_ptr = dns_server;
+	    srv = *srv_ptr++;
+	}
+
+        udp_write.status      = 0;
+        udp_write.ip          = srv;
+        udp_write.gw          = gateway(srv);
+        udp_write.src_port    = local_port;
+        udp_write.dst_port    = DNS_PORT;
+        udp_write.buffer_size = p - DNSSendBuf;
+        udp_write.buffer      = FAR_PTR(DNSSendBuf);
+        err = pxe_call(PXENV_UDP_WRITE, &udp_write);
+        if (err || udp_write.status)
+            continue;
+
+        oldtime = jiffies();
+	do {
+	    if (jiffies() - oldtime >= timeout)
+		goto again;
+
+            udp_read.status      = 0;
+            udp_read.src_ip      = srv;
+            udp_read.dest_ip     = IPInfo.myip;
+            udp_read.s_port      = DNS_PORT;
+            udp_read.d_port      = local_port;
+            udp_read.buffer_size = PKTBUF_SIZE;
+            udp_read.buffer      = FAR_PTR(DNSRecvBuf);
+            err = pxe_call(PXENV_UDP_READ, &udp_read);
+	} while (err || udp_read.status || hd2->id != hd1->id);
+
+        if ((hd2->flags ^ 0x80) & htons(0xf80f))
+            goto badness;
+
+        ques = htons(hd2->qdcount);   /* Questions */
+        reps = htons(hd2->ancount);   /* Replies   */
+        p = DNSRecvBuf + sizeof(struct dnshdr);
+        while (ques--) {
+            p = dns_skiplabel(p); /* Skip name */
+            p += 4;               /* Skip question trailer */
+        }
+
+        /* Parse the replies */
+        while (reps--) {
+            same = dns_compare(DNSSendBuf + sizeof(struct dnshdr),
+			       p, DNSRecvBuf);
+            p = dns_skiplabel(p);
+            rr = (struct dnsrr *)p;
+            rd_len = ntohs(rr->rdlength);
+            if (same && ntohs(rr->class) == CLASS_IN) {
+		switch (ntohs(rr->type)) {
+		case TYPE_A:
+		    if (rd_len == 4) {
+			result = *(uint32_t *)rr->rdata;
+			goto done;
+		    }
+		    break;
+		case TYPE_CNAME:
+		    dns_copylabel(DNSSendBuf + sizeof(struct dnshdr),
+				  rr->rdata, DNSRecvBuf);
+		    /*
+		     * We should probably rescan the packet from the top
+		     * here, and technically we might have to send a whole
+		     * new request here...
+		     */
+		    break;
+		default:
+		    break;
+		}
+	    }
+
+            /* not the one we want, try next */
+            p += sizeof(struct dnsrr) + rd_len;
+        }
+
+    badness:
+        /*
+         *
+         ; We got back no data from this server.
+         ; Unfortunately, for a recursive, non-authoritative
+         ; query there is no such thing as an NXDOMAIN reply,
+         ; which technically means we can't draw any
+         ; conclusions.  However, in practice that means the
+         ; domain doesn't exist.  If this turns out to be a
+         ; problem, we may want to add code to go through all
+         ; the servers before giving up.
+
+         ; If the DNS server wasn't capable of recursion, and
+         ; isn't capable of giving us an authoritative reply
+         ; (i.e. neither AA or RA set), then at least try a
+         ; different setver...
+        */
+        if (hd2->flags == htons(0x480))
+            continue;
+
+        break; /* failed */
+
+    again:
+	continue;
+    }
+
+done:
+    free_port(local_port);	/* Return port number to the free pool */
+
+    return result;
+}
+
+
+/*
+ * the one should be called from ASM file
+ */
+void pxe_dns_resolv(com32sys_t *regs)
+{
+    const char *name = MK_PTR(regs->ds, regs->esi.w[0]);
+
+    regs->eax.l = dns_resolv(name);
+}
diff --git a/contrib/syslinux-4.02/core/fs/pxe/idle.c b/contrib/syslinux-4.02/core/fs/pxe/idle.c
new file mode 100644
index 0000000..52a87c3
--- /dev/null
+++ b/contrib/syslinux-4.02/core/fs/pxe/idle.c
@@ -0,0 +1,112 @@
+/* ----------------------------------------------------------------------- *
+ *   
+ *   Copyright 2008 H. Peter Anvin - All Rights Reserved
+ *   Copyright 2009 Intel Corporation; author: H. Peter Anvin
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+ *   Boston MA 02110-1301, USA; either version 2 of the License, or
+ *   (at your option) any later version; incorporated herein by reference.
+ *
+ * ----------------------------------------------------------------------- */
+
+#include <stdio.h>
+#include <string.h>
+#include <core.h>
+#include <fs.h>
+#include <minmax.h>
+#include <sys/cpu.h>
+#include "pxe.h"
+
+static int pxe_idle_poll(void)
+{
+    static __lowmem char junk_pkt[PKTBUF_SIZE];
+    static __lowmem t_PXENV_UDP_READ read_buf;
+
+    memset(&read_buf, 0, sizeof read_buf);
+
+    read_buf.src_ip  = 0;	 /* Any destination */
+    read_buf.dest_ip = IPInfo.myip;
+    read_buf.s_port  = 0;	 /* Any source port */
+    read_buf.d_port  = htons(9); /* Discard port (not used...) */
+    read_buf.buffer_size = sizeof junk_pkt;
+    read_buf.buffer  = FAR_PTR(junk_pkt);
+
+    pxe_call(PXENV_UDP_READ, &read_buf);
+
+    return 0;
+}
+
+static uint32_t pxe_detect_nic_type(void)
+{
+    static __lowmem t_PXENV_UNDI_GET_NIC_TYPE nic_type;
+
+    if (pxe_call(PXENV_UNDI_GET_NIC_TYPE, &nic_type))
+	return -1;		/* Unknown NIC */
+
+    if (nic_type.NicType != PCI_NIC && nic_type.NicType != CardBus_NIC)
+	return -1;		/* Not a PCI NIC */
+
+    /*
+     * Return VID:DID as a single number, with the VID in the high word
+     * -- this is opposite from the usual order, but it makes it easier to
+     * enforce that the table is sorted.
+     */
+    return (nic_type.info.pci.Vendor_ID << 16) + nic_type.info.pci.Dev_ID;
+}
+
+#define PCI_DEV(vid, did)	(((vid) << 16) + (did))
+
+/* This array should be sorted!! */
+static const uint32_t pxe_need_idle_drain[] =
+{
+    /*
+     * Older Broadcom NICs: they need receive calls on idle to avoid
+     * FIFO stalls.
+     */
+    PCI_DEV(0x14e4, 0x1659),	/* BCM5721 */
+    PCI_DEV(0x14e4, 0x165a),	/* BCM5722 */
+    PCI_DEV(0x14e4, 0x165b),	/* BCM5723 */
+    PCI_DEV(0x14e4, 0x1668),	/* BCM5714 */
+    PCI_DEV(0x14e4, 0x1669),	/* BCM5714S */
+    PCI_DEV(0x14e4, 0x166a),	/* BCM5780 */
+    PCI_DEV(0x14e4, 0x1673),	/* BCM5755M */
+    PCI_DEV(0x14e4, 0x1674),	/* BCM5756ME */
+    PCI_DEV(0x14e4, 0x1678),	/* BCM5715 */
+    PCI_DEV(0x14e4, 0x1679),	/* BCM5715S */
+    PCI_DEV(0x14e4, 0x167b),	/* BCM5755 */
+};
+
+void pxe_idle_init(void)
+{
+    uint32_t dev_id = pxe_detect_nic_type();
+    int l, h;
+    bool found;
+
+    l = 0;
+    h = sizeof pxe_need_idle_drain / sizeof pxe_need_idle_drain[0] - 1;
+
+    found = false;
+    while (h >= l) {
+	int x = (l+h) >> 1;
+	uint32_t id = pxe_need_idle_drain[x];
+
+	if (id == dev_id) {
+	    found = true;
+	    break;
+	} else if (id < dev_id) {
+	    l = x+1;
+	} else {
+	    h = x-1;
+	}
+    }
+
+    if (found)
+	idle_hook_func = pxe_idle_poll;
+}
+
+void pxe_idle_cleanup(void)
+{
+    idle_hook_func = NULL;
+}
diff --git a/contrib/syslinux-4.02/core/fs/pxe/portnum.c b/contrib/syslinux-4.02/core/fs/pxe/portnum.c
new file mode 100644
index 0000000..19af0cd
--- /dev/null
+++ b/contrib/syslinux-4.02/core/fs/pxe/portnum.c
@@ -0,0 +1,68 @@
+/* ----------------------------------------------------------------------- *
+ *   
+ *   Copyright 2010 Intel Corporation; author: H. Peter Anvin
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+ *   Boston MA 02110-1301, USA; either version 2 of the License, or
+ *   (at your option) any later version; incorporated herein by reference.
+ *
+ * ----------------------------------------------------------------------- */
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <netinet/in.h>
+#include "pxe.h"
+
+/* Port number bitmap - port numbers 49152 (0xc000) to 57343 (0xefff) */
+#define PORT_NUMBER_BASE	49152
+#define PORT_NUMBER_COUNT	8192 /* Power of 2, please */
+static uint32_t port_number_bitmap[PORT_NUMBER_COUNT/32];
+static uint16_t first_port_number /* = 0 */;
+
+/*
+ * Bitmap functions
+ */
+static bool test_bit(const uint32_t *bitmap, int32_t index)
+{
+    uint8_t st;
+    asm("btl %2,%1 ; setc %0" : "=qm" (st) : "m" (*bitmap), "r" (index));
+    return st;
+}
+
+static void set_bit(uint32_t *bitmap, int32_t index)
+{
+    asm volatile("btsl %1,%0" : "+m" (*bitmap) : "r" (index) : "memory");
+}
+
+static void clr_bit(uint32_t *bitmap, int32_t index)
+{
+    asm volatile("btcl %1,%0" : "+m" (*bitmap) : "r" (index) : "memory");
+}
+
+/*
+ * Get and free a port number (host byte order)
+ */
+uint16_t get_port(void)
+{
+    uint16_t port;
+
+    do {
+	port = first_port_number++;
+	first_port_number &= PORT_NUMBER_COUNT - 1;
+    } while (test_bit(port_number_bitmap, port));
+
+    set_bit(port_number_bitmap, port);
+    return htons(port + PORT_NUMBER_BASE);
+}
+
+void free_port(uint16_t port)
+{
+    port = ntohs(port) - PORT_NUMBER_BASE;
+
+    if (port >= PORT_NUMBER_COUNT)
+	return;
+
+    clr_bit(port_number_bitmap, port);
+}
diff --git a/contrib/syslinux-4.02/core/fs/pxe/pxe.c b/contrib/syslinux-4.02/core/fs/pxe/pxe.c
new file mode 100644
index 0000000..0238ed4
--- /dev/null
+++ b/contrib/syslinux-4.02/core/fs/pxe/pxe.c
@@ -0,0 +1,1731 @@
+#include <dprintf.h>
+#include <stdio.h>
+#include <string.h>
+#include <core.h>
+#include <fs.h>
+#include <minmax.h>
+#include <sys/cpu.h>
+#include "pxe.h"
+
+#define GPXE 1
+
+static uint16_t real_base_mem;	   /* Amount of DOS memory after freeing */
+
+uint8_t MAC[MAC_MAX];		   /* Actual MAC address */
+uint8_t MAC_len;                   /* MAC address len */
+uint8_t MAC_type;                  /* MAC address type */
+
+char __bss16 BOOTIFStr[7+3*(MAC_MAX+1)];
+#define MAC_str (BOOTIFStr+7)	/* The actual hardware address */
+char __bss16 SYSUUIDStr[8+32+5];
+#define UUID_str (SYSUUIDStr+8)	/* The actual UUID */
+
+char boot_file[256];		   /* From DHCP */
+char path_prefix[256];		   /* From DHCP */
+char dot_quad_buf[16];
+
+static bool has_gpxe;
+static uint32_t gpxe_funcs;
+bool have_uuid = false;
+
+/* Common receive buffer */
+static __lowmem char packet_buf[PKTBUF_SIZE] __aligned(16);
+
+const uint8_t TimeoutTable[] = {
+    2, 2, 3, 3, 4, 5, 6, 7, 9, 10, 12, 15, 18, 21, 26, 31, 37, 44,
+    53, 64, 77, 92, 110, 132, 159, 191, 229, 255, 255, 255, 255, 0
+};
+
+struct tftp_options {
+    const char *str_ptr;        /* string pointer */
+    size_t      offset;		/* offset into socket structre */
+};
+
+#define IFIELD(x)	offsetof(struct inode, x)
+#define PFIELD(x)	(offsetof(struct inode, pvt) + \
+			 offsetof(struct pxe_pvt_inode, x))
+
+static const struct tftp_options tftp_options[] =
+{
+    { "tsize",   IFIELD(size) },
+    { "blksize", PFIELD(tftp_blksize) },
+};
+static const int tftp_nopts = sizeof tftp_options / sizeof tftp_options[0];
+
+static void tftp_error(struct inode *file, uint16_t errnum,
+		       const char *errstr);
+
+/*
+ * Allocate a local UDP port structure and assign it a local port number.
+ * Return the inode pointer if success, or null if failure
+ */
+static struct inode *allocate_socket(struct fs_info *fs)
+{
+    struct inode *inode = alloc_inode(fs, 0, sizeof(struct pxe_pvt_inode));
+
+    if (!inode) {
+	malloc_error("socket structure");
+    } else {
+	struct pxe_pvt_inode *socket = PVT(inode);
+	socket->tftp_localport = get_port();
+	inode->mode = DT_REG;	/* No other types relevant for PXE */
+    }
+
+    return inode;
+}
+
+static void free_socket(struct inode *inode)
+{
+    struct pxe_pvt_inode *socket = PVT(inode);
+
+    free_port(socket->tftp_localport);
+    free_inode(inode);
+}
+
+#if GPXE
+static void gpxe_close_file(struct inode *inode)
+{
+    struct pxe_pvt_inode *socket = PVT(inode);
+    static __lowmem struct s_PXENV_FILE_CLOSE file_close;
+
+    file_close.FileHandle = socket->tftp_remoteport;
+    pxe_call(PXENV_FILE_CLOSE, &file_close);
+}
+#endif
+
+static void pxe_close_file(struct file *file)
+{
+    struct inode *inode = file->inode;
+    struct pxe_pvt_inode *socket = PVT(inode);
+
+    if (!socket->tftp_goteof) {
+#if GPXE
+	if (socket->tftp_localport == 0xffff) {
+	    gpxe_close_file(inode);
+	} else
+#endif
+	if (socket->tftp_localport != 0) {
+	    tftp_error(inode, 0, "No error, file close");
+	}
+    }
+
+    free_socket(inode);
+}
+
+/**
+ * Take a nubmer of bytes in memory and convert to lower-case hxeadecimal
+ *
+ * @param: dst, output buffer
+ * @param: src, input buffer
+ * @param: count, number of bytes
+ *
+ */
+static void lchexbytes(char *dst, const void *src, int count)
+{
+    uint8_t half;
+    uint8_t c;
+    const uint8_t *s = src;
+
+    for(; count > 0; count--) {
+        c = *s++;
+        half   = ((c >> 4) & 0x0f) + '0';
+        *dst++ = half > '9' ? (half + 'a' - '9' - 1) : half;
+
+        half   = (c & 0x0f) + '0';
+        *dst++ = half > '9' ? (half + 'a' - '9' - 1) : half;
+    }
+}
+
+/*
+ * just like the lchexbytes, except to upper-case
+ *
+ */
+static void uchexbytes(char *dst, const void *src, int count)
+{
+    uint8_t half;
+    uint8_t c;
+    const uint8_t *s = src;
+
+    for(; count > 0; count--) {
+        c = *s++;
+        half   = ((c >> 4) & 0x0f) + '0';
+        *dst++ = half > '9' ? (half + 'A' - '9' - 1) : half;
+
+        half   = (c & 0x0f) + '0';
+        *dst++ = half > '9' ? (half + 'A' - '9' - 1) : half;
+    }
+}
+
+/*
+ * Parse a single hexadecimal byte, which must be complete (two
+ * digits).  This is used in URL parsing.
+ */
+static int hexbyte(const char *p)
+{
+    if (!is_hex(p[0]) || !is_hex(p[1]))
+	return -1;
+    else
+	return (hexval(p[0]) << 4) + hexval(p[1]);
+}
+
+/*
+ * Tests an IP address in _ip_ for validity; return with 0 for bad, 1 for good.
+ * We used to refuse class E, but class E addresses are likely to become
+ * assignable unicast addresses in the near future.
+ *
+ */
+bool ip_ok(uint32_t ip)
+{
+    uint8_t ip_hi = (uint8_t)ip; /* First octet of the ip address */
+
+    if (ip == 0xffffffff ||	/* Refuse the all-ones address */
+	ip_hi == 0 ||		/* Refuse network zero */
+	ip_hi == 127 ||		/* Refuse the loopback network */
+	(ip_hi & 240) == 224)	/* Refuse class D */
+	return false;
+
+    return true;
+}
+
+
+/*
+ * Take an IP address (in network byte order) in _ip_ and
+ * output a dotted quad string to _dst_, returns the length
+ * of the dotted quad ip string.
+ *
+ */
+static int gendotquad(char *dst, uint32_t ip)
+{
+    int part;
+    int i = 0, j;
+    char temp[4];
+    char *p = dst;
+
+    for (; i < 4; i++) {
+        j = 0;
+        part = ip & 0xff;
+        do {
+            temp[j++] = (part % 10) + '0';
+        }while(part /= 10);
+        for (; j > 0; j--)
+            *p++ = temp[j-1];
+        *p++ = '.';
+
+        ip >>= 8;
+    }
+    /* drop the last dot '.' and zero-terminate string*/
+    *(--p) = 0;
+
+    return p - dst;
+}
+
+/*
+ * parse the ip_str and return the ip address with *res.
+ * return the the string address after the ip string
+ *
+ */
+static const char *parse_dotquad(const char *ip_str, uint32_t *res)
+{
+    const char *p = ip_str;
+    uint8_t part = 0;
+    uint32_t ip = 0;
+    int i;
+
+    for (i = 0; i < 4; i++) {
+        while (is_digit(*p)) {
+            part = part * 10 + *p - '0';
+            p++;
+        }
+        if (i != 3 && *p != '.')
+            return NULL;
+
+        ip = (ip << 8) | part;
+        part = 0;
+        p++;
+    }
+    p--;
+
+    *res = htonl(ip);
+    return p;
+}
+
+/*
+ * the ASM pxenv function wrapper, return 1 if error, or 0
+ *
+ */
+int pxe_call(int opcode, void *data)
+{
+    extern void pxenv(void);
+    com32sys_t regs;
+
+#if 0
+    printf("pxe_call op %04x data %p\n", opcode, data);
+#endif
+
+    memset(&regs, 0, sizeof regs);
+    regs.ebx.w[0] = opcode;
+    regs.es       = SEG(data);
+    regs.edi.w[0] = OFFS(data);
+    call16(pxenv, &regs, &regs);
+
+    return regs.eflags.l & EFLAGS_CF;  /* CF SET if fail */
+}
+
+/**
+ * Send an ERROR packet.  This is used to terminate a connection.
+ *
+ * @inode:	Inode structure
+ * @errnum:	Error number (network byte order)
+ * @errstr:	Error string (included in packet)
+ */
+static void tftp_error(struct inode *inode, uint16_t errnum,
+		       const char *errstr)
+{
+    static __lowmem struct {
+	uint16_t err_op;
+	uint16_t err_num;
+	char err_msg[64];
+    } __packed err_buf;
+    static __lowmem struct s_PXENV_UDP_WRITE udp_write;
+    int len = min(strlen(errstr), sizeof(err_buf.err_msg)-1);
+    struct pxe_pvt_inode *socket = PVT(inode);
+
+    err_buf.err_op  = TFTP_ERROR;
+    err_buf.err_num = errnum;
+    memcpy(err_buf.err_msg, errstr, len);
+    err_buf.err_msg[len] = '\0';
+
+    udp_write.src_port    = socket->tftp_localport;
+    udp_write.dst_port    = socket->tftp_remoteport;
+    udp_write.ip          = socket->tftp_remoteip;
+    udp_write.gw          = gateway(udp_write.ip);
+    udp_write.buffer      = FAR_PTR(&err_buf);
+    udp_write.buffer_size = 4 + len + 1;
+
+    /* If something goes wrong, there is nothing we can do, anyway... */
+    pxe_call(PXENV_UDP_WRITE, &udp_write);
+}
+
+
+/**
+ * Send ACK packet. This is a common operation and so is worth canning.
+ *
+ * @param: inode,   Inode pointer
+ * @param: ack_num, Packet # to ack (network byte order)
+ *
+ */
+static void ack_packet(struct inode *inode, uint16_t ack_num)
+{
+    int err;
+    static __lowmem uint16_t ack_packet_buf[2];
+    static __lowmem struct s_PXENV_UDP_WRITE udp_write;
+    struct pxe_pvt_inode *socket = PVT(inode);
+
+    /* Packet number to ack */
+    ack_packet_buf[0]     = TFTP_ACK;
+    ack_packet_buf[1]     = ack_num;
+    udp_write.src_port    = socket->tftp_localport;
+    udp_write.dst_port    = socket->tftp_remoteport;
+    udp_write.ip          = socket->tftp_remoteip;
+    udp_write.gw          = gateway(udp_write.ip);
+    udp_write.buffer      = FAR_PTR(ack_packet_buf);
+    udp_write.buffer_size = 4;
+
+    err = pxe_call(PXENV_UDP_WRITE, &udp_write);
+#if 0
+    printf("sent %s\n", err ? "FAILED" : "OK");
+#endif
+}
+
+
+/**
+ * Get a DHCP packet from the PXE stack into the trackbuf
+ *
+ * @param:  type,  packet type
+ * @return: buffer size
+ *
+ */
+static int pxe_get_cached_info(int type)
+{
+    int err;
+    static __lowmem struct s_PXENV_GET_CACHED_INFO get_cached_info;
+    printf(" %02x", type);
+
+    get_cached_info.Status      = 0;
+    get_cached_info.PacketType  = type;
+    get_cached_info.BufferSize  = 8192;
+    get_cached_info.Buffer      = FAR_PTR(trackbuf);
+    err = pxe_call(PXENV_GET_CACHED_INFO, &get_cached_info);
+    if (err) {
+        printf("PXE API call failed, error  %04x\n", err);
+	kaboom();
+    }
+
+    return get_cached_info.BufferSize;
+}
+
+
+/*
+ * Return the type of pathname passed.
+ */
+enum pxe_path_type {
+    PXE_RELATIVE,		/* No :: or URL */
+    PXE_HOMESERVER,		/* Starting with :: */
+    PXE_TFTP,			/* host:: */
+    PXE_URL_TFTP,		/* tftp:// */
+    PXE_URL,			/* Absolute URL syntax */
+};
+
+static enum pxe_path_type pxe_path_type(const char *str)
+{
+    const char *p;
+    
+    p = str;
+
+    while (1) {
+	switch (*p) {
+	case ':':
+	    if (p[1] == ':') {
+		if (p == str)
+		    return PXE_HOMESERVER;
+		else
+		    return PXE_TFTP;
+	    } else if (p > str && p[1] == '/' && p[2] == '/') {
+		if (!strncasecmp(str, "tftp://", 7))
+		    return PXE_URL_TFTP;
+		else
+		    return PXE_URL;
+	    }
+
+	    /* else fall through */
+	case '/': case '!': case '@': case '#': case '%':
+	case '^': case '&': case '*': case '(': case ')':
+	case '[': case ']': case '{': case '}': case '\\':
+	case '|': case '=': case '`': case '~': case '\'':
+	case '\"': case ';': case '>': case '<': case '?':
+	case '\0':
+	    /* Any of these characters terminate the colon search */
+	    return PXE_RELATIVE;
+	default:
+	    break;
+	}
+	p++;
+    }
+}
+
+#if GPXE
+
+/**
+ * Get a fresh packet from a gPXE socket
+ * @param: inode -> Inode pointer
+ *
+ */
+static void get_packet_gpxe(struct inode *inode)
+{
+    struct pxe_pvt_inode *socket = PVT(inode);
+    static __lowmem struct s_PXENV_FILE_READ file_read;
+    int err;
+
+    while (1) {
+        file_read.FileHandle  = socket->tftp_remoteport;
+        file_read.Buffer      = FAR_PTR(packet_buf);
+        file_read.BufferSize  = PKTBUF_SIZE;
+        err = pxe_call(PXENV_FILE_READ, &file_read);
+        if (!err)  /* successed */
+            break;
+
+        if (file_read.Status != PXENV_STATUS_TFTP_OPEN)
+	    kaboom();
+    }
+
+    memcpy(socket->tftp_pktbuf, packet_buf, file_read.BufferSize);
+
+    socket->tftp_dataptr   = socket->tftp_pktbuf;
+    socket->tftp_bytesleft = file_read.BufferSize;
+    socket->tftp_filepos  += file_read.BufferSize;
+
+    if (socket->tftp_bytesleft == 0)
+        inode->size = socket->tftp_filepos;
+
+    /* if we're done here, close the file */
+    if (inode->size > socket->tftp_filepos)
+        return;
+
+    /* Got EOF, close it */
+    socket->tftp_goteof = 1;
+    gpxe_close_file(inode);
+}
+#endif /* GPXE */
+
+
+/*
+ * mangle a filename pointed to by _src_ into a buffer pointed
+ * to by _dst_; ends on encountering any whitespace.
+ *
+ */
+static void pxe_mangle_name(char *dst, const char *src)
+{
+    size_t len = FILENAME_MAX-1;
+
+    while (len-- && not_whitespace(*src))
+	*dst++ = *src++;
+
+    *dst = '\0';
+}
+
+/*
+ * Get a fresh packet if the buffer is drained, and we haven't hit
+ * EOF yet.  The buffer should be filled immediately after draining!
+ */
+static void fill_buffer(struct inode *inode)
+{
+    int err;
+    int last_pkt;
+    const uint8_t *timeout_ptr;
+    uint8_t timeout;
+    uint16_t buffersize;
+    uint32_t oldtime;
+    void *data = NULL;
+    static __lowmem struct s_PXENV_UDP_READ udp_read;
+    struct pxe_pvt_inode *socket = PVT(inode);
+
+    if (socket->tftp_bytesleft || socket->tftp_goteof)
+        return;
+
+#if GPXE
+    if (socket->tftp_localport == 0xffff) {
+        get_packet_gpxe(inode);
+        return;
+    }
+#endif
+
+    /*
+     * Start by ACKing the previous packet; this should cause
+     * the next packet to be sent.
+     */
+    timeout_ptr = TimeoutTable;
+    timeout = *timeout_ptr++;
+    oldtime = jiffies();
+
+ ack_again:
+    ack_packet(inode, socket->tftp_lastpkt);
+
+    while (timeout) {
+        udp_read.buffer      = FAR_PTR(packet_buf);
+        udp_read.buffer_size = PKTBUF_SIZE;
+        udp_read.src_ip      = socket->tftp_remoteip;
+        udp_read.dest_ip     = IPInfo.myip;
+        udp_read.s_port      = socket->tftp_remoteport;
+        udp_read.d_port      = socket->tftp_localport;
+        err = pxe_call(PXENV_UDP_READ, &udp_read);
+        if (err) {
+	    uint32_t now = jiffies();
+
+	    if (now-oldtime >= timeout) {
+		oldtime = now;
+		timeout = *timeout_ptr++;
+		if (!timeout)
+		    break;
+	    }
+            continue;
+        }
+
+        if (udp_read.buffer_size < 4)  /* Bad size for a DATA packet */
+            continue;
+
+        data = packet_buf;
+        if (*(uint16_t *)data != TFTP_DATA)    /* Not a data packet */
+            continue;
+
+        /* If goes here, recevie OK, break */
+        break;
+    }
+
+    /* time runs out */
+    if (timeout == 0)
+	kaboom();
+
+    last_pkt = socket->tftp_lastpkt;
+    last_pkt = ntohs(last_pkt);       /* Host byte order */
+    last_pkt++;
+    last_pkt = htons(last_pkt);       /* Network byte order */
+    if (*(uint16_t *)(data + 2) != last_pkt) {
+        /*
+         * Wrong packet, ACK the packet and try again.
+         * This is presumably because the ACK got lost,
+         * so the server just resent the previous packet.
+         */
+#if 0
+	printf("Wrong packet, wanted %04x, got %04x\n", \
+               htons(last_pkt), htons(*(uint16_t *)(data+2)));
+#endif
+        goto ack_again;
+    }
+
+    /* It's the packet we want.  We're also EOF if the size < blocksize */
+    socket->tftp_lastpkt = last_pkt;    /* Update last packet number */
+    buffersize = udp_read.buffer_size - 4;  /* Skip TFTP header */
+    memcpy(socket->tftp_pktbuf, packet_buf + 4, buffersize);
+    socket->tftp_dataptr = socket->tftp_pktbuf;
+    socket->tftp_filepos += buffersize;
+    socket->tftp_bytesleft = buffersize;
+    if (buffersize < socket->tftp_blksize) {
+        /* it's the last block, ACK packet immediately */
+        ack_packet(inode, *(uint16_t *)(data + 2));
+
+        /* Make sure we know we are at end of file */
+        inode->size 		= socket->tftp_filepos;
+        socket->tftp_goteof	= 1;
+    }
+}
+
+
+/**
+ * getfssec: Get multiple clusters from a file, given the starting cluster.
+ * In this case, get multiple blocks from a specific TCP connection.
+ *
+ * @param: fs, the fs_info structure address, in pxe, we don't use this.
+ * @param: buf, buffer to store the read data
+ * @param: openfile, TFTP socket pointer
+ * @param: blocks, 512-byte block count; 0FFFFh = until end of file
+ *
+ * @return: the bytes read
+ *
+ */
+static uint32_t pxe_getfssec(struct file *file, char *buf,
+			     int blocks, bool *have_more)
+{
+    struct inode *inode = file->inode;
+    struct pxe_pvt_inode *socket = PVT(inode);
+    int count = blocks;
+    int chunk;
+    int bytes_read = 0;
+
+    count <<= TFTP_BLOCKSIZE_LG2;
+    while (count) {
+        fill_buffer(inode); /* If we have no 'fresh' buffer, get it */
+        if (!socket->tftp_bytesleft)
+            break;
+
+        chunk = count;
+        if (chunk > socket->tftp_bytesleft)
+            chunk = socket->tftp_bytesleft;
+        socket->tftp_bytesleft -= chunk;
+        memcpy(buf, socket->tftp_dataptr, chunk);
+	socket->tftp_dataptr += chunk;
+        buf += chunk;
+        bytes_read += chunk;
+        count -= chunk;
+    }
+
+
+    if (socket->tftp_bytesleft || (socket->tftp_filepos < inode->size)) {
+	fill_buffer(inode);
+        *have_more = 1;
+    } else if (socket->tftp_goteof) {
+        /*
+         * The socket is closed and the buffer drained; the caller will
+	 * call close_file and therefore free the socket.
+         */
+        *have_more = 0;
+    }
+
+    return bytes_read;
+}
+
+/**
+ * Open a TFTP connection to the server
+ *
+ * @param:filename, the file we wanna open
+ *
+ * @out: open_file_t structure, stores in file->open_file
+ * @out: the lenght of this file, stores in file->file_len
+ *
+ */
+static void pxe_searchdir(const char *filename, struct file *file)
+{
+    struct fs_info *fs = file->fs;
+    struct inode *inode;
+    struct pxe_pvt_inode *socket;
+    char *buf;
+    const char *np;
+    char *p;
+    char *options;
+    char *data;
+    static __lowmem struct s_PXENV_UDP_WRITE udp_write;
+    static __lowmem struct s_PXENV_UDP_READ  udp_read;
+    static __lowmem struct s_PXENV_FILE_OPEN file_open;
+    static const char rrq_tail[] = "octet\0""tsize\0""0\0""blksize\0""1408";
+    static __lowmem char rrq_packet_buf[2+2*FILENAME_MAX+sizeof rrq_tail];
+    const struct tftp_options *tftp_opt;
+    int i = 0;
+    int err;
+    int buffersize;
+    int rrq_len;
+    const uint8_t  *timeout_ptr;
+    uint32_t timeout;
+    uint32_t oldtime;
+    uint16_t tid;
+    uint16_t opcode;
+    uint16_t blk_num;
+    uint32_t ip = 0;
+    uint32_t opdata, *opdata_ptr;
+    enum pxe_path_type path_type;
+    char fullpath[2*FILENAME_MAX];
+    uint16_t server_port = TFTP_PORT;  /* TFTP server port */
+
+    inode = file->inode = NULL;
+	
+    buf = rrq_packet_buf;
+    *(uint16_t *)buf = TFTP_RRQ;  /* TFTP opcode */
+    buf += 2;
+
+    path_type = pxe_path_type(filename);
+    if (path_type == PXE_RELATIVE) {
+	snprintf(fullpath, sizeof fullpath, "%s%s", fs->cwd_name, filename);
+	path_type = pxe_path_type(filename = fullpath);
+    }
+
+    switch (path_type) {
+    case PXE_RELATIVE:		/* Really shouldn't happen... */
+    case PXE_URL:
+	buf = stpcpy(buf, filename);
+	ip = IPInfo.serverip;	/* Default server */
+	break;
+
+    case PXE_HOMESERVER:
+	buf = stpcpy(buf, filename+2);
+	ip = IPInfo.serverip;
+	break;
+
+    case PXE_TFTP:
+	np = strchr(filename, ':');
+	buf = stpcpy(buf, np+2);
+	if (parse_dotquad(filename, &ip) != np)
+	    ip = dns_resolv(filename);
+	break;
+
+    case PXE_URL_TFTP:
+	np = filename + 7;
+	while (*np && *np != '/' && *np != ':')
+	    np++;
+	if (np > filename + 7) {
+	    if (parse_dotquad(filename + 7, &ip) != np)
+		ip = dns_resolv(filename + 7);
+	}
+	if (*np == ':') {
+	    np++;
+	    server_port = 0;
+	    while (*np >= '0' && *np <= '9')
+		server_port = server_port * 10 + *np++ - '0';
+	    server_port = server_port ? htons(server_port) : TFTP_PORT;
+	}
+	if (*np == '/')
+	    np++;		/* Do *NOT* eat more than one slash here... */
+	/*
+	 * The ; is because of a quirk in the TFTP URI spec (RFC
+	 * 3617); it is to be followed by TFTP modes, which we just ignore.
+	 */
+	while (*np && *np != ';') {
+	    int v;
+	    if (*np == '%' && (v = hexbyte(np+1)) > 0) {
+		*buf++ = v;
+		np += 3;
+	    } else {
+		*buf++ = *np++;
+	    }
+	}
+	*buf = '\0';
+	break;
+    }
+
+    if (!ip)
+	return;			/* No server */
+
+    buf++;			/* Point *past* the final NULL */
+    memcpy(buf, rrq_tail, sizeof rrq_tail);
+    buf += sizeof rrq_tail;
+
+    rrq_len = buf - rrq_packet_buf;
+
+    inode = allocate_socket(fs);
+    if (!inode)
+	return;			/* Allocation failure */
+    socket = PVT(inode);
+
+#if GPXE
+    if (path_type == PXE_URL) {
+	if (has_gpxe) {
+	    file_open.Status        = PXENV_STATUS_BAD_FUNC;
+	    file_open.FileName      = FAR_PTR(rrq_packet_buf + 2);
+	    err = pxe_call(PXENV_FILE_OPEN, &file_open);
+	    if (err)
+		goto done;
+	    
+	    socket->tftp_localport = -1;
+	    socket->tftp_remoteport = file_open.FileHandle;
+	    inode->size = -1;
+	    goto done;
+	} else {
+	    static bool already = false;
+	    if (!already) {
+		printf("URL syntax, but gPXE extensions not detected, "
+		       "trying plain TFTP...\n");
+		already = true;
+	    }
+	}
+    }
+#endif /* GPXE */
+
+    timeout_ptr = TimeoutTable;   /* Reset timeout */
+    
+sendreq:
+    timeout = *timeout_ptr++;
+    if (!timeout)
+	return;			/* No file available... */
+    oldtime = jiffies();
+
+    socket->tftp_remoteip = ip;
+    tid = socket->tftp_localport;   /* TID(local port No) */
+    udp_write.buffer    = FAR_PTR(rrq_packet_buf);
+    udp_write.ip        = ip;
+    udp_write.gw        = gateway(udp_write.ip);
+    udp_write.src_port  = tid;
+    udp_write.dst_port  = server_port;
+    udp_write.buffer_size = rrq_len;
+    pxe_call(PXENV_UDP_WRITE, &udp_write);
+
+    /* If the WRITE call fails, we let the timeout take care of it... */
+
+wait_pkt:
+    for (;;) {
+        buf                  = packet_buf;
+	udp_read.status      = 0;
+        udp_read.buffer      = FAR_PTR(buf);
+        udp_read.buffer_size = PKTBUF_SIZE;
+        udp_read.dest_ip     = IPInfo.myip;
+        udp_read.d_port      = tid;
+        err = pxe_call(PXENV_UDP_READ, &udp_read);
+        if (err || udp_read.status) {
+	    uint32_t now = jiffies();
+	    if (now - oldtime >= timeout)
+		goto sendreq;
+        } else {
+	    /* Make sure the packet actually came from the server */
+	    if (udp_read.src_ip == socket->tftp_remoteip)
+		break;
+	}
+    }
+
+    socket->tftp_remoteport = udp_read.s_port;
+
+    /* filesize <- -1 == unknown */
+    inode->size = -1;
+    /* Default blksize unless blksize option negotiated */
+    socket->tftp_blksize = TFTP_BLOCKSIZE;
+    buffersize = udp_read.buffer_size - 2;  /* bytes after opcode */
+    if (buffersize < 0)
+        goto wait_pkt;                     /* Garbled reply */
+
+    /*
+     * Get the opcode type, and parse it
+     */
+    opcode = *(uint16_t *)packet_buf;
+    switch (opcode) {
+    case TFTP_ERROR:
+        inode->size = 0;
+        break;			/* ERROR reply; don't try again */
+
+    case TFTP_DATA:
+        /*
+         * If the server doesn't support any options, we'll get a
+         * DATA reply instead of OACK. Stash the data in the file
+         * buffer and go with the default value for all options...
+         *
+         * We got a DATA packet, meaning no options are
+         * suported. Save the data away and consider the
+         * length undefined, *unless* this is the only
+         * data packet...
+         */
+        buffersize -= 2;
+        if (buffersize < 0)
+            goto wait_pkt;
+        data = packet_buf + 2;
+        blk_num = *(uint16_t *)data;
+        data += 2;
+        if (blk_num != htons(1))
+            goto wait_pkt;
+        socket->tftp_lastpkt = blk_num;
+        if (buffersize > TFTP_BLOCKSIZE)
+            goto err_reply;  /* Corrupt */
+        else if (buffersize < TFTP_BLOCKSIZE) {
+            /*
+             * This is the final EOF packet, already...
+             * We know the filesize, but we also want to
+             * ack the packet and set the EOF flag.
+             */
+            inode->size = buffersize;
+            socket->tftp_goteof = 1;
+            ack_packet(inode, blk_num);
+        }
+
+        socket->tftp_bytesleft = buffersize;
+        socket->tftp_dataptr = socket->tftp_pktbuf;
+        memcpy(socket->tftp_pktbuf, data, buffersize);
+	break;
+
+    case TFTP_OACK:
+        /*
+         * Now we need to parse the OACK packet to get the transfer
+         * and packet sizes.
+         */
+
+        options = packet_buf + 2;
+	p = options;
+
+	while (buffersize) {
+	    const char *opt = p;
+
+	    /*
+	     * If we find an option which starts with a NUL byte,
+	     * (a null option), we're either seeing garbage that some
+	     * TFTP servers add to the end of the packet, or we have
+	     * no clue how to parse the rest of the packet (what is
+	     * an option name and what is a value?)  In either case,
+	     * discard the rest.
+	     */
+	    if (!*opt)
+		goto done;
+
+            while (buffersize) {
+                if (!*p)
+                    break;	/* Found a final null */
+                *p++ |= 0x20;
+		buffersize--;
+            }
+	    if (!buffersize)
+		break;		/* Unterminated option */
+
+	    /* Consume the terminal null */
+	    p++;
+	    buffersize--;
+
+	    if (!buffersize)
+		break;		/* No option data */
+
+            /*
+             * Parse option pointed to by options; guaranteed to be
+	     * null-terminated
+             */
+            tftp_opt = tftp_options;
+            for (i = 0; i < tftp_nopts; i++) {
+                if (!strcmp(opt, tftp_opt->str_ptr))
+                    break;
+                tftp_opt++;
+            }
+            if (i == tftp_nopts)
+                goto err_reply; /* Non-negotitated option returned,
+				   no idea what it means ...*/
+
+            /* get the address of the filed that we want to write on */
+            opdata_ptr = (uint32_t *)((char *)inode + tftp_opt->offset);
+	    opdata = 0;
+
+            /* do convert a number-string to decimal number, just like atoi */
+            while (buffersize--) {
+		uint8_t d = *p++;
+                if (d == '\0')
+                    break;              /* found a final null */
+		d -= '0';
+                if (d > 9)
+                    goto err_reply;     /* Not a decimal digit */
+                opdata = opdata*10 + d;
+            }
+	    *opdata_ptr = opdata;
+	}
+	break;
+
+    default:
+	printf("TFTP unknown opcode %d\n", ntohs(opcode));
+	goto err_reply;
+    }
+
+done:
+    if (!inode->size) {
+        free_socket(inode);
+	return;
+    }
+    file->inode = inode;
+    return;
+
+err_reply:
+    /* Build the TFTP error packet */
+    tftp_error(inode, TFTP_EOPTNEG, "TFTP protocol error");
+    printf("TFTP server sent an incomprehesible reply\n");
+    kaboom();
+}
+
+
+/*
+ * Store standard filename prefix
+ */
+static void get_prefix(void)
+{
+    int len;
+    char *p;
+    char c;
+
+    if (!(DHCPMagic & 0x04)) {
+	/* No path prefix option, derive from boot file */
+
+	strlcpy(path_prefix, boot_file, sizeof path_prefix);
+	len = strlen(path_prefix);
+	p = &path_prefix[len - 1];
+	
+	while (len--) {
+	    c = *p--;
+	    c |= 0x20;
+	    
+	    c = (c >= '0' && c <= '9') ||
+		(c >= 'a' && c <= 'z') ||
+		(c == '.' || c == '-');
+	    if (!c)
+		break;
+	};
+	
+	if (len < 0)
+	    p --;
+	
+	*(p + 2) = 0;                /* Zero-terminate after delimiter */
+    }
+
+    printf("TFTP prefix: %s\n", path_prefix);
+    chdir(path_prefix);
+}
+
+/*
+ * realpath for PXE
+ */
+static size_t pxe_realpath(struct fs_info *fs, char *dst, const char *src,
+			   size_t bufsize)
+{
+    enum pxe_path_type path_type = pxe_path_type(src);
+
+    return snprintf(dst, bufsize, "%s%s",
+		    path_type == PXE_RELATIVE ? fs->cwd_name : "", src);
+}
+
+/*
+ * chdir for PXE
+ */
+static int pxe_chdir(struct fs_info *fs, const char *src)
+{
+    /* The cwd for PXE is just a text prefix */
+    enum pxe_path_type path_type = pxe_path_type(src);
+
+    if (path_type == PXE_RELATIVE)
+	strlcat(fs->cwd_name, src, sizeof fs->cwd_name);
+    else
+	strlcpy(fs->cwd_name, src, sizeof fs->cwd_name);
+
+    dprintf("cwd = \"%s\"\n", fs->cwd_name);
+    return 0;
+}
+
+ /*
+  * try to load a config file, if found, return 1, or return 0
+  *
+  */
+static int try_load(char *config_name)
+{
+    com32sys_t regs;
+
+    printf("Trying to load: %-50s  ", config_name);
+    pxe_mangle_name(KernelName, config_name);
+
+    memset(&regs, 0, sizeof regs);
+    regs.edi.w[0] = OFFS_WRT(KernelName, 0);
+    call16(core_open, &regs, &regs);
+    if (regs.eflags.l & EFLAGS_ZF) {
+	strcpy(ConfigName, KernelName);
+        printf("\r");
+        return 0;
+    } else {
+        printf("ok\n");
+        return 1;
+    }
+}
+
+
+/* Load the config file, return 1 if failed, or 0 */
+static int pxe_load_config(void)
+{
+    const char *cfgprefix = "pxelinux.cfg/";
+    const char *default_str = "default";
+    char *config_file;
+    char *last;
+    int tries = 8;
+
+    get_prefix();
+    if (DHCPMagic & 0x02) {
+        /* We got a DHCP option, try it first */
+	if (try_load(ConfigName))
+	    return 0;
+    }
+
+    /*
+     * Have to guess config file name ...
+     */
+    config_file = stpcpy(ConfigName, cfgprefix);
+
+    /* Try loading by UUID */
+    if (have_uuid) {
+	strcpy(config_file, UUID_str);
+	if (try_load(ConfigName))
+            return 0;
+    }
+
+    /* Try loading by MAC address */
+    strcpy(config_file, MAC_str);
+    if (try_load(ConfigName))
+        return 0;
+
+    /* Nope, try hexadecimal IP prefixes... */
+    uchexbytes(config_file, (uint8_t *)&IPInfo.myip, 4);
+    last = &config_file[8];
+    while (tries) {
+        *last = '\0';        /* Zero-terminate string */
+	if (try_load(ConfigName))
+            return 0;
+        last--;           /* Drop one character */
+        tries--;
+    };
+
+    /* Final attempt: "default" string */
+    strcpy(config_file, default_str);
+    if (try_load(ConfigName))
+        return 0;
+
+    printf("%-68s\n", "Unable to locate configuration file");
+    kaboom();
+}
+
+/*
+ * Generate the bootif string.
+ */
+static void make_bootif_string(void)
+{
+    const uint8_t *src;
+    char *dst = BOOTIFStr;
+    int i;
+
+    dst += sprintf(dst, "BOOTIF=%02x", MAC_type);
+    src = MAC;
+    for (i = MAC_len; i; i--)
+	dst += sprintf(dst, "-%02x", *src++);
+}
+/*
+ * Generate the SYSUUID string, if we have one...
+ */
+static void make_sysuuid_string(void)
+{
+    static const uint8_t uuid_dashes[] = {4, 2, 2, 2, 6, 0};
+    const uint8_t *src = uuid;
+    const uint8_t *uuid_ptr = uuid_dashes;
+    char *dst;
+
+    SYSUUIDStr[0] = '\0';	/* If nothing there... */
+
+    /* Try loading by UUID */
+    if (have_uuid) {
+	dst = stpcpy(SYSUUIDStr, "SYSUUID=");
+
+        while (*uuid_ptr) {
+	    int len = *uuid_ptr;
+
+            lchexbytes(dst, src, len);
+            dst += len * 2;
+            src += len;
+            uuid_ptr++;
+            *dst++ = '-';
+        }
+        /* Remove last dash and zero-terminate */
+	*--dst = '\0';
+    }
+}
+
+/*
+ * Generate an ip=<client-ip>:<boot-server-ip>:<gw-ip>:<netmask>
+ * option into IPOption based on a DHCP packet in trackbuf.
+ *
+ */
+char __bss16 IPOption[3+4*16];
+
+static void genipopt(void)
+{
+    char *p = IPOption;
+    const uint32_t *v = &IPInfo.myip;
+    int i;
+
+    p = stpcpy(p, "ip=");
+
+    for (i = 0; i < 4; i++) {
+	p += gendotquad(p, *v++);
+	*p++ = ':';
+    }
+    *--p = '\0';
+}
+
+
+/* Generate ip= option and print the ip adress */
+static void ip_init(void)
+{
+    uint32_t ip = IPInfo.myip;
+
+    genipopt();
+    gendotquad(dot_quad_buf, ip);
+
+    ip = ntohl(ip);
+    printf("My IP address seems to be %08X %s\n", ip, dot_quad_buf);
+}
+
+/*
+ * Print the IPAPPEND strings, in order
+ */
+extern const uint16_t IPAppends[];
+extern const char numIPAppends[];
+
+static void print_ipappend(void)
+{
+    size_t i;
+
+    for (i = 0; i < (size_t)numIPAppends; i++) {
+	const char *p = (const char *)(size_t)IPAppends[i];
+	if (*p)
+	    printf("%s\n", p);
+    }
+}
+
+/*
+ * Validity check on possible !PXE structure in buf
+ * return 1 for success, 0 for failure.
+ *
+ */
+static int is_pxe(const void *buf)
+{
+    const struct pxe_t *pxe = buf;
+    const uint8_t *p = buf;
+    int i = pxe->structlength;
+    uint8_t sum = 0;
+
+    if (i < sizeof(struct pxe_t) ||
+	memcmp(pxe->signature, "!PXE", 4))
+        return 0;
+
+    while (i--)
+        sum += *p++;
+
+    return sum == 0;
+}
+
+/*
+ * Just like is_pxe, it checks PXENV+ structure
+ *
+ */
+static int is_pxenv(const void *buf)
+{
+    const struct pxenv_t *pxenv = buf;
+    const uint8_t *p = buf;
+    int i = pxenv->length;
+    uint8_t sum = 0;
+
+    /* The pxeptr field isn't present in old versions */
+    if (i < offsetof(struct pxenv_t, pxeptr) ||
+	memcmp(pxenv->signature, "PXENV+", 6))
+        return 0;
+
+    while (i--)
+        sum += *p++;
+
+    return sum == 0;
+}
+
+
+
+/*
+ * memory_scan_for_pxe_struct:
+ * memory_scan_for_pxenv_struct:
+ *
+ *	If none of the standard methods find the !PXE/PXENV+ structure,
+ *	look for it by scanning memory.
+ *
+ *	return the corresponding pxe structure if found, or NULL;
+ */
+static const void *memory_scan(uintptr_t start, int (*func)(const void *))
+{
+    const char *ptr;
+
+    /* Scan each 16 bytes of conventional memory before the VGA region */
+    for (ptr = (const char *)start; ptr < (const char *)0xA0000; ptr += 16) {
+        if (func(ptr))
+            return ptr;		/* found it! */
+	ptr += 16;
+    }
+    return NULL;
+}
+
+static const struct pxe_t *memory_scan_for_pxe_struct(void)
+{
+    extern uint16_t BIOS_fbm;  /* Starting segment */
+
+    return memory_scan(BIOS_fbm << 10, is_pxe);
+}
+
+static const struct pxenv_t *memory_scan_for_pxenv_struct(void)
+{
+    return memory_scan(0x10000, is_pxenv);
+}
+
+/*
+ * Find the !PXE structure; we search for the following, in order:
+ *
+ * a. !PXE structure as SS:[SP + 4]
+ * b. PXENV+ structure at [ES:BX]
+ * c. INT 1Ah AX=0x5650 -> PXENV+
+ * d. Search memory for !PXE
+ * e. Search memory for PXENV+
+ *
+ * If we find a PXENV+ structure, we try to find a !PXE structure from
+ * if if the API version is 2.1 or later
+ *
+ */
+static int pxe_init(bool quiet)
+{
+    extern void pxe_int1a(void);
+    char plan = 'A';
+    uint16_t seg, off;
+    uint16_t code_seg, code_len;
+    uint16_t data_seg, data_len;
+    const char *base = GET_PTR(InitStack);
+    com32sys_t regs;
+    const char *type;
+    const struct pxenv_t *pxenv;
+    const struct pxe_t *pxe;
+
+    /* Assume API version 2.1 */
+    APIVer = 0x201;
+
+    /* Plan A: !PXE structure as SS:[SP + 4] */
+    off = *(const uint16_t *)(base + 48);
+    seg = *(const uint16_t *)(base + 50);
+    pxe = MK_PTR(seg, off);
+    if (is_pxe(pxe))
+        goto have_pxe;
+
+    /* Plan B: PXENV+ structure at [ES:BX] */
+    plan++;
+    off = *(const uint16_t *)(base + 24);  /* Original BX */
+    seg = *(const uint16_t *)(base + 4);   /* Original ES */
+    pxenv = MK_PTR(seg, off);
+    if (is_pxenv(pxenv))
+        goto have_pxenv;
+
+    /* Plan C: PXENV+ structure via INT 1Ah AX=5650h  */
+    plan++;
+    memset(&regs, 0, sizeof regs);
+    regs.eax.w[0] = 0x5650;
+    call16(pxe_int1a, &regs, &regs);
+    if (!(regs.eflags.l & EFLAGS_CF) && (regs.eax.w[0] == 0x564e)) {
+	pxenv = MK_PTR(regs.es, regs.ebx.w[0]);
+        if (is_pxenv(pxenv))
+            goto have_pxenv;
+    }
+
+    /* Plan D: !PXE memory scan */
+    plan++;
+    if ((pxe = memory_scan_for_pxe_struct()))
+        goto have_pxe;
+
+    /* Plan E: PXENV+ memory scan */
+    plan++;
+    if ((pxenv = memory_scan_for_pxenv_struct()))
+        goto have_pxenv;
+
+    /* Found nothing at all !! */
+    if (!quiet)
+	printf("No !PXE or PXENV+ API found; we're dead...\n");
+    return -1;
+
+ have_pxenv:
+    APIVer = pxenv->version;
+    if (!quiet)
+	printf("Found PXENV+ structure\nPXE API version is %04x\n", APIVer);
+
+    /* if the API version number is 0x0201 or higher, use the !PXE structure */
+    if (APIVer >= 0x201) {
+	if (pxenv->length >= sizeof(struct pxenv_t)) {
+	    pxe = GET_PTR(pxenv->pxeptr);
+	    if (is_pxe(pxe))
+		goto have_pxe;
+	    /*
+	     * Nope, !PXE structure missing despite API 2.1+, or at least
+	     * the pointer is missing. Do a last-ditch attempt to find it
+	     */
+	    if ((pxe = memory_scan_for_pxe_struct()))
+		goto have_pxe;
+	}
+	APIVer = 0x200;		/* PXENV+ only, assume version 2.00 */
+    }
+
+    /* Otherwise, no dice, use PXENV+ structure */
+    data_len = pxenv->undidatasize;
+    data_seg = pxenv->undidataseg;
+    code_len = pxenv->undicodesize;
+    code_seg = pxenv->undicodeseg;
+    PXEEntry = pxenv->rmentry;
+    type = "PXENV+";
+    goto have_entrypoint;
+
+ have_pxe:
+    data_len = pxe->seg[PXE_Seg_UNDIData].size;
+    data_seg = pxe->seg[PXE_Seg_UNDIData].sel;
+    code_len = pxe->seg[PXE_Seg_UNDICode].size;
+    code_seg = pxe->seg[PXE_Seg_UNDICode].sel;
+    PXEEntry = pxe->entrypointsp;
+    type = "!PXE";
+
+ have_entrypoint:
+    if (!quiet) {
+	printf("%s entry point found (we hope) at %04X:%04X via plan %c\n",
+	       type, PXEEntry.seg, PXEEntry.offs, plan);
+	printf("UNDI code segment at %04X len %04X\n", code_seg, code_len);
+	printf("UNDI data segment at %04X len %04X\n", data_seg, data_len);
+    }
+
+    code_seg = code_seg + ((code_len + 15) >> 4);
+    data_seg = data_seg + ((data_len + 15) >> 4);
+
+    real_base_mem = max(code_seg, data_seg) >> 6; /* Convert to kilobytes */
+
+    return 0;
+}
+
+/*
+ * See if we have gPXE
+ */
+static void gpxe_init(void)
+{
+    int err;
+    static __lowmem struct s_PXENV_FILE_API_CHECK api_check;
+
+    if (APIVer >= 0x201) {
+	api_check.Size = sizeof api_check;
+	api_check.Magic = 0x91d447b2;
+	err = pxe_call(PXENV_FILE_API_CHECK, &api_check);
+	if (!err && api_check.Magic == 0xe9c17b20)
+	    gpxe_funcs = api_check.APIMask;
+    }
+
+    /* Necessary functions for us to use the gPXE file API */
+    has_gpxe = (~gpxe_funcs & 0x4b) == 0;
+}
+
+/*
+ * Initialize UDP stack
+ *
+ */
+static void udp_init(void)
+{
+    int err;
+    static __lowmem struct s_PXENV_UDP_OPEN udp_open;
+    udp_open.src_ip = IPInfo.myip;
+    err = pxe_call(PXENV_UDP_OPEN, &udp_open);
+    if (err || udp_open.status) {
+        printf("Failed to initialize UDP stack ");
+        printf("%d\n", udp_open.status);
+	kaboom();
+    }
+}
+
+
+/*
+ * Network-specific initialization
+ */
+static void network_init(void)
+{
+    struct bootp_t *bp = (struct bootp_t *)trackbuf;
+    int pkt_len;
+
+    *LocalDomain = 0;   /* No LocalDomain received */
+
+    /*
+     * Get the DHCP client identifiers (query info 1)
+     */
+    printf("Getting cached packet ");
+    pkt_len = pxe_get_cached_info(1);
+    parse_dhcp(pkt_len);
+    /*
+     * We don't use flags from the request packet, so
+     * this is a good time to initialize DHCPMagic...
+     * Initialize it to 1 meaning we will accept options found;
+     * in earlier versions of PXELINUX bit 0 was used to indicate
+     * we have found option 208 with the appropriate magic number;
+     * we no longer require that, but MAY want to re-introduce
+     * it in the future for vendor encapsulated options.
+     */
+    *(char *)&DHCPMagic = 1;
+
+    /*
+     * Get the BOOTP/DHCP packet that brought us file (and an IP
+     * address). This lives in the DHCPACK packet (query info 2)
+     */
+    pkt_len = pxe_get_cached_info(2);
+    parse_dhcp(pkt_len);
+    /*
+     * Save away MAC address (assume this is in query info 2. If this
+     * turns out to be problematic it might be better getting it from
+     * the query info 1 packet
+     */
+    MAC_len = bp->hardlen > 16 ? 0 : bp->hardlen;
+    MAC_type = bp->hardware;
+    memcpy(MAC, bp->macaddr, MAC_len);
+
+    /*
+     * Get the boot file and other info. This lives in the CACHED_REPLY
+     * packet (query info 3)
+     */
+    pkt_len = pxe_get_cached_info(3);
+    parse_dhcp(pkt_len);
+    printf("\n");
+
+    make_bootif_string();
+    make_sysuuid_string();
+    ip_init();
+    print_ipappend();
+
+    /*
+     * Check to see if we got any PXELINUX-specific DHCP options; in particular,
+     * if we didn't get the magic enable, do not recognize any other options.
+     */
+    if ((DHCPMagic & 1) == 0)
+        DHCPMagic = 0;
+
+    udp_init();
+}
+
+/*
+ * Initialize pxe fs
+ *
+ */
+static int pxe_fs_init(struct fs_info *fs)
+{
+    (void)fs;    /* drop the compile warning message */
+
+    /* This block size is actually arbitrary... */
+    fs->sector_shift = fs->block_shift = TFTP_BLOCKSIZE_LG2;
+    fs->sector_size  = fs->block_size  = 1 << TFTP_BLOCKSIZE_LG2;
+
+    /* This block size is actually arbitrary... */
+    fs->sector_shift = fs->block_shift = TFTP_BLOCKSIZE_LG2;
+    fs->sector_size  = fs->block_size  = 1 << TFTP_BLOCKSIZE_LG2;
+
+    /* Find the PXE stack */
+    if (pxe_init(false))
+	kaboom();
+
+    /* See if we also have a gPXE stack */
+    gpxe_init();
+
+    /* Network-specific initialization */
+    network_init();
+
+    /* Initialize network-card-specific idle handling */
+    pxe_idle_init();
+
+    /* Our name for the root */
+    strcpy(fs->cwd_name, "::");
+
+    return 0;
+}
+
+/*
+ * Look to see if we are on an EFI CSM system.  Some EFI
+ * CSM systems put the BEV stack in low memory, which means
+ * a return to the PXE stack will crash the system.  However,
+ * INT 18h works reliably, so in that case hack the stack and
+ * point the "return address" to an INT 18h instruction.
+ *
+ * Hack the stack instead of the much simpler "just invoke INT 18h
+ * if we want to reset", so that chainloading other NBPs will work.
+ *
+ * This manipulates the real-mode InitStack directly.  It relies on this
+ * *not* being a currently active stack, i.e. the former
+ * USE_PXE_PROVIDED_STACK no longer works.
+ */
+extern far_ptr_t InitStack;
+
+struct efi_struct {
+    uint32_t magic;
+    uint8_t  csum;
+    uint8_t  len;
+} __attribute__((packed));
+#define EFI_MAGIC (('$' << 24)+('E' << 16)+('F' << 8)+'I')
+
+static inline bool is_efi(const struct efi_struct *efi)
+{
+    /*
+     * We don't verify the checksum, because it seems some CSMs leave
+     * it at zero, sigh...
+     */
+    return (efi->magic == EFI_MAGIC) && (efi->len >= 83);
+}
+
+static void install_efi_csm_hack(void)
+{
+    static const uint8_t efi_csm_hack[] =
+    {
+	0xcd, 0x18,			/* int $0x18 */
+	0xea, 0xf0, 0xff, 0x00, 0xf0,	/* ljmpw $0xf000,$0xfff0 */
+	0xf4				/* hlt */
+    };
+    uint16_t *retcode;
+
+    retcode = GET_PTR(*(far_ptr_t *)((char *)GET_PTR(InitStack) + 44));
+
+    /* Don't do this if the return already points to int $0x18 */
+    if (*retcode != 0x18cd) {
+	uint32_t efi_ptr;
+	bool efi = false;
+
+	for (efi_ptr = 0xe0000 ; efi_ptr < 0x100000 ; efi_ptr += 16) {
+	    if (is_efi((const struct efi_struct *)efi_ptr)) {
+		efi = true;
+		break;
+	    }
+	}
+
+	if (efi) {
+	    uint8_t *src = GET_PTR(InitStack);
+	    uint8_t *dst = src - sizeof efi_csm_hack;
+
+	    memmove(dst, src, 52);
+	    memcpy(dst+52, efi_csm_hack, sizeof efi_csm_hack);
+	    InitStack.offs -= sizeof efi_csm_hack;
+
+	    /* Clobber the return address */
+	    *(uint16_t *)(dst+44) = OFFS_WRT(dst+52, InitStack.seg);
+	    *(uint16_t *)(dst+46) = InitStack.seg;
+	}
+    }
+}
+
+int reset_pxe(void)
+{
+    static __lowmem struct s_PXENV_UDP_CLOSE udp_close;
+    extern void gpxe_unload(void);
+    int err = 0;
+
+    pxe_idle_cleanup();
+
+    pxe_call(PXENV_UDP_CLOSE, &udp_close);
+
+    if (gpxe_funcs & 0x80) {
+	/* gPXE special unload implemented */
+	call16(gpxe_unload, &zero_regs, NULL);
+
+	/* Locate the actual vendor stack... */
+	err = pxe_init(true);
+    }
+
+    install_efi_csm_hack();
+    return err;
+}
+
+/*
+ * This function unloads the PXE and UNDI stacks and
+ * unclaims the memory.
+ */
+void unload_pxe(void)
+{
+    /* PXE unload sequences */
+    static const uint8_t new_api_unload[] = {
+	PXENV_UNDI_SHUTDOWN, PXENV_UNLOAD_STACK, PXENV_STOP_UNDI, 0
+    };
+    static const uint8_t old_api_unload[] = {
+	PXENV_UNDI_SHUTDOWN, PXENV_UNLOAD_STACK, PXENV_UNDI_CLEANUP, 0
+    };
+
+    unsigned int api;
+    const uint8_t *api_ptr;
+    int err;
+    size_t int_addr;
+    static __lowmem union {
+	struct s_PXENV_UNDI_SHUTDOWN undi_shutdown;
+	struct s_PXENV_UNLOAD_STACK unload_stack;
+	struct s_PXENV_STOP_UNDI stop_undi;
+	struct s_PXENV_UNDI_CLEANUP undi_cleanup;
+	uint16_t Status;	/* All calls have this as the first member */
+    } unload_call;
+
+    dprintf("FBM before unload = %d\n", BIOS_fbm);
+
+    err = reset_pxe();
+
+    dprintf("FBM after reset_pxe = %d, err = %d\n", BIOS_fbm, err);
+
+    /* If we want to keep PXE around, we still need to reset it */
+    if (KeepPXE || err)
+	return;
+
+    dprintf("APIVer = %04x\n", APIVer);
+
+    api_ptr = APIVer >= 0x0200 ? new_api_unload : old_api_unload;
+    while((api = *api_ptr++)) {
+	dprintf("PXE call %04x\n", api);
+	memset(&unload_call, 0, sizeof unload_call);
+	err = pxe_call(api, &unload_call);
+	if (err || unload_call.Status != PXENV_STATUS_SUCCESS) {
+	    dprintf("PXE unload API call %04x failed\n", api);
+	    goto cant_free;
+	}
+    }
+
+    api = 0xff00;
+    if (real_base_mem <= BIOS_fbm) {  /* Sanity check */ 
+	dprintf("FBM %d < real_base_mem %d\n", BIOS_fbm, real_base_mem);
+	goto cant_free;
+    }
+    api++;
+
+    /* Check that PXE actually unhooked the INT 0x1A chain */
+    int_addr = (size_t)GET_PTR(*(far_ptr_t *)(4 * 0x1a));
+    int_addr >>= 10;
+    if (int_addr >= real_base_mem || int_addr < BIOS_fbm) {
+	BIOS_fbm = real_base_mem;
+	dprintf("FBM after unload_pxe = %d\n", BIOS_fbm);
+	return;
+    }
+
+    dprintf("Can't free FBM, real_base_mem = %d, "
+	    "FBM = %d, INT 1A = %08x (%d)\n",
+	    real_base_mem, BIOS_fbm,
+	    *(uint32_t *)(4 * 0x1a), int_addr);
+
+cant_free:
+    printf("Failed to free base memory error %04x-%08x (%d/%dK)\n",
+	   api, *(uint32_t *)(4 * 0x1a), BIOS_fbm, real_base_mem);
+    return;
+}
+
+const struct fs_ops pxe_fs_ops = {
+    .fs_name       = "pxe",
+    .fs_flags      = FS_NODEV,
+    .fs_init       = pxe_fs_init,
+    .searchdir     = pxe_searchdir,
+    .chdir         = pxe_chdir,
+    .realpath      = pxe_realpath,
+    .getfssec      = pxe_getfssec,
+    .close_file    = pxe_close_file,
+    .mangle_name   = pxe_mangle_name,
+    .load_config   = pxe_load_config,
+};
diff --git a/contrib/syslinux-4.02/core/fs/pxe/pxe.h b/contrib/syslinux-4.02/core/fs/pxe/pxe.h
new file mode 100644
index 0000000..1e6fa76
--- /dev/null
+++ b/contrib/syslinux-4.02/core/fs/pxe/pxe.h
@@ -0,0 +1,252 @@
+/* -----------------------------------------------------------------------
+ *
+ *   Copyright 1999-2008 H. Peter Anvin - All Rights Reserved
+ *   Copyright 2009-2010 Intel Corporation; author: H. Peter Anvin
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
+ *   Boston MA 02111-1307, USA; either version 2 of the License, or
+ *   (at your option) any later version; incorporated herein by reference.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * pxe.h
+ *
+ * PXE opcodes
+ *
+ */
+#ifndef PXE_H
+#define PXE_H
+
+#include <syslinux/pxe_api.h>
+#include "fs.h"			/* For MAX_OPEN, should go away */
+
+/*
+ * Some basic defines...
+ */
+#define TFTP_PORT        htons(69)              /* Default TFTP port */
+#define TFTP_BLOCKSIZE_LG2 9
+#define TFTP_BLOCKSIZE  (1 << TFTP_BLOCKSIZE_LG2)
+#define PKTBUF_SIZE     2048			/*  */
+
+#define is_digit(c)     (((c) >= '0') && ((c) <= '9'))
+
+static inline bool is_hex(char c)
+{
+    return (c >= '0' && c <= '9') ||
+	(c >= 'A' && c <= 'F') ||
+	(c >= 'a' && c <= 'f');
+}
+
+static inline int hexval(char c)
+{
+    return (c >= 'A') ? (c & ~0x20) - 'A' + 10 : (c - '0');
+}
+
+/*
+ * TFTP operation codes
+ */
+#define TFTP_RRQ	 htons(1)		// Read rest
+#define TFTP_WRQ	 htons(2)		// Write rest
+#define TFTP_DATA	 htons(3)		// Data packet
+#define TFTP_ACK	 htons(4)		// ACK packet
+#define TFTP_ERROR	 htons(5)		// ERROR packet
+#define TFTP_OACK	 htons(6)		// OACK packet
+
+/*
+ * TFTP error codes
+ */
+#define TFTP_EUNDEF	 htons(0)		// Unspecified error
+#define TFTP_ENOTFOUND	 htons(1)		// File not found
+#define TFTP_EACCESS	 htons(2)		// Access violation
+#define TFTP_ENOSPACE	 htons(3)		// Disk full
+#define TFTP_EBADOP	 htons(4)		// Invalid TFTP operation
+#define TFTP_EBADID	 htons(5)		// Unknown transfer
+#define TFTP_EEXISTS	 htons(6)		// File exists
+#define TFTP_ENOUSER	 htons(7)		// No such user
+#define TFTP_EOPTNEG	 htons(8)		// Option negotiation failure
+
+
+#define BOOTP_OPTION_MAGIC  htonl(0x63825363)
+#define MAC_MAX 32
+
+/* Defines for DNS */
+#define DNS_PORT	htons(53)		/* Default DNS port */
+#define DNS_MAX_PACKET	512			/* Defined by protocol */
+#define DNS_MAX_SERVERS 4			/* Max no of DNS servers */
+
+
+/*
+ * structures 
+ */
+
+struct pxenv_t {
+    uint8_t    signature[6];	/* PXENV+ */
+    uint16_t   version;
+    uint8_t    length;
+    uint8_t    checksum;
+    segoff16_t rmentry;
+    uint32_t   pmoffset;
+    uint16_t   pmselector;
+    uint16_t   stackseg;
+    uint16_t   stacksize;
+    uint16_t   bc_codeseg;
+    uint16_t   bc_codesize;
+    uint16_t   bc_dataseg;
+    uint16_t   bc_datasize;
+    uint16_t   undidataseg;
+    uint16_t   undidatasize;
+    uint16_t   undicodeseg;
+    uint16_t   undicodesize;
+    segoff16_t pxeptr;
+} __packed;
+
+struct pxe_t {
+    uint8_t    signature[4];	/* !PXE */
+    uint8_t    structlength;
+    uint8_t    structcksum;
+    uint8_t    structrev;
+    uint8_t    _pad1;
+    segoff16_t undiromid;
+    segoff16_t baseromid;
+    segoff16_t entrypointsp;
+    segoff16_t entrypointesp;
+    segoff16_t statuscallout;
+    uint8_t    _pad2;
+    uint8_t    segdesccnt;
+    uint16_t   firstselector;
+    pxe_segdesc_t  seg[7];
+} __packed;
+
+enum pxe_segments {
+    PXE_Seg_Stack         = 0,
+    PXE_Seg_UNDIData      = 1,
+    PXE_Seg_UNDICode      = 2,
+    PXE_Seg_UNDICodeWrite = 3,
+    PXE_Seg_BC_Data       = 4,
+    PXE_Seg_BC_Code       = 5,
+    PXE_Seg_BC_CodeWrite  = 6
+};
+
+struct bootp_t {
+    uint8_t  opcode;        /* BOOTP/DHCP "opcode" */
+    uint8_t  hardware;      /* ARP hreadware type */
+    uint8_t  hardlen;       /* Hardware address length */
+    uint8_t  gatehops;      /* Used by forwarders */
+    uint32_t ident;         /* Transaction ID */
+    uint16_t seconds;       /* Seconds elapsed */
+    uint16_t flags;         /* Broadcast flags */
+    uint32_t cip;           /* Cient IP */
+    uint32_t yip;           /* "Your" IP */
+    uint32_t sip;           /* Next Server IP */
+    uint32_t gip;           /* Relay agent IP */
+    uint8_t  macaddr[16];   /* Client MAC address */
+    uint8_t  sname[64];     /* Server name (optional) */
+    char     bootfile[128]; /* Boot file name */
+    uint32_t option_magic;  /* Vendor option magic cookie */
+    uint8_t  options[1260]; /* Vendor options */
+} __attribute__ ((packed));
+
+/*
+ * Our inode private information -- this includes the packet buffer!
+ */
+struct pxe_pvt_inode {
+    uint16_t tftp_localport;   /* Local port number  (0=not in us)*/
+    uint16_t tftp_remoteport;  /* Remote port number */
+    uint32_t tftp_remoteip;    /* Remote IP address */
+    uint32_t tftp_filepos;     /* bytes downloaded (includeing buffer) */
+    uint32_t tftp_blksize;     /* Block size for this connection(*) */
+    uint16_t tftp_bytesleft;   /* Unclaimed data bytes */
+    uint16_t tftp_lastpkt;     /* Sequence number of last packet (NBO) */
+    char    *tftp_dataptr;     /* Pointer to available data */
+    uint8_t  tftp_goteof;      /* 1 if the EOF packet received */
+    uint8_t  tftp_unused[3];   /* Currently unused */
+    char     tftp_pktbuf[PKTBUF_SIZE];
+} __attribute__ ((packed));
+
+#define PVT(i) ((struct pxe_pvt_inode *)((i)->pvt))
+
+/*
+ * Network boot information
+ */
+struct ip_info {
+    uint32_t ipv4;
+    uint32_t myip;
+    uint32_t serverip;
+    uint32_t gateway;
+    uint32_t netmask;
+};
+
+/*
+ * Variable externs
+ */
+extern struct ip_info IPInfo;
+
+extern uint8_t MAC[];
+extern char BOOTIFStr[];
+extern uint8_t MAC_len;
+extern uint8_t MAC_type;
+
+extern uint8_t  DHCPMagic;
+extern uint32_t RebootTime;
+
+extern char boot_file[];
+extern char path_prefix[];
+extern char LocalDomain[];
+
+extern char IPOption[];
+extern char dot_quad_buf[];
+
+extern uint32_t dns_server[];
+
+extern uint16_t APIVer;
+extern far_ptr_t PXEEntry;
+extern uint8_t KeepPXE;
+
+extern far_ptr_t InitStack;
+
+extern bool have_uuid;
+extern uint8_t uuid_type;
+extern uint8_t uuid[];
+
+extern uint16_t BIOS_fbm;
+extern const uint8_t TimeoutTable[];
+
+/*
+ * Compute the suitable gateway for a specific route -- too many
+ * vendor PXE stacks don't do this correctly...
+ */
+static inline uint32_t gateway(uint32_t ip)
+{
+    if ((ip ^ IPInfo.myip) & IPInfo.netmask)
+	return IPInfo.gateway;
+    else
+	return 0;
+}
+
+/*
+ * functions 
+ */
+
+/* pxe.c */
+bool ip_ok(uint32_t);
+int pxe_call(int, void *);
+
+/* dhcp_options.c */
+void parse_dhcp(int);
+
+/* dnsresolv.c */
+int dns_mangle(char **, const char *);
+uint32_t dns_resolv(const char *);
+
+/* idle.c */
+void pxe_idle_init(void);
+void pxe_idle_cleanup(void);
+
+/* socknum.c */
+uint16_t get_port(void);
+void free_port(uint16_t port);
+
+#endif /* pxe.h */
diff --git a/contrib/syslinux-4.02/core/fs/readdir.c b/contrib/syslinux-4.02/core/fs/readdir.c
new file mode 100644
index 0000000..d071aff
--- /dev/null
+++ b/contrib/syslinux-4.02/core/fs/readdir.c
@@ -0,0 +1,57 @@
+#include <stdio.h>
+#include <string.h>
+#include <sys/dirent.h>
+#include "fs.h"
+#include "core.h"
+
+/* 
+ * Open a directory
+ */
+DIR *opendir(const char *path)
+{
+    int rv;
+    struct file *file;
+
+    rv = searchdir(path);
+    if (rv < 0)
+	return NULL;
+
+    file = handle_to_file(rv);
+
+    if (file->inode->mode != DT_DIR) {
+	_close_file(file);
+	return NULL;
+    }
+
+    return (DIR *)file;
+}
+
+/*
+ * Read one directory entry at one time. 
+ */
+struct dirent *readdir(DIR *dir)
+{
+    static struct dirent buf;
+    struct file *dd_dir = (struct file *)dir;
+    int rv = -1;
+    
+    if (dd_dir) {
+        if (dd_dir->fs->fs_ops->readdir) {
+	    rv = dd_dir->fs->fs_ops->readdir(dd_dir, &buf);
+        }
+    }
+
+    return rv < 0 ? NULL : &buf;
+}
+
+/*
+ * Close a directory
+ */
+int closedir(DIR *dir)
+{
+    struct file *dd_dir = (struct file *)dir;
+    _close_file(dd_dir);
+    return 0;
+}
+
+
diff --git a/contrib/syslinux-4.02/core/genhash.pl b/contrib/syslinux-4.02/core/genhash.pl
new file mode 100755
index 0000000..c79139f
--- /dev/null
+++ b/contrib/syslinux-4.02/core/genhash.pl
@@ -0,0 +1,26 @@
+#!/usr/bin/perl
+#
+# Generate hash values for keywords
+#
+
+eval { use bytes; };
+
+while ( defined($keywd = <STDIN>) ) {
+    chomp $keywd;
+
+    ($keywd,$keywdname) = split(/\s+/, $keywd);
+    $keywdname = $keywd unless ( $keywdname );
+
+    $l = length($keywd);
+    $h = 0;
+    for ( $i = 0 ; $i < $l ; $i++ ) {
+	$c = ord(substr($keywd,$i,1)) | 0x20;
+	$h = ((($h << 5)|($h >> 27)) ^ $c) & 0xFFFFFFFF;
+    }
+    if ( $seenhash{$h} ) {
+	printf STDERR "$0: hash collision (0x%08x) %s %s\n",
+	$h, $keywd, $seenhash{$h};
+    }
+    $seenhash{$h} = $keywd;
+    printf("%-23s equ 0x%08x\n", "hash_${keywdname}", $h);
+}
diff --git a/contrib/syslinux-4.02/core/getc.inc b/contrib/syslinux-4.02/core/getc.inc
new file mode 100644
index 0000000..33656b4
--- /dev/null
+++ b/contrib/syslinux-4.02/core/getc.inc
@@ -0,0 +1,415 @@
+;; -----------------------------------------------------------------------
+;;
+;;   Copyright 1994-2009 H. Peter Anvin - All Rights Reserved
+;;   Copyright 2009 Intel Corporation; author: H. Peter Anvin
+;;
+;;   This program is free software; you can redistribute it and/or modify
+;;   it under the terms of the GNU General Public License as published by
+;;   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
+;;   Boston MA 02111-1307, USA; either version 2 of the License, or
+;;   (at your option) any later version; incorporated herein by reference.
+;;
+;; -----------------------------------------------------------------------
+
+;;
+;; getc.inc
+;;
+;; Simple file handling library (open, getc, ungetc)
+;;
+;; WARNING: This interface uses the real_mode_seg/comboot_seg.
+;;
+
+MAX_GETC_LG2	equ 4			; Max number of file nesting
+MAX_GETC	equ (1 << MAX_GETC_LG2)
+bytes_per_getc_lg2	equ 16-MAX_GETC_LG2
+bytes_per_getc		equ (1 << bytes_per_getc_lg2)
+MAX_UNGET	equ 9			; Max bytes that can be pushed back
+
+		struc getc_file
+gc_file		resw 1			; File pointer
+gc_bufbytes	resw 1			; Bytes left in buffer
+gc_bufdata	resw 1			; Pointer to data in buffer
+gc_unget_cnt	resb 1			; Character pushed back count
+gc_unget_buf	resb MAX_UNGET		; Character pushed back buffer
+		endstruc
+getc_file_lg2	equ 4			; Size of getc_file as a power of 2
+
+%ifndef DEPEND
+%if (getc_file_size != (1 << getc_file_lg2))
+%error "getc_file_size != (1 << getc_file_lg2)"
+%endif
+%endif
+
+;
+; open,getc:	Load a file a character at a time for parsing in a manner
+;		similar to the C library getc routine.
+;		Up to MAX_GETC files can be open at the same time,
+;		they are accessed in a stack-like fashion.
+;
+;		All routines assume CS == DS.
+;
+;		open:	Input:	mangled filename in DS:DI
+;			Output: ZF set on file not found or zero length
+;
+;		openfd:	Input:	file handle in SI, file size in EAX
+;			Output:	ZF set on getc stack overflow
+;
+;		getc:	Output: CF set on end of file
+;				Character loaded in AL
+;
+;		close:	Output:	CF set if nothing open
+;
+		global core_open
+core_open:
+		pm_call pm_searchdir
+		jz openfd.ret
+openfd:
+		push bx
+
+		mov bx,[CurrentGetC]
+		sub bx,getc_file_size
+		cmp bx,GetCStack
+		jb .stack_full		; Excessive nesting
+		mov [CurrentGetC],bx
+
+		mov [bx+gc_file],si	; File pointer
+		xor ax,ax
+		mov [bx+gc_bufbytes],ax		; Buffer empty
+		mov [bx+gc_unget_cnt],al	; ungetc buffer empty
+
+		inc ax			; ZF <- 0
+		pop bx
+.ret:		ret
+
+.stack_full:
+		pm_call pm_close_file
+		xor ax,ax		; ZF <- 1
+		pop bx
+		ret
+		
+getc:
+		push bx
+		push si
+		push di
+		push es
+
+		mov di,[CurrentGetC]
+		movzx bx,byte [di+gc_unget_cnt]
+		and bx,bx
+		jnz .have_unget
+
+		mov si,real_mode_seg	; Borrow the real_mode_seg
+		mov es,si
+
+.got_data:
+		sub word [di+gc_bufbytes],1
+		jc .get_data		; Was it zero already?
+		mov si,[di+gc_bufdata]
+		mov al,[es:si]
+		inc si
+		mov [di+gc_bufdata],si
+.done:
+		clc
+.ret:
+		pop es
+		pop di
+		pop si
+		pop bx
+		ret
+.have_unget:
+		dec bx
+		mov al,[di+bx+gc_unget_buf]
+		mov [di+gc_unget_cnt],bl
+		jmp .done
+
+.get_data:
+		pushad
+		; Compute start of buffer
+		mov bx,di
+		sub bx,GetCStack
+		shl bx,bytes_per_getc_lg2-getc_file_lg2
+
+		mov [di+gc_bufdata],bx
+		mov si,[di+gc_file]
+		and si,si
+		mov [di+gc_bufbytes],si	; In case SI == 0
+		jz .empty
+		mov cx,bytes_per_getc
+		pm_call getfsbytes
+		mov [di+gc_bufbytes],cx
+		mov [di+gc_file],si
+		jcxz .empty
+		popad
+		TRACER 'd'
+		jmp .got_data
+
+.empty:
+		TRACER 'e'
+		; [di+gc_bufbytes] is zero already, thus we will continue
+		; to get EOF on any further attempts to read the file.
+		popad
+		xor al,al		; Return a predictable zero
+		stc
+		jmp .ret
+
+;
+; This is similar to getc, except that we read up to CX bytes and
+; store them in ES:DI.  Eventually this could get optimized...
+;
+; On return, CX and DI are adjusted by the number of bytes actually read.
+;
+readc:
+		push ax
+.loop:
+		call getc
+		jc .out
+		stosb
+		loop .loop
+.out:
+		pop ax
+		ret
+
+;
+; close: close the top of the getc stack
+;
+close:
+		push bx
+		push si
+		mov bx,[CurrentGetC]
+		mov si,[bx+gc_file]
+		pm_call pm_close_file
+		add bx,getc_file_size
+		mov [CurrentGetC],bx
+		pop si
+		pop bx
+		ret
+
+;
+; ungetc:	Push a character (in AL) back into the getc buffer
+;		Note: if more than MAX_UNGET bytes are pushed back, all
+;		hell will break loose.
+;
+ungetc:
+		push di
+		push bx
+		mov di,[CurrentGetC]
+		movzx bx,[di+gc_unget_cnt]
+		mov [bx+di+gc_unget_buf],al
+		inc bx
+		mov [di+gc_unget_cnt],bl
+		pop bx
+		pop di
+		ret
+
+;
+; skipspace:	Skip leading whitespace using "getc".  If we hit end-of-line
+;		or end-of-file, return with carry set; ZF = true of EOF
+;		ZF = false for EOLN; otherwise CF = ZF = 0.
+;
+;		Otherwise AL = first character after whitespace
+;
+skipspace:
+.loop:		call getc
+		jc .eof
+		cmp al,1Ah			; DOS EOF
+		je .eof
+		cmp al,0Ah
+		je .eoln
+		cmp al,' '
+		jbe .loop
+		ret				; CF = ZF = 0
+.eof:		cmp al,al			; Set ZF
+		stc				; Set CF
+		ret
+.eoln:		add al,0FFh			; Set CF, clear ZF
+		ret
+
+;
+; getint:	Load an integer from the getc file.
+;		Return CF if error; otherwise return integer in EBX
+;
+getint:
+		mov di,NumBuf
+.getnum:	cmp di,NumBufEnd	; Last byte in NumBuf
+		jae .loaded
+		push di
+		call getc
+		pop di
+		jc .loaded
+		stosb
+		cmp al,'-'
+		jnb .getnum
+		call ungetc		; Unget non-numeric
+.loaded:	mov byte [di],0
+		mov si,NumBuf
+		; Fall through to parseint
+;
+; parseint:	Convert an integer to a number in EBX
+;		Get characters from string in DS:SI
+;		Return CF on error
+;		DS:SI points to first character after number
+;
+;               Syntaxes accepted: [-]dec, [-]0+oct, [-]0x+hex, val+[KMG]
+;
+parseint:
+                push eax
+                push ecx
+		push bp
+		xor eax,eax		; Current digit (keep eax == al)
+		mov ebx,eax		; Accumulator
+		mov ecx,ebx		; Base
+                xor bp,bp               ; Used for negative flag
+.begin:		lodsb
+		cmp al,'-'
+		jne .not_minus
+		xor bp,1		; Set unary minus flag
+		jmp short .begin
+.not_minus:
+		cmp al,'0'
+		jb .err
+		je .octhex
+		cmp al,'9'
+		ja .err
+		mov cl,10		; Base = decimal
+		jmp short .foundbase
+.octhex:
+		lodsb
+		cmp al,'0'
+		jb .km		; Value is zero
+		or al,20h		; Downcase
+		cmp al,'x'
+		je .ishex
+		cmp al,'7'
+		ja .err
+		mov cl,8		; Base = octal
+		jmp short .foundbase
+.ishex:
+		mov al,'0'		; No numeric value accrued yet
+		mov cl,16		; Base = hex
+.foundbase:
+                call unhexchar
+                jc .km                ; Not a (hex) digit
+                cmp al,cl
+		jae .km			; Invalid for base
+		imul ebx,ecx		; Multiply accumulated by base
+                add ebx,eax             ; Add current digit
+		lodsb
+		jmp short .foundbase
+.km:
+		dec si			; Back up to last non-numeric
+		lodsb
+		or al,20h
+		cmp al,'k'
+		je .isk
+		cmp al,'m'
+		je .ism
+		cmp al,'g'
+		je .isg
+		dec si			; Back up
+.fini:		and bp,bp
+		jz .ret		; CF=0!
+		neg ebx			; Value was negative
+.done:		clc
+.ret:		pop bp
+                pop ecx
+                pop eax
+		ret
+.err:		stc
+		jmp short .ret
+.isg:		shl ebx,10		; * 2^30
+.ism:		shl ebx,10		; * 2^20
+.isk:		shl ebx,10		; * 2^10
+		jmp .fini
+
+		section .bss16
+		alignb 4
+NumBuf		resb 15			; Buffer to load number
+NumBufEnd	resb 1			; Last byte in NumBuf
+
+GetCStack	resb getc_file_size*MAX_GETC
+.end		equ $
+
+		section .data16
+CurrentGetC	dw GetCStack.end	; GetCStack empty
+
+;
+; unhexchar:    Convert a hexadecimal digit in AL to the equivalent number;
+;               return CF=1 if not a hex digit
+;
+		section .text16
+unhexchar:
+                cmp al,'0'
+		jb .ret			; If failure, CF == 1 already
+                cmp al,'9'
+                ja .notdigit
+		sub al,'0'		; CF <- 0
+		ret
+.notdigit:	or al,20h		; upper case -> lower case
+		cmp al,'a'
+                jb .ret			; If failure, CF == 1 already
+                cmp al,'f'
+                ja .err
+                sub al,'a'-10           ; CF <- 0
+                ret
+.err:		stc
+.ret:		ret
+
+;
+;
+; getline:	Get a command line, converting control characters to spaces
+;               and collapsing streches to one; a space is appended to the
+;               end of the string, unless the line is empty.
+;		The line is terminated by ^J, ^Z or EOF and is written
+;		to ES:DI.  On return, DI points to first char after string.
+;		CF is set if we hit EOF.
+;
+getline:
+		call skipspace
+                mov dl,1                ; Empty line -> empty string.
+                jz .eof               ; eof
+                jc .eoln              ; eoln
+		call ungetc
+.fillloop:	push dx
+		push di
+		call getc
+		pop di
+		pop dx
+		jc .ret		; CF set!
+		cmp al,' '
+		jna .ctrl
+		xor dx,dx
+.store:		stosb
+		jmp short .fillloop
+.ctrl:		cmp al,10
+		je .ret		; CF clear!
+		cmp al,26
+		je .eof
+		and dl,dl
+		jnz .fillloop		; Ignore multiple spaces
+		mov al,' '		; Ctrl -> space
+		inc dx
+		jmp short .store
+.eoln:		clc                     ; End of line is not end of file
+                jmp short .ret
+.eof:		stc
+.ret:		pushf			; We want the last char to be space!
+		and dl,dl
+		jnz .xret
+		mov al,' '
+		stosb
+.xret:		popf
+		ret
+
+;
+; parseint_esdi:
+;		Same as parseint, but takes the input in ES:DI
+;
+parseint_esdi:
+		push ds
+		push es
+		pop ds
+		xchg si,di
+		call parseint
+		xchg si,di
+		pop ds
+		ret
diff --git a/contrib/syslinux-4.02/core/graphics.inc b/contrib/syslinux-4.02/core/graphics.inc
new file mode 100644
index 0000000..a8d2851
--- /dev/null
+++ b/contrib/syslinux-4.02/core/graphics.inc
@@ -0,0 +1,353 @@
+;; -----------------------------------------------------------------------
+;;
+;;   Copyright 1994-2008 H. Peter Anvin - All Rights Reserved
+;;
+;;   This program is free software; you can redistribute it and/or modify
+;;   it under the terms of the GNU General Public License as published by
+;;   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
+;;   Boston MA 02111-1307, USA; either version 2 of the License, or
+;;   (at your option) any later version; incorporated herein by reference.
+;;
+;; -----------------------------------------------------------------------
+
+; ----------------------------------------------------------------------------
+;  VGA splash screen code
+; ----------------------------------------------------------------------------
+
+;
+; vgadisplayfile:
+;	Display a graphical splash screen.
+;	The file is already opened on the top of the getc stack.
+;
+;	Assumes CS == DS == ES.
+;
+		section .text16
+
+vgadisplayfile:
+		; This is a cheap and easy way to make sure the screen is
+		; cleared in case we were in graphics mode already
+		call vgaclearmode
+		call vgasetmode
+		jnz .error_nz
+
+.graphalready:
+		; Load the header.
+		mov cx,4+2*2+16*3
+		mov di,LSSHeader
+.gethdr:
+		call getc
+		stosb
+		loop .gethdr
+		jc .error
+
+		; The header WILL be in the first chunk.
+		cmp dword [LSSMagic],0x1413f33d	; Magic number
+.error_nz:	jne .error
+
+		mov dx,GraphColorMap		; Color map offset
+		mov ax,1012h			; Set RGB registers
+		xor bx,bx			; First register number
+		mov cx,16			; 16 registers
+		int 10h
+
+.movecursor:
+		mov ax,[GraphYSize]		; Number of pixel rows
+		mov dx,[VGAFontSize]
+		add ax,dx
+		dec ax
+		div dl
+		xor dx,dx			; Set column to 0
+		cmp al,[VidRows]
+		jb .rowsok
+		mov al,[VidRows]
+		dec al
+.rowsok:
+		mov dh,al
+		mov ah,2
+		xor bx,bx
+		int 10h				; Set cursor below image
+
+		mov cx,[GraphYSize]		; Number of graphics rows
+		mov word [VGAPos],0
+
+.drawpixelrow:
+		push cx
+		mov di,VGARowBuffer
+		; Pre-clear the row buffer
+		push di
+		push di
+		mov cx,640/4
+		xor eax,eax
+		rep stosd
+		pop di
+		mov cx,[GraphXSize]
+		call rledecode			; Decode one row
+		pop si
+		mov di,VGAPlaneBuffer
+		push di
+		mov bp,640
+		call packedpixel2vga
+		pop si
+		push es
+		mov di,0A000h			; VGA segment
+		mov es,di
+		mov di,[VGAPos]
+		call outputvga
+		pop es
+		add word [VGAPos],640/8
+		pop cx
+		loop .drawpixelrow
+
+.error:
+		jmp close			; Tailcall!
+
+;
+; rledecode:
+;	Decode a pixel row in RLE16 format.
+;
+; getc stack	-> input
+; CX		-> pixel count
+; ES:DI		-> output (packed pixel)
+;
+rledecode:
+		xor dx,dx		; DL = last pixel, DH = nybble buffer
+.loop:
+		call .getnybble
+		cmp al,dl
+		je .run			; Start of run sequence
+		stosb
+		mov dl,al
+		dec cx
+		jnz .loop
+.done:
+		ret
+.run:
+		xor bx,bx
+		call .getnybble
+		or bl,al
+		jz .longrun
+.dorun:
+		push cx
+		mov cx,bx
+		mov al,dl
+		rep stosb
+		pop cx
+		sub cx,bx
+		ja .loop
+		jmp short .done
+.longrun:
+		call .getnybble
+		mov bl,al
+		call .getnybble
+		shl al,4
+		or bl,al
+		add bx,16
+		jmp short .dorun
+
+.getnybble:
+		test dh,10h
+		jz .low
+		and dh,0Fh
+		mov al,dh
+		ret
+.low:
+		call getc
+		mov dh,al
+		shr dh,4
+		or dh,10h		; Nybble already read
+		and al,0Fh
+		ret
+
+;
+; packedpixel2vga:
+;	Convert packed-pixel to VGA bitplanes
+;
+; DS:SI -> packed pixel string
+; BP    -> pixel count (multiple of 8)
+; DS:DI -> output (four planes)
+;
+packedpixel2vga:
+		xor cx,cx
+.planeloop:
+		inc cx
+		push si
+		push bp
+.loop1:
+		mov bx,8
+.loop2:
+		lodsb
+		shr al,cl
+		rcl dl,1		; VGA is bigendian.  Sigh.
+		dec bx
+		jnz .loop2
+		mov [di],dl
+		inc di
+		sub bp,byte 8
+		ja .loop1
+		pop bp
+		pop si
+		cmp cl,3
+		jbe .planeloop
+		ret
+
+;
+; outputvga:
+;	Output four subsequent lines of VGA data
+;
+; DS:SI	-> four planes @ 640/8=80 bytes
+; ES:DI	-> pointer into VGA memory
+;
+outputvga:
+		mov dx,3C4h	; VGA Sequencer Register select port
+		mov al,2	; Sequencer mask
+		out dx,al	; Select the sequencer mask
+		inc dx		; VGA Sequencer Register data port
+		dec ax		; AL <- 1
+.loop1:
+		out dx,al	; Select the bit plane to write
+		push di
+		mov cx,640/32
+		rep movsd
+		pop di
+		add ax,ax
+		cmp al,8
+		jbe .loop1
+		ret
+
+;
+; vgasetmode:
+;	Enable VGA graphics, if possible; return ZF=1 on success
+;	DS must be set to the base segment; ES is set to DS.
+;
+vgasetmode:
+		push ds
+		pop es
+		mov al,[UsingVGA]
+		cmp al,01h
+		je .success		; Nothing to do...
+		test al,04h
+		jz .notvesa
+		; We're in a VESA mode, which means VGA; use VESA call
+		; to revert the mode, and then call the conventional
+		; mode-setting for good measure...
+		mov ax,4F02h
+		mov bx,0012h
+		int 10h
+		jmp .setmode
+.notvesa:
+		mov ax,1A00h		; Get video card and monitor
+		xor bx,bx
+		int 10h
+		sub bl, 7		; BL=07h and BL=08h OK
+		cmp bl, 1
+		ja .error		; ZF=0
+;		mov bx,TextColorReg
+;		mov dx,1009h		; Read color registers
+;		int 10h
+.setmode:
+		mov ax,0012h		; Set mode = 640x480 VGA 16 colors
+		int 10h
+		mov dx,linear_color
+		mov ax,1002h		; Write color registers
+		int 10h
+		mov [UsingVGA], byte 1
+
+		; Set GXPixCols and GXPixRows
+		mov dword [GXPixCols],640+(480 << 16)
+
+		call use_font		; Set graphics font/data
+		mov byte [ScrollAttribute], 00h
+
+.success:
+		xor ax,ax		; Set ZF
+.error:
+		ret
+
+;
+; vgaclearmode:
+;	Disable VGA graphics.  It is not safe to assume any value
+;	for DS or ES.
+;
+vgaclearmode:
+		push ds
+		push es
+		pushad
+		mov ax,cs
+		mov ds,ax
+		mov es,ax
+		mov al,[UsingVGA]
+		and al,al		; Already in text mode?
+		jz .done
+		test al,04h
+		jz .notvesa
+		mov ax,4F02h		; VESA return to normal video mode
+		mov bx,0003h
+		int 10h
+.notvesa:
+		mov ax,0003h		; Return to normal video mode
+		int 10h
+;		mov dx,TextColorReg	; Restore color registers
+;		mov ax,1002h
+;		int 10h
+		mov [UsingVGA], byte 0
+
+		mov byte [ScrollAttribute], 07h
+		call use_font		; Restore text font/data
+.done:
+		popad
+		pop es
+		pop ds
+		ret
+
+;
+; vgashowcursor/vgahidecursor:
+;	If VGA graphics is enabled, draw a cursor/clear a cursor
+;
+vgashowcursor:
+		pushad
+		mov al,'_'
+		jmp short vgacursorcommon
+vgahidecursor:
+		pushad
+		mov al,' '
+vgacursorcommon:
+		cmp [UsingVGA], byte 1
+		jne .done
+		mov ah,09h
+		mov bx,0007h
+		mov cx,1
+		int 10h
+.done:
+		popad
+		ret
+
+
+		section .data16
+		; Map colors to consecutive DAC registers
+linear_color	db 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0
+
+		; See comboot.doc, INT 22h AX=0017h for the semantics
+		; of this byte.
+UsingVGA	db 0
+
+		section .bss16
+		alignb 4
+LSSHeader	equ $
+LSSMagic	resd 1			; Magic number
+GraphXSize	resw 1			; Width of splash screen file
+GraphYSize	resw 1			; Height of splash screen file
+GraphColorMap	resb 3*16
+VGAPos		resw 1			; Pointer into VGA memory
+VGAFilePtr	resw 1			; Pointer into VGAFileBuf
+; TextColorReg	resb 17			; VGA color registers for text mode
+%if IS_SYSLINUX
+VGAFileBuf	resb FILENAME_MAX+2	; Unmangled VGA image name
+%else
+VGAFileBuf	resb FILENAME_MAX	; Unmangled VGA image name
+%endif
+VGAFileBufEnd	equ $
+VGAFileMBuf	resb FILENAME_MAX	; Mangled VGA image name
+
+		alignb 4
+VGARowBuffer	resb 640+80		; Decompression buffer
+VGAPlaneBuffer	resb (640/8)*4		; Plane buffers
diff --git a/contrib/syslinux-4.02/core/head.inc b/contrib/syslinux-4.02/core/head.inc
new file mode 100644
index 0000000..18ce132
--- /dev/null
+++ b/contrib/syslinux-4.02/core/head.inc
@@ -0,0 +1,38 @@
+; -*- fundamental -*- (asm-mode sucks)
+; -----------------------------------------------------------------------
+;
+;   Copyright 2006-2008 H. Peter Anvin - All Rights Reserved
+;
+;   This program is free software; you can redistribute it and/or modify
+;   it under the terms of the GNU General Public License as published by
+;   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
+;   Boston MA 02111-1307, USA; either version 2 of the License, or
+;   (at your option) any later version; incorporated herein by reference.
+;
+; -----------------------------------------------------------------------
+
+;
+; head.inc
+;
+; Common header includes
+;
+
+%ifndef _HEAD_INC
+%define _HEAD_INC
+
+%if __NASM_MAJOR__ < 2
+ %error "NASM 2.00 or later required to compile correctly"
+%endif
+
+%include "macros.inc"
+%include "config.inc"
+%include "layout.inc"
+%include "pmcall.inc"
+%include "extern.inc"
+%include "kernel.inc"
+%include "bios.inc"
+%include "tracers.inc"
+%include "stack.inc"
+%include "io.inc"
+
+%endif ; _HEAD_INC
diff --git a/contrib/syslinux-4.02/core/highmem.inc b/contrib/syslinux-4.02/core/highmem.inc
new file mode 100644
index 0000000..ea386ff
--- /dev/null
+++ b/contrib/syslinux-4.02/core/highmem.inc
@@ -0,0 +1,158 @@
+;; -----------------------------------------------------------------------
+;;
+;;   Copyright 1994-2008 H. Peter Anvin - All Rights Reserved
+;;
+;;   This program is free software; you can redistribute it and/or modify
+;;   it under the terms of the GNU General Public License as published by
+;;   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
+;;   Boston MA 02111-1307, USA; either version 2 of the License, or
+;;   (at your option) any later version; incorporated herein by reference.
+;;
+;; -----------------------------------------------------------------------
+
+;;
+;; highmem.inc
+;;
+;; Probe for the size of high memory.  This can be overridden by a
+;; mem= command on the command line while booting a new kernel.
+;;
+
+		section .text16
+
+;
+; This is set up as a subroutine; it will set up the global variable
+; HighMemSize.  All registers are preserved.
+;
+highmemsize:
+		push es
+		pushfd
+		pushad
+
+		push cs
+		pop es
+
+;
+; First, try INT 15:E820 (get BIOS memory map)
+;
+; Note: we may have to scan this multiple times, because some (daft) BIOSes
+; report main memory as multiple contiguous ranges...
+;
+get_e820:
+		mov dword [E820Max],-(1 << 20)	; Max amount of high memory
+		mov dword [E820Mem],(1 << 20)	; End of detected high memory
+.start_over:
+		mov di,E820Buf
+		xor ax,ax
+		mov cx,10
+		rep stosw			; Clear buffer
+		xor ebx,ebx			; Start with first record
+		jmp short .do_e820		; Skip "at end" check first time!
+.int_loop:	and ebx,ebx			; If we're back at beginning...
+		jz .e820_done			; ... we're done
+.do_e820:	mov eax,0000E820h
+		mov edx,534D4150h		; "SMAP" backwards
+		xor ecx,ecx
+		mov cl,20			; ECX <- 20 (size of buffer)
+		mov di,E820Buf
+		int 15h
+		jnc .no_carry
+		; If carry, ebx == 0 means error, ebx != 0 means we're done
+		and ebx,ebx
+		jnz .e820_done
+		jmp no_e820
+.no_carry:
+		cmp eax,534D4150h
+		jne no_e820
+		cmp cx,20
+		jb no_e820
+
+;
+; Look for a memory block starting at <= 1 MB and continuing upward
+;
+		cmp dword [E820Buf+4], byte 0
+		ja .int_loop			; Start >= 4 GB?
+		mov eax, [E820Buf]
+		cmp dword [E820Buf+16],1
+		je .is_ram			; Is it memory?
+		;
+		; Non-memory range.  Remember this as a limit; some BIOSes get the length
+		; of primary RAM incorrect!
+		;
+.not_ram:
+		cmp eax, (1 << 20)
+		jb .int_loop			; Starts in lowmem region
+		cmp eax,[E820Max]
+		jae .int_loop			; Already above limit
+		mov [E820Max],eax		; Set limit
+		jmp .int_loop
+
+.is_ram:
+		cmp eax,[E820Mem]
+		ja .int_loop			; Not contiguous with our starting point
+		add eax,[E820Buf+8]
+		jc .overflow
+		cmp dword [E820Buf+12],0
+		je .nooverflow
+.overflow:
+		or eax,-1
+.nooverflow:
+		cmp eax,[E820Mem]
+		jbe .int_loop			; All is below our baseline
+		mov [E820Mem],eax
+		jmp .start_over			; Start over in case we find an adjacent range
+
+.e820_done:
+		mov eax,[E820Mem]
+		cmp eax,[E820Max]
+		jna .not_limited
+		mov eax,[E820Max]
+.not_limited:
+		cmp eax,(1 << 20)
+		ja got_highmem			; Did we actually find memory?
+		; otherwise fall through
+
+;
+; INT 15:E820 failed.  Try INT 15:E801.
+;
+no_e820:
+		mov ax,0e801h			; Query high memory (semi-recent)
+		int 15h
+		jc no_e801
+		cmp ax,3c00h
+		ja no_e801			; > 3C00h something's wrong with this call
+		jb e801_hole			; If memory hole we can only use low part
+
+		mov ax,bx
+		shl eax,16			; 64K chunks
+		add eax,(16 << 20)		; Add first 16M
+		jmp short got_highmem
+
+;
+; INT 15:E801 failed.  Try INT 15:88.
+;
+no_e801:
+		mov ah,88h			; Query high memory (oldest)
+		int 15h
+		cmp ax,14*1024			; Don't trust memory >15M
+		jna e801_hole
+		mov ax,14*1024
+e801_hole:
+		and eax,0ffffh
+		shl eax,10			; Convert from kilobytes
+		add eax,(1 << 20)		; First megabyte
+got_highmem:
+%if HIGHMEM_SLOP != 0
+		sub eax,HIGHMEM_SLOP
+%endif
+		mov [HighMemSize],eax
+		popad
+		popfd
+		pop es
+		ret				; Done!
+
+		section .bss16
+		alignb 4
+E820Buf		resd 5			; INT 15:E820 data buffer
+E820Mem		resd 1			; Memory detected by E820
+E820Max		resd 1			; Is E820 memory capped?
+; HighMemSize is defined in com32.inc
diff --git a/contrib/syslinux-4.02/core/idle.c b/contrib/syslinux-4.02/core/idle.c
new file mode 100644
index 0000000..3f57393
--- /dev/null
+++ b/contrib/syslinux-4.02/core/idle.c
@@ -0,0 +1,49 @@
+/* -*- fundamental -*- ---------------------------------------------------
+ *
+ *   Copyright 2008 H. Peter Anvin - All Rights Reserved
+ *   Copyright 2009-2010 Intel Corporation; author: H. Peter Anvin
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+ *   Boston MA 02110-1301, USA; either version 2 of the License, or
+ *   (at your option) any later version; incorporated herein by reference.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * idle.c:
+ *
+ * This function provided protected-mode access to the idle handling.
+ * It needs to be carefully coordinated with idle.inc, which provides
+ * idle services to real-mode code.
+ */
+
+#include "core.h"
+#include <sys/cpu.h>
+
+#define TICKS_TO_IDLE	4	/* Also in idle.inc */
+
+extern uint32_t _IdleTimer;
+extern uint16_t NoHalt;
+
+int (*idle_hook_func)(void);
+
+void reset_idle(void)
+{
+    _IdleTimer = jiffies();
+}
+
+void __idle(void)
+{
+    if (jiffies() - _IdleTimer < TICKS_TO_IDLE)
+	return;
+
+    if (idle_hook_func && idle_hook_func())
+	return;			/* Nonzero return = do not idle */
+
+    if (NoHalt)
+	cpu_relax();
+    else
+	hlt();
+}
diff --git a/contrib/syslinux-4.02/core/idle.inc b/contrib/syslinux-4.02/core/idle.inc
new file mode 100644
index 0000000..9677c82
--- /dev/null
+++ b/contrib/syslinux-4.02/core/idle.inc
@@ -0,0 +1,81 @@
+;; -*- fundamental -*- ---------------------------------------------------
+;;
+;;   Copyright 2008 H. Peter Anvin - All Rights Reserved
+;;   Copyright 2009-2010 Intel Corporation; author: H. Peter Anvin
+;;
+;;   This program is free software; you can redistribute it and/or modify
+;;   it under the terms of the GNU General Public License as published by
+;;   the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+;;   Boston MA 02110-1301, USA; either version 2 of the License, or
+;;   (at your option) any later version; incorporated herein by reference.
+;;
+;; -----------------------------------------------------------------------
+
+		section .text16
+TICKS_TO_IDLE	equ 4		; Also in idle.c
+
+reset_idle:
+		push eax
+		mov eax,[cs:__jiffies]
+		mov [cs:_IdleTimer],eax
+		pop eax
+		sti		; Guard against BIOS/PXE brokenness...
+		ret
+
+do_idle:
+		push eax
+		push ds
+		push es
+		mov ax,cs
+		mov ds,ax
+		mov es,ax
+		pushf
+		pop ax
+		test ah,2
+		jnz .ok
+		push si
+		push cx
+		mov si,hlt_err
+		call writestr
+		mov si,sp
+		add si,10
+		mov cx,16
+.errloop:
+		ss lodsw
+		call writehex4
+		dec cx
+		jz .endloop
+		mov al,' '
+		call writechr
+		jmp .errloop
+.endloop:
+		call crlf
+		pop cx
+		pop si
+		sti
+.ok:
+		; Don't spend time jumping to PM unless we're actually idle...
+
+		mov eax,[__jiffies]
+		sub eax,[_IdleTimer]
+		cmp eax,TICKS_TO_IDLE
+		jb .done
+
+		extern __idle
+		pm_call __idle
+.done:
+		pop es
+		pop ds
+		pop eax
+.ret:		ret
+
+		section .data16
+		alignz 4
+		global _IdleTimer
+_IdleTimer	dd 0
+		global NoHalt
+NoHalt		dw 0
+
+hlt_err		db 'ERROR: idle with IF=0', CR, LF, 0 
+
+		section .text16
diff --git a/contrib/syslinux-4.02/core/include/cache.h b/contrib/syslinux-4.02/core/include/cache.h
new file mode 100644
index 0000000..1f451af
--- /dev/null
+++ b/contrib/syslinux-4.02/core/include/cache.h
@@ -0,0 +1,23 @@
+#ifndef _CACHE_H
+#define _CACHE_H
+
+#include <stdint.h>
+#include <com32.h>
+#include "disk.h"
+#include "fs.h"
+
+/* The cache structure */
+struct cache {
+    block_t block;
+    struct cache *prev;
+    struct cache *next;
+    void *data;
+};
+
+/* functions defined in cache.c */
+void cache_init(struct device *, int);
+const void *get_cache(struct device *, block_t);
+struct cache *_get_cache_block(struct device *, block_t);
+void cache_lock_block(struct cache *);
+
+#endif /* cache.h */
diff --git a/contrib/syslinux-4.02/core/include/codepage.h b/contrib/syslinux-4.02/core/include/codepage.h
new file mode 100644
index 0000000..a24d90f
--- /dev/null
+++ b/contrib/syslinux-4.02/core/include/codepage.h
@@ -0,0 +1,27 @@
+/*
+ * Codepage data structure as generated by cptable.pl
+ */
+#ifndef CODEPAGE_H
+#define CODEPAGE_H
+
+#include <stdint.h>
+
+#define CODEPAGE_MAGIC	UINT64_C(0x51d21eb158a8b3d4)
+
+struct codepage {
+    uint64_t	magic;
+    uint32_t	reserved[6];
+
+    uint8_t	upper[256];	/* Codepage upper case table */
+    uint8_t	lower[256];	/* Codepage lower case table */
+
+    /*
+     * The primary Unicode match is the same case, i.e. A -> A,
+     * the secondary Unicode match is the opposite case, i.e. A -> a.
+     */
+    uint16_t	uni[2][256];	/* Primary and alternate Unicode matches */
+};
+
+extern const struct codepage codepage;
+
+#endif /* CODEPAGE_H */
diff --git a/contrib/syslinux-4.02/core/include/core.h b/contrib/syslinux-4.02/core/include/core.h
new file mode 100644
index 0000000..7db5daf
--- /dev/null
+++ b/contrib/syslinux-4.02/core/include/core.h
@@ -0,0 +1,78 @@
+#ifndef CORE_H
+#define CORE_H
+
+#include <klibc/compiler.h>
+#include <com32.h>
+#include <syslinux/pmapi.h>
+
+extern char core_xfer_buf[65536];
+extern char core_cache_buf[65536];
+extern char trackbuf[];
+extern char CurrentDirName[];
+extern char SubvolName[];
+extern char ConfigName[];
+extern char KernelName[];
+extern char cmd_line[];
+extern char ConfigFile[];
+
+/* diskstart.inc isolinux.asm*/
+extern void getlinsec(void);
+
+/* getc.inc */
+extern void core_open(void);
+
+/* hello.c */
+extern void myputs(const char*);
+
+/* idle.c */
+extern int (*idle_hook_func)(void);
+extern void __idle(void);
+extern void reset_idle(void);
+
+/* mem/malloc.c, mem/free.c, mem/init.c */
+extern void *malloc(size_t);
+extern void *lmalloc(size_t);
+extern void *pmapi_lmalloc(size_t);
+extern void *zalloc(size_t);
+extern void free(void *);
+extern void mem_init(void);
+
+void __cdecl core_intcall(uint8_t, const com32sys_t *, com32sys_t *);
+void __cdecl core_farcall(uint32_t, const com32sys_t *, com32sys_t *);
+int __cdecl core_cfarcall(uint32_t, const void *, uint32_t);
+
+extern const com32sys_t zero_regs;
+void call16(void (*)(void), const com32sys_t *, com32sys_t *);
+
+/*
+ * __lowmem is in the low 1 MB; __bss16 in the low 64K
+ */
+#define __lowmem __attribute__((nocommon,section(".lowmem")))
+#define __bss16  __attribute__((nocommon,section(".bss16")))
+
+/*
+ * Section for very large aligned objects, not zeroed on startup
+ */
+#define __hugebss __attribute__((nocommon,section(".hugebss"),aligned(4096)))
+
+/*
+ * Death!  The macro trick is to avoid symbol conflict with
+ * the real-mode symbol kaboom.
+ */
+__noreturn _kaboom(void);
+#define kaboom() _kaboom()
+
+/*
+ * Basic timer function...
+ */
+extern volatile uint32_t __jiffies, __ms_timer;
+static inline uint32_t jiffies(void)
+{
+    return __jiffies;
+}
+static inline uint32_t ms_timer(void)
+{
+    return __ms_timer;
+}
+
+#endif /* CORE_H */
diff --git a/contrib/syslinux-4.02/core/include/ctype.h b/contrib/syslinux-4.02/core/include/ctype.h
new file mode 100644
index 0000000..5c6d4cb
--- /dev/null
+++ b/contrib/syslinux-4.02/core/include/ctype.h
@@ -0,0 +1,25 @@
+#ifndef CTYPE_H
+#define CTYPE_H
+
+/*
+ * Small subset of <ctype.h> for parsing uses, only handles ASCII
+ * and passes the rest through.
+ */
+
+static inline int toupper(int c)
+{
+    if (c >= 'a' && c <= 'z')
+	c -= 0x20;
+
+    return c;
+}
+
+static inline int tolower(int c)
+{
+    if (c >= 'A' && c <= 'Z')
+	c += 0x20;
+
+    return c;
+}
+
+#endif /* CTYPE_H */
diff --git a/contrib/syslinux-4.02/core/include/disk.h b/contrib/syslinux-4.02/core/include/disk.h
new file mode 100644
index 0000000..ac23e92
--- /dev/null
+++ b/contrib/syslinux-4.02/core/include/disk.h
@@ -0,0 +1,37 @@
+#ifndef DISK_H
+#define DISK_H
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+typedef uint64_t sector_t;
+typedef uint64_t block_t;
+
+/*
+ * struct disk: contains the information about a specific disk and also
+ * contains the I/O function.
+ */
+struct disk {
+    unsigned int disk_number;	/* in BIOS style */
+    unsigned int sector_size;	/* gener512B or 2048B */
+    unsigned int sector_shift;
+    unsigned int maxtransfer;	/* Max sectors per transfer */
+    
+    unsigned int h, s;		/* CHS geometry */
+    unsigned int secpercyl;	/* h*s */
+    unsigned int _pad;
+
+    sector_t part_start;   /* the start address of this partition(in sectors) */
+
+    int (*rdwr_sectors)(struct disk *, void *, sector_t, size_t, bool);
+};
+
+extern void read_sectors(char *, sector_t, int);
+extern void getoneblk(struct disk *, char *, block_t, int);
+
+/* diskio.c */
+struct disk *disk_init(uint8_t, bool, sector_t, uint16_t, uint16_t, uint32_t);
+struct device *device_init(uint8_t, bool, sector_t, uint16_t, uint16_t, uint32_t);
+
+#endif /* DISK_H */
diff --git a/contrib/syslinux-4.02/core/include/fs.h b/contrib/syslinux-4.02/core/include/fs.h
new file mode 100644
index 0000000..ecd148d
--- /dev/null
+++ b/contrib/syslinux-4.02/core/include/fs.h
@@ -0,0 +1,227 @@
+#ifndef FS_H
+#define FS_H
+
+#include <stddef.h>
+#include <stdbool.h>
+#include <string.h>
+#include <com32.h>
+#include <stdio.h>
+#include <sys/dirent.h>
+#include "core.h"
+#include "disk.h"
+
+/*
+ * Maximum number of open files.  This is *currently* constrained by the
+ * fact that PXE needs to be able to fit all its packet buffers into a
+ * 64K segment; this should be fixed by moving the packet buffers to high
+ * memory.
+ */
+#define MAX_OPEN_LG2	5
+#define MAX_OPEN	(1 << MAX_OPEN_LG2)
+
+#define FILENAME_MAX_LG2 8
+#define FILENAME_MAX     (1 << FILENAME_MAX_LG2)
+
+#define CURRENTDIR_MAX	FILENAME_MAX
+
+#define BLOCK_SIZE(fs)   ((fs)->block_size)
+#define BLOCK_SHIFT(fs)	 ((fs)->block_shift)
+#define SECTOR_SIZE(fs)  ((fs)->sector_size)
+#define SECTOR_SHIFT(fs) ((fs)->sector_shift)
+
+struct fs_info {
+    const struct fs_ops *fs_ops;
+    struct device *fs_dev;
+    void *fs_info;             /* The fs-specific information */
+    int sector_shift, sector_size;
+    int block_shift, block_size;
+    struct inode *root, *cwd;	   	/* Root and current directories */
+    char cwd_name[CURRENTDIR_MAX];	/* Current directory by name */
+};
+
+extern struct fs_info *this_fs;
+
+struct dirent;                  /* Directory entry structure */
+struct file;
+enum fs_flags {
+    FS_NODEV   = 1 << 0,
+    FS_USEMEM  = 1 << 1,        /* If we need a malloc routine, set it */
+    FS_THISIND = 1 << 2,        /* Set cwd based on config file location */
+};
+
+struct fs_ops {
+    /* in fact, we use fs_ops structure to find the right fs */
+    const char *fs_name;
+    enum fs_flags fs_flags;
+    
+    int      (*fs_init)(struct fs_info *);
+    void     (*searchdir)(const char *, struct file *);
+    uint32_t (*getfssec)(struct file *, char *, int, bool *);
+    void     (*close_file)(struct file *);
+    void     (*mangle_name)(char *, const char *);
+    size_t   (*realpath)(struct fs_info *, char *, const char *, size_t);
+    int      (*chdir)(struct fs_info *, const char *);
+    int      (*load_config)(void);
+
+    struct inode * (*iget_root)(struct fs_info *);
+    struct inode * (*iget)(const char *, struct inode *);
+    int	     (*readlink)(struct inode *, char *);
+
+    /* the _dir_ stuff */
+    int	     (*readdir)(struct file *, struct dirent *);
+
+    int      (*next_extent)(struct inode *, uint32_t);
+};
+
+/*
+ * Extent structure: contains the mapping of some chunk of a file
+ * that is contiguous on disk.
+ */
+struct extent {
+    sector_t	pstart;		/* Physical start sector */
+    uint32_t	lstart;		/* Logical start sector */
+    uint32_t	len;		/* Number of contiguous sectors */
+};
+
+/* Special sector numbers used for struct extent.pstart */
+#define EXTENT_ZERO	((sector_t)-1) /* All-zero extent */
+#define EXTENT_VOID	((sector_t)-2) /* Invalid information */
+
+#define EXTENT_SPECIAL(x)	((x) >= EXTENT_VOID)
+
+/* 
+ * The inode structure, including the detail file information 
+ */
+struct inode {
+    struct fs_info *fs;	 /* The filesystem this inode is associated with */
+    struct inode *parent;	/* Parent directory, if any */
+    int		 refcnt;
+    int          mode;   /* FILE , DIR or SYMLINK */
+    uint32_t     size;
+    uint32_t	 blocks; /* How many blocks the file take */
+    uint32_t     ino;    /* Inode number */
+    uint32_t     atime;  /* Access time */
+    uint32_t     mtime;  /* Modify time */
+    uint32_t     ctime;  /* Create time */
+    uint32_t     dtime;  /* Delete time */
+    uint32_t     flags;
+    uint32_t     file_acl;
+    struct extent this_extent, next_extent;
+    char         pvt[0]; /* Private filesystem data */
+};
+
+struct file {
+    struct fs_info *fs;
+    uint32_t offset;            /* for next read */
+    struct inode *inode;        /* The file-specific information */
+};
+
+/*
+ * Struct device contains:
+ *     the pointer points to the disk structure,
+ *     the cache stuff.
+ */
+struct cache;
+
+struct device {
+    struct disk *disk;
+
+    /* the cache stuff */
+    char *cache_data;
+    struct cache *cache_head;
+    uint16_t cache_block_size;
+    uint16_t cache_entries;
+    uint32_t cache_size;
+};
+
+/*
+ * Our definition of "not whitespace"
+ */
+static inline bool not_whitespace(char c)
+{
+  return (unsigned char)c > ' ';
+}
+
+/*
+ * Inode allocator/deallocator
+ */
+struct inode *alloc_inode(struct fs_info *fs, uint32_t ino, size_t data);
+static inline void free_inode(struct inode * inode)
+{
+    free(inode);
+}
+
+static inline struct inode *get_inode(struct inode *inode)
+{
+    inode->refcnt++;
+    return inode;
+}
+
+void put_inode(struct inode *inode);
+
+static inline void malloc_error(char *obj)
+{
+        printf("Out of memory: can't allocate memory for %s\n", obj);
+	kaboom();
+}
+
+/*
+ * File handle conversion functions
+ */
+extern struct file files[];
+static inline uint16_t file_to_handle(struct file *file)
+{
+    return file ? (file - files)+1 : 0;
+}
+static inline struct file *handle_to_file(uint16_t handle)
+{
+    return handle ? &files[handle-1] : NULL;
+}
+
+/* fs.c */
+void pm_mangle_name(com32sys_t *);
+void pm_searchdir(com32sys_t *);
+void mangle_name(char *, const char *);
+int searchdir(const char *name);
+void _close_file(struct file *);
+size_t pmapi_read_file(uint16_t *handle, void *buf, size_t sectors);
+int open_file(const char *name, struct com32_filedata *filedata);
+void pm_open_file(com32sys_t *);
+void close_file(uint16_t handle);
+void pm_close_file(com32sys_t *);
+
+/* chdir.c */
+void pm_realpath(com32sys_t *regs);
+size_t realpath(char *dst, const char *src, size_t bufsize);
+int chdir(const char *src);
+
+/* readdir.c */
+DIR *opendir(const char *pathname);
+struct dirent *readdir(DIR *dir);
+int closedir(DIR *dir);
+
+/* getcwd.c */
+char *getcwd(char *buf, size_t size);
+
+/*
+ * Generic functions that filesystem drivers may choose to use
+ */
+
+/* mangle.c */
+void generic_mangle_name(char *, const char *);
+
+/* loadconfig.c */
+int search_config(const char *search_directores[], const char *filenames[]);
+int generic_load_config(void);
+
+/* close.c */
+void generic_close_file(struct file *file);
+
+/* getfssec.c */
+uint32_t generic_getfssec(struct file *file, char *buf,
+			  int sectors, bool *have_more);
+
+/* nonextextent.c */
+int no_next_extent(struct inode *, uint32_t);
+
+#endif /* FS_H */
diff --git a/contrib/syslinux-4.02/core/include/pmapi.h b/contrib/syslinux-4.02/core/include/pmapi.h
new file mode 100644
index 0000000..57d2e6f
--- /dev/null
+++ b/contrib/syslinux-4.02/core/include/pmapi.h
@@ -0,0 +1,8 @@
+#ifndef PMAPI_H
+#define PMAPI_H
+
+#include <syslinux/pmapi.h>
+
+size_t pmapi_read_file(uint16_t *, void *, size_t);
+
+#endif /* PMAPI_H */
diff --git a/contrib/syslinux-4.02/core/init.inc b/contrib/syslinux-4.02/core/init.inc
new file mode 100644
index 0000000..e06ca96
--- /dev/null
+++ b/contrib/syslinux-4.02/core/init.inc
@@ -0,0 +1,133 @@
+; -*- fundamental -*-
+; -----------------------------------------------------------------------
+;
+;   Copyright 2004-2008 H. Peter Anvin - All Rights Reserved
+;   Copyright 2009 Intel Corporation; author: H. Peter Anvin
+;
+;   This program is free software; you can redistribute it and/or modify
+;   it under the terms of the GNU General Public License as published by
+;   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
+;   Boston MA 02111-1307, USA; either version 2 of the License, or
+;   (at your option) any later version; incorporated herein by reference.
+;
+; -----------------------------------------------------------------------
+
+;
+; init.inc
+;
+; Common initialization code (inline)
+;
+
+		section .text16
+common_init:
+		; Initialize PM invocation framework
+		call pm_init
+
+		; Decompress PM code to its target location
+		pm_call pm_decompress
+		cmp eax,__pm_code_len
+		jne kaboom
+
+;
+; Initialize timer
+;
+		call timer_init
+
+;
+; Initialize configuration information
+;
+		call reset_config
+
+;
+; Set up the COMBOOT APIs
+;
+		call comboot_setup_api
+
+;
+; Now set up screen parameters
+;
+		call adjust_screen
+
+;
+; CPU-dependent initialization and related checks.
+;
+check_escapes:
+		mov ah,02h			; Check keyboard flags
+		int 16h
+		mov [KbdFlags],al		; Save for boot prompt check
+		test al,04h			; Ctrl->skip 386 check
+		jnz skip_checks
+
+;
+; Now check that there is sufficient low (DOS) memory
+;
+; NOTE: Linux doesn't use all of real_mode_seg, but we use the same
+; segment for COMBOOT images, which can use all 64K
+;
+		int 12h
+		mov edx,__lowmem_heap + min_lowmem_heap + 1023
+		shr edx,10
+		cmp ax,dx
+		jae enough_ram
+		mov ax,dx
+		mov si,err_noram
+		mov cl,10
+		div cl
+		add [si+err_noram.size-err_noram+2],ah
+		cbw
+		div cl
+		add [si+err_noram.size-err_noram],ax
+		call writestr_early
+		jmp kaboom
+enough_ram:
+skip_checks:
+
+		section .data16
+err_noram	db 'It appears your computer has less than '
+.size		db '000'
+		db 'K of low ("DOS")'
+		db CR, LF
+		db 'RAM.  Syslinux needs at least this amount to boot.  If you get'
+		db CR, LF
+		db 'this message in error, hold down the Ctrl key while'
+		db CR, LF
+		db 'booting, and I will take your word for it.', CR, LF, 0
+
+		section .text16
+;
+; The code to decompress the PM code and initialize other segments.
+;
+		extern _lzo1x_decompress_asm_fast
+
+		section .textnr
+		bits 32
+pm_decompress:
+		push 0				; Space for decompressed size
+		push esp			; Pointer to previous word
+		push __pm_code_start		; Target address
+		push dword [lzo_data_size]	; Compressed size
+		push dword __pm_code_lma
+		call _lzo1x_decompress_asm_fast
+		add esp,16
+		pop RM_EAX			; Decompressed size
+
+		; Zero bss sections (but not .earlybss, since it may
+		; contain already-live data.)
+		xor eax,eax
+		mov edi,__bss_start
+		mov ecx,__bss_dwords
+		rep stosd
+		mov edi,__bss16_start
+		mov ecx,__bss16_dwords
+		rep stosd
+		mov edi,__high_clear_start	; .uibss, .auxseg, .lowmem
+		mov ecx,__high_clear_dwords
+		rep stosd
+
+		ret
+
+		section .data16
+lzo_data_size	dd 0				; filled in by compressor
+
+		section .text16
+		bits 16
diff --git a/contrib/syslinux-4.02/core/io.inc b/contrib/syslinux-4.02/core/io.inc
new file mode 100644
index 0000000..7161346
--- /dev/null
+++ b/contrib/syslinux-4.02/core/io.inc
@@ -0,0 +1,35 @@
+;; -----------------------------------------------------------------------
+;;
+;;   Copyright 1994-2009 H. Peter Anvin - All Rights Reserved
+;;   Copyright 2009 Intel Corporation; author: H. Peter Anvin
+;;
+;;   This program is free software; you can redistribute it and/or modify
+;;   it under the terms of the GNU General Public License as published by
+;;   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
+;;   Boston MA 02111-1307, USA; either version 2 of the License, or
+;;   (at your option) any later version; incorporated herein by reference.
+;;
+;; -----------------------------------------------------------------------
+
+;;
+;; io.inc
+;;
+;; I/O related macros
+;;
+
+%ifndef _IO_INC
+%define _IO_INC
+
+%define IO_DELAY_PORT	80h		; Invalid port (we hope!)
+
+%macro io_delay 0.nolist
+		out IO_DELAY_PORT,al
+		out IO_DELAY_PORT,al
+%endmacro
+
+%macro slow_out 2.nolist
+		out %1,%2
+		io_delay
+%endmacro
+
+%endif ; _IO_INC
diff --git a/contrib/syslinux-4.02/core/isolinux-debug.asm b/contrib/syslinux-4.02/core/isolinux-debug.asm
new file mode 100644
index 0000000..9c74b7c
--- /dev/null
+++ b/contrib/syslinux-4.02/core/isolinux-debug.asm
@@ -0,0 +1,2 @@
+%define DEBUG_MESSAGES 1
+%include "isolinux.asm"
diff --git a/contrib/syslinux-4.02/core/isolinux.asm b/contrib/syslinux-4.02/core/isolinux.asm
new file mode 100644
index 0000000..1ef68d8
--- /dev/null
+++ b/contrib/syslinux-4.02/core/isolinux.asm
@@ -0,0 +1,1383 @@
+; -*- fundamental -*- (asm-mode sucks)
+; ****************************************************************************
+;
+;  isolinux.asm
+;
+;  A program to boot Linux kernels off a CD-ROM using the El Torito
+;  boot standard in "no emulation" mode, making the entire filesystem
+;  available.  It is based on the SYSLINUX boot loader for MS-DOS
+;  floppies.
+;
+;   Copyright 1994-2009 H. Peter Anvin - All Rights Reserved
+;   Copyright 2009 Intel Corporation; author: H. Peter Anvin
+;
+;  This program is free software; you can redistribute it and/or modify
+;  it under the terms of the GNU General Public License as published by
+;  the Free Software Foundation, Inc., 53 Temple Place Ste 330,
+;  Boston MA 02111-1307, USA; either version 2 of the License, or
+;  (at your option) any later version; incorporated herein by reference.
+;
+; ****************************************************************************
+
+%define IS_ISOLINUX 1
+%include "head.inc"
+
+;
+; Some semi-configurable constants... change on your own risk.
+;
+my_id		equ isolinux_id
+NULLFILE	equ 0			; Zero byte == null file name
+NULLOFFSET	equ 0			; Position in which to look
+retry_count	equ 6			; How patient are we with the BIOS?
+%assign HIGHMEM_SLOP 128*1024		; Avoid this much memory near the top
+SECTOR_SHIFT	equ 11			; 2048 bytes/sector (El Torito requirement)
+SECTOR_SIZE	equ (1 << SECTOR_SHIFT)
+
+ROOT_DIR_WORD	equ 0x002F
+
+;
+; The following structure is used for "virtual kernels"; i.e. LILO-style
+; option labels.  The options we permit here are `kernel' and `append
+; Since there is no room in the bottom 64K for all of these, we
+; stick them in high memory and copy them down before we need them.
+;
+		struc vkernel
+vk_vname:	resb FILENAME_MAX	; Virtual name **MUST BE FIRST!**
+vk_rname:	resb FILENAME_MAX	; Real name
+vk_appendlen:	resw 1
+vk_type:	resb 1			; Type of file
+		alignb 4
+vk_append:	resb max_cmd_len+1	; Command line
+		alignb 4
+vk_end:		equ $			; Should be <= vk_size
+		endstruc
+
+;
+; File structure.  This holds the information for each currently open file.
+;
+		struc open_file_t
+file_sector	resd 1			; Sector pointer (0 = structure free)
+file_bytesleft	resd 1			; Number of bytes left
+file_left	resd 1			; Number of sectors left
+		resd 1			; Unused
+		endstruc
+
+%ifndef DEPEND
+%if (open_file_t_size & (open_file_t_size-1))
+%error "open_file_t is not a power of 2"
+%endif
+%endif
+
+; ---------------------------------------------------------------------------
+;   BEGIN CODE
+; ---------------------------------------------------------------------------
+
+;
+; Memory below this point is reserved for the BIOS and the MBR
+;
+		section .earlybss
+		global trackbuf
+trackbufsize	equ 8192
+trackbuf	resb trackbufsize	; Track buffer goes here
+;		ends at 2800h
+
+		; Some of these are touched before the whole image
+		; is loaded.  DO NOT move this to .bss16/.uibss.
+		section .earlybss
+		alignb 4
+FirstSecSum	resd 1			; Checksum of bytes 64-2048
+ImageDwords	resd 1			; isolinux.bin size, dwords
+InitStack	resd 1			; Initial stack pointer (SS:SP)
+DiskSys		resw 1			; Last INT 13h call
+ImageSectors	resw 1			; isolinux.bin size, sectors
+; These following two are accessed as a single dword...
+GetlinsecPtr	resw 1			; The sector-read pointer
+BIOSName	resw 1			; Display string for BIOS type
+%define HAVE_BIOSNAME 1
+BIOSType	resw 1
+DiskError	resb 1			; Error code for disk I/O
+DriveNumber	resb 1			; CD-ROM BIOS drive number
+ISOFlags	resb 1			; Flags for ISO directory search
+RetryCount      resb 1			; Used for disk access retries
+
+		alignb 8
+Hidden		resq 1			; Used in hybrid mode
+bsSecPerTrack	resw 1			; Used in hybrid mode
+bsHeads		resw 1			; Used in hybrid mode
+
+
+;
+; El Torito spec packet
+;
+
+		alignb 8
+_spec_start	equ $
+spec_packet:	resb 1				; Size of packet
+sp_media:	resb 1				; Media type
+sp_drive:	resb 1				; Drive number
+sp_controller:	resb 1				; Controller index
+sp_lba:		resd 1				; LBA for emulated disk image
+sp_devspec:	resw 1				; IDE/SCSI information
+sp_buffer:	resw 1				; User-provided buffer
+sp_loadseg:	resw 1				; Load segment
+sp_sectors:	resw 1				; Sector count
+sp_chs:		resb 3				; Simulated CHS geometry
+sp_dummy:	resb 1				; Scratch, safe to overwrite
+
+;
+; EBIOS drive parameter packet
+;
+		alignb 8
+drive_params:	resw 1				; Buffer size
+dp_flags:	resw 1				; Information flags
+dp_cyl:		resd 1				; Physical cylinders
+dp_head:	resd 1				; Physical heads
+dp_sec:		resd 1				; Physical sectors/track
+dp_totalsec:	resd 2				; Total sectors
+dp_secsize:	resw 1				; Bytes per sector
+dp_dpte:	resd 1				; Device Parameter Table
+dp_dpi_key:	resw 1				; 0BEDDh if rest valid
+dp_dpi_len:	resb 1				; DPI len
+		resb 1
+		resw 1
+dp_bus:		resb 4				; Host bus type
+dp_interface:	resb 8				; Interface type
+db_i_path:	resd 2				; Interface path
+db_d_path:	resd 2				; Device path
+		resb 1
+db_dpi_csum:	resb 1				; Checksum for DPI info
+
+;
+; EBIOS disk address packet
+;
+		alignb 8
+dapa:		resw 1				; Packet size
+.count:		resw 1				; Block count
+.off:		resw 1				; Offset of buffer
+.seg:		resw 1				; Segment of buffer
+.lba:		resd 2				; LBA (LSW, MSW)
+
+;
+; Spec packet for disk image emulation
+;
+		alignb 8
+dspec_packet:	resb 1				; Size of packet
+dsp_media:	resb 1				; Media type
+dsp_drive:	resb 1				; Drive number
+dsp_controller:	resb 1				; Controller index
+dsp_lba:	resd 1				; LBA for emulated disk image
+dsp_devspec:	resw 1				; IDE/SCSI information
+dsp_buffer:	resw 1				; User-provided buffer
+dsp_loadseg:	resw 1				; Load segment
+dsp_sectors:	resw 1				; Sector count
+dsp_chs:	resb 3				; Simulated CHS geometry
+dsp_dummy:	resb 1				; Scratch, safe to overwrite
+
+		alignb 4
+_spec_end	equ $
+_spec_len	equ _spec_end - _spec_start
+
+		section .init
+;;
+;; Primary entry point.  Because BIOSes are buggy, we only load the first
+;; CD-ROM sector (2K) of the file, so the number one priority is actually
+;; loading the rest.
+;;
+StackBuf	equ STACK_TOP-44	; 44 bytes needed for
+					; the bootsector chainloading
+					; code!
+OrigESDI	equ StackBuf-4          ; The high dword on the stack
+StackHome	equ OrigESDI
+
+bootsec		equ $
+
+_start:		; Far jump makes sure we canonicalize the address
+		cli
+		jmp 0:_start1
+		times 8-($-$$) nop		; Pad to file offset 8
+
+		; This table hopefully gets filled in by mkisofs using the
+		; -boot-info-table option.  If not, the values in this
+		; table are default values that we can use to get us what
+		; we need, at least under a certain set of assumptions.
+		global iso_boot_info
+iso_boot_info:
+bi_pvd:		dd 16				; LBA of primary volume descriptor
+bi_file:	dd 0				; LBA of boot file
+bi_length:	dd 0xdeadbeef			; Length of boot file
+bi_csum:	dd 0xdeadbeef			; Checksum of boot file
+bi_reserved:	times 10 dd 0xdeadbeef		; Reserved
+bi_end:
+
+		; Custom entry point for the hybrid-mode disk.
+		; The following values will have been pushed onto the
+		; entry stack:
+		;	- partition offset (qword)
+		;	- ES
+		;	- DI
+		;	- DX (including drive number)
+		;	- CBIOS Heads
+		;	- CBIOS Sectors
+		;	- EBIOS flag
+		;       (top of stack)
+		;
+		; If we had an old isohybrid, the partition offset will
+		; be missing; we can check for that with sp >= 0x7c00.
+		; Serious hack alert.
+%ifndef DEBUG_MESSAGES
+_hybrid_signature:
+	       dd 0x7078c0fb			; An arbitrary number...
+
+_start_hybrid:
+		pop cx				; EBIOS flag
+		pop word [cs:bsSecPerTrack]
+		pop word [cs:bsHeads]
+		pop dx
+		pop di
+		pop es
+		xor eax,eax
+		xor ebx,ebx
+		cmp sp,7C00h
+		jae .nooffset
+		pop eax
+		pop ebx
+.nooffset:
+		mov si,bios_cbios
+		jcxz _start_common
+		mov si,bios_ebios
+		jmp _start_common
+%endif
+
+_start1:
+		mov si,bios_cdrom
+		xor eax,eax
+		xor ebx,ebx
+_start_common:
+		mov [cs:InitStack],sp	; Save initial stack pointer
+		mov [cs:InitStack+2],ss
+		xor cx,cx
+		mov ss,cx
+		mov sp,StackBuf		; Set up stack
+		push es			; Save initial ES:DI -> $PnP pointer
+		push di
+		mov ds,cx
+		mov es,cx
+		mov fs,cx
+		mov gs,cx
+		sti
+		cld
+
+		mov [Hidden],eax
+		mov [Hidden+4],ebx
+
+		mov [BIOSType],si
+		mov eax,[si]
+		mov [GetlinsecPtr],eax
+
+		; Show signs of life
+		mov si,syslinux_banner
+		call writestr_early
+%ifdef DEBUG_MESSAGES
+		mov si,copyright_str
+%else
+		mov si,[BIOSName]
+%endif
+		call writestr_early
+
+		;
+		; Before modifying any memory, get the checksum of bytes
+		; 64-2048
+		;
+initial_csum:	xor edi,edi
+		mov si,bi_end
+		mov cx,(SECTOR_SIZE-64) >> 2
+.loop:		lodsd
+		add edi,eax
+		loop .loop
+		mov [FirstSecSum],edi
+
+		mov [DriveNumber],dl
+%ifdef DEBUG_MESSAGES
+		mov si,startup_msg
+		call writemsg
+		mov al,dl
+		call writehex2
+		call crlf
+%endif
+		;
+		; Initialize spec packet buffers
+		;
+		mov di,_spec_start
+		mov cx,_spec_len >> 2
+		xor eax,eax
+		rep stosd
+
+		; Initialize length field of the various packets
+		mov byte [spec_packet],13h
+		mov byte [drive_params],30
+		mov byte [dapa],16
+		mov byte [dspec_packet],13h
+
+		; Other nonzero fields
+		inc word [dsp_sectors]
+
+		; Are we just pretending to be a CD-ROM?
+		cmp word [BIOSType],bios_cdrom
+		jne found_drive			; If so, no spec packet...
+
+		; Now figure out what we're actually doing
+		; Note: use passed-in DL value rather than 7Fh because
+		; at least some BIOSes will get the wrong value otherwise
+		mov ax,4B01h			; Get disk emulation status
+		mov dl,[DriveNumber]
+		mov si,spec_packet
+		call int13
+		jc award_hack			; changed for BrokenAwardHack
+		mov dl,[DriveNumber]
+		cmp [sp_drive],dl		; Should contain the drive number
+		jne spec_query_failed
+
+%ifdef DEBUG_MESSAGES
+		mov si,spec_ok_msg
+		call writemsg
+		mov al,byte [sp_drive]
+		call writehex2
+		call crlf
+%endif
+
+found_drive:
+		; Alright, we have found the drive.  Now, try to find the
+		; boot file itself.  If we have a boot info table, life is
+		; good; if not, we have to make some assumptions, and try
+		; to figure things out ourselves.  In particular, the
+		; assumptions we have to make are:
+		; - single session only
+		; - only one boot entry (no menu or other alternatives)
+
+		cmp dword [bi_file],0		; Address of code to load
+		jne found_file			; Boot info table present :)
+
+%ifdef DEBUG_MESSAGES
+		mov si,noinfotable_msg
+		call writemsg
+%endif
+
+		; No such luck.  See if the spec packet contained one.
+		mov eax,[sp_lba]
+		and eax,eax
+		jz set_file			; Good enough
+
+%ifdef DEBUG_MESSAGES
+		mov si,noinfoinspec_msg
+		call writemsg
+%endif
+
+		; No such luck.  Get the Boot Record Volume, assuming single
+		; session disk, and that we're the first entry in the chain.
+		mov eax,17			; Assumed address of BRV
+		mov bx,trackbuf
+		call getonesec
+
+		mov eax,[trackbuf+47h]		; Get boot catalog address
+		mov bx,trackbuf
+		call getonesec			; Get boot catalog
+
+		mov eax,[trackbuf+28h]		; First boot entry
+		; And hope and pray this is us...
+
+		; Some BIOSes apparently have limitations on the size
+		; that may be loaded (despite the El Torito spec being very
+		; clear on the fact that it must all be loaded.)  Therefore,
+		; we load it ourselves, and *bleep* the BIOS.
+
+set_file:
+		mov [bi_file],eax
+
+found_file:
+		; Set up boot file sizes
+		mov eax,[bi_length]
+		sub eax,SECTOR_SIZE-3		; ... minus sector loaded
+		shr eax,2			; bytes->dwords
+		mov [ImageDwords],eax		; boot file dwords
+		add eax,((SECTOR_SIZE-1) >> 2)
+		shr eax,SECTOR_SHIFT-2		; dwords->sectors
+		mov [ImageSectors],ax		; boot file sectors
+
+		mov eax,[bi_file]		; Address of code to load
+		inc eax				; Don't reload bootstrap code
+%ifdef DEBUG_MESSAGES
+		mov si,offset_msg
+		call writemsg
+		call writehex8
+		call crlf
+%endif
+
+		; Load the rest of the file.  However, just in case there
+		; are still BIOSes with 64K wraparound problems, we have to
+		; take some extra precautions.  Since the normal load
+		; address (TEXT_START) is *not* 2K-sector-aligned, we round
+		; the target address upward to a sector boundary,
+		; and then move the entire thing down as a unit.
+MaxLMA		equ 384*1024		; Reasonable limit (384K)
+
+		mov bx,((TEXT_START+2*SECTOR_SIZE-1) & ~(SECTOR_SIZE-1)) >> 4
+		mov bp,[ImageSectors]
+		push bx			; Load segment address
+
+.more:
+		push bx			; Segment address
+		push bp			; Sector count
+		mov es,bx
+		mov cx,0xfff
+		and bx,cx
+		inc cx
+		sub cx,bx
+		shr cx,SECTOR_SHIFT - 4
+		jnz .notaligned
+		mov cx,0x10000 >> SECTOR_SHIFT	; Full 64K segment possible
+.notaligned:
+		cmp bp,cx
+		jbe .ok
+		mov bp,cx
+.ok:
+		xor bx,bx
+		push bp
+		call getlinsec
+		pop cx
+		mov dx,cx
+		pop bp
+		pop bx
+
+		shl cx,SECTOR_SHIFT - 4
+		add bx,cx
+		sub bp,dx
+		jnz .more
+
+		; Move the image into place, and also verify the
+		; checksum
+		pop ax				; Load segment address
+		mov bx,(TEXT_START + SECTOR_SIZE) >> 4
+		mov ecx,[ImageDwords]
+		mov edi,[FirstSecSum]		; First sector checksum
+		xor si,si
+
+move_verify_image:
+.setseg:
+		mov ds,ax
+		mov es,bx
+.loop:
+		mov edx,[si]
+		add edi,edx
+		dec ecx
+		mov [es:si],edx
+		jz .done
+		add si,4
+		jnz .loop
+		add ax,1000h
+		add bx,1000h
+		jmp .setseg
+.done:
+		mov ax,cs
+		mov ds,ax
+		mov es,ax
+
+		; Verify the checksum on the loaded image.
+		cmp [bi_csum],edi
+		je integrity_ok
+
+		mov si,checkerr_msg
+		call writemsg
+		jmp kaboom
+
+integrity_ok:
+%ifdef DEBUG_MESSAGES
+		mov si,allread_msg
+		call writemsg
+%endif
+		jmp all_read			; Jump to main code
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Start of BrokenAwardHack --- 10-nov-2002           Knut_Petersen@t-online.de
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; There is a problem with certain versions of the AWARD BIOS ...
+;; the boot sector will be loaded and executed correctly, but, because the
+;; int 13 vector points to the wrong code in the BIOS, every attempt to
+;; load the spec packet will fail. We scan for the equivalent of
+;;
+;;	mov	ax,0201h
+;;	mov	bx,7c00h
+;;	mov	cx,0006h
+;;	mov	dx,0180h
+;;	pushf
+;;	call	<direct far>
+;;
+;; and use <direct far> as the new vector for int 13. The code above is
+;; used to load the boot code into ram, and there should be no reason
+;; for anybody to change it now or in the future. There are no opcodes
+;; that use encodings relativ to IP, so scanning is easy. If we find the
+;; code above in the BIOS code we can be pretty sure to run on a machine
+;; with an broken AWARD BIOS ...
+;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+									     ;;
+%ifdef DEBUG_MESSAGES							     ;;
+									     ;;
+award_notice	db	"Trying BrokenAwardHack first ...",CR,LF,0	     ;;
+award_not_orig	db	"BAH: Original Int 13 vector   : ",0		     ;;
+award_not_new	db	"BAH: Int 13 vector changed to : ",0		     ;;
+award_not_succ	db	"BAH: SUCCESS",CR,LF,0				     ;;
+award_not_fail	db	"BAH: FAILURE"					     ;;
+award_not_crlf	db	CR,LF,0						     ;;
+									     ;;
+%endif									     ;;
+									     ;;
+award_oldint13	dd	0						     ;;
+award_string	db	0b8h,1,2,0bbh,0,7ch,0b9h,6,0,0bah,80h,1,09ch,09ah    ;;
+									     ;;
+						;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+award_hack:	mov	si,spec_err_msg		; Moved to this place from
+		call	writemsg		; spec_query_faild
+						;
+%ifdef DEBUG_MESSAGES				;
+						;
+		mov	si,award_notice		; display our plan
+		call	writemsg		;
+		mov	si,award_not_orig	; display original int 13
+		call	writemsg		; vector
+%endif						;
+		mov	eax,[13h*4]		;
+		mov	[award_oldint13],eax	;
+						;
+%ifdef DEBUG_MESSAGES				;
+						;
+		call	writehex8		;
+		mov	si,award_not_crlf	;
+		call	writestr_early		;
+%endif						;
+		push	es			; save ES
+		mov	ax,0f000h		; ES = BIOS Seg
+		mov	es,ax			;
+		cld				;
+		xor	di,di			; start at ES:DI = f000:0
+award_loop:	push	di			; save DI
+		mov	si,award_string		; scan for award_string
+		mov	cx,7			; length of award_string = 7dw
+		repz	cmpsw			; compare
+		pop	di			; restore DI
+		jcxz	award_found		; jmp if found
+		inc	di			; not found, inc di
+		jno	award_loop		;
+						;
+award_failed:	pop	es			; No, not this way :-((
+award_fail2:					;
+						;
+%ifdef DEBUG_MESSAGES				;
+						;
+		mov	si,award_not_fail	; display failure ...
+		call	writemsg		;
+%endif						;
+		mov	eax,[award_oldint13]	; restore the original int
+		or	eax,eax			; 13 vector if there is one
+		jz	spec_query_failed	; and try other workarounds
+		mov	[13h*4],eax		;
+		jmp	spec_query_failed	;
+						;
+award_found:	mov	eax,[es:di+0eh]		; load possible int 13 addr
+		pop	es			; restore ES
+						;
+		cmp	eax,[award_oldint13]	; give up if this is the
+		jz	award_failed		; active int 13 vector,
+		mov	[13h*4],eax		; otherwise change 0:13h*4
+						;
+						;
+%ifdef DEBUG_MESSAGES				;
+						;
+		push	eax			; display message and
+		mov	si,award_not_new	; new vector address
+		call	writemsg		;
+		pop	eax			;
+		call	writehex8		;
+		mov	si,award_not_crlf	;
+		call	writestr_early		;
+%endif						;
+		mov	ax,4B01h		; try to read the spec packet
+		mov	dl,[DriveNumber]	; now ... it should not fail
+		mov	si,spec_packet		; any longer
+		int	13h			;
+		jc	award_fail2		;
+						;
+%ifdef DEBUG_MESSAGES				;
+						;
+		mov	si,award_not_succ	; display our SUCCESS
+		call	writemsg		;
+%endif						;
+		jmp	found_drive		; and leave error recovery code
+						;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; End of BrokenAwardHack ----            10-nov-2002 Knut_Petersen@t-online.de
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+
+		; INT 13h, AX=4B01h, DL=<passed in value> failed.
+		; Try to scan the entire 80h-FFh from the end.
+
+spec_query_failed:
+
+		; some code moved to BrokenAwardHack
+
+		mov dl,0FFh
+.test_loop:	pusha
+		mov ax,4B01h
+		mov si,spec_packet
+		mov byte [si],13h		; Size of buffer
+		call int13
+		popa
+		jc .still_broken
+
+		mov si,maybe_msg
+		call writemsg
+		mov al,dl
+		call writehex2
+		call crlf
+
+		cmp byte [sp_drive],dl
+		jne .maybe_broken
+
+		; Okay, good enough...
+		mov si,alright_msg
+		call writemsg
+.found_drive0:	mov [DriveNumber],dl
+.found_drive:	jmp found_drive
+
+		; Award BIOS 4.51 apparently passes garbage in sp_drive,
+		; but if this was the drive number originally passed in
+		; DL then consider it "good enough"
+.maybe_broken:
+		mov al,[DriveNumber]
+		cmp al,dl
+		je .found_drive
+
+		; Intel Classic R+ computer with Adaptec 1542CP BIOS 1.02
+		; passes garbage in sp_drive, and the drive number originally
+		; passed in DL does not have 80h bit set.
+		or al,80h
+		cmp al,dl
+		je .found_drive0
+
+.still_broken:	dec dx
+		cmp dl, 80h
+		jnb .test_loop
+
+		; No spec packet anywhere.  Some particularly pathetic
+		; BIOSes apparently don't even implement function
+		; 4B01h, so we can't query a spec packet no matter
+		; what.  If we got a drive number in DL, then try to
+		; use it, and if it works, then well...
+		mov dl,[DriveNumber]
+		cmp dl,81h			; Should be 81-FF at least
+		jb fatal_error			; If not, it's hopeless
+
+		; Write a warning to indicate we're on *very* thin ice now
+		mov si,nospec_msg
+		call writemsg
+		mov al,dl
+		call writehex2
+		call crlf
+		mov si,trysbm_msg
+		call writemsg
+		jmp .found_drive		; Pray that this works...
+
+fatal_error:
+		mov si,nothing_msg
+		call writemsg
+
+.norge:		jmp short .norge
+
+		; Information message (DS:SI) output
+		; Prefix with "isolinux: "
+		;
+writemsg:	push ax
+		push si
+		mov si,isolinux_str
+		call writestr_early
+		pop si
+		call writestr_early
+		pop ax
+		ret
+
+;
+; Write a character to the screen.  There is a more "sophisticated"
+; version of this in the subsequent code, so we patch the pointer
+; when appropriate.
+;
+
+writechr:
+.simple:
+		pushfd
+		pushad
+		mov ah,0Eh
+		xor bx,bx
+		int 10h
+		popad
+		popfd
+		ret
+
+;
+; int13: save all the segment registers and call INT 13h.
+;	 Some CD-ROM BIOSes have been found to corrupt segment registers
+;	 and/or disable interrupts.
+;
+int13:
+		pushf
+		push bp
+		push ds
+		push es
+		push fs
+		push gs
+		int 13h
+		mov bp,sp
+		setc [bp+10]		; Propagate CF to the caller
+		pop gs
+		pop fs
+		pop es
+		pop ds
+		pop bp
+		popf
+		ret
+
+;
+; Get one sector.  Convenience entry point.
+;
+getonesec:
+		mov bp,1
+		; Fall through to getlinsec
+
+;
+; Get linear sectors - EBIOS LBA addressing, 2048-byte sectors.
+;
+; Input:
+;	EAX	- Linear sector number
+;	ES:BX	- Target buffer
+;	BP	- Sector count
+;
+		global getlinsec
+getlinsec:	jmp word [cs:GetlinsecPtr]
+
+%ifndef DEBUG_MESSAGES
+
+;
+; First, the variants that we use when actually loading off a disk
+; (hybrid mode.)  These are adapted versions of the equivalent routines
+; in ldlinux.asm.
+;
+
+;
+; getlinsec_ebios:
+;
+; getlinsec implementation for floppy/HDD EBIOS (EDD)
+;
+getlinsec_ebios:
+		xor edx,edx
+		shld edx,eax,2
+		shl eax,2			; Convert to HDD sectors
+		add eax,[Hidden]
+		adc edx,[Hidden+4]
+		shl bp,2
+
+.loop:
+                push bp                         ; Sectors left
+.retry2:
+		call maxtrans			; Enforce maximum transfer size
+		movzx edi,bp			; Sectors we are about to read
+		mov cx,retry_count
+.retry:
+
+		; Form DAPA on stack
+		push edx
+		push eax
+		push es
+		push bx
+		push di
+		push word 16
+		mov si,sp
+		pushad
+                mov dl,[DriveNumber]
+		push ds
+		push ss
+		pop ds				; DS <- SS
+		mov ah,42h			; Extended Read
+		call int13
+		pop ds
+		popad
+		lea sp,[si+16]			; Remove DAPA
+		jc .error
+		pop bp
+		add eax,edi			; Advance sector pointer
+		adc edx,0
+		sub bp,di			; Sectors left
+                shl di,9			; 512-byte sectors
+                add bx,di			; Advance buffer pointer
+                and bp,bp
+                jnz .loop
+
+                ret
+
+.error:
+		; Some systems seem to get "stuck" in an error state when
+		; using EBIOS.  Doesn't happen when using CBIOS, which is
+		; good, since some other systems get timeout failures
+		; waiting for the floppy disk to spin up.
+
+		pushad				; Try resetting the device
+		xor ax,ax
+		mov dl,[DriveNumber]
+		call int13
+		popad
+		loop .retry			; CX-- and jump if not zero
+
+		;shr word [MaxTransfer],1	; Reduce the transfer size
+		;jnz .retry2
+
+		; Total failure.  Try falling back to CBIOS.
+		mov word [GetlinsecPtr], getlinsec_cbios
+		;mov byte [MaxTransfer],63	; Max possibe CBIOS transfer
+
+		pop bp
+		jmp getlinsec_cbios.loop
+
+;
+; getlinsec_cbios:
+;
+; getlinsec implementation for legacy CBIOS
+;
+getlinsec_cbios:
+		xor edx,edx
+		shl eax,2			; Convert to HDD sectors
+		add eax,[Hidden]
+		shl bp,2
+
+.loop:
+		push edx
+		push eax
+		push bp
+		push bx
+
+		movzx esi,word [bsSecPerTrack]
+		movzx edi,word [bsHeads]
+		;
+		; Dividing by sectors to get (track,sector): we may have
+		; up to 2^18 tracks, so we need to use 32-bit arithmetric.
+		;
+		div esi
+		xor cx,cx
+		xchg cx,dx		; CX <- sector index (0-based)
+					; EDX <- 0
+		; eax = track #
+		div edi			; Convert track to head/cyl
+
+		; We should test this, but it doesn't fit...
+		; cmp eax,1023
+		; ja .error
+
+		;
+		; Now we have AX = cyl, DX = head, CX = sector (0-based),
+		; BP = sectors to transfer, SI = bsSecPerTrack,
+		; ES:BX = data target
+		;
+
+		call maxtrans			; Enforce maximum transfer size
+
+		; Must not cross track boundaries, so BP <= SI-CX
+		sub si,cx
+		cmp bp,si
+		jna .bp_ok
+		mov bp,si
+.bp_ok:
+
+		shl ah,6		; Because IBM was STOOPID
+					; and thought 8 bits were enough
+					; then thought 10 bits were enough...
+		inc cx			; Sector numbers are 1-based, sigh
+		or cl,ah
+		mov ch,al
+		mov dh,dl
+		mov dl,[DriveNumber]
+		xchg ax,bp		; Sector to transfer count
+		mov ah,02h		; Read sectors
+		mov bp,retry_count
+.retry:
+		pushad
+		call int13
+		popad
+		jc .error
+.resume:
+		movzx ecx,al		; ECX <- sectors transferred
+		shl ax,9		; Convert sectors in AL to bytes in AX
+		pop bx
+		add bx,ax
+		pop bp
+		pop eax
+		pop edx
+		add eax,ecx
+		sub bp,cx
+		jnz .loop
+		ret
+
+.error:
+		dec bp
+		jnz .retry
+
+		xchg ax,bp		; Sectors transferred <- 0
+		shr word [MaxTransfer],1
+		jnz .resume
+		jmp disk_error
+
+;
+; Truncate BP to MaxTransfer
+;
+maxtrans:
+		cmp bp,[MaxTransfer]
+		jna .ok
+		mov bp,[MaxTransfer]
+.ok:		ret
+
+%endif
+
+;
+; This is the variant we use for real CD-ROMs:
+; LBA, 2K sectors, some special error handling.
+;
+getlinsec_cdrom:
+		mov si,dapa			; Load up the DAPA
+		mov [si+4],bx
+		mov [si+6],es
+		mov [si+8],eax
+.loop:
+		push bp				; Sectors left
+		cmp bp,[MaxTransferCD]
+		jbe .bp_ok
+		mov bp,[MaxTransferCD]
+.bp_ok:
+		mov [si+2],bp
+		push si
+		mov dl,[DriveNumber]
+		mov ah,42h			; Extended Read
+		call xint13
+		pop si
+		pop bp
+		movzx eax,word [si+2]		; Sectors we read
+		add [si+8],eax			; Advance sector pointer
+		sub bp,ax			; Sectors left
+		shl ax,SECTOR_SHIFT-4		; 2048-byte sectors -> segment
+		add [si+6],ax			; Advance buffer pointer
+		and bp,bp
+		jnz .loop
+		mov eax,[si+8]			; Next sector
+		ret
+
+		; INT 13h with retry
+xint13:		mov byte [RetryCount],retry_count
+.try:		pushad
+		call int13
+		jc .error
+		add sp,byte 8*4			; Clean up stack
+		ret
+.error:
+		mov [DiskError],ah		; Save error code
+		popad
+		mov [DiskSys],ax		; Save system call number
+		dec byte [RetryCount]
+		jz .real_error
+		push ax
+		mov al,[RetryCount]
+		mov ah,[dapa+2]			; Sector transfer count
+		cmp al,2			; Only 2 attempts left
+		ja .nodanger
+		mov ah,1			; Drop transfer size to 1
+		jmp short .setsize
+.nodanger:
+		cmp al,retry_count-2
+		ja .again			; First time, just try again
+		shr ah,1			; Otherwise, try to reduce
+		adc ah,0			; the max transfer size, but not to 0
+.setsize:
+		mov [MaxTransferCD],ah
+		mov [dapa+2],ah
+.again:
+		pop ax
+		jmp .try
+
+.real_error:	mov si,diskerr_msg
+		call writemsg
+		mov al,[DiskError]
+		call writehex2
+		mov si,oncall_str
+		call writestr_early
+		mov ax,[DiskSys]
+		call writehex4
+		mov si,ondrive_str
+		call writestr_early
+		mov al,dl
+		call writehex2
+		call crlf
+		; Fall through to kaboom
+
+;
+; kaboom: write a message and bail out.  Wait for a user keypress,
+;	  then do a hard reboot.
+;
+		global kaboom
+disk_error:
+kaboom:
+		RESET_STACK_AND_SEGS AX
+		mov si,err_bootfailed
+		call writestr
+		call getchar
+		cli
+		mov word [BIOS_magic],0	; Cold reboot
+		jmp 0F000h:0FFF0h	; Reset vector address
+
+; -----------------------------------------------------------------------------
+;  Common modules needed in the first sector
+; -----------------------------------------------------------------------------
+
+%include "writestr.inc"		; String output
+writestr_early	equ writestr
+%include "writehex.inc"		; Hexadecimal output
+
+; -----------------------------------------------------------------------------
+; Data that needs to be in the first sector
+; -----------------------------------------------------------------------------
+
+syslinux_banner	db CR, LF, MY_NAME, ' ', VERSION_STR, ' ', DATE_STR, ' ', 0
+copyright_str   db ' Copyright (C) 1994-'
+		asciidec YEAR
+		db ' H. Peter Anvin et al', CR, LF, 0
+isolinux_str	db 'isolinux: ', 0
+%ifdef DEBUG_MESSAGES
+startup_msg:	db 'Starting up, DL = ', 0
+spec_ok_msg:	db 'Loaded spec packet OK, drive = ', 0
+secsize_msg:	db 'Sector size ', 0
+offset_msg:	db 'Main image LBA = ', 0
+verify_msg:	db 'Image checksum verified.', CR, LF, 0
+allread_msg	db 'Main image read, jumping to main code...', CR, LF, 0
+%endif
+noinfotable_msg	db 'No boot info table, assuming single session disk...', CR, LF, 0
+noinfoinspec_msg db 'Spec packet missing LBA information, trying to wing it...', CR, LF, 0
+spec_err_msg:	db 'Loading spec packet failed, trying to wing it...', CR, LF, 0
+maybe_msg:	db 'Found something at drive = ', 0
+alright_msg:	db 'Looks reasonable, continuing...', CR, LF, 0
+nospec_msg	db 'Extremely broken BIOS detected, last attempt with drive = ', 0
+nothing_msg:	db 'Failed to locate CD-ROM device; boot failed.', CR, LF
+trysbm_msg	db 'See http://syslinux.zytor.com/sbm for more information.', CR, LF, 0
+diskerr_msg:	db 'Disk error ', 0
+oncall_str:	db ', AX = ',0
+ondrive_str:	db ', drive ', 0
+checkerr_msg:	db 'Image checksum error, sorry...', CR, LF, 0
+
+err_bootfailed	db CR, LF, 'Boot failed: press a key to retry...'
+bailmsg		equ err_bootfailed
+crlf_msg	db CR, LF
+null_msg	db 0
+
+bios_cdrom_str	db 'ETCD', 0
+%ifndef DEBUG_MESSAGES
+bios_cbios_str	db 'CHDD', 0
+bios_ebios_str	db 'EHDD' ,0
+%endif
+
+		alignz 4
+bios_cdrom:	dw getlinsec_cdrom, bios_cdrom_str
+%ifndef DEBUG_MESSAGES
+bios_cbios:	dw getlinsec_cbios, bios_cbios_str
+bios_ebios:	dw getlinsec_ebios, bios_ebios_str
+%endif
+
+; Maximum transfer size
+MaxTransfer	dw 127				; Hard disk modes
+MaxTransferCD	dw 32				; CD mode
+
+rl_checkpt	equ $				; Must be <= 800h
+
+		; This pads to the end of sector 0 and errors out on
+		; overflow.
+		times 2048-($-$$) db 0
+
+; ----------------------------------------------------------------------------
+;  End of code and data that have to be in the first sector
+; ----------------------------------------------------------------------------
+
+		section .text16
+
+all_read:
+
+; Test tracers
+		TRACER 'T'
+		TRACER '>'
+
+;
+; Common initialization code
+;
+%include "init.inc"
+
+		; Patch the writechr routine to point to the full code
+		mov di,writechr
+		mov al,0e9h
+		stosb
+		mov ax,writechr_full-2
+		sub ax,di
+		stosw
+
+; Tell the user we got this far...
+%ifndef DEBUG_MESSAGES			; Gets messy with debugging on
+		mov si,copyright_str
+		call writestr_early
+%endif
+
+;
+; Now we're all set to start with our *real* business.	First load the
+; configuration file (if any) and parse it.
+;
+; In previous versions I avoided using 32-bit registers because of a
+; rumour some BIOSes clobbered the upper half of 32-bit registers at
+; random.  I figure, though, that if there are any of those still left
+; they probably won't be trying to install Linux on them...
+;
+; The code is still ripe with 16-bitisms, though.  Not worth the hassle
+; to take'm out.  In fact, we may want to put them back if we're going
+; to boot ELKS at some point.
+;
+
+;
+; Now, we need to sniff out the actual filesystem data structures.
+; mkisofs gave us a pointer to the primary volume descriptor
+; (which will be at 16 only for a single-session disk!); from the PVD
+; we should be able to find the rest of what we need to know.
+;
+init_fs:
+		pushad
+	        mov eax,ROOT_FS_OPS
+	        mov dl,[DriveNumber]
+               	cmp word [BIOSType],bios_cdrom
+                sete dh                        ; 1 for cdrom, 0 for hybrid mode
+		jne .hybrid
+		movzx ebp,word [MaxTransferCD]
+		jmp .common
+.hybrid:
+		movzx ebp,word [MaxTransfer]
+.common:
+	        mov ecx,[Hidden]
+	        mov ebx,[Hidden+4]
+                mov si,[bsHeads]
+		mov di,[bsSecPerTrack]
+		pm_call fs_init
+		popad
+
+		section .rodata
+		alignz 4
+ROOT_FS_OPS:
+		extern iso_fs_ops
+		dd iso_fs_ops
+		dd 0
+
+		section .text16
+
+;
+; Locate the configuration file
+;
+		pm_call load_config
+
+;
+; Now we have the config file open.  Parse the config file and
+; run the user interface.
+;
+%include "ui.inc"
+
+;
+; Enable disk emulation.  The kind of disk we emulate is dependent on the
+; size of the file: 1200K, 1440K or 2880K floppy, otherwise harddisk.
+;
+is_disk_image:
+		TRACER CR
+		TRACER LF
+		TRACER 'D'
+		TRACER ':'
+
+		mov edx,eax			; File size
+		mov di,img_table
+		mov cx,img_table_count
+		mov eax,[si+file_sector]	; Starting LBA of file
+		mov [dsp_lba],eax		; Location of file
+		mov byte [dsp_drive], 0		; 00h floppy, 80h hard disk
+.search_table:
+		TRACER 't'
+		mov eax,[di+4]
+		cmp edx,[di]
+		je .type_found
+		add di,8
+		loop .search_table
+
+		; Hard disk image.  Need to examine the partition table
+		; in order to deduce the C/H/S geometry.  Sigh.
+.hard_disk_image:
+		TRACER 'h'
+		cmp edx,512
+		jb .bad_image
+
+		mov bx,trackbuf
+		mov cx,1			; Load 1 sector
+		pm_call getfssec
+
+		cmp word [trackbuf+510],0aa55h	; Boot signature
+		jne .bad_image		; Image not bootable
+
+		mov cx,4			; 4 partition entries
+		mov di,trackbuf+446		; Start of partition table
+
+		xor ax,ax			; Highest sector(al) head(ah)
+
+.part_scan:
+		cmp byte [di+4], 0
+		jz .part_loop
+		lea si,[di+1]
+		call .hs_check
+		add si,byte 4
+		call .hs_check
+.part_loop:
+		add di,byte 16
+		loop .part_scan
+
+		push eax			; H/S
+		push edx			; File size
+		mov bl,ah
+		xor bh,bh
+		inc bx				; # of heads in BX
+		xor ah,ah			; # of sectors in AX
+		cwde				; EAX[31:16] <- 0
+		mul bx
+		shl eax,9			; Convert to bytes
+		; Now eax contains the number of bytes per cylinder
+		pop ebx				; File size
+		xor edx,edx
+		div ebx
+		and edx,edx
+		jz .no_remainder
+		inc eax				; Fractional cylinder...
+		; Now (e)ax contains the number of cylinders
+.no_remainder:	cmp eax,1024
+		jna .ok_cyl
+		mov ax,1024			; Max possible #
+.ok_cyl:	dec ax				; Convert to max cylinder no
+		pop ebx				; S(bl) H(bh)
+		shl ah,6
+		or bl,ah
+		xchg ax,bx
+		shl eax,16
+		mov ah,bl
+		mov al,4			; Hard disk boot
+		mov byte [dsp_drive], 80h	; Drive 80h = hard disk
+
+.type_found:
+		TRACER 'T'
+		mov bl,[sp_media]
+		and bl,0F0h			; Copy controller info bits
+		or al,bl
+		mov [dsp_media],al		; Emulation type
+		shr eax,8
+		mov [dsp_chs],eax		; C/H/S geometry
+		mov ax,[sp_devspec]		; Copy device spec
+		mov [dsp_devspec],ax
+		mov al,[sp_controller]		; Copy controller index
+		mov [dsp_controller],al
+
+		TRACER 'V'
+		call vgaclearmode		; Reset video
+
+		mov ax,4C00h			; Enable emulation and boot
+		mov si,dspec_packet
+		mov dl,[DriveNumber]
+		lss sp,[InitStack]
+		TRACER 'X'
+
+		call int13
+
+		; If this returns, we have problems
+.bad_image:
+		mov si,err_disk_image
+		call writestr
+		jmp enter_command
+
+;
+; Look for the highest seen H/S geometry
+; We compute cylinders separately
+;
+.hs_check:
+		mov bl,[si]			; Head #
+		cmp bl,ah
+		jna .done_track
+		mov ah,bl			; New highest head #
+.done_track:	mov bl,[si+1]
+		and bl,3Fh			; Sector #
+		cmp bl,al
+		jna .done_sector
+		mov al,bl
+.done_sector:	ret
+
+
+
+; -----------------------------------------------------------------------------
+;  Common modules
+; -----------------------------------------------------------------------------
+
+%include "common.inc"		; Universal modules
+%include "rawcon.inc"		; Console I/O w/o using the console functions
+%include "localboot.inc"	; Disk-based local boot
+
+; -----------------------------------------------------------------------------
+;  Begin data section
+; -----------------------------------------------------------------------------
+
+		section .data16
+err_disk_image	db 'Cannot load disk image (invalid file)?', CR, LF, 0
+
+;
+; Config file keyword table
+;
+%include "keywords.inc"
+
+;
+; Extensions to search for (in *forward* order).
+;
+		alignz 4
+exten_table:	db '.cbt'		; COMBOOT (specific)
+		db '.img'		; Disk image
+		db '.bin'		; CD boot sector
+		db '.com'		; COMBOOT (same as DOS)
+		db '.c32'		; COM32
+exten_table_end:
+		dd 0, 0			; Need 8 null bytes here
+
+;
+; Floppy image table
+;
+		alignz 4
+img_table_count	equ 3
+img_table:
+		dd 1200*1024		; 1200K floppy
+		db 1			; Emulation type
+		db 80-1			; Max cylinder
+		db 15			; Max sector
+		db 2-1			; Max head
+
+		dd 1440*1024		; 1440K floppy
+		db 2			; Emulation type
+		db 80-1			; Max cylinder
+		db 18			; Max sector
+		db 2-1			; Max head
+
+		dd 2880*1024		; 2880K floppy
+		db 3			; Emulation type
+		db 80-1			; Max cylinder
+		db 36			; Max sector
+		db 2-1			; Max head
diff --git a/contrib/syslinux-4.02/core/kaboom.c b/contrib/syslinux-4.02/core/kaboom.c
new file mode 100644
index 0000000..d639915
--- /dev/null
+++ b/contrib/syslinux-4.02/core/kaboom.c
@@ -0,0 +1,16 @@
+/*
+ * kaboom.c
+ */
+
+#include "core.h"
+
+#undef kaboom
+
+__noreturn _kaboom(void)
+{
+    extern void kaboom(void);
+    call16(kaboom, &zero_regs, NULL);
+    /* Do this if kaboom somehow returns... */
+    for (;;)
+	asm volatile("hlt");
+}
diff --git a/contrib/syslinux-4.02/core/kernel.inc b/contrib/syslinux-4.02/core/kernel.inc
new file mode 100644
index 0000000..245cd6d
--- /dev/null
+++ b/contrib/syslinux-4.02/core/kernel.inc
@@ -0,0 +1,118 @@
+;; -----------------------------------------------------------------------
+;;
+;;   Copyright 1994-2008 H. Peter Anvin - All Rights Reserved
+;;
+;;   This program is free software; you can redistribute it and/or modify
+;;   it under the terms of the GNU General Public License as published by
+;;   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
+;;   Boston MA 02111-1307, USA; either version 2 of the License, or
+;;   (at your option) any later version; incorporated herein by reference.
+;;
+;; -----------------------------------------------------------------------
+
+;;
+;; kernel.inc
+;;
+;; Header file for the kernel interface definitions
+;;
+
+%ifndef _KERNEL_INC
+%define _KERNEL_INC
+
+;;
+;; Structure of the real_mode_seg
+;;
+
+		struc real_mode_seg_t
+		resb 20h-($-$$)		; org 20h
+kern_cmd_magic	resw 1			; 0020 Magic # for command line
+kern_cmd_offset resw 1			; 0022 Offset for kernel command line
+		resb 497-($-$$)		; org 497d
+bs_setupsecs	resb 1			; 01F1 Sectors for setup code (0 -> 4)
+bs_rootflags	resw 1			; 01F2 Root readonly flag
+bs_syssize	resw 1			; 01F4
+bs_swapdev	resw 1			; 01F6 Swap device (obsolete)
+bs_ramsize	resw 1			; 01F8 Ramdisk flags, formerly ramdisk size
+bs_vidmode	resw 1			; 01FA Video mode
+bs_rootdev	resw 1			; 01FC Root device
+bs_bootsign	resw 1			; 01FE Boot sector signature (0AA55h)
+su_jump		resb 1			; 0200 0EBh
+su_jump2	resb 1			; 0201 Size of following header
+su_header	resd 1			; 0202 New setup code: header
+su_version	resw 1			; 0206 See linux/arch/i386/boot/setup.S
+su_switch	resw 1			; 0208
+su_setupseg	resw 1			; 020A
+su_startsys	resw 1			; 020C
+su_kver		resw 1			; 020E Kernel version pointer
+su_loader	resb 1			; 0210 Loader ID
+su_loadflags	resb 1			; 0211 Load high flag
+su_movesize	resw 1			; 0212
+su_code32start	resd 1			; 0214 Start of code loaded high
+su_ramdiskat	resd 1			; 0218 Start of initial ramdisk
+su_ramdisklen	resd 1			; 021C Length of initial ramdisk
+su_bsklugeoffs	resw 1			; 0220
+su_bsklugeseg	resw 1			; 0222
+su_heapend	resw 1			; 0224
+su_pad1		resw 1			; 0226
+su_cmd_line_ptr	resd 1			; 0228
+su_ramdisk_max	resd 1			; 022C
+		resb (0f800h-12)-($-$$)
+linux_stack	equ $			; F7F4
+linux_fdctab	resb 12
+cmd_line_here	equ $			; F800 Should be out of the way
+		endstruc
+
+		global cmd_line
+cmd_line	equ core_real_mode + cmd_line_here
+
+;
+; Old kernel command line signature
+;
+CMD_MAGIC	equ 0A33Fh		; Command line magic
+
+;
+; If we're loading the command line old-style, we need a smaller
+; heap.
+;
+old_cmd_line_here equ 9800h
+old_max_cmd_len   equ 2047
+old_linux_fdctab  equ old_cmd_line_here-12
+old_linux_stack   equ old_linux_fdctab
+
+;
+; Magic number of su_header field
+;
+HEADER_ID       equ 'HdrS'		; HdrS (in littleendian hex)
+
+;
+; Flags for the su_loadflags field
+;
+LOAD_HIGH	equ 01h			; Large kernel, load high
+QUIET_FLAG	equ 20h			; Quiet the kernel
+KEEP_SEGMENTS	equ 40h			; Don't reload segments
+CAN_USE_HEAP    equ 80h                 ; Boot loader reports heap size
+
+;
+; ID codes for various modules
+;
+syslinux_id	equ 031h		; 3 = SYSLINUX family; 1 = SYSLINUX
+pxelinux_id	equ 032h		; 3 = SYSLINUX family; 2 = PXELINUX
+isolinux_id	equ 033h		; 3 = SYSLINUX family; 3 = ISOLINUX
+extlinux_id	equ 034h		; 3 = SYSLINUX family; 4 = EXTLINUX
+
+;
+; Types of vkernels
+;
+VK_LOCALBOOT	equ -1			; localboot (no actual kernel loaded)
+VK_KERNEL	equ 0			; Choose by filename
+VK_LINUX	equ 1			; Linux kernel image
+VK_BOOT		equ 2			; Boot sector
+VK_BSS		equ 3			; BSS boot sector
+VK_PXE		equ 4			; PXE NBP
+VK_FDIMAGE	equ 5			; Floppy disk image
+VK_COMBOOT	equ 6			; COMBOOT image
+VK_COM32	equ 7			; COM32 image
+VK_CONFIG	equ 8			; Configuration file
+VK_TYPES	equ 9			; Number of VK types
+
+%endif ; _KERNEL_INC
diff --git a/contrib/syslinux-4.02/core/keywords b/contrib/syslinux-4.02/core/keywords
new file mode 100644
index 0000000..c289ae2
--- /dev/null
+++ b/contrib/syslinux-4.02/core/keywords
@@ -0,0 +1,48 @@
+menu
+text
+include
+append
+initrd
+config
+default
+ui
+display
+font
+implicit
+ipappend
+kbdmap
+kernel
+linux
+boot
+bss
+pxe
+fdimage
+comboot
+com32
+label
+localboot
+prompt
+say
+serial
+console
+timeout
+totaltimeout
+allowoptions
+ontimeout
+onerror
+noescape
+nocomplete
+nohalt
+f0
+f1
+f2
+f3
+f4
+f5
+f6
+f7
+f8
+f9
+f10
+f11
+f12
diff --git a/contrib/syslinux-4.02/core/keywords.inc b/contrib/syslinux-4.02/core/keywords.inc
new file mode 100644
index 0000000..d0f7db3
--- /dev/null
+++ b/contrib/syslinux-4.02/core/keywords.inc
@@ -0,0 +1,101 @@
+;; -----------------------------------------------------------------------
+;;
+;;   Copyright 1994-2008 H. Peter Anvin - All Rights Reserved
+;;
+;;   This program is free software; you can redistribute it and/or modify
+;;   it under the terms of the GNU General Public License as published by
+;;   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
+;;   Boston MA 02111-1307, USA; either version 2 of the License, or
+;;   (at your option) any later version; incorporated herein by reference.
+;;
+;; -----------------------------------------------------------------------
+
+;;
+;; keywords.inc
+;;
+;; Common header file for the handling of keyword hash and macros
+;;
+
+%ifndef DEPEND		; Generated file
+%include "kwdhash.gen"
+%endif
+
+%macro keyword 2
+	dd hash_%1	; Hash value
+	dw 0		; No argument
+	dw %2		; Entrypoint
+%endmacro
+
+%macro keyword 3
+	dd hash_%1	; Hash value
+	dw %3		; 16-bit argument
+	dw %2		; Entrypoint
+%endmacro
+
+%macro keyword 4
+	dd hash_%1	; Hash value
+	db %3, %4	; 2 8-bit arguments
+	dw %2		; Entrypoint
+%endmacro
+
+keywd_size	equ 8	; Bytes per keyword
+
+		alignz 4
+
+%define FKeyN(n) (FKeyName+(((n)-1) << FILENAME_MAX_LG2))
+
+keywd_table:
+		keyword menu,		pc_comment
+		keyword text,		pc_text
+		keyword include,	pc_opencmd,	pc_include
+		keyword append,		pc_append
+		keyword initrd,		pc_filename,	InitRD
+		keyword default,	pc_default,	1
+		keyword ui,		pc_default,	2
+		keyword display,	pc_opencmd,	get_msg_file
+		keyword font,		pc_opencmd,	loadfont
+		keyword implicit,	pc_setint16,	AllowImplicit
+		keyword kbdmap,		pc_opencmd,	loadkeys
+		keyword kernel,		pc_kernel,	VK_KERNEL
+		keyword linux,		pc_kernel,	VK_LINUX
+		keyword boot,		pc_kernel,	VK_BOOT
+		keyword bss,		pc_kernel,	VK_BSS
+		keyword pxe,		pc_kernel,	VK_PXE
+		keyword fdimage,	pc_kernel,	VK_FDIMAGE
+		keyword comboot,	pc_kernel,	VK_COMBOOT
+		keyword com32,		pc_kernel,	VK_COM32
+		keyword config,		pc_kernel,	VK_CONFIG
+		keyword label,		pc_label
+		keyword prompt,		pc_setint16,	ForcePrompt
+		keyword say,		pc_say
+		keyword serial,		pc_serial
+		keyword console,	pc_setint16,	DisplayCon
+		keyword timeout,	pc_timeout,	KbdTimeout
+		keyword totaltimeout,	pc_timeout,	TotalTimeout
+		keyword ontimeout,	pc_ontimeout
+		keyword onerror,	pc_onerror
+		keyword allowoptions,	pc_setint16,	AllowOptions
+		keyword noescape,	pc_setint16,	NoEscape
+		keyword nocomplete,	pc_setint16,	NoComplete
+		keyword nohalt,		pc_setint16,	NoHalt
+		keyword f1,		pc_filename,	FKeyN(1)
+		keyword f2,		pc_filename,	FKeyN(2)
+		keyword f3,		pc_filename,	FKeyN(3)
+		keyword f4,		pc_filename,	FKeyN(4)
+		keyword f5,		pc_filename,	FKeyN(5)
+		keyword f6,		pc_filename,	FKeyN(6)
+		keyword f7,		pc_filename,	FKeyN(7)
+		keyword f8,		pc_filename,	FKeyN(8)
+		keyword f9,		pc_filename,	FKeyN(9)
+		keyword f10,		pc_filename,	FKeyN(10)
+		keyword f0,		pc_filename,	FKeyN(10)
+		keyword f11,		pc_filename,	FKeyN(11)
+		keyword f12,		pc_filename,	FKeyN(12)
+%if IS_PXELINUX
+		keyword ipappend,	pc_ipappend
+%endif
+%if HAS_LOCALBOOT
+		keyword localboot,	pc_localboot
+%endif
+
+keywd_count	equ ($-keywd_table)/keywd_size
diff --git a/contrib/syslinux-4.02/core/layout.inc b/contrib/syslinux-4.02/core/layout.inc
new file mode 100644
index 0000000..dab27dd
--- /dev/null
+++ b/contrib/syslinux-4.02/core/layout.inc
@@ -0,0 +1,171 @@
+; -----------------------------------------------------------------------
+;
+;   Copyright 1994-2009 H. Peter Anvin - All Rights Reserved
+;   Copyright 2009-2010 Intel Corporation; author: H. Peter Anvin
+;
+;   This program is free software; you can redistribute it and/or modify
+;   it under the terms of the GNU General Public License as published by
+;   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
+;   Bostom MA 02111-1307, USA; either version 2 of the License, or
+;   (at your option) any later version; incorporated herein by reference.
+;
+; -----------------------------------------------------------------------
+
+;
+; layout.inc
+;
+; Memory layout of segments
+;
+
+		; Default to 16-bit code
+		bits 16
+
+; Memory below 0800h is reserved for the BIOS and the MBR.
+BSS_START	equ 0800h
+
+; Text starts at the load address of 07C00h.
+TEXT_START	equ 7C00h
+
+;
+; 16-bit stack layout
+;
+; PXELINUX: There are apparently some AMI BIOSes in the field which
+; put their BEV stack somewhere below 7C00h (and therefore don't
+; handle localboot properly), so avoid that immediate memory region.
+; The range that is known to be bad is approximately 75E8..7C00; the
+; lower bound is tight.
+; 
+		global STACK_LEN, STACK_TOP, STACK_BASE
+STACK_LEN	equ 4096
+%if IS_PXELINUX
+STACK_TOP	equ 7000h
+%else
+STACK_TOP	equ 7c00h
+%endif
+STACK_BASE	equ STACK_TOP - STACK_LEN
+
+; The secondary BSS section, above the text; we really wish we could
+; just make it follow .bcopy32 or hang off the end,
+; but it doesn't seem to work that way.
+LATEBSS_START	equ 0B800h
+
+;
+; 32-bit stack layout
+;
+		global STACK32_LEN
+STACK32_LEN	equ 64*1024
+
+		section	.stack		nobits write align=4096
+		resb STACK32_LEN
+
+;
+; The various sections and their relationship
+;
+		; Use .earlybss for things that MUST be in low memory.
+		section .earlybss	nobits write
+		section .config		write progbits align=4
+		section .replacestub	exec write progbits align=16
+		section .gentextnr	exec write nobits align=16
+
+		; Use .bss16 for things that doesn't have to be in low memory;
+		; .earlybss should be used for things that absolutely have
+		; to be below 0x7c00.
+		section .bss16		write nobits align=16
+
+%if 0 ; IS_PXELINUX
+		; Warning here: RBFG build 22 randomly overwrites
+		; memory location [0x5680,0x576c), possibly more.  It
+		; seems that it gets confused and screws up the
+		; pointer to its own internal packet buffer and starts
+		; writing a received ARP packet into low memory.
+		section .rbfg		write nobits
+RBFG_brainfuck:	resb 2048		; Bigger than an Ethernet packet...
+%endif
+
+		section .init		exec write progbits align=1
+		section .text16		exec write progbits align=1
+		section .textnr		exec nowrite progbits align=1
+		section .bcopyxx.text	exec nowrite progbits align=16
+		section .bcopyxx.data	noexec write progbits align=16
+		section .data16		noexec write progbits align=16
+
+		section .adv		write nobits align=512
+
+		; .uibss contains bss data which is guaranteed to be
+		; safe to clobber during the loading of the image.  This
+		; is because while loading the primary image we will clobber
+		; the spillover from the last fractional sector load.
+		section .uibss		write nobits align=16
+
+		; Symbols from linker script
+%macro SECINFO 1
+		extern __%1_start, __%1_lma, __%1_end
+		extern __%1_len, __%1_dwords
+%endmacro
+		SECINFO bss16
+		SECINFO uibss
+		SECINFO config
+		SECINFO replacestub
+		SECINFO bcopyxx
+
+		SECINFO pm_code
+		SECINFO high_clear
+
+		SECINFO bss
+
+		extern free_high_memory
+
+		global _start
+
+		section .text16
+
+;
+; Segment assignments in the bottom 640K
+; Keep the low-memory footprint as small as possible... overrun is a hard
+; failure!
+;
+
+serial_buf_size	equ 4096		; Should be a power of 2
+
+;
+; Contents of aux_seg
+;
+		extern aux_seg		; Actual segment assigned by linker
+
+		struc aux
+.fontbuf	resb 8192
+.serial		resb serial_buf_size
+
+		alignb 4096		; Align the next segment to 4K
+		endstruc
+
+		section .auxseg		write nobits align=16
+auxseg		resb aux_size
+
+;
+; Transfer buffer segment: guaranteed to be aligned 64K, used for disk I/O
+; One symbol for the segment number, one for the absolute address
+;
+		extern	xfer_buf_seg
+		section .xfer_buf	write nobits align=65536
+		global	core_xfer_buf
+core_xfer_buf	resb 65536
+
+;
+; Segment for the real mode code (needed as long as we have a in-kernel
+; loader and/or COM16 support.
+; One symbol for the segment number, one for the absolute address
+;
+		extern	real_mode_seg
+		section .real_mode	write nobits align=65536
+		global	core_real_mode
+core_real_mode	resb 65536
+comboot_seg	equ real_mode_seg	; COMBOOT image loading zone
+
+;
+; At the very end, the lowmem heap
+;
+		extern __lowmem_heap
+min_lowmem_heap	equ 65536
+
+		section .text16
diff --git a/contrib/syslinux-4.02/core/ldlinux.asm b/contrib/syslinux-4.02/core/ldlinux.asm
new file mode 100644
index 0000000..f62f55b
--- /dev/null
+++ b/contrib/syslinux-4.02/core/ldlinux.asm
@@ -0,0 +1,44 @@
+; -*- fundamental -*- (asm-mode sucks)
+; ****************************************************************************
+;
+;  ldlinux.asm
+;
+;  A program to boot Linux kernels off an MS-DOS formatted floppy disk.	 This
+;  functionality is good to have for installation floppies, where it may
+;  be hard to find a functional Linux system to run LILO off.
+;
+;  This program allows manipulation of the disk to take place entirely
+;  from MS-LOSS, and can be especially useful in conjunction with the
+;  umsdos filesystem.
+;
+;   Copyright 1994-2009 H. Peter Anvin - All Rights Reserved
+;   Copyright 2009 Intel Corporation; author: H. Peter Anvin
+;
+;  This program is free software; you can redistribute it and/or modify
+;  it under the terms of the GNU General Public License as published by
+;  the Free Software Foundation, Inc., 53 Temple Place Ste 330,
+;  Boston MA 02111-1307, USA; either version 2 of the License, or
+;  (at your option) any later version; incorporated herein by reference.
+;
+; ****************************************************************************
+
+%define IS_SYSLINUX 1
+%include "head.inc"
+
+;
+; Some semi-configurable constants... change on your own risk.
+;
+my_id		equ syslinux_id
+
+		section .rodata
+		alignz 4
+ROOT_FS_OPS:
+		extern vfat_fs_ops
+		dd vfat_fs_ops
+		extern ext2_fs_ops
+		dd ext2_fs_ops
+		extern btrfs_fs_ops
+		dd btrfs_fs_ops
+		dd 0
+
+%include "diskfs.inc"
diff --git a/contrib/syslinux-4.02/core/loadhigh.inc b/contrib/syslinux-4.02/core/loadhigh.inc
new file mode 100644
index 0000000..89de5e8
--- /dev/null
+++ b/contrib/syslinux-4.02/core/loadhigh.inc
@@ -0,0 +1,60 @@
+;; -----------------------------------------------------------------------
+;;
+;;   Copyright 1994-2009 H. Peter Anvin - All Rights Reserved
+;;   Copyright 2009-2010 Intel Corporation; author: H. Peter Anvin
+;;
+;;   This program is free software; you can redistribute it and/or modify
+;;   it under the terms of the GNU General Public License as published by
+;;   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
+;;   Boston MA 02111-1307, USA; either version 2 of the License, or
+;;   (at your option) any later version; incorporated herein by reference.
+;;
+;; -----------------------------------------------------------------------
+
+;;
+;; loadhigh.inc
+;;
+;; Load a file into high memory
+;;
+
+		section .text16
+
+;
+; load_high:	loads (the remainder of) a file into high memory.
+;
+;		Assumes CS == DS.
+;
+; Inputs:	SI  = file handle/cluster pointer
+;		EDI = target address in high memory
+;		EAX = maximum number of bytes to load
+;		DX  = zero-padding mask (e.g. 0003h for pad to dword)
+;		BX  = subroutine to call at the top of each loop
+;                     (to print status and check for abort)
+;		[MyHighMemSize] = maximum load address
+;
+; Outputs:	SI  = file handle/cluster pointer
+;		EBX = first untouched address (not including padding)
+;		EDI = first untouched address (including padding)
+;		CF  = reached EOF
+;
+		extern pm_load_high
+load_high:
+		push ebp
+		mov ebp,[MyHighMemSize]
+		pm_call pm_load_high
+		pop ebp
+		jo .overflow
+		ret
+
+.overflow:	mov si,err_nohighmem
+		jmp abort_load
+
+		section .data16
+err_nohighmem   db CR, LF
+		db 'Not enough memory to load specified image.', CR, LF, 0
+
+		section .bss16
+		alignb 2
+PauseBird	resw 1
+
+		section .text16
diff --git a/contrib/syslinux-4.02/core/localboot.inc b/contrib/syslinux-4.02/core/localboot.inc
new file mode 100644
index 0000000..a66cf20
--- /dev/null
+++ b/contrib/syslinux-4.02/core/localboot.inc
@@ -0,0 +1,76 @@
+; -----------------------------------------------------------------------
+;
+;   Copyright 1999-2008 H. Peter Anvin - All Rights Reserved
+;
+;   This program is free software; you can redistribute it and/or modify
+;   it under the terms of the GNU General Public License as published by
+;   the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+;   Boston MA 02110-1301, USA; either version 2 of the License, or
+;   (at your option) any later version; incorporated herein by reference.
+;
+; -----------------------------------------------------------------------
+
+;
+; localboot.inc
+;
+; Boot from a local disk, or invoke INT 18h.
+;
+
+%if HAS_LOCALBOOT
+
+;
+; Boot a specified local disk.  AX specifies the BIOS disk number; or
+; -1 in case we should execute INT 18h ("next device.")
+;
+		section .text16
+
+local_boot:
+		call vgaclearmode
+		RESET_STACK_AND_SEGS dx		; dx <- 0
+		mov fs,dx
+		mov gs,dx
+		mov si,localboot_msg
+		call writestr
+		call cleanup_hardware
+		cmp ax,-1
+		je .int18
+
+		; Load boot sector from the specified BIOS device and jump to it.
+		mov dl,al
+		xor dh,dh
+		push dx
+		xor ax,ax			; Reset drive
+		int 13h
+		mov ax,0201h			; Read one sector
+		mov cx,0001h			; C/H/S = 0/0/1 (first sector)
+		mov bx,trackbuf
+		mov bp,retry_count
+.again:
+		pusha
+		int 13h
+		popa
+		jnc .ok
+		dec bp
+		jnz .again
+		jmp kaboom			; Failure...
+.ok:
+		pop dx
+		cli				; Abandon hope, ye who enter here
+		mov si,trackbuf
+		mov di,07C00h
+		mov cx,512			; Probably overkill, but should be safe
+		rep movsd
+		mov ss,cx			; SS <- 0
+		mov sp,7C00h
+		jmp 0:07C00h			; Jump to new boot sector
+
+.int18:
+		int 18h				; Hope this does the right thing...
+		jmp kaboom			; If we returned, oh boy...
+
+		section .data16
+localboot_msg	db 'Booting from local disk...', CR, LF, 0
+
+		section .text16
+
+%endif ; HAS_LOCALBOOT
diff --git a/contrib/syslinux-4.02/core/lstadjust.pl b/contrib/syslinux-4.02/core/lstadjust.pl
new file mode 100755
index 0000000..cec5402
--- /dev/null
+++ b/contrib/syslinux-4.02/core/lstadjust.pl
@@ -0,0 +1,57 @@
+#!/usr/bin/perl
+#
+# Take a NASM list and map file and make the offsets in the list file
+# absolute.  This makes debugging a lot easier.
+#
+# Usage:
+#
+#  lstadjust.pl listfile mapfile outfile
+#
+
+($listfile, $mapfile, $outfile) = @ARGV;
+
+open(LST, "< $listfile\0")
+    or die "$0: cannot open: $listfile: $!\n";
+open(MAP, "< $mapfile\0")
+    or die "$0: cannot open: $mapfile: $!\n";
+open(OUT, "> $outfile\0")
+    or die "$0: cannot create: $outfile: $!\n";
+
+%vstart = ();
+
+while (defined($line = <MAP>)) {
+    if ($line =~ /^\s*([0-9]+)\s+(\S+)\s+([0-9a-f]+)\s+([0-9a-f]+)\s+([0-9a-f]+)\s+([0-9a-f]+)\s+2\*\*([0-9]+)/i) {
+	$vstart{$2} = hex $4;
+    }
+}
+close(MAP);
+
+$offset = 0;
+@ostack = ();
+
+while (defined($line = <LST>)) {
+    chomp $line;
+
+    $source = substr($line, 40);
+    if ($source =~ /^([^;]*);/) {
+	$source = $1;
+    }
+
+    ($label, $op, $arg, $tail) = split(/\s+/, $source);
+    if ($op =~ /^(|\[)section$/i) {
+	$offset = $vstart{$arg};
+    } elsif ($op =~ /^(absolute|\[absolute)$/i) {
+	$offset = 0;
+    } elsif ($op =~ /^struc$/i) {
+	push(@ostack, $offset);
+	$offset = 0;
+    } elsif ($op =~ /^endstruc$/i) {
+	$offset = pop(@ostack);
+    }
+
+    if ($line =~ /^(\s*[0-9]+ )([0-9A-F]{8})(\s.*)$/) {
+	$line = sprintf("%s%08X%s", $1, (hex $2)+$offset, $3);
+    }
+
+    print OUT $line, "\n";
+}
diff --git a/contrib/syslinux-4.02/core/lzo/enter.ash b/contrib/syslinux-4.02/core/lzo/enter.ash
new file mode 100644
index 0000000..49c455d
--- /dev/null
+++ b/contrib/syslinux-4.02/core/lzo/enter.ash
@@ -0,0 +1,89 @@
+/* enter.ash -- LZO assembler stuff
+
+   This file is part of the LZO real-time data compression library.
+
+   Copyright (C) 2008 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2007 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2006 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2005 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2004 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2003 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2002 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2001 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2000 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1999 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1998 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1997 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996 Markus Franz Xaver Johannes Oberhumer
+   All Rights Reserved.
+
+   The LZO library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU General Public License as
+   published by the Free Software Foundation; either version 2 of
+   the License, or (at your option) any later version.
+
+   The LZO library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with the LZO library; see the file COPYING.
+   If not, write to the Free Software Foundation, Inc.,
+   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+   Markus F.X.J. Oberhumer
+   <markus@oberhumer.com>
+   http://www.oberhumer.com/opensource/lzo/
+ */
+
+
+/***********************************************************************
+//
+************************************************************************/
+
+        pushl   %ebp
+        pushl   %edi
+        pushl   %esi
+        pushl   %ebx
+        pushl   %ecx
+        pushl   %edx
+        subl    $12,%esp
+
+        cld
+
+        movl    INP,%esi
+        movl    OUTP,%edi
+#if defined(N_3_EBP)
+        movl    $3,%ebp
+#endif
+#if defined(N_255_EBP)
+        movl    $255,%ebp
+#endif
+
+#if defined(LZO_TEST_DECOMPRESS_OVERRUN_INPUT)
+#if defined(INIT_OVERRUN)
+        INIT_OVERRUN
+# undef INIT_OVERRUN
+#endif
+        leal    -3(%esi),%eax       /* 3 == length of EOF code */
+        addl    INS,%eax
+        movl    %eax,INEND
+#endif
+
+#if defined(LZO_TEST_DECOMPRESS_OVERRUN_OUTPUT)
+#if defined(INIT_OVERRUN)
+        INIT_OVERRUN
+# undef INIT_OVERRUN
+#endif
+        movl    %edi,%eax
+        movl    OUTS,%edx
+        addl    (%edx),%eax
+        movl    %eax,OUTEND
+#endif
+
+
+/*
+vi:ts=4
+*/
+
diff --git a/contrib/syslinux-4.02/core/lzo/leave.ash b/contrib/syslinux-4.02/core/lzo/leave.ash
new file mode 100644
index 0000000..9550b46
--- /dev/null
+++ b/contrib/syslinux-4.02/core/lzo/leave.ash
@@ -0,0 +1,114 @@
+/* leave.ash -- LZO assembler stuff
+
+   This file is part of the LZO real-time data compression library.
+
+   Copyright (C) 2008 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2007 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2006 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2005 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2004 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2003 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2002 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2001 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2000 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1999 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1998 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1997 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996 Markus Franz Xaver Johannes Oberhumer
+   All Rights Reserved.
+
+   The LZO library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU General Public License as
+   published by the Free Software Foundation; either version 2 of
+   the License, or (at your option) any later version.
+
+   The LZO library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with the LZO library; see the file COPYING.
+   If not, write to the Free Software Foundation, Inc.,
+   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+   Markus F.X.J. Oberhumer
+   <markus@oberhumer.com>
+   http://www.oberhumer.com/opensource/lzo/
+ */
+
+
+/***********************************************************************
+//
+************************************************************************/
+
+/* check uncompressed size */
+#if defined(LZO_TEST_DECOMPRESS_OVERRUN_OUTPUT)
+        cmpl    OUTEND,%edi
+        ja      .L_output_overrun
+#endif
+
+/* check compressed size */
+        movl    INP,%edx
+        addl    INS,%edx
+        cmpl    %edx,%esi       /* check compressed size */
+        ja      .L_input_overrun
+        jb      .L_input_not_consumed
+
+.L_leave:
+        subl    OUTP,%edi       /* write back the uncompressed size */
+        movl    OUTS,%edx
+        movl    %edi,(%edx)
+
+        negl    %eax
+        addl    $12,%esp
+        popl    %edx
+        popl    %ecx
+        popl    %ebx
+        popl    %esi
+        popl    %edi
+        popl    %ebp
+#if 1
+        ret
+#else
+        jmp     .L_end
+#endif
+
+
+.L_error:
+        movl    $1,%eax         /* LZO_E_ERROR */
+        jmp     .L_leave
+
+.L_input_not_consumed:
+        movl    $8,%eax         /* LZO_E_INPUT_NOT_CONSUMED */
+        jmp     .L_leave
+
+.L_input_overrun:
+        movl    $4,%eax         /* LZO_E_INPUT_OVERRUN */
+        jmp     .L_leave
+
+#if defined(LZO_TEST_DECOMPRESS_OVERRUN_OUTPUT)
+.L_output_overrun:
+        movl    $5,%eax         /* LZO_E_OUTPUT_OVERRUN */
+        jmp     .L_leave
+#endif
+
+#if defined(LZO_TEST_DECOMPRESS_OVERRUN_LOOKBEHIND)
+.L_lookbehind_overrun:
+        movl    $6,%eax         /* LZO_E_LOOKBEHIND_OVERRUN */
+        jmp     .L_leave
+#endif
+
+#if defined(LZO_DEBUG)
+.L_assert_fail:
+        movl    $99,%eax
+        jmp     .L_leave
+#endif
+
+.L_end:
+
+
+/*
+vi:ts=4
+*/
+
diff --git a/contrib/syslinux-4.02/core/lzo/lzo1c_d.ash b/contrib/syslinux-4.02/core/lzo/lzo1c_d.ash
new file mode 100644
index 0000000..9969c86
--- /dev/null
+++ b/contrib/syslinux-4.02/core/lzo/lzo1c_d.ash
@@ -0,0 +1,184 @@
+/* lzo1c_d.ash -- assembler implementation of the LZO1C decompression algorithm
+
+   This file is part of the LZO real-time data compression library.
+
+   Copyright (C) 2008 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2007 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2006 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2005 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2004 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2003 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2002 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2001 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2000 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1999 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1998 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1997 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996 Markus Franz Xaver Johannes Oberhumer
+   All Rights Reserved.
+
+   The LZO library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU General Public License as
+   published by the Free Software Foundation; either version 2 of
+   the License, or (at your option) any later version.
+
+   The LZO library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with the LZO library; see the file COPYING.
+   If not, write to the Free Software Foundation, Inc.,
+   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+   Markus F.X.J. Oberhumer
+   <markus@oberhumer.com>
+   http://www.oberhumer.com/opensource/lzo/
+ */
+
+
+/***********************************************************************
+//
+************************************************************************/
+
+        ALIGN3
+.L1:
+        xorl    %eax,%eax
+        movb    (%esi),%al
+        incl    %esi
+        cmpb    $32,%al
+        jnb     .LMATCH
+
+        orb     %al,%al
+        jz      .L12
+        movl    %eax,%ecx
+.LIT:
+        TEST_OP((%edi,%ecx),%ebx)
+        TEST_IP((%esi,%ecx),%ebx)
+        rep
+        movsb
+.LM1:
+        movb    (%esi),%al
+        incl    %esi
+
+        cmpb    $32,%al
+        jb      .LM2
+.LMATCH:
+        cmpb    $64,%al
+        jb      .LN3
+
+        movl    %eax,%ecx
+        andb    $31,%al
+        leal    -1(%edi),%edx
+        shrl    $5,%ecx
+        subl    %eax,%edx
+        movb    (%esi),%al
+        incl    %esi
+
+        shll    $5,%eax
+        subl    %eax,%edx
+        incl    %ecx
+        xchgl   %esi,%edx
+        TEST_LOOKBEHIND(%esi)
+        TEST_OP((%edi,%ecx),%ebx)
+        rep
+        movsb
+        movl    %edx,%esi
+        jmp     .L1
+
+        ALIGN3
+.L12:
+        LODSB
+        leal    32(%eax),%ecx
+        cmpb    $248,%al
+        jb      .LIT
+
+        movl    $280,%ecx
+        subb    $248,%al
+        jz      .L11
+        xchgl   %eax,%ecx
+        xorb    %al,%al
+        shll    %cl,%eax
+        xchgl   %eax,%ecx
+.L11:
+        TEST_OP((%edi,%ecx),%ebx)
+        TEST_IP((%esi,%ecx),%ebx)
+        rep
+        movsb
+        jmp     .L1
+
+        ALIGN3
+.LM2:
+        leal    -1(%edi),%edx
+        subl    %eax,%edx
+        LODSB
+        shll    $5,%eax
+        subl    %eax,%edx
+        xchgl   %esi,%edx
+        TEST_LOOKBEHIND(%esi)
+        TEST_OP(4(%edi),%ebx)
+        movsb
+        movsb
+        movsb
+        movl    %edx,%esi
+        movsb
+        xorl    %eax,%eax
+        jmp     .LM1
+.LN3:
+        andb    $31,%al
+        movl    %eax,%ecx
+        jnz     .LN6
+        movb    $31,%cl
+.LN4:
+        LODSB
+        orb     %al,%al
+        jnz     .LN5
+        addl    N_255,%ecx
+        jmp     .LN4
+
+        ALIGN3
+.LN5:
+        addl    %eax,%ecx
+.LN6:
+        movb    (%esi),%al
+        incl    %esi
+
+        movl    %eax,%ebx
+        andb    $63,%al
+        movl    %edi,%edx
+        subl    %eax,%edx
+
+        movb    (%esi),%al
+        incl    %esi
+
+        shll    $6,%eax
+        subl    %eax,%edx
+        cmpl    %edi,%edx
+        jz      .LEOF
+
+        xchgl   %edx,%esi
+        leal    3(%ecx),%ecx
+        TEST_LOOKBEHIND(%esi)
+        TEST_OP((%edi,%ecx),%eax)
+        rep
+        movsb
+
+        movl    %edx,%esi
+        xorl    %eax,%eax
+        shrl    $6,%ebx
+        movl    %ebx,%ecx
+        jnz     .LIT
+        jmp     .L1
+
+.LEOF:
+/****   xorl    %eax,%eax          eax=0 from above */
+
+        cmpl    $1,%ecx         /* ecx must be 1 */
+        setnz   %al
+
+
+/*
+vi:ts=4
+*/
+
diff --git a/contrib/syslinux-4.02/core/lzo/lzo1f_d.ash b/contrib/syslinux-4.02/core/lzo/lzo1f_d.ash
new file mode 100644
index 0000000..aa9279e
--- /dev/null
+++ b/contrib/syslinux-4.02/core/lzo/lzo1f_d.ash
@@ -0,0 +1,176 @@
+/* lzo1f_d.ash -- assembler implementation of the LZO1F decompression algorithm
+
+   This file is part of the LZO real-time data compression library.
+
+   Copyright (C) 2008 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2007 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2006 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2005 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2004 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2003 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2002 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2001 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2000 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1999 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1998 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1997 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996 Markus Franz Xaver Johannes Oberhumer
+   All Rights Reserved.
+
+   The LZO library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU General Public License as
+   published by the Free Software Foundation; either version 2 of
+   the License, or (at your option) any later version.
+
+   The LZO library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with the LZO library; see the file COPYING.
+   If not, write to the Free Software Foundation, Inc.,
+   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+   Markus F.X.J. Oberhumer
+   <markus@oberhumer.com>
+   http://www.oberhumer.com/opensource/lzo/
+ */
+
+
+/***********************************************************************
+//
+************************************************************************/
+
+        ALIGN3
+.L0:
+        xorl    %eax,%eax
+        movb    (%esi),%al
+        incl    %esi
+        cmpb    $31,%al
+        ja      .LM2
+
+        orb     %al,%al
+        movl    %eax,%ecx
+        jnz     .L2
+1:
+        LODSB
+        orb     %al,%al
+        jnz     2f
+        addl    N_255,%ecx
+        jmp     1b
+2:
+        lea     31(%eax,%ecx),%ecx
+.L2:
+        TEST_OP((%edi,%ecx),%ebx)
+        TEST_IP((%esi,%ecx),%ebx)
+        movb    %cl,%al
+        shrl    $2,%ecx
+        rep
+        movsl
+        andb    $3,%al
+        jz      1f
+        movl    (%esi),%ebx
+        addl    %eax,%esi
+        movl    %ebx,(%edi)
+        addl    %eax,%edi
+1:
+        movb    (%esi),%al
+        incl    %esi
+.LM1:
+        cmpb    $31,%al
+        jbe     .LM21
+
+.LM2:
+        cmpb    $223,%al
+        ja      .LM3
+
+        movl    %eax,%ecx
+        shrl    $2,%eax
+        lea     -1(%edi),%edx
+        andb    $7,%al
+        shrl    $5,%ecx
+        movl    %eax,%ebx
+
+        movb    (%esi),%al
+        leal    (%ebx,%eax,8),%eax
+        incl    %esi
+.LM5:
+        subl    %eax,%edx
+        addl    $2,%ecx
+        xchgl   %edx,%esi
+        TEST_LOOKBEHIND(%esi)
+        TEST_OP((%edi,%ecx),%ebx)
+        cmpl    $6,%ecx
+        jb      1f
+        cmpl    $4,%eax
+        jb      1f
+        movb    %cl,%al
+        shrl    $2,%ecx
+        rep
+        movsl
+        andb    $3,%al
+        movb    %al,%cl
+1:
+        rep
+        movsb
+        movl    %edx,%esi
+.LN1:
+        movb    -2(%esi),%cl
+        andl    $3,%ecx
+        jz      .L0
+        movl    (%esi),%eax
+        addl    %ecx,%esi
+        movl    %eax,(%edi)
+        addl    %ecx,%edi
+        xorl    %eax,%eax
+        movb    (%esi),%al
+        incl    %esi
+        jmp     .LM1
+.LM21:
+        TEST_OP(3(%edi),%edx)
+        shrl    $2,%eax
+        leal    -0x801(%edi),%edx
+        movl    %eax,%ecx
+        movb    (%esi),%al
+        incl    %esi
+        leal    (%ecx,%eax,8),%eax
+        subl    %eax,%edx
+        TEST_LOOKBEHIND(%edx)
+        movl    (%edx),%eax
+        movl    %eax,(%edi)
+        addl    $3,%edi
+        jmp     .LN1
+1:
+        LODSB
+        orb     %al,%al
+        jnz     2f
+        addl    N_255,%ecx
+        jmp     1b
+2:
+        lea     31(%eax,%ecx),%ecx
+        jmp     .LM4
+
+        ALIGN3
+.LM3:
+        andb    $31,%al
+        movl    %eax,%ecx
+        jz      1b
+.LM4:
+        movl    %edi,%edx
+        movw    (%esi),%ax
+        addl    $2,%esi
+        shrl    $2,%eax
+        jnz     .LM5
+
+.LEOF:
+/****   xorl    %eax,%eax          eax=0 from above */
+
+        cmpl    $1,%ecx         /* ecx must be 1 */
+        setnz   %al
+
+
+/*
+vi:ts=4
+*/
+
diff --git a/contrib/syslinux-4.02/core/lzo/lzo1x_d.ash b/contrib/syslinux-4.02/core/lzo/lzo1x_d.ash
new file mode 100644
index 0000000..aa13835
--- /dev/null
+++ b/contrib/syslinux-4.02/core/lzo/lzo1x_d.ash
@@ -0,0 +1,401 @@
+/* lzo1x_d.ash -- assembler implementation of the LZO1X decompression algorithm
+
+   This file is part of the LZO real-time data compression library.
+
+   Copyright (C) 2008 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2007 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2006 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2005 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2004 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2003 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2002 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2001 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2000 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1999 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1998 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1997 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996 Markus Franz Xaver Johannes Oberhumer
+   All Rights Reserved.
+
+   The LZO library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU General Public License as
+   published by the Free Software Foundation; either version 2 of
+   the License, or (at your option) any later version.
+
+   The LZO library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with the LZO library; see the file COPYING.
+   If not, write to the Free Software Foundation, Inc.,
+   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+   Markus F.X.J. Oberhumer
+   <markus@oberhumer.com>
+   http://www.oberhumer.com/opensource/lzo/
+ */
+
+
+#if !defined(LZO1X) && !defined(LZO1Y)
+#  define LZO1X
+#endif
+
+#if defined(LZO_FAST)
+#  define NN    3
+#else
+#  define NN    0
+#endif
+
+
+/***********************************************************************
+// init
+************************************************************************/
+
+        xorl    %eax,%eax
+        xorl    %ebx,%ebx       /* high bits 9-32 stay 0 */
+        lodsb
+        cmpb    $17,%al
+        jbe     .L01
+        subb    $17-NN,%al
+#if defined(LZO_FAST)
+        jmp     .LFLR
+#else
+        cmpb    $4,%al
+        jae     .LFLR
+#if 1
+        TEST_OP((%edi,%eax),%edx)
+        TEST_IP((%esi,%eax),%edx)
+        movl    %eax,%ecx
+        jmp     .LFLR2
+#else
+        jmp     .LFLR3
+#endif
+#endif
+
+
+/***********************************************************************
+// literal run
+************************************************************************/
+
+0:      addl    N_255,%eax
+        TEST_IP(18(%esi,%eax),%edx)     /* minimum */
+1:      movb    (%esi),%bl
+        incl    %esi
+        orb     %bl,%bl
+        jz      0b
+        leal    18+NN(%eax,%ebx),%eax
+        jmp     3f
+
+
+        ALIGN3
+.L00:
+#ifdef LZO_DEBUG
+    andl $0xffffff00,%eax ; jnz .L_assert_fail
+    andl $0xffffff00,%ebx ; jnz .L_assert_fail
+    xorl %eax,%eax ; xorl %ebx,%ebx
+    xorl %ecx,%ecx ; xorl %edx,%edx
+#endif
+        TEST_IP_R(%esi)
+        LODSB
+.L01:
+        cmpb    $16,%al
+        jae     .LMATCH
+
+/* a literal run */
+        orb     %al,%al
+        jz      1b
+        addl    $3+NN,%eax
+3:
+.LFLR:
+        TEST_OP(-NN(%edi,%eax),%edx)
+        TEST_IP(-NN(%esi,%eax),%edx)
+#if defined(LZO_FAST)
+        movl    %eax,%ecx
+        NOTL_3(%eax)
+        shrl    $2,%ecx
+        andl    N_3,%eax
+        COPYL(%esi,%edi,%edx)
+        subl    %eax,%esi
+        subl    %eax,%edi
+#else
+        movl    %eax,%ecx
+        shrl    $2,%eax
+        andl    N_3,%ecx
+        COPYL_C(%esi,%edi,%edx,%eax)
+.LFLR2:
+        rep
+        movsb
+#endif
+
+#ifdef LZO_DEBUG
+    andl $0xffffff00,%eax ; jnz .L_assert_fail
+    andl $0xffffff00,%ebx ; jnz .L_assert_fail
+    xorl %eax,%eax ; xorl %ebx,%ebx
+    xorl %ecx,%ecx ; xorl %edx,%edx
+#endif
+        LODSB
+        cmpb    $16,%al
+        jae     .LMATCH
+
+
+/***********************************************************************
+// R1
+************************************************************************/
+
+        TEST_OP(3(%edi),%edx)
+        shrl    $2,%eax
+        movb    (%esi),%bl
+#if defined(LZO1X)
+        leal    -0x801(%edi),%edx
+#elif defined(LZO1Y)
+        leal    -0x401(%edi),%edx
+#endif
+        leal    (%eax,%ebx,4),%eax
+        incl    %esi
+        subl    %eax,%edx
+        TEST_LOOKBEHIND(%edx)
+#if defined(LZO_FAST)
+        movl    (%edx),%ecx
+        movl    %ecx,(%edi)
+#else
+        movb    (%edx),%al
+        movb    %al,(%edi)
+        movb    1(%edx),%al
+        movb    %al,1(%edi)
+        movb    2(%edx),%al
+        movb    %al,2(%edi)
+#endif
+        addl    N_3,%edi
+        jmp     .LMDONE
+
+
+/***********************************************************************
+// M2
+************************************************************************/
+
+        ALIGN3
+.LMATCH:
+        cmpb    $64,%al
+        jb      .LM3MATCH
+
+/* a M2 match */
+        movl    %eax,%ecx
+        shrl    $2,%eax
+        leal    -1(%edi),%edx
+#if defined(LZO1X)
+        andl    $7,%eax
+        movb    (%esi),%bl
+        shrl    $5,%ecx
+        leal    (%eax,%ebx,8),%eax
+#elif defined(LZO1Y)
+        andl    N_3,%eax
+        movb    (%esi),%bl
+        shrl    $4,%ecx
+        leal    (%eax,%ebx,4),%eax
+#endif
+        incl    %esi
+        subl    %eax,%edx
+
+#if defined(LZO_FAST)
+#if defined(LZO1X)
+        addl    $1+3,%ecx
+#elif defined(LZO1Y)
+        addl    $2,%ecx
+#endif
+#else
+#if defined(LZO1X)
+        incl    %ecx
+#elif defined(LZO1Y)
+        decl    %ecx
+#endif
+#endif
+
+        cmpl    N_3,%eax
+        jae     .LCOPYLONG
+        jmp     .LCOPYBYTE
+
+
+/***********************************************************************
+// M3
+************************************************************************/
+
+0:      addl    N_255,%eax
+        TEST_IP(3(%esi),%edx)       /* minimum */
+1:      movb    (%esi),%bl
+        incl    %esi
+        orb     %bl,%bl
+        jz      0b
+        leal    33+NN(%eax,%ebx),%ecx
+        xorl    %eax,%eax
+        jmp     3f
+
+
+        ALIGN3
+.LM3MATCH:
+        cmpb    $32,%al
+        jb      .LM4MATCH
+
+/* a M3 match */
+        andl    $31,%eax
+        jz      1b
+        lea     2+NN(%eax),%ecx
+3:
+#ifdef LZO_DEBUG
+    andl $0xffff0000,%eax ; jnz .L_assert_fail
+#endif
+        movw    (%esi),%ax
+        leal    -1(%edi),%edx
+        shrl    $2,%eax
+        addl    $2,%esi
+        subl    %eax,%edx
+
+        cmpl    N_3,%eax
+        jb      .LCOPYBYTE
+
+
+/***********************************************************************
+// copy match
+************************************************************************/
+
+        ALIGN1
+.LCOPYLONG:                      /* copy match using longwords */
+        TEST_LOOKBEHIND(%edx)
+#if defined(LZO_FAST)
+        leal    -3(%edi,%ecx),%eax
+        shrl    $2,%ecx
+        TEST_OP_R(%eax)
+        COPYL(%edx,%edi,%ebx)
+        movl    %eax,%edi
+        xorl    %ebx,%ebx
+#else
+        TEST_OP((%edi,%ecx),%eax)
+        movl    %ecx,%ebx
+        shrl    $2,%ebx
+        jz      2f
+        COPYL_C(%edx,%edi,%eax,%ebx)
+        andl    N_3,%ecx
+        jz      1f
+2:      COPYB_C(%edx,%edi,%al,%ecx)
+1:
+#endif
+
+.LMDONE:
+        movb    -2(%esi),%al
+        andl    N_3,%eax
+        jz      .L00
+.LFLR3:
+        TEST_OP((%edi,%eax),%edx)
+        TEST_IP((%esi,%eax),%edx)
+#if defined(LZO_FAST)
+        movl    (%esi),%edx
+        addl    %eax,%esi
+        movl    %edx,(%edi)
+        addl    %eax,%edi
+#else
+        COPYB_C(%esi,%edi,%cl,%eax)
+#endif
+
+#ifdef LZO_DEBUG
+    andl $0xffffff00,%eax ; jnz .L_assert_fail
+    andl $0xffffff00,%ebx ; jnz .L_assert_fail
+    xorl %eax,%eax ; xorl %ebx,%ebx
+    xorl %ecx,%ecx ; xorl %edx,%edx
+#endif
+        LODSB
+        jmp     .LMATCH
+
+
+        ALIGN3
+.LCOPYBYTE:                      /* copy match using bytes */
+        TEST_LOOKBEHIND(%edx)
+        TEST_OP(-NN(%edi,%ecx),%eax)
+        xchgl   %edx,%esi
+#if defined(LZO_FAST)
+        subl    N_3,%ecx
+#endif
+        rep
+        movsb
+        movl    %edx,%esi
+        jmp     .LMDONE
+
+
+/***********************************************************************
+// M4
+************************************************************************/
+
+0:      addl    N_255,%ecx
+        TEST_IP(3(%esi),%edx)       /* minimum */
+1:      movb    (%esi),%bl
+        incl    %esi
+        orb     %bl,%bl
+        jz      0b
+        leal    9+NN(%ebx,%ecx),%ecx
+        jmp     3f
+
+
+        ALIGN3
+.LM4MATCH:
+        cmpb    $16,%al
+        jb      .LM1MATCH
+
+/* a M4 match */
+        movl    %eax,%ecx
+        andl    $8,%eax
+        shll    $13,%eax        /* save in bit 16 */
+        andl    $7,%ecx
+        jz      1b
+        addl    $2+NN,%ecx
+3:
+#ifdef LZO_DEBUG
+    movl %eax,%edx ; andl $0xfffe0000,%edx ; jnz .L_assert_fail
+#endif
+        movw    (%esi),%ax
+        addl    $2,%esi
+        leal    -0x4000(%edi),%edx
+        shrl    $2,%eax
+        jz      .LEOF
+        subl    %eax,%edx
+        jmp     .LCOPYLONG
+
+
+/***********************************************************************
+// M1
+************************************************************************/
+
+        ALIGN3
+.LM1MATCH:
+/* a M1 match */
+        TEST_OP(2(%edi),%edx)
+        shrl    $2,%eax
+        movb    (%esi),%bl
+        leal    -1(%edi),%edx
+        leal    (%eax,%ebx,4),%eax
+        incl    %esi
+        subl    %eax,%edx
+        TEST_LOOKBEHIND(%edx)
+
+        movb    (%edx),%al      /* we must use this because edx can be edi-1 */
+        movb    %al,(%edi)
+        movb    1(%edx),%bl
+        movb    %bl,1(%edi)
+        addl    $2,%edi
+        jmp     .LMDONE
+
+
+/***********************************************************************
+//
+************************************************************************/
+
+.LEOF:
+/****   xorl    %eax,%eax          eax=0 from above */
+
+        cmpl    $3+NN,%ecx      /* ecx must be 3/6 */
+        setnz   %al
+
+
+/*
+vi:ts=4
+*/
+
diff --git a/contrib/syslinux-4.02/core/lzo/lzo1x_f1.S b/contrib/syslinux-4.02/core/lzo/lzo1x_f1.S
new file mode 100644
index 0000000..8360e34
--- /dev/null
+++ b/contrib/syslinux-4.02/core/lzo/lzo1x_f1.S
@@ -0,0 +1,63 @@
+/* lzo1x_f1.S -- fast LZO1X decompression in assembler (i386 + gcc)
+
+   This file is part of the LZO real-time data compression library.
+
+   Copyright (C) 2008 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2007 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2006 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2005 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2004 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2003 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2002 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2001 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2000 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1999 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1998 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1997 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996 Markus Franz Xaver Johannes Oberhumer
+   All Rights Reserved.
+
+   The LZO library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU General Public License as
+   published by the Free Software Foundation; either version 2 of
+   the License, or (at your option) any later version.
+
+   The LZO library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with the LZO library; see the file COPYING.
+   If not, write to the Free Software Foundation, Inc.,
+   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+   Markus F.X.J. Oberhumer
+   <markus@oberhumer.com>
+   http://www.oberhumer.com/opensource/lzo/
+ */
+
+
+/***********************************************************************
+//
+************************************************************************/
+
+#define LZO_FAST
+
+#include "lzo_asm.h"
+
+    .section ".textnr","ax"
+
+    LZO_PUBLIC(lzo1x_decompress_asm_fast)
+
+#include "enter.ash"
+#include "lzo1x_d.ash"
+#include "leave.ash"
+
+    LZO_PUBLIC_END(lzo1x_decompress_asm_fast)
+
+
+/*
+vi:ts=4
+*/
+
diff --git a/contrib/syslinux-4.02/core/lzo/lzo_asm.h b/contrib/syslinux-4.02/core/lzo/lzo_asm.h
new file mode 100644
index 0000000..55fdf6d
--- /dev/null
+++ b/contrib/syslinux-4.02/core/lzo/lzo_asm.h
@@ -0,0 +1,287 @@
+/* lzo_asm.h -- LZO assembler stuff
+
+   This file is part of the LZO real-time data compression library.
+
+   Copyright (C) 2008 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2007 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2006 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2005 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2004 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2003 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2002 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2001 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2000 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1999 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1998 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1997 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996 Markus Franz Xaver Johannes Oberhumer
+   All Rights Reserved.
+
+   The LZO library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU General Public License as
+   published by the Free Software Foundation; either version 2 of
+   the License, or (at your option) any later version.
+
+   The LZO library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with the LZO library; see the file COPYING.
+   If not, write to the Free Software Foundation, Inc.,
+   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+   Markus F.X.J. Oberhumer
+   <markus@oberhumer.com>
+   http://www.oberhumer.com/opensource/lzo/
+ */
+
+
+/***********************************************************************
+// <asmconfig.h>
+************************************************************************/
+
+#if !defined(__i386__)
+#  error
+#endif
+
+#if !defined(IN_CONFIGURE)
+#if defined(LZO_HAVE_CONFIG_H)
+#  include <config.h>
+#else
+   /* manual configuration - see defaults below */
+#  if defined(__ELF__)
+#    define MFX_ASM_HAVE_TYPE
+#    define MFX_ASM_NAME_NO_UNDERSCORES
+#  elif defined(__linux__)              /* Linux a.out */
+#    define MFX_ASM_ALIGN_PTWO
+#  elif defined(__DJGPP__)
+#    define MFX_ASM_ALIGN_PTWO
+#  elif defined(__GO32__)               /* djgpp v1 */
+#    define MFX_ASM_CANNOT_USE_EBP
+#  elif defined(__EMX__)
+#    define MFX_ASM_ALIGN_PTWO
+#    define MFX_ASM_CANNOT_USE_EBP
+#  endif
+#endif
+#endif
+
+#if 1 && defined(__ELF__)
+.section .note.GNU-stack,"",@progbits
+#endif
+#if 0 && defined(__ELF__)
+#undef i386
+.arch i386
+.code32
+#endif
+
+
+/***********************************************************************
+// name always uses underscores
+// [ OLD: name (default: with underscores) ]
+************************************************************************/
+
+#if !defined(LZO_ASM_NAME)
+#  define LZO_ASM_NAME(n)       _ ## n
+#if 0
+#  if defined(MFX_ASM_NAME_NO_UNDERSCORES)
+#    define LZO_ASM_NAME(n)     n
+#  else
+#    define LZO_ASM_NAME(n)     _ ## n
+#  endif
+#endif
+#endif
+
+
+/***********************************************************************
+// .type (default: do not use)
+************************************************************************/
+
+#if !defined(LZO_PUBLIC)
+#if defined(__LZO_DB__)
+#  define LZO_PUBLIC(func) \
+        .p2align 4 ; .byte 0,0,0,0,0,0,0 ; .ascii "LZO_START"
+#  define LZO_PUBLIC_END(func) \
+        .p2align 4,0x90 ; .ascii "LZO_END"
+#elif defined(MFX_ASM_HAVE_TYPE)
+#  define LZO_PUBLIC(func) \
+        ALIGN3 ; .type LZO_ASM_NAME(func),@function ; \
+        .globl LZO_ASM_NAME(func) ; LZO_ASM_NAME(func):
+#  define LZO_PUBLIC_END(func) \
+        .size LZO_ASM_NAME(func),.-LZO_ASM_NAME(func)
+#else
+#  define LZO_PUBLIC(func) \
+        ALIGN3 ; .globl LZO_ASM_NAME(func) ; LZO_ASM_NAME(func):
+#  define LZO_PUBLIC_END(func)
+#endif
+#endif
+
+
+/***********************************************************************
+// .align (default: bytes)
+************************************************************************/
+
+#if !defined(MFX_ASM_ALIGN_BYTES) && !defined(MFX_ASM_ALIGN_PTWO)
+#  define MFX_ASM_ALIGN_BYTES
+#endif
+
+#if !defined(LZO_ASM_ALIGN)
+#  if defined(MFX_ASM_ALIGN_PTWO)
+#    define LZO_ASM_ALIGN(x)    .align x
+#  else
+#    define LZO_ASM_ALIGN(x)    .align (1 << (x))
+#  endif
+#endif
+
+#define ALIGN1              LZO_ASM_ALIGN(1)
+#define ALIGN2              LZO_ASM_ALIGN(2)
+#define ALIGN3              LZO_ASM_ALIGN(3)
+
+
+/***********************************************************************
+// ebp usage (default: can use)
+************************************************************************/
+
+#if !defined(MFX_ASM_CANNOT_USE_EBP)
+#  if 1 && !defined(N_3_EBP) && !defined(N_255_EBP)
+#    define N_3_EBP
+#  endif
+#  if 0 && !defined(N_3_EBP) && !defined(N_255_EBP)
+#    define N_255_EBP
+#  endif
+#endif
+
+#if defined(N_3_EBP) && defined(N_255_EBP)
+#  error
+#endif
+#if defined(MFX_ASM_CANNOT_USE_EBP)
+#  if defined(N_3_EBP) || defined(N_255_EBP)
+#    error
+#  endif
+#endif
+
+#if !defined(N_3)
+#  if defined(N_3_EBP)
+#    define N_3         %ebp
+#  else
+#    define N_3         $3
+#  endif
+#endif
+
+#if !defined(N_255)
+#  if defined(N_255_EBP)
+#    define N_255       %ebp
+#    define NOTL_3(r)   xorl %ebp,r
+#  else
+#    define N_255       $255
+#  endif
+#endif
+
+#if !defined(NOTL_3)
+#  define NOTL_3(r)     xorl N_3,r
+#endif
+
+
+/***********************************************************************
+//
+************************************************************************/
+
+#ifndef INP
+#define INP      4+36(%esp)
+#define INS      8+36(%esp)
+#define OUTP    12+36(%esp)
+#define OUTS    16+36(%esp)
+#endif
+
+#define INEND         4(%esp)
+#define OUTEND        (%esp)
+
+
+#if defined(LZO_TEST_DECOMPRESS_OVERRUN_INPUT)
+#  define TEST_IP_R(r)      cmpl r,INEND ; jb .L_input_overrun
+#  define TEST_IP(addr,r)   leal addr,r ; TEST_IP_R(r)
+#else
+#  define TEST_IP_R(r)
+#  define TEST_IP(addr,r)
+#endif
+
+#if defined(LZO_TEST_DECOMPRESS_OVERRUN_OUTPUT)
+#  define TEST_OP_R(r)      cmpl r,OUTEND ; jb .L_output_overrun
+#  define TEST_OP(addr,r)   leal addr,r ; TEST_OP_R(r)
+#else
+#  define TEST_OP_R(r)
+#  define TEST_OP(addr,r)
+#endif
+
+#if defined(LZO_TEST_DECOMPRESS_OVERRUN_LOOKBEHIND)
+#  define TEST_LOOKBEHIND(r)    cmpl OUTP,r ; jb .L_lookbehind_overrun
+#else
+#  define TEST_LOOKBEHIND(r)
+#endif
+
+
+/***********************************************************************
+//
+************************************************************************/
+
+#define LODSB           movb (%esi),%al ; incl %esi
+
+#define MOVSB(r1,r2,x)  movb (r1),x ; incl r1 ; movb x,(r2) ; incl r2
+#define MOVSW(r1,r2,x)  movb (r1),x ; movb x,(r2) ; \
+                        movb 1(r1),x ; addl $2,r1 ; \
+                        movb x,1(r2) ; addl $2,r2
+#define MOVSL(r1,r2,x)  movl (r1),x ; addl $4,r1 ; movl x,(r2) ; addl $4,r2
+
+#if defined(LZO_DEBUG)
+#define COPYB_C(r1,r2,x,rc) \
+                        cmpl $0,rc ; jz .L_assert_fail; \
+                        9: MOVSB(r1,r2,x) ; decl rc ; jnz 9b
+#define COPYL_C(r1,r2,x,rc) \
+                        cmpl $0,rc ; jz .L_assert_fail; \
+                        9: MOVSL(r1,r2,x) ; decl rc ; jnz 9b
+#else
+#define COPYB_C(r1,r2,x,rc) \
+                        9: MOVSB(r1,r2,x) ; decl rc ; jnz 9b
+#define COPYL_C(r1,r2,x,rc) \
+                        9: MOVSL(r1,r2,x) ; decl rc ; jnz 9b
+#endif
+
+#define COPYB(r1,r2,x)  COPYB_C(r1,r2,x,%ecx)
+#define COPYL(r1,r2,x)  COPYL_C(r1,r2,x,%ecx)
+
+
+/***********************************************************************
+// not used
+************************************************************************/
+
+#if 0
+
+#if 0
+#define REP_MOVSB(x)    rep ; movsb
+#define REP_MOVSL(x)    shrl $2,%ecx ; rep ; movsl
+#elif 1
+#define REP_MOVSB(x)    COPYB(%esi,%edi,x)
+#define REP_MOVSL(x)    shrl $2,%ecx ; COPYL(%esi,%edi,x)
+#else
+#define REP_MOVSB(x)    rep ; movsb
+#define REP_MOVSL(x)    jmp 9f ; 8: movsb ; decl %ecx ; \
+                        9: testl $3,%edi ; jnz 8b ; \
+                        movl %ecx,x ; shrl $2,%ecx ; andl $3,x ; \
+                        rep ; movsl ; movl x,%ecx ; rep ; movsb
+#endif
+
+#if 1
+#define NEGL(x)         negl x
+#else
+#define NEGL(x)         xorl $-1,x ; incl x
+#endif
+
+#endif
+
+
+
+/*
+vi:ts=4
+*/
+
diff --git a/contrib/syslinux-4.02/core/macros.inc b/contrib/syslinux-4.02/core/macros.inc
new file mode 100644
index 0000000..e3aedca
--- /dev/null
+++ b/contrib/syslinux-4.02/core/macros.inc
@@ -0,0 +1,116 @@
+;; -----------------------------------------------------------------------
+;;
+;;   Copyright 1994-2008 H. Peter Anvin - All Rights Reserved
+;;   Copyright 2009 Intel Corporation; author: H. Peter Anvin
+;;
+;;   This program is free software; you can redistribute it and/or modify
+;;   it under the terms of the GNU General Public License as published by
+;;   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
+;;   Boston MA 02111-1307, USA; either version 2 of the License, or
+;;   (at your option) any later version; incorporated herein by reference.
+;;
+;; -----------------------------------------------------------------------
+
+;;
+;; macros.inc
+;;
+;; Convenient macros
+;;
+
+%ifndef _MACROS_INC
+%define _MACROS_INC
+
+;
+; Identify the module we're compiling; the "correct" should be defined
+; in the module itself to 1
+;
+%ifdef IS_SYSLINUX
+ %define MY_NAME 'SYSLINUX'
+%else
+ %define IS_SYSLINUX 0
+%endif
+%ifdef IS_PXELINUX
+ %define MY_NAME 'PXELINUX'
+%else
+ %define IS_PXELINUX 0
+%endif
+%ifdef IS_ISOLINUX
+ %define MY_NAME 'ISOLINUX'
+%else
+ %define IS_ISOLINUX 0
+%endif
+%ifdef IS_EXTLINUX
+ %define MY_NAME 'EXTLINUX'
+%else
+ %define IS_EXTLINUX 0
+%endif
+
+;
+; Macros similar to res[bwd], but which works in the code segment (after
+; section .text16) or the data segment (section .data16)
+;
+%macro	zb	1.nolist
+	times %1 db 0
+%endmacro
+
+%macro	zw	1.nolist
+	times %1 dw 0
+%endmacro
+
+%macro	zd	1.nolist
+	times %1 dd 0
+%endmacro
+
+;
+; Align with zero bytes in a progbits segment
+;
+%macro	alignz	1.nolist
+	times (((%1) - (($-$$) % (%1))) % (%1)) db 0
+%endmacro
+
+;
+; Macro to emit an unsigned decimal number as a string
+;
+%macro asciidec	1.nolist
+  %ifndef DEPEND	; Not safe for "depend"
+    %push asciidec
+      %assign %$v %1
+      %if %$v == 0
+        db '0'
+      %else
+        %assign %$dcount 0
+        %assign %$n %$v
+        %assign %$d 1
+        %rep 20
+          %if %$n != 0
+            %assign %$dcount %$dcount + 1
+            %assign %$n %$n / 10
+            %assign %$d %$d * 10
+          %endif
+        %endrep
+        %rep %$dcount
+	  %assign %$d %$d / 10
+          db ((%$v / %$d) % 10) + '0'
+        %endrep
+      %endif
+    %pop
+  %endif
+%endmacro
+
+;
+; Macros for network byte order of constants
+;
+%define htons(x)  ( ( ((x) & 0FFh) << 8 ) + ( ((x) & 0FF00h) >> 8 ) )
+%define ntohs(x) htons(x)
+%define htonl(x)  ( ( ((x) & 0FFh) << 24) + ( ((x) & 0FF00h) << 8 ) + ( ((x) & 0FF0000h) >> 8 ) + ( ((x) & 0FF000000h) >> 24) )
+%define ntohl(x) htonl(x)
+
+;
+; ASCII
+;
+CR		equ 13		; Carriage Return
+LF		equ 10		; Line Feed
+FF		equ 12		; Form Feed
+BS		equ  8		; Backspace
+
+%endif ; _MACROS_INC
diff --git a/contrib/syslinux-4.02/core/mem/free.c b/contrib/syslinux-4.02/core/mem/free.c
new file mode 100644
index 0000000..0becb9e
--- /dev/null
+++ b/contrib/syslinux-4.02/core/mem/free.c
@@ -0,0 +1,154 @@
+/*
+ * free.c
+ *
+ * Very simple linked-list based malloc()/free().
+ */
+
+#include <stdlib.h>
+#include <dprintf.h>
+#include "malloc.h"
+
+static struct free_arena_header *
+__free_block(struct free_arena_header *ah)
+{
+    struct free_arena_header *pah, *nah;
+    struct free_arena_header *head =
+	&__malloc_head[ARENA_HEAP_GET(ah->a.attrs)];
+
+    pah = ah->a.prev;
+    nah = ah->a.next;
+    if ( ARENA_TYPE_GET(pah->a.attrs) == ARENA_TYPE_FREE &&
+           (char *)pah+ARENA_SIZE_GET(pah->a.attrs) == (char *)ah ) {
+        /* Coalesce into the previous block */
+        ARENA_SIZE_SET(pah->a.attrs, ARENA_SIZE_GET(pah->a.attrs) +
+		ARENA_SIZE_GET(ah->a.attrs));
+        pah->a.next = nah;
+        nah->a.prev = pah;
+
+#ifdef DEBUG_MALLOC
+        ARENA_TYPE_SET(ah->a.attrs, ARENA_TYPE_DEAD);
+#endif
+
+        ah = pah;
+        pah = ah->a.prev;
+    } else {
+        /* Need to add this block to the free chain */
+        ARENA_TYPE_SET(ah->a.attrs, ARENA_TYPE_FREE);
+        ah->a.tag = MALLOC_FREE;
+
+        ah->next_free = head->next_free;
+        ah->prev_free = head;
+        head->next_free = ah;
+        ah->next_free->prev_free = ah;
+    }
+
+    /* In either of the previous cases, we might be able to merge
+       with the subsequent block... */
+    if ( ARENA_TYPE_GET(nah->a.attrs) == ARENA_TYPE_FREE &&
+           (char *)ah+ARENA_SIZE_GET(ah->a.attrs) == (char *)nah ) {
+        ARENA_SIZE_SET(ah->a.attrs, ARENA_SIZE_GET(ah->a.attrs) +
+		ARENA_SIZE_GET(nah->a.attrs));
+
+        /* Remove the old block from the chains */
+        nah->next_free->prev_free = nah->prev_free;
+        nah->prev_free->next_free = nah->next_free;
+        ah->a.next = nah->a.next;
+        nah->a.next->a.prev = ah;
+
+#ifdef DEBUG_MALLOC
+        ARENA_TYPE_SET(nah->a.attrs, ARENA_TYPE_DEAD);
+#endif
+    }
+
+    /* Return the block that contains the called block */
+    return ah;
+}
+
+void free(void *ptr)
+{
+    struct free_arena_header *ah;
+
+    dprintf("free(%p) @ %p\n", ptr, __builtin_return_address(0));
+
+    if ( !ptr )
+        return;
+
+    ah = (struct free_arena_header *)
+        ((struct arena_header *)ptr - 1);
+
+#ifdef DEBUG_MALLOC
+    assert( ARENA_TYPE_GET(ah->a.attrs) == ARENA_TYPE_USED );
+#endif
+
+    __free_block(ah);
+
+  /* Here we could insert code to return memory to the system. */
+}
+
+/*
+ * This is used to insert a block which is not previously on the
+ * free list.  Only the a.size field of the arena header is assumed
+ * to be valid.
+ */
+void __inject_free_block(struct free_arena_header *ah)
+{
+    struct free_arena_header *head =
+	&__malloc_head[ARENA_HEAP_GET(ah->a.attrs)];
+    struct free_arena_header *nah;
+    size_t a_end = (size_t) ah + ARENA_SIZE_GET(ah->a.attrs);
+    size_t n_end;
+
+    dprintf("inject: %#zx bytes @ %p, heap %u (%p)\n",
+	    ARENA_SIZE_GET(ah->a.attrs), ah,
+	    ARENA_HEAP_GET(ah->a.attrs), head);
+
+    for (nah = head->a.next ; nah != head ; nah = nah->a.next) {
+        n_end = (size_t) nah + ARENA_SIZE_GET(nah->a.attrs);
+
+        /* Is nah entirely beyond this block? */
+        if ((size_t) nah >= a_end)
+            break;
+
+        /* Is this block entirely beyond nah? */
+        if ((size_t) ah >= n_end)
+            continue;
+
+        /* Otherwise we have some sort of overlap - reject this block */
+        return;
+    }
+
+    /* Now, nah should point to the successor block */
+    ah->a.next = nah;
+    ah->a.prev = nah->a.prev;
+    nah->a.prev = ah;
+    ah->a.prev->a.next = ah;
+
+    __free_block(ah);
+}
+
+/*
+ * Free all memory which is tagged with a specific tag.
+ */
+static void __free_tagged(malloc_tag_t tag) {
+    struct free_arena_header *fp, *head;
+    int i;
+
+    for (i = 0; i < NHEAP; i++) {
+	dprintf("__free_tagged(%u) heap %d\n", tag, i);
+	head = &__malloc_head[i];
+	for (fp = head ; fp != head ; fp = fp->a.next) {
+	    if (ARENA_TYPE_GET(fp->a.attrs) == ARENA_TYPE_USED &&
+		fp->a.tag == tag)
+		fp = __free_block(fp);
+	}
+    }
+
+    dprintf("__free_tagged(%u) done\n", tag);
+}
+
+void comboot_cleanup_lowmem(com32sys_t *regs)
+{
+    (void)regs;
+
+    __free_tagged(MALLOC_MODULE);
+}
diff --git a/contrib/syslinux-4.02/core/mem/init.c b/contrib/syslinux-4.02/core/mem/init.c
new file mode 100644
index 0000000..487bbb3
--- /dev/null
+++ b/contrib/syslinux-4.02/core/mem/init.c
@@ -0,0 +1,38 @@
+#include <stdlib.h>
+#include <errno.h>
+#include <string.h>
+#include "malloc.h"
+
+struct free_arena_header __malloc_head[NHEAP];
+
+static __hugebss char main_heap[128 << 10];
+extern char __lowmem_heap[];
+
+void mem_init(void)
+{
+    struct free_arena_header *fp;
+    int i;
+    uint16_t *bios_free_mem = (uint16_t *)0x413;
+
+    /* Initialize the head nodes */
+
+    fp = &__malloc_head[0];
+    for (i = 0 ; i < NHEAP ; i++) {
+	fp->a.next = fp->a.prev = fp->next_free = fp->prev_free = fp;
+	fp->a.attrs = ARENA_TYPE_HEAD | (i << ARENA_HEAP_POS);
+	fp->a.tag = MALLOC_HEAD;
+	fp++;
+    }
+
+    /* Initialize the main heap */
+    fp = (struct free_arena_header *)main_heap;
+    fp->a.attrs = ARENA_TYPE_USED | (HEAP_MAIN << ARENA_HEAP_POS);
+    ARENA_SIZE_SET(fp->a.attrs, sizeof main_heap);
+    __inject_free_block(fp);
+
+    /* Initialize the lowmem heap */
+    fp = (struct free_arena_header *)__lowmem_heap;
+    fp->a.attrs = ARENA_TYPE_USED | (HEAP_LOWMEM << ARENA_HEAP_POS);
+    ARENA_SIZE_SET(fp->a.attrs, (*bios_free_mem << 10) - (uintptr_t)fp);
+    __inject_free_block(fp);
+}
diff --git a/contrib/syslinux-4.02/core/mem/malloc.c b/contrib/syslinux-4.02/core/mem/malloc.c
new file mode 100644
index 0000000..78f7b41
--- /dev/null
+++ b/contrib/syslinux-4.02/core/mem/malloc.c
@@ -0,0 +1,99 @@
+/*
+ * malloc.c
+ *
+ * Very simple linked-list based malloc()/free().
+ */
+
+#include <stdlib.h>
+#include <errno.h>
+#include <string.h>
+#include <dprintf.h>
+#include "malloc.h"
+
+static void *__malloc_from_block(struct free_arena_header *fp,
+				 size_t size, malloc_tag_t tag)
+{
+    size_t fsize;
+    struct free_arena_header *nfp, *na;
+    unsigned int heap = ARENA_HEAP_GET(fp->a.attrs);
+
+    fsize = ARENA_SIZE_GET(fp->a.attrs);
+
+    /* We need the 2* to account for the larger requirements of a free block */
+    if ( fsize >= size+2*sizeof(struct arena_header) ) {
+        /* Bigger block than required -- split block */
+        nfp = (struct free_arena_header *)((char *)fp + size);
+        na = fp->a.next;
+
+        ARENA_TYPE_SET(nfp->a.attrs, ARENA_TYPE_FREE);
+	ARENA_HEAP_SET(nfp->a.attrs, heap);
+        ARENA_SIZE_SET(nfp->a.attrs, fsize-size);
+        nfp->a.tag = MALLOC_FREE;
+        ARENA_TYPE_SET(fp->a.attrs, ARENA_TYPE_USED);
+        ARENA_SIZE_SET(fp->a.attrs, size);
+        fp->a.tag = tag;
+
+        /* Insert into all-block chain */
+        nfp->a.prev = fp;
+        nfp->a.next = na;
+        na->a.prev = nfp;
+        fp->a.next = nfp;
+
+        /* Replace current block on free chain */
+        nfp->next_free = fp->next_free;
+        nfp->prev_free = fp->prev_free;
+        fp->next_free->prev_free = nfp;
+        fp->prev_free->next_free = nfp;
+    } else {
+        /* Allocate the whole block */
+        ARENA_TYPE_SET(fp->a.attrs, ARENA_TYPE_USED);
+        fp->a.tag = tag;
+
+        /* Remove from free chain */
+        fp->next_free->prev_free = fp->prev_free;
+        fp->prev_free->next_free = fp->next_free;
+    }
+
+    return (void *)(&fp->a + 1);
+}
+
+static void *_malloc(size_t size, enum heap heap, malloc_tag_t tag)
+{
+    struct free_arena_header *fp;
+    struct free_arena_header *head = &__malloc_head[heap];
+    void *p = NULL;
+
+    dprintf("_malloc(%zu, %u, %u) @ %p = ",
+	    size, heap, tag, __builtin_return_address(0));
+
+    if (size) {
+	/* Add the obligatory arena header, and round up */
+	size = (size + 2 * sizeof(struct arena_header) - 1) & ARENA_SIZE_MASK;
+
+	for ( fp = head->next_free ; fp != head ; fp = fp->next_free ) {
+	    if ( ARENA_SIZE_GET(fp->a.attrs) >= size ) {
+		/* Found fit -- allocate out of this block */
+		p = __malloc_from_block(fp, size, tag);
+		break;
+	    }
+        }
+    }
+
+    dprintf("%p\n", p);
+    return p;
+}
+
+void *malloc(size_t size)
+{
+    return _malloc(size, HEAP_MAIN, MALLOC_CORE);
+}
+
+void *lmalloc(size_t size)
+{
+    return _malloc(size, HEAP_LOWMEM, MALLOC_CORE);
+}
+
+void *pmapi_lmalloc(size_t size)
+{
+    return _malloc(size, HEAP_LOWMEM, MALLOC_MODULE);
+}
diff --git a/contrib/syslinux-4.02/core/mem/malloc.h b/contrib/syslinux-4.02/core/mem/malloc.h
new file mode 100644
index 0000000..b8ec44d
--- /dev/null
+++ b/contrib/syslinux-4.02/core/mem/malloc.h
@@ -0,0 +1,82 @@
+/*
+ * malloc.h
+ *
+ * Internals for the memory allocator
+ */
+
+#include <stdint.h>
+#include <stddef.h>
+#include "core.h"
+
+/*
+ * This is a temporary hack.  In Syslinux 5 this will be a pointer to
+ * the owner module.
+ */
+typedef size_t malloc_tag_t;
+enum malloc_owner {
+    MALLOC_FREE,
+    MALLOC_HEAD,
+    MALLOC_CORE,
+    MALLOC_MODULE,
+};
+
+struct free_arena_header;
+
+/*
+ * This structure should be a power of two.  This becomes the
+ * alignment unit.
+ */
+struct arena_header {
+    malloc_tag_t tag;
+    size_t attrs;			/* Bits 0..1:  Type
+					        2..3:  Heap,
+						4..31: MSB of the size  */
+    struct free_arena_header *next, *prev;
+};
+
+enum arena_type {
+    ARENA_TYPE_USED = 0,
+    ARENA_TYPE_FREE = 1,
+    ARENA_TYPE_HEAD = 2,
+    ARENA_TYPE_DEAD = 3,
+};
+enum heap {
+    HEAP_MAIN,
+    HEAP_LOWMEM,
+    NHEAP
+};
+
+#define ARENA_SIZE_MASK (~(uintptr_t)(sizeof(struct arena_header)-1))
+#define ARENA_HEAP_MASK ((size_t)0xc)
+#define ARENA_HEAP_POS	2
+#define ARENA_TYPE_MASK	((size_t)0x3)
+
+#define ARENA_ALIGN_UP(p)	((char *)(((uintptr_t)(p) + ~ARENA_SIZE_MASK) \
+					  & ARENA_SIZE_MASK))
+#define ARENA_ALIGN_DOWN(p)	((char *)((uintptr_t)(p) & ARENA_SIZE_MASK))
+
+#define ARENA_SIZE_GET(attrs)	((attrs) & ARENA_SIZE_MASK)
+#define ARENA_HEAP_GET(attrs)	(((attrs) & ARENA_HEAP_MASK) >> ARENA_HEAP_POS)
+#define ARENA_TYPE_GET(attrs)	((attrs) & ARENA_TYPE_MASK)
+
+#define ARENA_SIZE_SET(attrs, size)	\
+	((attrs) = ((size) & ARENA_SIZE_MASK) | ((attrs) & ~ARENA_SIZE_MASK))
+#define ARENA_HEAP_SET(attrs, heap)	\
+	((attrs) = (((heap) << ARENA_HEAP_POS) & ARENA_HEAP_MASK) | \
+	 ((attrs) & ~ARENA_HEAP_MASK))
+#define ARENA_TYPE_SET(attrs, type) \
+	((attrs) = ((attrs) & ~ARENA_TYPE_MASK) | \
+	 ((type) & ARENA_TYPE_MASK))
+
+/*
+ * This structure should be no more than twice the size of the
+ * previous structure.
+ */
+struct free_arena_header {
+    struct arena_header a;
+    struct free_arena_header *next_free, *prev_free;
+    size_t _pad[2];		/* Pad to 2*sizeof(struct arena_header) */
+};
+
+extern struct free_arena_header __malloc_head[NHEAP];
+void __inject_free_block(struct free_arena_header *ah);
diff --git a/contrib/syslinux-4.02/core/parsecmd.inc b/contrib/syslinux-4.02/core/parsecmd.inc
new file mode 100644
index 0000000..30cd67f
--- /dev/null
+++ b/contrib/syslinux-4.02/core/parsecmd.inc
@@ -0,0 +1,129 @@
+;; -----------------------------------------------------------------------
+;;
+;;   Copyright 1994-2009 H. Peter Anvin - All Rights Reserved
+;;   Copyright 2009 Intel Corporation; author: H. Peter Anvin
+;;
+;;   This program is free software; you can redistribute it and/or modify
+;;   it under the terms of the GNU General Public License as published by
+;;   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
+;;   Boston MA 02111-1307, USA; either version 2 of the License, or
+;;   (at your option) any later version; incorporated herein by reference.
+;;
+;; -----------------------------------------------------------------------
+
+;;
+;; parsecmd.inc
+;;
+;; Command line parser code
+;;
+
+		section .text16
+
+; -------------------------------------------------------------------------
+;  getcommand:	Get a keyword from the current "getc" file and match it
+;		against a list of keywords (keywd_table).  Each entry in
+;		that table should have the following form:
+;		<32 bit hash value> <16 bit handler offset>
+;
+;               The handler is called, and upon return this function
+;               returns with CF = 0.  On EOF, this function returns
+;		with CF = 1.
+; -------------------------------------------------------------------------
+
+getcommand.skipline:
+		call skipline
+
+getcommand:
+.find:
+		call skipspace		; Skip leading whitespace
+		jz .eof			; End of file
+		jc .find		; End of line: try again
+
+		; Do this explicitly so #foo is treated as a comment
+		cmp al,'#'		; Leading hash mark -> comment
+		je .skipline
+
+		; Abuse the trackbuf by putting the keyword there for
+		; possible error messaging...
+		mov di,trackbuf
+		stosb
+		or al,20h		; Convert to lower case
+		movzx ebx,al		; Hash for a one-char keyword
+.read_loop:
+		call getc
+		jc .eof
+		cmp al,' '		; Whitespace
+		jbe .done
+		stosb
+		or al,20h
+		rol ebx,5
+		xor bl,al
+		jmp short .read_loop
+.done:		call ungetc
+		xor ax,ax
+		stosb			; Null-terminate the trackbuf
+		call skipspace
+		jz .eof
+		jc .noparm
+		call ungetc		; Return nonwhitespace char to buf
+		mov si,keywd_table
+		mov cx,keywd_count
+.table_search:
+		lodsd
+		cmp ebx,eax
+		je .found_keywd
+		lodsd			; Skip entrypoint/argument
+		loop .table_search
+
+		; Otherwise unrecognized keyword
+		mov si,err_badcfg
+		call writestr
+		mov si,trackbuf
+		call writestr
+		call crlf
+		jmp .skipline
+
+		; No parameter
+.noparm:
+		mov si,err_noparm
+		call writestr
+		mov si,trackbuf
+		call writestr
+		call crlf
+		jmp .find
+
+.found_keywd:	lodsw			; Load argument into ax
+		call [si]
+		clc
+		ret
+
+.eof:		stc
+		ret
+
+skipline:	cmp al,10		; Search for LF
+		je .end
+		call getc
+		jnc skipline
+.end:		ret
+
+		section .data16
+err_badcfg      db 'Unknown keyword in configuration file: ',0
+err_noparm      db 'Missing parameter in configuration file. Keyword: ',0
+
+		section .uibss
+		alignb 4
+vk_size		equ (vk_end + 3) & ~3
+VKernelBuf:	resb vk_size		; "Current" vkernel
+AppendBuf       resb max_cmd_len+1	; append=
+Ontimeout	resb max_cmd_len+1	; ontimeout
+Onerror		resb max_cmd_len+1	; onerror
+		; This could be in .uibss but that makes PXELINUX overflow
+		section .bss16
+KbdMap		resb 256		; Keyboard map
+FKeyName	resb MAX_FKEYS*FILENAME_MAX	; File names for F-key help
+                global KernelName
+KernelName      resb FILENAME_MAX	; Mangled name for kernel
+MNameBuf        resb FILENAME_MAX
+InitRD          resb FILENAME_MAX
+
+		section .text16
diff --git a/contrib/syslinux-4.02/core/parseconfig.inc b/contrib/syslinux-4.02/core/parseconfig.inc
new file mode 100644
index 0000000..e7b3108
--- /dev/null
+++ b/contrib/syslinux-4.02/core/parseconfig.inc
@@ -0,0 +1,475 @@
+;; -----------------------------------------------------------------------
+;;
+;;   Copyright 1994-2009 H. Peter Anvin - All Rights Reserved
+;;   Copyright 2009 Intel Corporation; author: H. Peter Anvin
+;;
+;;   This program is free software; you can redistribute it and/or modify
+;;   it under the terms of the GNU General Public License as published by
+;;   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
+;;   Boston MA 02111-1307, USA; either version 2 of the License, or
+;;   (at your option) any later version; incorporated herein by reference.
+;;
+;; -----------------------------------------------------------------------
+
+;;
+;; parseconfig.inc
+;;
+;; Configuration file operations
+;;
+
+		section .text16
+;
+; "default" or "ui" command, with level (1 = default, 2 = ui)
+;
+pc_default:	cmp ax,[DefaultLevel]
+		jb skipline			; == call skipline + ret
+		mov [DefaultLevel],ax
+		mov di,default_cmd
+		call getline
+		mov byte [di-1],0		; null-terminate
+		ret
+
+;
+; "ontimeout" command
+;
+pc_ontimeout:	mov di,Ontimeout
+		call getline
+		sub di,Ontimeout+1		; Don't need final space
+		mov [OntimeoutLen],di
+		ret
+
+;
+; "onerror" command
+;
+pc_onerror:	mov di,Onerror
+		call getline
+		sub di,Onerror
+		mov [OnerrorLen],di
+		ret
+
+;
+; "append" command
+;
+pc_append:      cmp byte [VKernel],0
+		ja .vk
+                mov di,AppendBuf
+		call getline
+                sub di,AppendBuf
+.app1:		mov [AppendLen],di
+		ret
+.vk:		mov di,VKernelBuf+vk_append	; "append" command (vkernel)
+		call getline
+		sub di,VKernelBuf+vk_append
+                cmp di,byte 2
+                jne .app2
+                cmp byte [VKernelBuf+vk_append],'-'
+                jne .app2
+                xor di,di			; If "append -" -> null string
+.app2:		mov [VKernelBuf+vk_appendlen],di
+		ret
+
+;
+; "ipappend" command (PXELINUX only)
+;
+%if IS_PXELINUX
+pc_ipappend:	call getint
+		jc .err
+		cmp byte [VKernel],0
+		jne .vk
+		mov [IPAppend],bl
+.err:		ret
+.vk:		mov [VKernelBuf+vk_ipappend],bl
+		ret
+%endif
+
+;
+; "localboot" command
+;
+%if HAS_LOCALBOOT
+
+pc_localboot:	call getint
+		cmp byte [VKernel],0		; ("label" section only)
+		je .err
+		mov [VKernelBuf+vk_rname],bx
+		mov byte [VKernelBuf+vk_type],VK_LOCALBOOT
+.err:		ret
+
+%endif ; HAS_LOCALBOOT
+
+;
+; "kernel", "config", ... command
+;
+pc_kernel:	cmp byte [VKernel],0
+		je .err				; ("label" section only)
+		mov [VKernelBuf+vk_type],al
+		call pc_getline
+		mov di,VKernelBuf+vk_rname
+		pm_call pm_mangle_name
+.err:		ret
+
+;
+; "timeout", "totaltimeout" command
+;
+; N.B. 1/10 s ~ 1.D2162AABh clock ticks
+;
+pc_timeout:	push ax
+		call getint
+		pop si
+		jc .err
+		mov eax,0D2162AABh
+		mul ebx				; clock ticks per 1/10 s
+		add ebx,edx
+		mov [si],ebx
+.err:		ret
+
+
+;
+; "totaltimeout" command
+;
+pc_totaltimeout:
+
+;
+; Generic integer variable setting commands:
+; "prompt", "implicit"
+;
+pc_setint16:
+		push ax
+		call getint
+		pop si
+		jc .err
+		mov [si],bx
+.err:		ret
+
+;
+; Generic file-processing commands:
+; "font", "kbdmap",
+;
+pc_filecmd:	push ax				; Function to tailcall
+		call pc_getline
+		mov di,MNameBuf
+		pm_call pm_mangle_name
+		pm_call pm_searchdir
+		jnz .ok
+		pop ax				; Drop the successor function
+.ok:		ret				; Tailcall if OK, error return
+
+;
+; Commands that expect the file to be opened on top of the getc stack.
+; "display", "include"
+;
+pc_opencmd:	push ax				; Function to tailcall
+		call pc_getline
+		mov di,MNameBuf
+		pm_call pm_mangle_name
+		call core_open
+		jnz .ok
+		pop ax				; Drop the successor function
+.ok:		ret				; Tailcall if OK, error return
+
+;
+; "include" command (invoked from pc_opencmd)
+;
+pc_include:	inc word [IncludeLevel]
+.err:		ret
+
+;
+; "serial" command
+;
+pc_serial:	call getint
+		jc .err
+		push bx				; Serial port #
+		xor eax,eax
+		mov [FlowControl],eax		; Default to no flow control
+		call skipspace
+		jc .nobaud
+		call ungetc
+		call getint
+		jc .nobaud
+.valid_baud:
+		push ebx
+		call skipspace
+		jc .no_flow
+		call ungetc
+		call getint			; Hardware flow control?
+		jnc .valid_flow
+.no_flow:
+		xor bx,bx			; Default -> no flow control
+.valid_flow:
+		and bh,0Fh			; FlowIgnore
+		shl bh,4
+		mov [FlowIgnore],bh
+		mov bh,bl
+		and bx,0F00Bh			; Valid bits
+		mov [FlowControl],bx
+		pop ebx				; Baud rate
+		jmp short .parse_baud
+.nobaud:
+		mov ebx,DEFAULT_BAUD		; No baud rate given
+.parse_baud:
+		pop di				; Serial port #
+		cmp ebx,byte 75
+		jb .err				; < 75 baud == bogus
+		mov eax,BAUD_DIVISOR
+		cdq
+		div ebx
+		mov [BaudDivisor],ax
+		push ax				; Baud rate divisor
+		cmp di,3
+		ja .port_is_io			; If port > 3 then port is I/O addr
+		shl di,1
+		mov di,[di+serial_base]		; Get the I/O port from the BIOS
+.port_is_io:
+		mov [SerialPort],di
+
+		;
+		; Begin code to actually set up the serial port
+		;
+		call sirq_cleanup_nowipe	; Cleanup existing IRQ handler
+
+		lea dx,[di+3]			; DX -> LCR
+		mov al,83h			; Enable DLAB
+		slow_out dx,al
+
+		pop ax				; Divisor
+		mov dx,di			; DX -> LS
+		slow_out dx,al
+
+		inc dx				; DX -> MS
+		mov al,ah
+		slow_out dx,al
+
+		mov al,03h			; Disable DLAB
+		inc dx				; DX -> LCR
+		inc dx
+		slow_out dx,al
+
+		in al,dx		; Read back LCR (detect missing hw)
+		cmp al,03h		; If nothing here we'll read 00 or FF
+		jne .err		; Assume serial port busted
+		dec dx				; DX -> IIR/FCR
+		mov al,01h
+		slow_out dx,al			; Enable FIFOs if present
+		in al,dx
+		cmp al,0C0h			; FIFOs enabled and usable?
+		jae .fifo_ok
+		xor ax,ax			; Disable FIFO if unusable
+		slow_out dx,al
+.fifo_ok:
+
+		inc dx
+		inc dx				; DX -> MCR
+		mov al,[FlowOutput]		; Assert bits
+		slow_out dx,al
+
+		; Enable interrupts if requested
+		test al,8
+		jz .noirq
+		call sirq_install
+.noirq:
+
+		; Show some life
+		cmp byte [SerialNotice],0
+		je .notfirst
+		mov byte [SerialNotice],0
+
+		mov si,syslinux_banner
+		call write_serial_str
+		mov si,copyright_str
+		call write_serial_str
+.notfirst:
+		ret
+
+.err:
+		mov [SerialPort], word 0
+		ret
+
+;
+; Store mangled filename command (F-keys, "initrd")
+;
+pc_filename:	push ax
+		call pc_getline
+		pop di
+		pm_call pm_mangle_name		; Mangle file name
+		ret
+
+;
+; "label" command
+;
+pc_label:	call commit_vk			; Commit any current vkernel
+		mov byte [InitRD+NULLOFFSET],NULLFILE	; No "initrd" statement
+		mov di,VKernelBuf		; Erase the vkernelbuf for better compression
+		mov cx,(vk_size >> 1)
+		xor ax,ax
+		rep stosw
+		call pc_getline
+		mov di,VKernelBuf+vk_vname
+		mov cx,FILENAME_MAX-1
+.loop:
+		lodsb
+		cmp al,' '
+		jna .done
+		stosb
+		loop .loop
+.done:
+		mov byte [VKernel],1		; We've seen a "label" statement
+		mov si,VKernelBuf+vk_vname	; By default, rname == mangled vname
+		mov di,VKernelBuf+vk_rname
+		pm_call pm_mangle_name
+		mov si,AppendBuf		; Default append==global append
+		mov di,VKernelBuf+vk_append
+		mov cx,[AppendLen]
+		mov [VKernelBuf+vk_appendlen],cx
+		rep movsb
+%if IS_PXELINUX					; PXELINUX only
+		mov al,[IPAppend]		; Default ipappend==global ipappend
+		mov [VKernelBuf+vk_ipappend],al
+%endif
+		ret
+
+;
+; "say" command
+;
+pc_say:		call pc_getline			; "say" command
+		call writestr
+		jmp crlf			; tailcall
+
+;
+; "text" command; ignore everything until we get an "endtext" line
+;
+pc_text:	call skipline			; Ignore rest of line
+.loop:
+		call pc_getline
+		jc .eof
+
+		; Leading spaces are already removed...
+		lodsd
+		and eax,0xdfdfdfdf		; Upper case
+		cmp eax,'ENDT'
+		jne .loop
+		lodsd
+		and eax,0x00dfdfdf		; Upper case and mask
+		cmp eax,'EXT'
+		jne .loop
+		; If we get here we hit ENDTEXT
+.eof:
+		ret
+
+;
+; Comment line
+;
+pc_comment:	; Fall into pc_getline
+
+;
+; Common subroutine: load line into trackbuf; returns with SI -> trackbuf
+; CF is set on EOF.
+;
+pc_getline:	mov di,trackbuf
+		push di
+		call getline
+		mov byte [di],0			; Null-terminate
+		pop si
+		ret
+
+;
+; Main loop for configuration file parsing
+;
+parse_config:
+		mov di,VKernelBuf		; Clear VKernelBuf at start
+		xor ax,ax
+		mov cx,vk_size
+		rep stosb
+
+.again:
+		call getcommand			; Parse one command
+                jnc .again			; If not EOF...
+		call close
+		dec word [IncludeLevel]		; Still parsing?
+		jnz .again
+
+		;
+		; The fall through to commit_vk to commit any final
+		; VKernel being read
+		;
+;
+; commit_vk: Store the current VKernelBuf into buffer segment
+;
+commit_vk:
+		cmp byte [VKernel],0
+		jz .nolabel			; Nothing to commit...
+
+		mov di,VKernelBuf+vk_append
+		add di,[VKernelBuf+vk_appendlen]
+
+		; If we have an initrd statement, append it to the
+		; append statement
+		cmp byte [InitRD+NULLOFFSET],NULLFILE
+		je .noinitrd
+
+		mov si,str_initrd
+		mov cx,7	; "initrd="
+		rep movsb
+		mov si,InitRD
+		call strcpy
+		mov byte [es:di-1],' '
+
+		; For better compression, clean up the append field
+.noinitrd:
+		mov ax,di
+		sub ax,VKernelBuf+vk_append
+		mov [VKernelBuf+vk_appendlen],ax
+		mov cx,max_cmd_len+1
+		sub cx,ax
+		xor ax,ax
+		rep stosb
+
+		; Pack into high memory
+		mov esi,VKernelBuf
+		mov edi,[VKernelEnd]
+		mov ecx,vk_size
+		pm_call rllpack
+		mov [VKernelEnd],edi
+.nolabel:
+		ret
+.overflow:
+		mov si,vk_overflow_msg
+		call writestr
+		ret
+
+		section .data16
+vk_overflow_msg	db 'Out of memory parsing config file', CR, LF, 0
+SerialNotice	db 1			; Only print this once
+
+		section .bss16
+		alignb 4
+VKernelEnd	resd 1			; Lowest high memory address used
+
+		; This symbol should be used by loaders to indicate
+		; the highest address *they* are allowed to use.
+HighMemRsvd	equ VKernelEnd
+					; by vkernels
+		section .config
+		alignz 4
+KbdTimeout      dd 0                    ; Keyboard timeout (if any)
+TotalTimeout	dd 0			; Total timeout (if any)
+AppendLen       dw 0                    ; Bytes in append= command
+OntimeoutLen	dw 0			; Bytes in ontimeout command
+OnerrorLen	dw 0			; Bytes in onerror command
+CmdLinePtr	dw cmd_line_here	; Command line advancing pointer
+ForcePrompt	dw 0			; Force prompt
+NoEscape	dw 0			; No escape
+NoComplete	dw 0			; No label completion on TAB key
+AllowImplicit   dw 1                    ; Allow implicit kernels
+AllowOptions	dw 1			; User-specified options allowed
+IncludeLevel	dw 1			; Nesting level
+DefaultLevel	dw 0			; The current level of default
+VKernel		db 0			; Have we seen any "label" statements?
+
+%if IS_PXELINUX
+IPAppend	db 0			; Default IPAPPEND option
+%endif
+
+		section .uibss
+                alignb 4		; For the good of REP MOVSD
+command_line	resb max_cmd_len+2	; Command line buffer
+		alignb 4
+default_cmd	resb max_cmd_len+1	; "default" command line
diff --git a/contrib/syslinux-4.02/core/plaincon.inc b/contrib/syslinux-4.02/core/plaincon.inc
new file mode 100644
index 0000000..c41629d
--- /dev/null
+++ b/contrib/syslinux-4.02/core/plaincon.inc
@@ -0,0 +1,24 @@
+;
+; writechr:	Write a single character in AL to the console without
+;		mangling any registers; handle video pages correctly.
+;
+		section .text16
+
+writechr:
+		call write_serial	; write to serial port if needed
+		pushfd
+		test byte [cs:UsingVGA], 08h
+		jz .videook
+		call vgaclearmode
+.videook:
+		test byte [cs:DisplayCon], 01h
+		jz .nothing
+		pushad
+		mov ah,0Eh
+		mov bl,07h		; attribute
+		mov bh,[cs:BIOS_page]	; current page
+		int 10h
+		popad
+.nothing:
+		popfd
+		ret
diff --git a/contrib/syslinux-4.02/core/pm.inc b/contrib/syslinux-4.02/core/pm.inc
new file mode 100644
index 0000000..9584cda
--- /dev/null
+++ b/contrib/syslinux-4.02/core/pm.inc
@@ -0,0 +1,450 @@
+;; -----------------------------------------------------------------------
+;;
+;;   Copyright 1994-2009 H. Peter Anvin - All Rights Reserved
+;;   Copyright 2009 Intel Corporation; author: H. Peter Anvin
+;;
+;;   This program is free software; you can redistribute it and/or modify
+;;   it under the terms of the GNU General Public License as published by
+;;   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
+;;   Boston MA 02111-1307, USA; either version 2 of the License, or
+;;   (at your option) any later version; incorporated herein by reference.
+;;
+;; -----------------------------------------------------------------------
+
+;;
+;; pm.inc
+;;
+;; Functions to enter and exit 32-bit protected mode, handle interrupts
+;; and cross-mode calls.
+;;
+;; PM refers to 32-bit flat protected mode; RM to 16-bit real mode.
+;;
+
+		bits 16
+		section .text16
+;
+; _pm_call: call PM routine in low memory from RM
+;
+;	on stack	= PM routine to call (a 32-bit address)
+;
+;	ECX, ESI, EDI passed to the called function;
+;	EAX = EBP in the called function points to the stack frame
+;	which includes all registers (which can be changed if desired.)
+;
+;	All registers and the flags saved/restored
+;
+;	This routine is invoked by the pm_call macro.
+;
+_pm_call:
+		pushfd
+		pushad
+		push ds
+		push es
+		push fs
+		push gs
+		mov bp,sp
+		mov ax,cs
+		mov ebx,.pm
+		mov ds,ax
+		jmp enter_pm
+
+		bits 32
+		section .textnr
+.pm:
+		; EAX points to the top of the RM stack, which is EFLAGS
+		test RM_FLAGSH,02h		; RM EFLAGS.IF
+		jz .no_sti
+		sti
+.no_sti:
+		call [ebp+4*2+9*4+2]		; Entrypoint on RM stack
+		mov bx,.rm
+		jmp enter_rm
+
+		bits 16
+		section .text16
+.rm:
+		pop gs
+		pop fs
+		pop es
+		pop ds
+		popad
+		popfd
+		ret 4		; Drop entrypoint
+
+;
+; enter_pm: Go to PM with interrupt service configured
+;	EBX	  = PM entry point
+;	EAX = EBP = on exit, points to the RM stack as a 32-bit value
+;	ECX, EDX, ESI, EDI preserved across this routine
+;
+;	Assumes CS == DS
+;
+; This routine doesn't enable interrupts, but the target routine
+; can enable interrupts by executing STI.
+;
+		bits 16
+		section .text16
+enter_pm:
+		cli
+		xor eax,eax
+		mov ds,ax
+		mov ax,ss
+		mov [RealModeSSSP],sp
+		mov [RealModeSSSP+2],ax
+		movzx ebp,sp
+		shl eax,4
+		add ebp,eax		; EBP -> top of real-mode stack
+		cld
+		call enable_a20
+
+.a20ok:
+		mov byte [bcopy_gdt.TSS+5],89h	; Mark TSS unbusy
+
+		lgdt [bcopy_gdt]	; We can use the same GDT just fine
+		lidt [PM_IDT_ptr]	; Set up the IDT
+		mov eax,cr0
+		or al,1
+		mov cr0,eax		; Enter protected mode
+		jmp PM_CS32:.in_pm
+
+		bits 32
+		section .textnr
+.in_pm:
+		xor eax,eax		; Available for future use...
+		mov fs,eax
+		mov gs,eax
+		lldt ax
+
+		mov al,PM_DS32		; Set up data segments
+		mov es,eax
+		mov ds,eax
+		mov ss,eax
+
+		mov al,PM_TSS		; Be nice to Intel's VT by
+		ltr ax			; giving it a valid TR
+
+		mov esp,[PMESP]		; Load protmode %esp
+		mov eax,ebp		; EAX -> top of real-mode stack
+		jmp ebx			; Go to where we need to go
+
+;
+; enter_rm: Return to RM from PM
+;
+;	BX	= RM entry point (CS = 0)
+;	ECX, EDX, ESI, EDI preserved across this routine
+;	EAX	clobbered
+;	EBP	reserved
+;
+; This routine doesn't enable interrupts, but the target routine
+; can enable interrupts by executing STI.
+;
+		bits 32
+		section .textnr
+enter_rm:
+		cli
+		cld
+		mov [PMESP],esp		; Save exit %esp
+		jmp PM_CS16:.in_pm16	; Return to 16-bit mode first
+
+		bits 16
+		section .text16
+.in_pm16:
+		mov ax,PM_DS16		; Real-mode-like segment
+		mov es,ax
+		mov ds,ax
+		mov ss,ax
+		mov fs,ax
+		mov gs,ax
+
+		lidt [RM_IDT_ptr]	; Real-mode IDT (rm needs no GDT)
+		xor dx,dx
+		mov eax,cr0
+		and al,~1
+		mov cr0,eax
+		jmp 0:.in_rm
+
+.in_rm:					; Back in real mode
+		lss sp,[cs:RealModeSSSP]	; Restore stack
+		movzx esp,sp		; Make sure the high bits are zero
+		mov ds,dx		; Set up sane segments
+		mov es,dx
+		mov fs,dx
+		mov gs,dx
+		jmp bx			; Go to whereever we need to go...
+
+		section .data16
+		alignz 4
+
+		extern __stack_end
+PMESP		dd __stack_end		; Protected-mode ESP
+
+PM_IDT_ptr:	dw 8*256-1		; Length
+		dd IDT			; Offset
+
+;
+; This is invoked on getting an interrupt in protected mode.  At
+; this point, we need to context-switch to real mode and invoke
+; the interrupt routine.
+;
+; When this gets invoked, the registers are saved on the stack and
+; AL contains the register number.
+;
+		bits 32
+		section .textnr
+pm_irq:
+		pushad
+		movzx esi,byte [esp+8*4] ; Interrupt number
+		mov ebx,.rm
+		jmp enter_rm		; Go to real mode
+
+		bits 16
+		section .text16
+.rm:
+		pushf			; Flags on stack
+		call far [cs:esi*4]	; Call IVT entry
+		mov ebx,.pm
+		jmp enter_pm		; Go back to PM
+
+		bits 32
+		section .textnr
+.pm:
+		popad
+		add esp,4		; Drop interrupt number
+		iretd
+
+		bits 16
+		section .text16
+;
+; Routines to enable and disable (yuck) A20.  These routines are gathered
+; from tips from a couple of sources, including the Linux kernel and
+; http://www.x86.org/.  The need for the delay to be as large as given here
+; is indicated by Donnie Barnes of RedHat, the problematic system being an
+; IBM ThinkPad 760EL.
+;
+
+		section .data16
+		alignz 2
+A20Ptr		dw a20_dunno
+
+		section .bss16
+		alignb 4
+A20Test		resd 1			; Counter for testing A20 status
+A20Tries	resb 1			; Times until giving up on A20
+
+		section .text16
+enable_a20:
+		pushad
+		mov byte [cs:A20Tries],255 ; Times to try to make this work
+
+try_enable_a20:
+
+;
+; First, see if we are on a system with no A20 gate, or the A20 gate
+; is already enabled for us...
+;
+a20_none:
+		call a20_test
+		jnz a20_done
+		; Otherwise, see if we had something memorized...
+		jmp word [cs:A20Ptr]
+
+;
+; Next, try the BIOS (INT 15h AX=2401h)
+;
+a20_dunno:
+a20_bios:
+		mov word [cs:A20Ptr], a20_bios
+		mov ax,2401h
+		pushf				; Some BIOSes muck with IF
+		int 15h
+		popf
+
+		call a20_test
+		jnz a20_done
+
+;
+; Enable the keyboard controller A20 gate
+;
+a20_kbc:
+		mov dl, 1			; Allow early exit
+		call empty_8042
+		jnz a20_done			; A20 live, no need to use KBC
+
+		mov word [cs:A20Ptr], a20_kbc	; Starting KBC command sequence
+
+		mov al,0D1h			; Write output port
+		out 064h, al
+		call empty_8042_uncond
+
+		mov al,0DFh			; A20 on
+		out 060h, al
+		call empty_8042_uncond
+
+		; Apparently the UHCI spec assumes that A20 toggle
+		; ends with a null command (assumed to be for sychronization?)
+		; Put it here to see if it helps anything...
+		mov al,0FFh			; Null command
+		out 064h, al
+		call empty_8042_uncond
+
+		; Verify that A20 actually is enabled.  Do that by
+		; observing a word in low memory and the same word in
+		; the HMA until they are no longer coherent.  Note that
+		; we don't do the same check in the disable case, because
+		; we don't want to *require* A20 masking (SYSLINUX should
+		; work fine without it, if the BIOS does.)
+.kbc_wait:	push cx
+		xor cx,cx
+.kbc_wait_loop:
+		call a20_test
+		jnz a20_done_pop
+		loop .kbc_wait_loop
+
+		pop cx
+;
+; Running out of options here.  Final attempt: enable the "fast A20 gate"
+;
+a20_fast:
+		mov word [cs:A20Ptr], a20_fast
+		in al, 092h
+		or al,02h
+		and al,~01h			; Don't accidentally reset the machine!
+		out 092h, al
+
+.fast_wait:	push cx
+		xor cx,cx
+.fast_wait_loop:
+		call a20_test
+		jnz a20_done_pop
+		loop .fast_wait_loop
+
+		pop cx
+
+;
+; Oh bugger.  A20 is not responding.  Try frobbing it again; eventually give up
+; and report failure to the user.
+;
+		dec byte [cs:A20Tries]
+		jnz a20_dunno		; Did we get the wrong type?
+
+		mov si, err_a20
+		jmp abort_load
+
+		section .data16
+err_a20		db CR, LF, 'A20 gate not responding!', CR, LF, 0
+		section .text16
+
+;
+; A20 unmasked, proceed...
+;
+a20_done_pop:	pop cx
+a20_done:	popad
+		ret
+
+;
+; This routine tests if A20 is enabled (ZF = 0).  This routine
+; must not destroy any register contents.
+;
+; The no-write early out avoids the io_delay in the (presumably common)
+; case of A20 already enabled (e.g. from a previous call.)
+;
+a20_test:
+		push es
+		push cx
+		push eax
+		mov cx,0FFFFh			; HMA = segment 0FFFFh
+		mov es,cx
+		mov eax,[cs:A20Test]
+		mov cx,32			; Loop count
+		jmp .test			; First iteration = early out
+.wait:		add eax,0x430aea41		; A large prime number
+		mov [cs:A20Test],eax
+		io_delay			; Serialize, and fix delay
+.test:		cmp eax,[es:A20Test+10h]
+		loopz .wait
+.done:		pop eax
+		pop cx
+		pop es
+		ret
+
+;
+; Routine to empty the 8042 KBC controller.  If dl != 0
+; then we will test A20 in the loop and exit if A20 is
+; suddenly enabled.
+;
+empty_8042_uncond:
+		xor dl,dl
+empty_8042:
+		call a20_test
+		jz .a20_on
+		and dl,dl
+		jnz .done
+.a20_on:	io_delay
+		in al, 064h		; Status port
+		test al,1
+		jz .no_output
+		io_delay
+		in al, 060h		; Read input
+		jmp short empty_8042
+.no_output:
+		test al,2
+		jnz empty_8042
+		io_delay
+.done:		ret
+
+;
+; This initializes the protected-mode interrupt thunk set
+;
+		section .text16
+pm_init:
+		xor edi,edi
+		mov bx,IDT
+		mov di,IRQStubs
+
+		mov eax,7aeb006ah	; push byte .. jmp short ..
+
+		mov cx,8		; 8 groups of 32 IRQs
+.gloop:
+		push cx
+		mov cx,32		; 32 entries per group
+.eloop:
+		mov [bx],di		; IDT offset [15:0]
+		mov word [bx+2],PM_CS32	; IDT segment
+		mov dword [bx+4],08e00h	; IDT offset [31:16], 32-bit interrupt
+					; gate, CPL 0 (we don't have a TSS
+					; set up...)
+		add bx,8
+
+		stosd
+		; Increment IRQ, decrement jmp short offset
+		add eax,(-4 << 24)+(1 << 8)
+
+		loop .eloop
+
+		; At the end of each group, replace the EBxx with
+		; the final E9xxxxxxxx
+		add di,3
+		mov byte [di-5],0E9h	; JMP NEAR
+		mov edx,pm_irq
+		sub edx,edi
+		mov [di-4],edx
+
+		add eax,(0x80 << 24)	; Proper offset for the next one
+		pop cx
+		loop .gloop
+
+		ret
+
+		; pm_init is called before bss clearing, so put these
+		; in .earlybss!
+		section .earlybss
+		alignb 8
+IDT:		resq 256
+RealModeSSSP	resd 1			; Real-mode SS:SP
+
+		section .gentextnr	; Autogenerated 32-bit code
+IRQStubs:	resb 4*256+3*8
+
+		section .text16
+
+%include "callback.inc"			; Real-mode callbacks
diff --git a/contrib/syslinux-4.02/core/pmapi.c b/contrib/syslinux-4.02/core/pmapi.c
new file mode 100644
index 0000000..4b1ccbb
--- /dev/null
+++ b/contrib/syslinux-4.02/core/pmapi.c
@@ -0,0 +1,43 @@
+/* -----------------------------------------------------------------------
+ *
+ *   Copyright 1994-2009 H. Peter Anvin - All Rights Reserved
+ *   Copyright 2009-2010 Intel Corporation; author: H. Peter Anvin
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
+ *   Boston MA 02111-1307, USA; either version 2 of the License, or
+ *   (at your option) any later version; incorporated herein by reference.
+ *
+ * ----------------------------------------------------------------------- */
+
+#include <inttypes.h>
+#include <com32.h>
+#include <syslinux/pmapi.h>
+#include "core.h"
+#include "fs.h"
+
+const struct com32_pmapi pm_api_vector =
+{
+    .__pmapi_size = sizeof(struct com32_pmapi),
+
+    .lmalloc	= pmapi_lmalloc, /* Allocate low memory */
+    .lfree	= free,		 /* Free low memory */
+
+    .open_file	= open_file,
+    .read_file	= pmapi_read_file,
+    .close_file	= close_file,
+
+    .opendir	= opendir,
+    .readdir	= readdir,
+    .closedir	= closedir,
+
+    .idle	= __idle,
+    .reset_idle	= reset_idle,
+
+    .chdir	= chdir,
+    .getcwd	= getcwd,
+
+    .jiffies	= &__jiffies,
+    .ms_timer	= &__ms_timer,
+};
diff --git a/contrib/syslinux-4.02/core/pmcall.inc b/contrib/syslinux-4.02/core/pmcall.inc
new file mode 100644
index 0000000..0a58015
--- /dev/null
+++ b/contrib/syslinux-4.02/core/pmcall.inc
@@ -0,0 +1,70 @@
+;;
+;; pmcall.inc
+;;
+;; Macros for the stack frame set up by pm_call, assuming ebp is left
+;; as the RM frame pointer.
+;;
+
+%ifndef PMCALL_INC
+%define PMCALL_INC
+
+%define RM_GS		word [ebp]
+%define RM_FS		word [ebp+2]
+%define RM_ES		word [ebp+4]
+%define RM_DS		word [ebp+6]
+
+%define RM_EDI		dword [ebp+8]
+%define RM_DI		word [ebp+8]
+%define RM_HDI		word [ebp+10]
+%define RM_DIL		byte [ebp+8]
+%define RM_DIH		byte [ebp+9]
+
+%define RM_ESI		dword [ebp+12]
+%define RM_SI		word [ebp+12]
+%define RM_HSI		word [ebp+14]
+%define RM_SIL		byte [ebp+12]
+%define RM_SIH		byte [ebp+13]
+
+%define RM_EBP		dword [ebp+16]
+%define RM_BP		word [ebp+16]
+%define RM_HBP		word [ebp+18]
+%define RM_BPL		byte [ebp+16]
+%define RM_BPH		byte [ebp+17]
+
+%define RM_EBX		dword [ebp+24]
+%define RM_BX		word [ebp+24]
+%define RM_HBX		word [ebp+26]
+%define RM_BL		byte [ebp+24]
+%define RM_BH		byte [ebp+25]
+
+%define RM_EDX		dword [ebp+28]
+%define RM_DX		word [ebp+28]
+%define RM_HDX		word [ebp+30]
+%define RM_DL		byte [ebp+28]
+%define RM_DH		byte [ebp+29]
+
+%define RM_ECX		dword [ebp+32]
+%define RM_CX		word [ebp+32]
+%define RM_HCX		word [ebp+34]
+%define RM_CL		byte [ebp+32]
+%define RM_CH		byte [ebp+33]
+
+%define RM_EAX		dword [ebp+36]
+%define RM_AX		word [ebp+36]
+%define RM_HAX		word [ebp+38]
+%define RM_AL		byte [ebp+36]
+%define RM_AH		byte [ebp+37]
+
+%define RM_EFLAGS	dword [ebp+40]
+%define RM_FLAGS	word [ebp+40]
+%define RM_HFLAGS	word [ebp+42]
+%define RM_FLAGSL	byte [ebp+40]
+%define RM_FLAGSH	byte [ebp+41]
+
+; Convenience macro to call a PM function
+%macro	pm_call	1
+	push dword %1
+	call _pm_call
+%endmacro
+
+%endif ; PMCALL_INC
diff --git a/contrib/syslinux-4.02/core/prefix.inc b/contrib/syslinux-4.02/core/prefix.inc
new file mode 100644
index 0000000..9c8724b
--- /dev/null
+++ b/contrib/syslinux-4.02/core/prefix.inc
@@ -0,0 +1,17 @@
+;
+; The prefix is a small structure that prefaces the actual code;
+; it gives the compression program necessary information.
+;
+
+		section .prefix		nowrite progbits align=16
+pfx_start	dd _start		; Start of raw chunk
+pfx_compressed	dd __pm_code_lma	; Start of compressed chunk
+pfx_cdatalen	dd lzo_data_size	; Pointer to compressed size field
+%if IS_ISOLINUX
+pfx_checksum	dd bi_length		; File length and checksum fields
+%else
+pfx_checksum	dd 0			; No checksum
+%endif
+pfx_maxlma	dd MaxLMA		; Maximum size
+
+		section .text16
diff --git a/contrib/syslinux-4.02/core/printf.c b/contrib/syslinux-4.02/core/printf.c
new file mode 100644
index 0000000..b1b0466
--- /dev/null
+++ b/contrib/syslinux-4.02/core/printf.c
@@ -0,0 +1,20 @@
+#include <stdio.h>
+#include <unistd.h>
+
+#include "core.h"
+
+int printf(const char *format, ...)
+{
+    char buf[1024];
+    va_list ap;
+    int rv;
+    
+    va_start(ap, format);
+    rv = vsnprintf(buf, sizeof buf, format, ap);
+    va_end(ap);
+    
+    myputs(buf);
+
+    return rv;
+
+}
diff --git a/contrib/syslinux-4.02/core/pxe.inc b/contrib/syslinux-4.02/core/pxe.inc
new file mode 100644
index 0000000..2fd1edb
--- /dev/null
+++ b/contrib/syslinux-4.02/core/pxe.inc
@@ -0,0 +1,155 @@
+;; -----------------------------------------------------------------------
+;;
+;;   Copyright 1999-2008 H. Peter Anvin - All Rights Reserved
+;;
+;;   This program is free software; you can redistribute it and/or modify
+;;   it under the terms of the GNU General Public License as published by
+;;   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
+;;   Boston MA 02111-1307, USA; either version 2 of the License, or
+;;   (at your option) any later version; incorporated herein by reference.
+;;
+;; -----------------------------------------------------------------------
+
+;;
+;; pxe.inc
+;;
+;; PXE opcodes
+;;
+
+%ifndef _PXE_INC
+%define _PXE_INC 1
+
+%define PXENV_TFTP_OPEN					 0x0020
+%define PXENV_TFTP_CLOSE				 0x0021
+%define PXENV_TFTP_READ					 0x0022
+%define PXENV_TFTP_READ_FILE				 0x0023
+%define PXENV_TFTP_READ_FILE_PMODE			 0x0024
+%define PXENV_TFTP_GET_FSIZE				 0x0025
+
+%define PXENV_UDP_OPEN					 0x0030
+%define PXENV_UDP_CLOSE					 0x0031
+%define PXENV_UDP_READ					 0x0032
+%define PXENV_UDP_WRITE					 0x0033
+
+%define PXENV_START_UNDI				 0x0000
+%define PXENV_UNDI_STARTUP				 0x0001
+%define PXENV_UNDI_CLEANUP				 0x0002
+%define PXENV_UNDI_INITIALIZE				 0x0003
+%define PXENV_UNDI_RESET_NIC				 0x0004
+%define PXENV_UNDI_SHUTDOWN				 0x0005
+%define PXENV_UNDI_OPEN					 0x0006
+%define PXENV_UNDI_CLOSE				 0x0007
+%define PXENV_UNDI_TRANSMIT				 0x0008
+%define PXENV_UNDI_SET_MCAST_ADDR			 0x0009
+%define PXENV_UNDI_SET_STATION_ADDR			 0x000A
+%define PXENV_UNDI_SET_PACKET_FILTER			 0x000B
+%define PXENV_UNDI_GET_INFORMATION			 0x000C
+%define PXENV_UNDI_GET_STATISTICS			 0x000D
+%define PXENV_UNDI_CLEAR_STATISTICS			 0x000E
+%define PXENV_UNDI_INITIATE_DIAGS			 0x000F
+%define PXENV_UNDI_FORCE_INTERRUPT			 0x0010
+%define PXENV_UNDI_GET_MCAST_ADDR			 0x0011
+%define PXENV_UNDI_GET_NIC_TYPE				 0x0012
+%define PXENV_UNDI_GET_IFACE_INFO			 0x0013
+%define PXENV_UNDI_ISR					 0x0014
+%define PXENV_STOP_UNDI					 0x0015	; Overlap...?
+%define PXENV_UNDI_GET_STATE				 0x0015	; Overlap...?
+
+%define PXENV_UNLOAD_STACK				 0x0070
+%define PXENV_GET_CACHED_INFO				 0x0071
+%define PXENV_RESTART_DHCP				 0x0072
+%define PXENV_RESTART_TFTP				 0x0073
+%define PXENV_MODE_SWITCH				 0x0074
+%define PXENV_START_BASE				 0x0075
+%define PXENV_STOP_BASE					 0x0076
+
+; gPXE extensions...
+%define PXENV_FILE_OPEN					 0x00e0
+%define PXENV_FILE_CLOSE				 0x00e1
+%define PXENV_FILE_SELECT				 0x00e2
+%define PXENV_FILE_READ					 0x00e3
+%define PXENV_GET_FILE_SIZE				 0x00e4
+%define PXENV_FILE_EXEC					 0x00e5
+%define PXENV_FILE_API_CHECK				 0x00e6
+%define PXENV_FILE_EXIT_HOOK				 0x00e7
+
+; Exit codes
+%define PXENV_EXIT_SUCCESS				 0x0000
+%define PXENV_EXIT_FAILURE				 0x0001
+
+; Status codes
+%define PXENV_STATUS_SUCCESS				 0x00
+%define PXENV_STATUS_FAILURE				 0x01
+%define PXENV_STATUS_BAD_FUNC				 0x02
+%define PXENV_STATUS_UNSUPPORTED			 0x03
+%define PXENV_STATUS_KEEP_UNDI				 0x04
+%define PXENV_STATUS_KEEP_ALL				 0x05
+%define PXENV_STATUS_OUT_OF_RESOURCES			 0x06
+%define PXENV_STATUS_ARP_TIMEOUT			 0x11
+%define PXENV_STATUS_UDP_CLOSED				 0x18
+%define PXENV_STATUS_UDP_OPEN				 0x19
+%define PXENV_STATUS_TFTP_CLOSED			 0x1a
+%define PXENV_STATUS_TFTP_OPEN				 0x1b
+%define PXENV_STATUS_MCOPY_PROBLEM			 0x20
+%define PXENV_STATUS_BIS_INTEGRITY_FAILURE		 0x21
+%define PXENV_STATUS_BIS_VALIDATE_FAILURE		 0x22
+%define PXENV_STATUS_BIS_INIT_FAILURE			 0x23
+%define PXENV_STATUS_BIS_SHUTDOWN_FAILURE		 0x24
+%define PXENV_STATUS_BIS_GBOA_FAILURE			 0x25
+%define PXENV_STATUS_BIS_FREE_FAILURE			 0x26
+%define PXENV_STATUS_BIS_GSI_FAILURE			 0x27
+%define PXENV_STATUS_BIS_BAD_CKSUM			 0x28
+%define PXENV_STATUS_TFTP_CANNOT_ARP_ADDRESS		 0x30
+%define PXENV_STATUS_TFTP_OPEN_TIMEOUT			 0x32
+
+%define PXENV_STATUS_TFTP_UNKNOWN_OPCODE		 0x33
+%define PXENV_STATUS_TFTP_READ_TIMEOUT			 0x35
+%define PXENV_STATUS_TFTP_ERROR_OPCODE			 0x36
+%define PXENV_STATUS_TFTP_CANNOT_OPEN_CONNECTION	 0x38
+%define PXENV_STATUS_TFTP_CANNOT_READ_FROM_CONNECTION	 0x39
+%define PXENV_STATUS_TFTP_TOO_MANY_PACKAGES		 0x3a
+%define PXENV_STATUS_TFTP_FILE_NOT_FOUND		 0x3b
+%define PXENV_STATUS_TFTP_ACCESS_VIOLATION		 0x3c
+%define PXENV_STATUS_TFTP_NO_MCAST_ADDRESS		 0x3d
+%define PXENV_STATUS_TFTP_NO_FILESIZE			 0x3e
+%define PXENV_STATUS_TFTP_INVALID_PACKET_SIZE		 0x3f
+%define PXENV_STATUS_DHCP_TIMEOUT			 0x51
+%define PXENV_STATUS_DHCP_NO_IP_ADDRESS			 0x52
+%define PXENV_STATUS_DHCP_NO_BOOTFILE_NAME		 0x53
+%define PXENV_STATUS_DHCP_BAD_IP_ADDRESS		 0x54
+%define PXENV_STATUS_UNDI_INVALID_FUNCTION		 0x60
+%define PXENV_STATUS_UNDI_MEDIATEST_FAILED		 0x61
+%define PXENV_STATUS_UNDI_CANNOT_INIT_NIC_FOR_MCAST	 0x62
+%define PXENV_STATUS_UNDI_CANNOT_INITIALIZE_NIC		 0x63
+%define PXENV_STATUS_UNDI_CANNOT_INITIALIZE_PHY		 0x64
+%define PXENV_STATUS_UNDI_CANNOT_READ_CONFIG_DATA	 0x65
+%define PXENV_STATUS_UNDI_CANNOT_READ_INIT_DATA		 0x66
+%define PXENV_STATUS_UNDI_BAD_MAC_ADDRESS		 0x67
+%define PXENV_STATUS_UNDI_BAD_EEPROM_CHECKSUM		 0x68
+%define PXENV_STATUS_UNDI_ERROR_SETTING_ISR		 0x69
+%define PXENV_STATUS_UNDI_INVALID_STATE			 0x6a
+%define PXENV_STATUS_UNDI_TRANSMIT_ERROR		 0x6b
+%define PXENV_STATUS_UNDI_INVALID_PARAMETER		 0x6c
+%define PXENV_STATUS_BSTRAP_PROMPT_MENU			 0x74
+%define PXENV_STATUS_BSTRAP_MCAST_ADDR			 0x76
+%define PXENV_STATUS_BSTRAP_MISSING_LIST		 0x77
+%define PXENV_STATUS_BSTRAP_NO_RESPONSE			 0x78
+%define PXENV_STATUS_BSTRAP_FILE_TOO_BIG		 0x79
+%define PXENV_STATUS_BINL_CANCELED_BY_KEYSTROKE		 0xa0
+%define PXENV_STATUS_BINL_NO_PXE_SERVER			 0xa1
+%define PXENV_STATUS_NOT_AVAILABLE_IN_PMODE		 0xa2
+%define PXENV_STATUS_NOT_AVAILABLE_IN_RMODE		 0xa3
+%define PXENV_STATUS_BUSD_DEVICE_NOT_SUPPORTED		 0xb0
+%define PXENV_STATUS_LOADER_NO_FREE_BASE_MEMORY		 0xc0
+%define PXENV_STATUS_LOADER_NO_BC_ROMID			 0xc1
+%define PXENV_STATUS_LOADER_BAD_BC_ROMID		 0xc2
+%define PXENV_STATUS_LOADER_BAD_BC_RUNTIME_IMAGE	 0xc3
+%define PXENV_STATUS_LOADER_NO_UNDI_ROMID		 0xc4
+%define PXENV_STATUS_LOADER_BAD_UNDI_ROMID		 0xc5
+%define PXENV_STATUS_LOADER_BAD_UNDI_DRIVER_IMAGE	 0xc6
+%define PXENV_STATUS_LOADER_NO_PXE_STRUCT		 0xc8
+%define PXENV_STATUS_LOADER_NO_PXENV_STRUCT		 0xc9
+%define PXENV_STATUS_LOADER_UNDI_START			 0xca
+%define PXENV_STATUS_LOADER_BC_START			 0xcb
+
+%endif ; _PXE_INC
diff --git a/contrib/syslinux-4.02/core/pxelinux.asm b/contrib/syslinux-4.02/core/pxelinux.asm
new file mode 100644
index 0000000..8084ac9
--- /dev/null
+++ b/contrib/syslinux-4.02/core/pxelinux.asm
@@ -0,0 +1,544 @@
+; -*- fundamental -*- (asm-mode sucks)
+; ****************************************************************************
+;
+;  pxelinux.asm
+;
+;  A program to boot Linux kernels off a TFTP server using the Intel PXE
+;  network booting API.  It is based on the SYSLINUX boot loader for
+;  MS-DOS floppies.
+;
+;   Copyright 1994-2009 H. Peter Anvin - All Rights Reserved
+;   Copyright 2009 Intel Corporation; author: H. Peter Anvin
+;
+;  This program is free software; you can redistribute it and/or modify
+;  it under the terms of the GNU General Public License as published by
+;  the Free Software Foundation, Inc., 53 Temple Place Ste 330,
+;  Boston MA 02111-1307, USA; either version 2 of the License, or
+;  (at your option) any later version; incorporated herein by reference.
+;
+; ****************************************************************************
+
+%define IS_PXELINUX 1
+%include "head.inc"
+%include "pxe.inc"
+
+; gPXE extensions support
+%define GPXE	1
+
+;
+; Some semi-configurable constants... change on your own risk.
+;
+my_id		equ pxelinux_id
+NULLFILE	equ 0			; Zero byte == null file name
+NULLOFFSET	equ 0			; Position in which to look
+REBOOT_TIME	equ 5*60		; If failure, time until full reset
+%assign HIGHMEM_SLOP 128*1024		; Avoid this much memory near the top
+TFTP_BLOCKSIZE_LG2 equ 9		; log2(bytes/block)
+TFTP_BLOCKSIZE	equ (1 << TFTP_BLOCKSIZE_LG2)
+
+SECTOR_SHIFT	equ TFTP_BLOCKSIZE_LG2
+SECTOR_SIZE	equ TFTP_BLOCKSIZE
+
+;
+; The following structure is used for "virtual kernels"; i.e. LILO-style
+; option labels.  The options we permit here are `kernel' and `append
+; Since there is no room in the bottom 64K for all of these, we
+; stick them in high memory and copy them down before we need them.
+;
+		struc vkernel
+vk_vname:	resb FILENAME_MAX	; Virtual name **MUST BE FIRST!**
+vk_rname:	resb FILENAME_MAX	; Real name
+vk_ipappend:	resb 1			; "IPAPPEND" flag
+vk_type:	resb 1			; Type of file
+vk_appendlen:	resw 1
+		alignb 4
+vk_append:	resb max_cmd_len+1	; Command line
+		alignb 4
+vk_end:		equ $			; Should be <= vk_size
+		endstruc
+
+
+; ---------------------------------------------------------------------------
+;   BEGIN CODE
+; ---------------------------------------------------------------------------
+
+;
+; Memory below this point is reserved for the BIOS and the MBR
+;
+		section .earlybss
+                global trackbuf
+trackbufsize	equ 8192
+trackbuf	resb trackbufsize	; Track buffer goes here
+		; ends at 2800h
+
+		; These fields save information from before the time
+		; .bss is zeroed... must be in .earlybss
+		global InitStack
+InitStack	resd 1
+
+		section .bss16
+		alignb FILENAME_MAX
+PXEStack	resd 1			; Saved stack during PXE call
+
+		alignb 4
+                global DHCPMagic, RebootTime, APIVer
+RebootTime	resd 1			; Reboot timeout, if set by option
+StrucPtr	resw 2			; Pointer to PXENV+ or !PXE structure
+APIVer		resw 1			; PXE API version found
+LocalBootType	resw 1			; Local boot return code
+DHCPMagic	resb 1			; PXELINUX magic flags
+
+		section .text16
+StackBuf	equ STACK_TOP-44	; Base of stack if we use our own
+StackHome	equ StackBuf
+
+		; PXE loads the whole file, but assume it can't be more
+		; than (384-31)K in size.
+MaxLMA		equ 384*1024
+
+;
+; Primary entry point.
+;
+bootsec		equ $
+_start:
+		jmp 0:_start1		; Canonicalize the address and skip
+					; the patch header
+
+;
+; Patch area for adding hardwired DHCP options
+;
+		align 4
+
+hcdhcp_magic	dd 0x2983c8ac		; Magic number
+hcdhcp_len	dd 7*4			; Size of this structure
+hcdhcp_flags	dd 0			; Reserved for the future
+		; Parameters to be parsed before the ones from PXE
+bdhcp_offset	dd 0			; Offset (entered by patcher)
+bdhcp_len	dd 0			; Length (entered by patcher)
+		; Parameters to be parsed *after* the ones from PXE
+adhcp_offset	dd 0			; Offset (entered by patcher)
+adhcp_len	dd 0			; Length (entered by patcher)
+
+_start1:
+		pushfd			; Paranoia... in case of return to PXE
+		pushad			; ... save as much state as possible
+		push ds
+		push es
+		push fs
+		push gs
+
+		cld			; Copy upwards
+		xor ax,ax
+		mov ds,ax
+		mov es,ax
+
+%if 0 ; debugging code only... not intended for production use
+		; Clobber the stack segment, to test for specific pathologies
+		mov di,STACK_BASE
+		mov cx,STACK_LEN >> 1
+		mov ax,0xf4f4
+		rep stosw
+
+		; Clobber the tail of the 64K segment, too
+		extern __bss1_end
+		mov di,__bss1_end
+		sub cx,di		; CX = 0 previously
+		shr cx,1
+		rep stosw
+%endif
+
+		; That is all pushed onto the PXE stack.  Save the pointer
+		; to it and switch to an internal stack.
+		mov [InitStack],sp
+		mov [InitStack+2],ss
+
+		lss esp,[BaseStack]
+		sti			; Stack set up and ready
+;
+; Move the hardwired DHCP options (if present) to a safe place...
+;
+bdhcp_copy:
+		mov cx,[bdhcp_len]
+		mov ax,trackbufsize/2
+		jcxz .none
+		cmp cx,ax
+		jbe .oksize
+		mov cx,ax
+		mov [bdhcp_len],ax
+.oksize:
+		mov eax,[bdhcp_offset]
+		add eax,_start
+		mov si,ax
+		and si,000Fh
+		shr eax,4
+		push ds
+		mov ds,ax
+		mov di,trackbuf
+		add cx,3
+		shr cx,2
+		rep movsd
+		pop ds
+.none:
+
+adhcp_copy:
+		mov cx,[adhcp_len]
+		mov ax,trackbufsize/2
+		jcxz .none
+		cmp cx,ax
+		jbe .oksize
+		mov cx,ax
+		mov [adhcp_len],ax
+.oksize:
+		mov eax,[adhcp_offset]
+		add eax,_start
+		mov si,ax
+		and si,000Fh
+		shr eax,4
+		push ds
+		mov ds,ax
+		mov di,trackbuf+trackbufsize/2
+		add cx,3
+		shr cx,2
+		rep movsd
+		pop ds
+.none:
+
+;
+; Initialize screen (if we're using one)
+;
+%include "init.inc"
+
+;
+; Tell the user we got this far
+;
+		mov si,syslinux_banner
+		call writestr_early
+
+		mov si,copyright_str
+		call writestr_early
+
+;
+; do fs initialize
+;
+	        mov eax,ROOT_FS_OPS
+		xor ebp,ebp
+                pm_call fs_init
+
+		section .rodata
+		alignz 4
+ROOT_FS_OPS:
+                extern pxe_fs_ops
+		dd pxe_fs_ops
+		dd 0
+
+
+		section .text16
+;
+; Initialize the idle mechanism
+;
+		call reset_idle
+
+;
+; Now we're all set to start with our *real* business.	First load the
+; configuration file (if any) and parse it.
+;
+; In previous versions I avoided using 32-bit registers because of a
+; rumour some BIOSes clobbered the upper half of 32-bit registers at
+; random.  I figure, though, that if there are any of those still left
+; they probably won't be trying to install Linux on them...
+;
+; The code is still ripe with 16-bitisms, though.  Not worth the hassle
+; to take'm out.  In fact, we may want to put them back if we're going
+; to boot ELKS at some point.
+;
+
+;
+; Load configuration file
+;
+                pm_call load_config
+
+;
+; Linux kernel loading code is common.  However, we need to define
+; a couple of helper macros...
+;
+
+; Unload PXE stack
+%define HAVE_UNLOAD_PREP
+%macro	UNLOAD_PREP 0
+		pm_call unload_pxe
+%endmacro
+
+;
+; Now we have the config file open.  Parse the config file and
+; run the user interface.
+;
+%include "ui.inc"
+
+;
+; Boot to the local disk by returning the appropriate PXE magic.
+; AX contains the appropriate return code.
+;
+local_boot:
+		push cs
+		pop ds
+		mov [LocalBootType],ax
+		call vgaclearmode
+		mov si,localboot_msg
+		call writestr_early
+		; Restore the environment we were called with
+		pm_call reset_pxe
+		call cleanup_hardware
+		lss sp,[InitStack]
+		pop gs
+		pop fs
+		pop es
+		pop ds
+		popad
+		mov ax,[cs:LocalBootType]
+		cmp ax,-1			; localboot -1 == INT 18h
+		je .int18
+		popfd
+		retf				; Return to PXE
+.int18:
+		popfd
+		int 18h
+		jmp 0F000h:0FFF0h
+		hlt
+
+;
+; kaboom: write a message and bail out.  Wait for quite a while,
+;	  or a user keypress, then do a hard reboot.
+;
+;         Note: use BIOS_timer here; we may not have jiffies set up.
+;
+                global kaboom
+kaboom:
+		RESET_STACK_AND_SEGS AX
+.patch:		mov si,bailmsg
+		call writestr_early		; Returns with AL = 0
+.drain:		call pollchar
+		jz .drained
+		call getchar
+		jmp short .drain
+.drained:
+		mov edi,[RebootTime]
+		mov al,[DHCPMagic]
+		and al,09h		; Magic+Timeout
+		cmp al,09h
+		je .time_set
+		mov edi,REBOOT_TIME
+.time_set:
+		mov cx,18
+.wait1:		push cx
+		mov ecx,edi
+.wait2:		mov dx,[BIOS_timer]
+.wait3:		call pollchar
+		jnz .keypress
+		call do_idle
+		cmp dx,[BIOS_timer]
+		je .wait3
+		loop .wait2,ecx
+		mov al,'.'
+		call writechr
+		pop cx
+		loop .wait1
+.keypress:
+		call crlf
+		mov word [BIOS_magic],0	; Cold reboot
+		jmp 0F000h:0FFF0h	; Reset vector address
+
+
+;
+; pxenv
+;
+; This is the main PXENV+/!PXE entry point, using the PXENV+
+; calling convention.  This is a separate local routine so
+; we can hook special things from it if necessary.  In particular,
+; some PXE stacks seem to not like being invoked from anything but
+; the initial stack, so humour it.
+;
+; While we're at it, save and restore all registers.
+;
+                global pxenv
+pxenv:
+		pushfd
+		pushad
+
+		mov [cs:PXEStack],sp
+		mov [cs:PXEStack+2],ss
+		lss sp,[cs:InitStack]
+
+		; Pre-clear the Status field
+		mov word [es:di],cs
+
+		; This works either for the PXENV+ or the !PXE calling
+		; convention, as long as we ignore CF (which is redundant
+		; with AX anyway.)
+		push es
+		push di
+		push bx
+.jump:		call 0:0
+		add sp,6
+		mov [cs:PXEStatus],ax
+
+		lss sp,[cs:PXEStack]
+
+		mov bp,sp
+		and ax,ax
+		setnz [bp+32]			; If AX != 0 set CF on return
+
+		; This clobbers the AX return, but we already saved it into
+		; the PXEStatus variable.
+		popad
+		popfd				; Restore flags (incl. IF, DF)
+		ret
+
+; Must be after function def due to NASM bug
+                global PXEEntry
+PXEEntry	equ pxenv.jump+1
+
+		section .bss16
+		alignb 2
+PXEStatus	resb 2
+
+
+		section .text16
+;
+; Invoke INT 1Ah on the PXE stack.  This is used by the "Plan C" method
+; for finding the PXE entry point.
+;
+                global pxe_int1a
+pxe_int1a:
+		mov [cs:PXEStack],sp
+		mov [cs:PXEStack+2],ss
+		lss sp,[cs:InitStack]
+
+		int 1Ah			; May trash registers
+
+		lss sp,[cs:PXEStack]
+		ret
+
+;
+; Special unload for gPXE: this switches the InitStack from
+; gPXE to the ROM PXE stack.
+;
+%if GPXE
+		global gpxe_unload
+gpxe_unload:
+		mov bx,PXENV_FILE_EXIT_HOOK
+		mov di,pxe_file_exit_hook
+		call pxenv
+		jc .plain
+
+		; Now we actually need to exit back to gPXE, which will
+		; give control back to us on the *new* "original stack"...
+		pushfd
+		push ds
+		push es
+		mov [PXEStack],sp
+		mov [PXEStack+2],ss
+		lss sp,[InitStack]
+		pop gs
+		pop fs
+		pop es
+		pop ds
+		popad
+		popfd
+		xor ax,ax
+		retf
+.resume:
+		cli
+
+		; gPXE will have a stack frame looking much like our
+		; InitStack, except it has a magic cookie at the top,
+		; and the segment registers are in reverse order.
+		pop eax
+		pop ax
+		pop bx
+		pop cx
+		pop dx
+		push ax
+		push bx
+		push cx
+		push dx
+		mov [cs:InitStack],sp
+		mov [cs:InitStack+2],ss
+		lss sp,[cs:PXEStack]
+		pop es
+		pop ds
+		popfd
+
+.plain:
+		ret
+
+		section .data16
+		alignz 4
+pxe_file_exit_hook:
+.status:	dw 0
+.offset:	dw gpxe_unload.resume
+.seg:		dw 0
+%endif
+
+		section .text16
+
+; -----------------------------------------------------------------------------
+;  Common modules
+; -----------------------------------------------------------------------------
+
+%include "common.inc"		; Universal modules
+%include "writestr.inc"		; String output
+writestr_early	equ writestr
+%include "writehex.inc"		; Hexadecimal output
+%include "rawcon.inc"		; Console I/O w/o using the console functions
+
+; -----------------------------------------------------------------------------
+;  Begin data section
+; -----------------------------------------------------------------------------
+
+		section .data16
+
+copyright_str   db ' Copyright (C) 1994-'
+		asciidec YEAR
+		db ' H. Peter Anvin et al', CR, LF, 0
+err_bootfailed	db CR, LF, 'Boot failed: press a key to retry, or wait for reset...', CR, LF, 0
+bailmsg		equ err_bootfailed
+localboot_msg	db 'Booting from local disk...', CR, LF, 0
+syslinux_banner	db CR, LF, MY_NAME, ' ', VERSION_STR, ' ', DATE_STR, ' ', 0
+
+;
+; Config file keyword table
+;
+%include "keywords.inc"
+
+;
+; Extensions to search for (in *forward* order).
+; (.bs and .bss16 are disabled for PXELINUX, since they are not supported)
+;
+		alignz 4
+exten_table:	db '.cbt'		; COMBOOT (specific)
+		db '.0', 0, 0		; PXE bootstrap program
+		db '.com'		; COMBOOT (same as DOS)
+		db '.c32'		; COM32
+exten_table_end:
+		dd 0, 0			; Need 8 null bytes here
+
+;
+; Misc initialized (data) variables
+;
+		section .data16
+                global KeepPXE
+KeepPXE		db 0			; Should PXE be kept around?
+
+;
+; IP information.  Note that the field are in the same order as the
+; Linux kernel expects in the ip= option.
+;
+		section .bss16
+		alignb 4
+		global IPInfo
+IPInfo:
+.IPv4		resd 1			; IPv4 information
+.MyIP		resd 1			; My IP address 
+.ServerIP	resd 1
+.GatewayIP	resd 1
+.Netmask	resd 1
diff --git a/contrib/syslinux-4.02/core/rawcon.inc b/contrib/syslinux-4.02/core/rawcon.inc
new file mode 100644
index 0000000..f0d434c
--- /dev/null
+++ b/contrib/syslinux-4.02/core/rawcon.inc
@@ -0,0 +1,75 @@
+;
+; writechr:	Write a single character in AL to the console without
+;		mangling any registers.  This does raw console writes,
+;		since some PXE BIOSes seem to interfere regular console I/O.
+;
+%if IS_ISOLINUX
+writechr_full:
+%else
+writechr:
+%endif
+		pushfd
+		push ds
+		push cs
+		pop ds
+		test byte [UsingVGA], 08h
+		jz .videook
+		call vgaclearmode
+.videook:
+		call write_serial	; write to serial port if needed
+		test byte [DisplayCon],01h	; Write to screen?
+		jz .nothing
+
+		pushad
+		mov bh,[BIOS_page]
+		push ax
+                mov ah,03h              ; Read cursor position
+                int 10h
+		pop ax
+		cmp al,8
+		je .bs
+		cmp al,13
+		je .cr
+		cmp al,10
+		je .lf
+		push dx
+                mov bh,[BIOS_page]
+		mov bl,07h		; White on black
+		mov cx,1		; One only
+		mov ah,09h		; Write char and attribute
+		int 10h
+		pop dx
+		inc dl
+		cmp dl,[VidCols]
+		jna .curxyok
+		xor dl,dl
+.lf:		inc dh
+		cmp dh,[VidRows]
+		ja .scroll
+.curxyok:	mov bh,[BIOS_page]
+		mov ah,02h		; Set cursor position
+		int 10h
+.ret:		popad
+.nothing:
+		pop ds
+		popfd
+		ret
+.scroll:	dec dh
+		mov bh,[BIOS_page]
+		mov ah,02h
+		int 10h
+		mov ax,0601h		; Scroll up one line
+		mov bh,[ScrollAttribute]
+		xor cx,cx
+		mov dx,[ScreenSize]	; The whole screen
+		int 10h
+		jmp short .ret
+.cr:		xor dl,dl
+		jmp short .curxyok
+.bs:		sub dl,1
+		jnc .curxyok
+		mov dl,[VidCols]
+		sub dh,1
+		jnc .curxyok
+		xor dh,dh
+		jmp short .curxyok
diff --git a/contrib/syslinux-4.02/core/regdump.inc b/contrib/syslinux-4.02/core/regdump.inc
new file mode 100644
index 0000000..bdb5172
--- /dev/null
+++ b/contrib/syslinux-4.02/core/regdump.inc
@@ -0,0 +1,108 @@
+;; -----------------------------------------------------------------------
+;;
+;;   Copyright 2003-2008 H. Peter Anvin - All Rights Reserved
+;;
+;;   This program is free software; you can redistribute it and/or modify
+;;   it under the terms of the GNU General Public License as published by
+;;   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
+;;   Boston MA 02111-1307, USA; either version 2 of the License, or
+;;   (at your option) any later version; incorporated herein by reference.
+;;
+;; -----------------------------------------------------------------------
+
+;;
+;; regdump.inc
+;;
+;; Dump as much as possible of the register state; for debugging
+;;
+
+disk_dumpregs:
+	mov ah,02h
+	call dumpregs
+	int 13h
+	ret
+
+dumpregs:
+	push gs
+	push fs
+	push es
+	push ds
+	push ss
+	push cs
+	pushad
+	pushfd
+
+	push cs
+	pop ds
+
+	mov bp,sp
+	mov di,regnames
+
+	mov cx,9		; 9 32-bit registers
+.reg8:
+	mov si,[di]
+	inc di
+	inc di
+	call writestr
+	mov eax,[bp]
+	add bp,4
+	call writehex8
+	loop .reg8
+
+	mov cx,7		; 6 16-bit registers
+.reg4:
+	mov si,[di]
+	inc di
+	inc di
+	call writestr
+	mov eax,[bp]
+	inc bp
+	inc bp
+	call writehex4
+	loop .reg4
+
+	call crlf
+
+	popfd
+	popad
+	add sp,4		; Skip CS, SS
+	pop ds
+	pop es
+	pop fs
+	pop gs
+	ret
+
+regnames:
+	dw .eflags
+	dw .edi
+	dw .esi
+	dw .ebp
+	dw .esp
+	dw .ebx
+	dw .edx
+	dw .ecx
+	dw .eax
+	dw .cs
+	dw .ss
+	dw .ds
+	dw .es
+	dw .fs
+	dw .gs
+	dw .ip
+
+.eflags	db 'EFL: ', 0
+.edi	db 13,10,'EDI: ', 0
+.esi	db ' ESI: ', 0
+.ebp	db ' EBP: ', 0
+.esp	db ' ESP: ', 0
+.ebx	db 13,10,'EBX: ', 0
+.edx	db ' EDX: ', 0
+.ecx	db ' ECX: ', 0
+.eax	db ' EAX: ', 0
+.cs	db 13,10,'CS: ',0
+.ss	db ' SS: ',0
+.ds	db ' DS: ',0
+.es	db ' ES: ',0
+.fs	db ' FS: ',0
+.gs	db ' GS: ',0
+.ip	db ' IP: ',0
diff --git a/contrib/syslinux-4.02/core/rllpack.c b/contrib/syslinux-4.02/core/rllpack.c
new file mode 100644
index 0000000..bb9f046
--- /dev/null
+++ b/contrib/syslinux-4.02/core/rllpack.c
@@ -0,0 +1,105 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 2007-2009 H. Peter Anvin - All Rights Reserved
+ *   Copyright 2009 Intel Corporation; author: H. Peter Anvin
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+ *   Boston MA 02110-1301, USA; either version 2 of the License, or
+ *   (at your option) any later version; incorporated herein by reference.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * rllpack.inc
+ *
+ * Very simple RLL compressor/decompressor, used to pack binary structures
+ * together.
+ *
+ * Format of leading byte
+ * 1-128	= x verbatim bytes follow
+ * 129-223	= (x-126) times subsequent byte
+ * 224-255	= (x-224)*256+(next byte) times the following byte
+ * 0		= end of data
+ *
+ * These structures are stored *in reverse order* in high memory.
+ * High memory pointers point to one byte beyond the end.
+ */
+
+#include <com32.h>
+#include <stddef.h>
+#include <string.h>
+
+void rllpack(com32sys_t * regs)
+{
+    uint8_t *i = (uint8_t *) (regs->esi.l);
+    uint8_t *o = (uint8_t *) (regs->edi.l);
+    size_t cnt = regs->ecx.l;
+    size_t run, vrun, tcnt;
+    uint8_t *hdr = NULL;
+    uint8_t c;
+
+    vrun = (size_t)-1;
+    while (cnt) {
+	c = *i;
+
+	run = 1;
+	tcnt = (cnt > 8191) ? 8191 : cnt;
+	while (run < tcnt && i[run] == c)
+	    run++;
+
+	if (run < 3) {
+	    if (vrun >= 128) {
+		hdr = --o;
+		vrun = 0;
+	    }
+	    *--o = c;
+	    *hdr = ++vrun;
+	    i++;
+	    cnt--;
+	} else {
+	    if (run < 224 - 126) {
+		*--o = run + 126;
+	    } else {
+		o -= 2;
+		*(uint16_t *) o = run + (224 << 8);
+	    }
+	    *--o = c;
+	    vrun = (size_t)-1;
+	    i += run;
+	    cnt -= run;
+	}
+    }
+    *--o = 0;
+
+    regs->esi.l = (size_t)i;
+    regs->edi.l = (size_t)o;
+}
+
+void rllunpack(com32sys_t * regs)
+{
+    uint8_t *i = (uint8_t *) regs->esi.l;
+    uint8_t *o = (uint8_t *) regs->edi.l;
+    uint8_t c;
+    size_t n;
+
+    while ((c = *--i)) {
+	if (c <= 128) {
+	    while (c--)
+		*o++ = *--i;
+	} else {
+	    if (c < 224)
+		n = c - 126;
+	    else
+		n = ((c - 224) << 8) + *--i;
+	    c = *--i;
+	    while (n--)
+		*o++ = c;
+	}
+    }
+
+    regs->esi.l = (size_t)i;
+    regs->ecx.l = (size_t)o - regs->edi.l;
+    regs->edi.l = (size_t)o;
+}
diff --git a/contrib/syslinux-4.02/core/runkernel.inc b/contrib/syslinux-4.02/core/runkernel.inc
new file mode 100644
index 0000000..25b073f
--- /dev/null
+++ b/contrib/syslinux-4.02/core/runkernel.inc
@@ -0,0 +1,684 @@
+;; -----------------------------------------------------------------------
+;;
+;;   Copyright 1994-2009 H. Peter Anvin - All Rights Reserved
+;;   Copyright 2009-2010 Intel Corporation; author: H. Peter Anvin
+;;
+;;   This program is free software; you can redistribute it and/or modify
+;;   it under the terms of the GNU General Public License as published by
+;;   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
+;;   Boston MA 02111-1307, USA; either version 2 of the License, or
+;;   (at your option) any later version; incorporated herein by reference.
+;;
+;; -----------------------------------------------------------------------
+
+;;
+;; runkernel.inc
+;;
+;; Common code for running a Linux kernel
+;;
+
+;
+; Hook macros, that may or may not be defined
+;
+%ifndef HAVE_UNLOAD_PREP
+%macro UNLOAD_PREP 0
+%endmacro
+%endif
+
+;
+; A Linux kernel consists of three parts: boot sector, setup code, and
+; kernel code.	The boot sector is never executed when using an external
+; booting utility, but it contains some status bytes that are necessary.
+;
+; First check that our kernel is at least 1K, or else it isn't long
+; enough to have the appropriate headers.
+;
+; We used to require the kernel to be 64K or larger, but it has gotten
+; popular to use the Linux kernel format for other things, which may
+; not be so large.
+;
+; Additionally, we used to have a test for 8 MB or smaller.  Equally
+; obsolete.
+;
+is_linux_kernel:
+		push si				; <A> file pointer
+
+;
+; Now start transferring the kernel
+;
+		push word real_mode_seg
+		pop es
+
+;
+; Start by loading the bootsector/setup code, to see if we need to
+; do something funky.  It should fit in the first 32K (loading 64K won't
+; work since we might have funny stuff up near the end of memory).
+;
+		call abort_check		; Check for abort key
+		mov cx,8000h			; Half a moby (32K)
+		xor bx,bx
+                pop si                          ; <A> file pointer
+		pm_call getfsbytes
+		cmp cx,1024
+		jb kernel_corrupt
+                cmp word [es:bs_bootsign],0AA55h
+		jne kernel_corrupt		; Boot sec signature missing
+
+;
+; Save the file pointer for later...
+;
+		push si				; <A> file pointer
+
+;
+; Construct the command line (append options have already been copied)
+;
+construct_cmdline:
+		mov di,[CmdLinePtr]
+                mov si,boot_image		; BOOT_IMAGE=
+                mov cx,boot_image_len
+                rep movsb
+                mov si,KernelName		; Unmangled kernel name
+		call strcpy
+		mov byte [es:di-1],' '		; Follow by space
+
+		call do_ip_append		; Handle IPAppend
+
+                mov si,[CmdOptPtr]              ; Options from user input
+		call strcpy
+
+;
+; Scan through the command line for anything that looks like we might be
+; interested in.  The original version of this code automatically assumed
+; the first option was BOOT_IMAGE=, but that is no longer certain.
+;
+parse_cmdline:
+		mov di,cmd_line_here
+.skipspace:	mov al,[es:di]
+		inc di
+.skipspace_loaded:
+		and al,al
+		jz cmdline_end
+		cmp al,' '
+		jbe .skipspace
+		dec di
+
+		; ES:DI now points to the beginning of an option
+		mov si,options_list
+.next_opt:
+		movzx cx,byte [si]
+		jcxz .skip_opt
+		push di
+		inc si
+		repe cmpsb
+		jne .no_match
+
+		; This either needs to have been an option with parameter,
+		; or be followed by EOL/whitespace
+		mov ax,[es:di-1]		; AL = last chr; AH = following
+		cmp al,'='
+		je .is_match
+		cmp ah,' '
+		ja .no_match
+.is_match:
+		pop ax				; Drop option pointer on stack
+		call [si]
+.skip_opt:
+		mov al,[es:di]
+		inc di
+		cmp al,' '
+		ja .skip_opt
+		jmp .skipspace_loaded
+.no_match:
+		pop di
+		add si,cx			; Skip remaining bytes
+		inc si				; Skip function pointer
+		inc si
+		jmp .next_opt
+
+opt_vga:
+		mov ax,[es:di-1]
+		mov bx,-1
+		cmp ax,'=n'			; vga=normal
+		je .vc0
+		dec bx				; bx <- -2
+		cmp ax,'=e'			; vga=ext
+		je .vc0
+		dec bx				; bx <- -3
+		cmp ax,'=a'			; vga=ask
+		je .vc0
+		mov bx,0x0f04			; bx <- 0x0f04 (current mode)
+		cmp ax,'=c'			; vga=current
+		je .vc0
+		call parseint_esdi		; vga=<number>
+		jc .skip			; Not an integer
+.vc0:		mov [es:bs_vidmode],bx		; Set video mode
+.skip:
+		ret
+
+opt_mem:
+		call parseint_esdi
+		jc .skip
+%if HIGHMEM_SLOP != 0
+		sub ebx,HIGHMEM_SLOP
+%endif
+		mov [MyHighMemSize],ebx
+.skip:
+		ret
+
+opt_quiet:
+		mov byte [QuietBoot],QUIET_FLAG
+		ret
+
+%if IS_PXELINUX
+opt_keeppxe:
+		or byte [KeepPXE],1		; KeepPXE set by command line
+		ret
+%endif
+
+opt_initrd:
+		mov ax,di
+		cmp byte [es:di],' '
+		ja .have_initrd
+		xor ax,ax
+.have_initrd:
+		mov [InitRDPtr],ax
+		ret
+
+;
+; After command line parsing...
+;
+cmdline_end:
+		sub di,cmd_line_here
+		mov [CmdLineLen],di		; Length including final null
+
+;
+; Now check if we have a large kernel, which needs to be loaded high
+;
+prepare_header:
+		mov dword [RamdiskMax], HIGHMEM_MAX	; Default initrd limit
+		cmp dword [es:su_header],HEADER_ID	; New setup code ID
+		jne old_kernel			; Old kernel, load low
+		mov ax,[es:su_version]
+		mov [KernelVersion],ax
+		cmp ax,0200h			; Setup code version 2.0
+		jb old_kernel			; Old kernel, load low
+		cmp ax,0201h			; Version 2.01+?
+                jb new_kernel                   ; If 2.00, skip this step
+		; Set up the heap (assuming loading high for now)
+                mov word [es:su_heapend],linux_stack-512
+                or byte [es:su_loadflags],80h	; Let the kernel know we care
+		cmp ax,0203h			; Version 2.03+?
+		jb new_kernel			; Not 2.03+
+		mov eax,[es:su_ramdisk_max]
+		mov [RamdiskMax],eax		; Set the ramdisk limit
+
+;
+; We definitely have a new-style kernel.  Let the kernel know who we are,
+; and that we are clueful
+;
+new_kernel:
+		mov byte [es:su_loader],my_id	; Show some ID
+		xor eax,eax
+		mov [es:su_ramdisklen],eax	; No initrd loaded yet
+
+;
+; About to load the kernel.  This is a modern kernel, so use the boot flags
+; we were provided.
+;
+                mov al,[es:su_loadflags]
+		or al,[QuietBoot]		; Set QUIET_FLAG if needed
+		mov [es:su_loadflags],al
+		mov [LoadFlags],al
+
+any_kernel:
+		mov si,loading_msg
+                call writestr_qchk
+                mov si,KernelName		; Print kernel name part of
+                call writestr_qchk		; "Loading" message
+
+;
+; Load the kernel.  We always load it at 100000h even if we're supposed to
+; load it "low"; for a "low" load we copy it down to low memory right before
+; jumping to it.
+;
+read_kernel:
+		movzx ax,byte [es:bs_setupsecs]	; Setup sectors
+		and ax,ax
+		jnz .sects_ok
+		mov al,4			; 0 = 4 setup sectors
+.sects_ok:
+		inc ax				; Including the boot sector
+		mov [SetupSecs],ax
+
+		call dot_pause
+
+;
+; Move the stuff beyond the setup code to high memory at 100000h
+;
+		movzx esi,word [SetupSecs]	; Setup sectors
+                shl si,9			; Convert to bytes
+                mov ecx,8000h			; 32K
+		sub ecx,esi			; Number of bytes to copy
+		add esi,core_real_mode		; Pointer to source
+                mov edi,free_high_memory	; Copy to free high memory
+
+                call bcopy			; Transfer to high memory
+
+		pop si				; <A> File pointer
+		and si,si			; EOF already?
+		jz high_load_done
+
+		; On exit EDI -> where to load the rest
+
+		mov bx,dot_pause
+		or eax,-1			; Load the whole file
+		mov dx,3			; Pad to dword
+		call load_high
+
+high_load_done:
+		mov [KernelEnd],edi
+                mov ax,real_mode_seg		; Set to real mode seg
+                mov es,ax
+
+                mov si,dot_msg
+                call writestr_qchk
+
+;
+; Some older kernels (1.2 era) would have more than 4 setup sectors, but
+; would not rely on the boot protocol to manage that.  These kernels fail
+; if they see protected-mode kernel data after the setup sectors, so
+; clear that memory.
+;
+		push di
+		mov di,[SetupSecs]
+		shl di,9
+		xor eax,eax
+		mov cx,cmd_line_here
+		sub cx,di
+		shr cx,2
+		rep stosd
+		pop di
+
+;
+; Now see if we have an initial RAMdisk; if so, do requisite computation
+; We know we have a new kernel; the old_kernel code already will have objected
+; if we tried to load initrd using an old kernel
+;
+load_initrd:
+		; Cap the ramdisk memory range if appropriate
+		mov eax,[RamdiskMax]
+		cmp eax,[MyHighMemSize]
+		ja .ok
+		mov [MyHighMemSize],eax
+.ok:
+		xor eax,eax
+                cmp [InitRDPtr],ax
+                jz .noinitrd
+		call parse_load_initrd
+.noinitrd:
+
+;
+; Abandon hope, ye that enter here!  We do no longer permit aborts.
+;
+                call abort_check		; Last chance!!
+
+		mov si,ready_msg
+		call writestr_qchk
+
+		UNLOAD_PREP			; Module-specific hook
+
+;
+; Now, if we were supposed to load "low", copy the kernel down to 10000h
+; and the real mode stuff to 90000h.  We assume that all bzImage kernels are
+; capable of starting their setup from a different address.
+;
+		mov ax,real_mode_seg
+		mov es,ax
+		mov fs,ax
+
+;
+; If the default root device is set to FLOPPY (0000h), change to
+; /dev/fd0 (0200h)
+;
+		cmp word [es:bs_rootdev],byte 0
+		jne root_not_floppy
+		mov word [es:bs_rootdev],0200h
+root_not_floppy:
+
+;
+; Copy command line.  Unfortunately, the old kernel boot protocol requires
+; the command line to exist in the 9xxxxh range even if the rest of the
+; setup doesn't.
+;
+setup_command_line:
+		mov dx,[KernelVersion]
+		test byte [LoadFlags],LOAD_HIGH
+		jz .need_high_cmdline
+		cmp dx,0202h			; Support new cmdline protocol?
+		jb .need_high_cmdline
+		; New cmdline protocol
+		; Store 32-bit (flat) pointer to command line
+		; This is the "high" location, since we have bzImage
+		mov dword [fs:su_cmd_line_ptr],cmd_line
+		mov word [HeapEnd],linux_stack
+		mov word [fs:su_heapend],linux_stack-512
+		jmp .setup_done
+
+.need_high_cmdline:
+;
+; Copy command line down to fit in high conventional memory
+; -- this happens if we have a zImage kernel or the protocol
+; is less than 2.02.
+;
+		mov si,cmd_line_here
+		mov di,old_cmd_line_here
+		mov [fs:kern_cmd_magic],word CMD_MAGIC ; Store magic
+		mov [fs:kern_cmd_offset],di	; Store pointer
+		mov word [HeapEnd],old_linux_stack
+		mov ax,255			; Max cmdline limit
+		cmp dx,0201h
+		jb .adjusted
+		; Protocol 2.01+
+		mov word [fs:su_heapend],old_linux_stack-512
+		jbe .adjusted
+		; Protocol 2.02+
+		; Note that the only reason we would end up here is
+		; because we have a zImage, so we anticipate the move
+		; to 90000h already...
+		mov dword [fs:su_cmd_line_ptr],0x90000+old_cmd_line_here
+		mov ax,old_max_cmd_len		; 2.02+ allow a higher limit
+.adjusted:
+
+		mov cx,[CmdLineLen]
+		cmp cx,ax
+		jna .len_ok
+		mov cx,ax			; Truncate the command line
+.len_ok:
+		fs rep movsb
+		stosb				; Final null, note AL=0 already
+		mov [CmdLineEnd],di
+		cmp dx,0200h
+		jb .nomovesize
+		mov [es:su_movesize],di		; Tell the kernel what to move
+.nomovesize:
+.setup_done:
+
+;
+; Time to start setting up move descriptors
+;
+setup_move:
+		mov di,trackbuf
+		xor cx,cx			; Number of descriptors
+
+		mov bx,es			; real_mode_seg
+		mov fs,bx
+		push ds				; We need DS == ES == CS here
+		pop es
+
+		mov edx,100000h
+		test byte [LoadFlags],LOAD_HIGH
+		jnz .loading_high
+
+; Loading low: move real_mode stuff to 90000h, then move the kernel down
+		mov eax,90000h
+		stosd
+		mov eax,core_real_mode
+		stosd
+		movzx eax,word [CmdLineEnd]
+		stosd
+		inc cx
+		mov edx,10000h			; Revised target address
+		mov bx,9000h			; Revised real mode segment
+
+.loading_high:
+		mov eax,edx			; Target address of kernel
+		stosd
+		mov eax,free_high_memory	; Where currently loaded
+		stosd
+		neg eax
+		add eax,[KernelEnd]
+		stosd
+		inc cx
+
+		cmp word [InitRDPtr],0		; Did we have an initrd?
+		je .no_initrd
+
+		mov eax,[fs:su_ramdiskat]
+		stosd
+		mov eax,[InitRDStart]
+		stosd
+		mov eax,[fs:su_ramdisklen]
+		stosd
+		inc cx
+
+.no_initrd:
+		push dword run_linux_kernel
+		push cx				; Length of descriptor list
+
+		; BX points to the final real mode segment, and will be loaded
+		; into DS.
+
+		test byte [QuietBoot],QUIET_FLAG
+		jz replace_bootstrap
+		jmp replace_bootstrap_noclearmode
+
+run_linux_kernel:
+;
+; Set up segment registers and the Linux real-mode stack
+; Note: ds == the real mode segment
+;
+		cli
+		mov ax,ds
+		mov ss,ax
+		mov sp,strict word linux_stack
+		; Point HeapEnd to the immediate of the instruction above
+HeapEnd		equ $-2			; Self-modifying code!  Fun!
+		mov es,ax
+		mov fs,ax
+		mov gs,ax
+
+;
+; We're done... now RUN THAT KERNEL!!!!
+; Setup segment == real mode segment + 020h; we need to jump to offset
+; zero in the real mode segment.
+;
+		add ax,020h
+		push ax
+		push word 0h
+		retf
+
+;
+; Load an older kernel.  Older kernels always have 4 setup sectors, can't have
+; initrd, and are always loaded low.
+;
+old_kernel:
+		xor ax,ax
+		cmp word [InitRDPtr],ax		; Old kernel can't have initrd
+                je .load
+                mov si,err_oldkernel
+                jmp abort_load
+.load:
+		mov byte [LoadFlags],al		; Always low
+		mov word [KernelVersion],ax	; Version 0.00
+		jmp any_kernel
+
+;
+; parse_load_initrd
+;
+; Parse an initrd= option and load the initrds.  This sets
+; InitRDStart and InitRDEnd with dword padding between; we then
+; do a global memory shuffle to move it to the end of memory.
+;
+; On entry, EDI points to where to start loading.
+;
+parse_load_initrd:
+		push es
+		push ds
+		mov ax,real_mode_seg
+		mov ds,ax
+		push cs
+		pop es			; DS == real_mode_seg, ES == CS
+
+		mov [cs:InitRDStart],edi
+		mov [cs:InitRDEnd],edi
+
+		mov si,[cs:InitRDPtr]
+
+.get_chunk:
+		; DS:SI points to the start of a name
+
+		mov bx,si
+.find_end:
+		lodsb
+		cmp al,','
+		je .got_end
+		cmp al,' '
+		jbe .got_end
+		jmp .find_end
+
+.got_end:
+		push ax			; Terminating character
+		push si			; Next filename (if any)
+		mov byte [si-1],0	; Zero-terminate
+		mov si,bx		; Current filename
+
+		push di
+		mov di,InitRD		; Target buffer for mangled name
+		pm_call pm_mangle_name
+		pop di
+		call loadinitrd
+
+		pop si
+		pop ax
+		mov [si-1],al		; Restore ending byte
+
+		cmp al,','
+		je .get_chunk
+
+		; Compute the initrd target location
+		; Note: we round to a page boundary twice here.  The first
+		; time it is to make sure we don't use any fractional page
+		; which may be valid RAM but which will be ignored by the
+		; kernel (and therefore is inaccessible.)  The second time
+		; it is to make sure we start out on page boundary.
+		mov edx,[cs:InitRDEnd]
+		sub edx,[cs:InitRDStart]
+		mov [su_ramdisklen],edx
+		mov eax,[cs:MyHighMemSize]
+		and ax,0F000h		; Round to a page boundary
+		sub eax,edx
+		and ax,0F000h		; Round to a page boundary
+		mov [su_ramdiskat],eax
+
+		pop ds
+		pop es
+		ret
+
+;
+; Load RAM disk into high memory
+;
+; Input:	InitRD		- set to the mangled name of the initrd
+;		EDI		- location to load
+; Output:	EDI		- location for next initrd
+;		InitRDEnd	- updated
+;
+loadinitrd:
+		push ds
+		push es
+		mov ax,cs			; CS == DS == ES
+		mov ds,ax
+		mov es,ax
+		push edi
+                mov di,InitRD
+                pm_call pm_searchdir                  ; Look for it in directory
+		pop edi
+		jz .notthere
+
+		push si
+		mov si,crlfloading_msg		; Write "Loading "
+		call writestr_qchk
+                mov si,InitRD			; Write ramdisk name
+                call writestr_qchk
+                mov si,dotdot_msg		; Write dots
+                call writestr_qchk
+		pop si
+
+.li_skip_echo:
+		mov dx,3
+		mov bx,dot_pause
+		call load_high
+		mov [InitRDEnd],ebx
+
+		pop es
+		pop ds
+		ret
+
+.notthere:
+                mov si,err_noinitrd
+                call writestr
+                mov si,InitRD
+                call writestr
+                mov si,crlf_msg
+                jmp abort_load
+
+;
+; writestr_qchk: writestr, except allows output to be suppressed
+;		assumes CS == DS
+;
+writestr_qchk:
+		test byte [QuietBoot],QUIET_FLAG
+		jz writestr
+		ret
+
+		section .data16
+crlfloading_msg	db CR, LF
+loading_msg     db 'Loading ', 0
+dotdot_msg      db '.'
+dot_msg         db '.', 0
+ready_msg	db 'ready.', CR, LF, 0
+err_oldkernel   db 'Cannot load a ramdisk with an old kernel image.'
+                db CR, LF, 0
+err_noinitrd    db CR, LF, 'Could not find ramdisk image: ', 0
+
+boot_image      db 'BOOT_IMAGE='
+boot_image_len  equ $-boot_image
+
+;
+; Command line options we'd like to take a look at
+;
+%macro cmd_opt	2
+%strlen cmd_opt_len	%1
+	db cmd_opt_len
+	db %1
+	dw %2
+%endmacro
+options_list:
+		cmd_opt "vga=", opt_vga
+		cmd_opt "mem=", opt_mem
+		cmd_opt "quiet", opt_quiet
+str_initrd	equ $+1			; Pointer to "initrd=" in memory
+		cmd_opt "initrd=", opt_initrd
+%if IS_PXELINUX
+		cmd_opt "keeppxe", opt_keeppxe
+%endif
+		db 0
+
+		section .bss16
+		alignb 4
+MyHighMemSize	resd 1			; Possibly adjusted highmem size
+RamdiskMax	resd 1			; Highest address for ramdisk
+KernelSize	resd 1			; Size of kernel in bytes
+KernelSects	resd 1			; Size of kernel in sectors
+KernelEnd	resd 1			; Ending address of the kernel image
+InitRDStart	resd 1			; Start of initrd (pre-relocation)
+InitRDEnd	resd 1			; End of initrd (pre-relocation)
+CmdLineLen	resw 1			; Length of command line including null
+CmdLineEnd	resw 1			; End of the command line in real_mode_seg
+SetupSecs	resw 1			; Number of setup sectors (+bootsect)
+KernelVersion	resw 1			; Kernel protocol version
+;
+; These are derived from the command-line parser
+;
+InitRDPtr	resw 1			; Pointer to initrd= option in command line
+LoadFlags	resb 1			; Loadflags from kernel
+QuietBoot	resb 1			; Set if a quiet boot is requested
diff --git a/contrib/syslinux-4.02/core/serirq.inc b/contrib/syslinux-4.02/core/serirq.inc
new file mode 100644
index 0000000..47ccd50
--- /dev/null
+++ b/contrib/syslinux-4.02/core/serirq.inc
@@ -0,0 +1,219 @@
+;; -----------------------------------------------------------------------
+;;
+;;   Copyright 2009 Intel Corporation; author: H. Peter Anvin
+;;
+;;   This program is free software; you can redistribute it and/or modify
+;;   it under the terms of the GNU General Public License as published by
+;;   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
+;;   Boston MA 02111-1307, USA; either version 2 of the License, or
+;;   (at your option) any later version; incorporated herein by reference.
+;;
+;; -----------------------------------------------------------------------
+
+;;
+;; serirq.inc
+;;
+;; Serial port IRQ code
+;;
+;; We don't know what IRQ, if any, we have, so map all of them...
+;;
+
+		section .text16
+		bits 16
+		align 8
+
+		section .bss16
+		alignb 8
+
+%assign n 0
+%rep 16
+		section .text16
+serstub_irq %+ n :
+		push dword [cs:oldirq %+ n]
+		jmp short irq_common
+
+		section .bss16
+oldirq %+ n	resd 1
+%assign n n+1
+%endrep
+
+		section .text16
+irq_common:
+		pushf
+		push ax
+		push dx
+		mov dx,[cs:SerialPort]
+		add dx,5			; DX -> LSR
+		in al,dx
+		test al,1			; Received data
+		jnz .data
+.done:
+		pop dx
+		pop ax
+		popf
+		retf				; Chain to next handler
+.data:
+		push es
+		push di
+		mov ax,aux_seg + (aux.serial >> 4)
+		mov es,ax
+		mov di,[cs:SerialHead]
+.loop:
+		mov dx,[cs:SerialPort]		; DX -> RDR
+		in al,dx
+		stosb
+		mov ah,[cs:FlowIgnore]
+		add dx,5			; DX -> LSR
+		in al,dx
+		push ax
+		and al,ah
+		cmp al,ah
+		jne .drop
+		and di,serial_buf_size-1	; Wrap around if necessary
+		cmp di,[cs:SerialTail]		; Would this cause overflow?
+		je .drop			; If so, just drop the data
+		mov [cs:SerialHead],di
+.drop:
+		pop ax
+		test al,1			; More data?
+		jnz .loop
+.full:
+		pop di
+		pop es
+		jmp .done
+
+		section .bss16
+;
+; SerialIRQPort will generally track SerialPort, but will be 0 when an
+; IRQ service is not installed.
+;
+SerialIRQPort	resw 1			; Serial port w IRQ service
+SerialHead	resw 1			; Head of serial port rx buffer
+SerialTail	resw 1			; Tail of serial port rx buffer
+
+		section .bss16
+IRQMask		resw 1			; PIC IRQ mask status
+
+		section .text16
+
+sirq_install:
+		pushad
+
+		call sirq_cleanup
+
+		; Save the old interrupt vectors
+		mov si,4*08h
+		mov di,oldirq0
+		mov cx,8
+		rep movsd
+		mov si,4*70h
+		mov cx,8
+		rep movsd
+
+		; Install new interrupt vectors
+		mov di,4*08h
+		mov cx,8
+		mov eax,serstub_irq0
+.pic0:
+		stosd
+		add ax,serstub_irq1 - serstub_irq0
+		loop .pic0
+		mov di,4*70h
+		mov cx,8
+.pic1:
+		stosd
+		add ax,serstub_irq1 - serstub_irq0
+		loop .pic1
+
+		mov bx,[SerialPort]
+		mov [SerialIRQPort],bx
+
+		lea dx,[bx+5]		; DX -> LCR
+		mov al,03h		; Clear DLAB (should already be...)
+		slow_out dx,al
+
+		lea dx,[bx+1]		; DX -> IER
+		mov al,1		; Enable receive interrupt
+		slow_out dx,al
+
+		;
+		; Enable all ther interupt lines at the PIC.  Some BIOSes
+		; only enable the timer interrupts and other interrupts
+		; actively in use by the BIOS.
+		;
+		in al,0xA1		; Secondary PIC mask register
+		mov ah,al
+		in al,0x21		; Primary PIC mask register
+		mov [IRQMask],ax
+
+		io_delay
+
+		xor ax,ax		; Remove all interrupt masks
+		out 0x21,al
+		out 0xA1,al
+
+		popad
+		ret
+
+sirq_cleanup_nowipe:
+		pushad
+		push ds
+		push es
+		xor ax,ax
+		mov ds,ax
+		mov es,ax
+
+		mov bx,[SerialIRQPort]
+		and bx,bx
+		jz .done
+
+		lea dx,[bx+5]		; DX -> LCR
+		mov al,03h		; Clear DLAB (should already be...)
+		slow_out dx,al
+
+		lea dx,[bx+1]		; DX -> IER
+		xor ax,ax
+		slow_out dx,al		; Clear IER
+
+		; Restore PIC masks
+		mov ax,[IRQMask]
+		out 0x21,al
+		mov al,ah
+		out 0xA1,al
+
+		; Restore the original interrupt vectors
+		mov si,oldirq0
+		mov di,4*08h
+		mov cx,8
+		rep movsd
+		mov di,4*70h
+		mov cx,8
+		rep movsd
+
+		xor ax,ax
+		mov [SerialIRQPort],ax		; No active interrupt system
+
+.done:
+		pop es
+		pop ds
+		popad
+		ret
+
+sirq_cleanup:
+		call sirq_cleanup_nowipe
+		pushad
+		push es
+		; Just in case it might contain a password, erase the
+		; serial port receive buffer...
+		mov ax,aux_seg + (aux.serial >> 4)
+		mov es,ax
+		xor eax,eax
+		mov [cs:SerialHead],eax
+		mov cx,serial_buf_size >> 2
+		xor di,di
+		rep stosd
+		pop es
+		popad
+		ret
+
+		section .text16
diff --git a/contrib/syslinux-4.02/core/stack.inc b/contrib/syslinux-4.02/core/stack.inc
new file mode 100644
index 0000000..788db64
--- /dev/null
+++ b/contrib/syslinux-4.02/core/stack.inc
@@ -0,0 +1,47 @@
+; -----------------------------------------------------------------------
+;
+;   Copyright 2005-2008 H. Peter Anvin - All Rights Reserved
+;   Copyright 2009-2010 Intel Corporation; author: H. Peter Anvin
+;
+;   This program is free software; you can redistribute it and/or modify
+;   it under the terms of the GNU General Public License as published by
+;   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
+;   Boston MA 02111-1307, USA; either version 2 of the License, or
+;   (at your option) any later version; incorporated herein by reference.
+;
+; -----------------------------------------------------------------------
+
+;
+; stack.inc
+;
+; How to reset the stack pointer
+;
+
+%ifndef _STACK_INC
+%define _STACK_INC
+
+;
+; This macro resets the stack pointer (including SS), and sets
+; DS == ES == 0, interrupts on, DF = 0.
+;
+; It takes a 16-bit register that can be safely clobbered as parameter.
+;
+%macro RESET_STACK_AND_SEGS 1
+		xor %1,%1
+		mov ds,%1
+		mov es,%1
+		lss esp,[BaseStack]
+		mov dword [PMESP],__stack_end	; Reset PM stack
+		sti
+		cld
+%endmacro
+
+		section .data16
+		alignz 4
+		global BaseStack
+BaseStack	dd StackHome		; ESP of the "home" stack pointer
+		dw 0			; SS of the "home" stack pointer
+
+		section .text16
+
+%endif ; _STACK_INC
diff --git a/contrib/syslinux-4.02/core/strcasecmp.c b/contrib/syslinux-4.02/core/strcasecmp.c
new file mode 100644
index 0000000..2f7480d
--- /dev/null
+++ b/contrib/syslinux-4.02/core/strcasecmp.c
@@ -0,0 +1,11 @@
+/*
+ * strcasecmp.c
+ */
+
+#include <string.h>
+#include <ctype.h>
+
+int strcasecmp(const char *s1, const char *s2)
+{
+    return strncasecmp(s1, s2, -1);
+}
diff --git a/contrib/syslinux-4.02/core/strcpy.inc b/contrib/syslinux-4.02/core/strcpy.inc
new file mode 100644
index 0000000..9762cbb
--- /dev/null
+++ b/contrib/syslinux-4.02/core/strcpy.inc
@@ -0,0 +1,13 @@
+;
+; strcpy: Copy DS:SI -> ES:DI up to and including a null byte;
+;	  on exit SI and DI point to the byte *after* the null byte
+;
+		section .text16
+
+strcpy:		push ax
+.loop:		lodsb
+		stosb
+		and al,al
+		jnz .loop
+		pop ax
+		ret
diff --git a/contrib/syslinux-4.02/core/strncasecmp.c b/contrib/syslinux-4.02/core/strncasecmp.c
new file mode 100644
index 0000000..2caac0a
--- /dev/null
+++ b/contrib/syslinux-4.02/core/strncasecmp.c
@@ -0,0 +1,24 @@
+/*
+ * strncasecmp.c
+ */
+
+#include <string.h>
+#include <ctype.h>
+
+int strncasecmp(const char *s1, const char *s2, size_t n)
+{
+    const unsigned char *c1 = (const unsigned char *)s1;
+    const unsigned char *c2 = (const unsigned char *)s2;
+    unsigned char ch;
+    int d = 0;
+
+    while (n--) {
+	/* toupper() expects an unsigned char (implicitly cast to int)
+	   as input, and returns an int, which is exactly what we want. */
+	d = toupper(ch = *c1++) - toupper(*c2++);
+	if (d || !ch)
+	    break;
+    }
+
+    return d;
+}
diff --git a/contrib/syslinux-4.02/core/syslinux.ld b/contrib/syslinux-4.02/core/syslinux.ld
new file mode 100644
index 0000000..164c94c
--- /dev/null
+++ b/contrib/syslinux-4.02/core/syslinux.ld
@@ -0,0 +1,380 @@
+/* -----------------------------------------------------------------------
+ *   
+ *   Copyright 2008-2009 H. Peter Anvin - All Rights Reserved
+ *   Copyright 2009 Intel Corporation; author: H. Peter Anvin
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+ *   Boston MA 02110-1301, USA; either version 2 of the License, or
+ *   (at your option) any later version; incorporated herein by reference.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * Linker script for the SYSLINUX core
+ */
+
+OUTPUT_FORMAT("elf32-i386", "elf32-i386", "elf32-i386")
+OUTPUT_ARCH(i386)
+EXTERN(_start)
+ENTRY(_start)
+
+SECTIONS
+{
+	/* Prefix structure for the compression program */
+	. = 0;
+	.prefix : {
+		*(.prefix)
+	}
+
+	/* "Early" sections (before the load) */
+	. = 0x1000;
+
+	.earlybss : {
+		__earlybss_start = .;
+		*(.earlybss)
+		__earlybss_end = .;
+	}
+	__earlybss_len = __earlybss_end - __earlybss_start;
+	__earlybss_dwords = (__earlybss_len + 3) >> 2;
+
+	. = ALIGN(4);
+	.bss16 : {
+		__bss16_start = .;
+		*(.bss16)
+		__bss16_end = .;
+	}
+	__bss16_len = __bss16_end - __bss16_start;
+	__bss16_dwords = (__bss16_len + 3) >> 2;
+
+	. = ALIGN(4);
+ 	.config : AT (__config_lma) {
+		__config_start = .;
+		*(.config)
+		__config_end = .;
+	}
+	__config_len = __config_end - __config_start;
+	__config_dwords = (__config_len + 3) >> 2;
+
+	/* Generated and/or copied code */
+
+	. = ALIGN(128);		/* Minimum separation from mutable data */
+ 	.replacestub : AT (__replacestub_lma) {
+		__replacestub_start = .;
+		*(.replacestub)
+		__replacestub_end = .;
+	}
+	__replacestub_len = __replacestub_end - __replacestub_start;
+	__replacestub_dwords = (__replacestub_len + 3) >> 2;
+
+	. = ALIGN(16);
+	__gentextnr_lma = .;
+	.gentextnr : AT(__gentextnr_lma) {
+		__gentextnr_start = .;
+		*(.gentextnr)
+		__gentextnr_end = .;
+	}
+	__gentextnr_len = __gentextnr_end - __gentextnr_start;
+	__gentextnr_dwords = (__gentextnr_len + 3) >> 2;
+
+	. = STACK_BASE;
+	.stack16 : AT(STACK_BASE) {
+		__stack16_start = .;
+		. += STACK_LEN;
+		__stack16_end = .;
+	}
+	__stack16_len = __stack16_end - __stack16_start;
+	__stack16_dwords = (__stack16_len + 3) >> 2;
+
+	/* Initialized sections */
+
+	. = 0x7c00;
+	.init : {
+		FILL(0x90909090)
+		__init_start = .;
+		*(.init)
+		__init_end = .;
+	}
+	__init_len = __init_end - __init_start;
+	__init_dwords = (__init_len + 3) >> 2;
+
+	.text16 : {
+		FILL(0x90909090)
+		__text16_start = .;
+		*(.text16)
+		__text16_end = .;
+	}
+	__text16_len = __text16_end - __text16_start;
+	__text16_dwords = (__text16_len + 3) >> 2;
+
+	/*
+	 * .textnr is used for 32-bit code that is used on the code
+	 * path to initialize the .text segment
+	 */
+	. = ALIGN(16);
+	.textnr : {
+		FILL(0x90909090)
+		__textnr_start = .;
+		*(.textnr)
+		__textnr_end = .;
+	}
+	__textnr_len = __textnr_end - __textnr_start;
+	__textnr_dwords = (__textnr_len + 3) >> 2;
+
+	. = ALIGN(16);
+	__bcopyxx_start = .;
+
+	.bcopyxx.text : {
+		FILL(0x90909090)
+		__bcopyxx_text_start = .;
+		*(.bcopyxx.text)
+		__bcopyxx_text_end = .;
+	}
+	__bcopyxx_text_len = __bcopyxx_text_end - __bcopyxx_text_start;
+	__bcopyxx_text_dwords = (__bcopyxx_text_len + 3) >> 2;
+
+	.bcopyxx.data : {
+		__bcopyxx_data_start = .;
+		*(.bcopyxx.text)
+		__bcopyxx_data_end = .;
+	}
+	__bcopyxx_data_len = __bcopyxx_data_end - __bcopyxx_data_start;
+	__bcopyxx_data_dwords = (__bcopyxx_data_len + 3) >> 2;
+
+	__bcopyxx_end = .;
+	__bcopyxx_len = __bcopyxx_end - __bcopyxx_start;
+	__bcopyxx_dwords = (__bcopyxx_len + 3) >> 2;
+
+	. = ALIGN(4);
+	.data16 : {
+	      __data16_start = .;
+	      *(.data16)
+	      __data16_end = .;
+	}
+	__data16_len = __data16_end - __data16_start;
+	__data16_dwords = (__data16_len + 3) >> 2;
+
+	. = ALIGN(4);
+	__config_lma = .;
+	. += SIZEOF(.config);
+
+	. = ALIGN(4);
+	__replacestub_lma = .;
+	. += SIZEOF(.replacestub);
+
+	/* The 32-bit code loads above the non-progbits sections */
+
+	. = ALIGN(16);
+	__pm_code_lma = .;
+
+	__high_clear_start = .;
+
+	. = ALIGN(512);
+	.adv (NOLOAD) : {
+		__adv_start = .;
+		*(.adv)
+		__adv_end = .;
+	}
+	__adv_len = __adv_end - __adv_start;
+	__adv_dwords = (__adv_len + 3) >> 2;
+
+	/* Late uninitialized sections */
+
+	. = ALIGN(4);
+	.uibss (NOLOAD) : {
+		__uibss_start = .;
+		*(.uibss)
+		__uibss_end = .;
+	}
+	__uibss_len = __uibss_end - __uibss_start;
+	__uibss_dwords = (__uibss_len + 3) >> 2;
+
+	_end16 = .;
+	__assert_end16 = ASSERT(_end16 <= 0x10000, "64K overflow");
+
+	/*
+	 * Special 16-bit segments
+	 */
+
+	. = ALIGN(65536);
+	.real_mode (NOLOAD) : {
+		*(.real_mode)
+	}
+	real_mode_seg = core_real_mode >> 4;
+
+	. = ALIGN(65536);
+	.xfer_buf (NOLOAD) : {
+		*(.xfer_buf)
+	}
+	xfer_buf_seg = core_xfer_buf >> 4;
+
+	/*
+	 * The auxilliary data segment is used by the 16-bit code
+	 * for items that don't need to live in the bottom 64K.
+	 */
+
+	. = ALIGN(16);
+	.auxseg (NOLOAD) : {
+		__auxseg_start = .;
+		*(.auxseg)
+		__auxseg_end = .;
+	}
+	__auxseg_len = __auxseg_end - __auxseg_start;
+	__auxseg_dwords = (__auxseg_len + 3) >> 2;
+	aux_seg = __auxseg_start >> 4;
+
+	/*
+	 * Used to allocate lowmem buffers from 32-bit code
+	 */
+	.lowmem (NOLOAD) : {
+		__lowmem_start = .;
+		*(.lowmem)
+		__lowmem_end = .;
+	}
+	__lowmem_len = __lowmem_end - __lowmem_start;
+	__lowmem_dwords = (__lowmem_len + 3) >> 2;
+
+	__high_clear_end = .;
+
+	__high_clear_len = __high_clear_end - __high_clear_start;
+	__high_clear_dwords = (__high_clear_len + 3) >> 2;
+
+	/* Start of the lowmem heap */
+	. = ALIGN(16);
+	__lowmem_heap = .;
+
+	/*
+	 * 32-bit code.  This is a hack for the moment due to the
+	 * real-mode segments also allocated.
+	 */
+
+	. = 0x100000;
+
+	__pm_code_start = .;
+
+	__text_vma = .;
+	__text_lma = __pm_code_lma;
+	.text : AT(__text_lma) {
+		FILL(0x90909090)
+		__text_start = .;
+		*(.text)
+		*(.text.*)
+		__text_end = .;
+	}
+
+	. = ALIGN(16);
+
+	__rodata_vma = .;
+	__rodata_lma = __rodata_vma + __text_lma - __text_vma;
+	.rodata : AT(__rodata_lma) {
+		__rodata_start = .;
+		*(.rodata)
+		*(.rodata.*)
+		__rodata_end = .;
+	}
+
+	. = ALIGN(4);
+
+	__ctors_vma = .;
+	__ctors_lma = __ctors_vma + __text_lma - __text_vma;
+	.ctors : AT(__ctors_lma) {
+		__ctors_start = .;
+		KEEP (*(SORT(.ctors.*)))
+		KEEP (*(.ctors))
+		__ctors_end = .;
+	}
+
+	__dtors_vma = .;
+	__dtors_lma = __dtors_vma + __text_lma - __text_vma;
+	.dtors : AT(__dtors_lma) {
+		__dtors_start = .;
+		KEEP (*(SORT(.dtors.*)))
+		KEEP (*(.dtors))
+		__dtors_end = .;
+	}
+
+	. = ALIGN(4);
+
+	__dynlink_vma = .;
+	__dynlink_lma = __dynlink_vma + __text_lma - __text_vma;
+	.dynlink : AT(__dynlink_lma) {
+		__dynlink_start = .;
+		*(.dynlink)
+		__dynlink_end = .;
+	}
+
+	. = ALIGN(4);
+
+	__got_vma = .;
+	__got_lma = __got_vma + __text_lma - __text_vma;
+	.got : AT(__got_lma) {
+		__got_start = .;
+		KEEP (*(.got.plt))
+		KEEP (*(.got))
+		__got_end = .;
+	}
+
+	__data_vma = .;
+	__data_lma = __data_vma + __text_lma - __text_vma;
+	.data : AT(__data_lma) {
+		__data_start = .;
+		*(.data)
+		*(.data.*)
+		__data_end = .;
+	}
+
+	__pm_code_end = .;
+	__pm_code_len = __pm_code_end - __pm_code_start;
+	__pm_code_dwords = (__pm_code_len + 3) >> 2;
+
+	. = ALIGN(128);
+	
+	__bss_vma = .;
+	__bss_lma = .;		/* Dummy */
+	.bss (NOLOAD) : AT (__bss_lma) {
+		__bss_start = .;
+		*(.bss)
+		*(.bss.*)
+		*(COMMON)
+		__bss_end = .;
+	}
+	__bss_len = __bss_end - __bss_start;
+	__bss_dwords = (__bss_len + 3) >> 2;
+
+	/* Very large objects which don't need to be zeroed */
+
+	__hugebss_vma = .;
+	__hugebss_lma = .;		/* Dummy */
+	.hugebss (NOLOAD) : AT (__hugebss_lma) {
+		__hugebss_start = .;
+		*(.hugebss)
+		*(.hugebss.*)
+		__hugebss_end = .;
+	}
+	__hugebss_len = __hugebss_end - __hugebss_start;
+	__hugebss_dwords = (__hugebss_len + 3) >> 2;
+
+
+	/* XXX: This stack should be unified with the COM32 stack */
+	__stack_vma = .;
+	__stack_lma = .;	/* Dummy */
+	.stack (NOLOAD) : AT(__stack_lma) {
+		__stack_start = .;
+		*(.stack)
+		__stack_end = .;
+	}
+	__stack_len = __stack_end - __stack_start;
+	__stack_dwords = (__stack_len + 3) >> 2;
+
+	_end = .;
+
+	/* COM32R and kernels are loaded after our own PM code */
+	. = ALIGN(65536);
+	free_high_memory = .;
+
+	/* Stuff we don't need... */
+	/DISCARD/ : {
+		*(.eh_frame)
+	}
+}
diff --git a/contrib/syslinux-4.02/core/timer.inc b/contrib/syslinux-4.02/core/timer.inc
new file mode 100644
index 0000000..b01ff91
--- /dev/null
+++ b/contrib/syslinux-4.02/core/timer.inc
@@ -0,0 +1,57 @@
+;; -----------------------------------------------------------------------
+;;
+;;   Copyright 2009 Intel Corporation; author: H. Peter Anvin
+;;
+;;   This program is free software; you can redistribute it and/or modify
+;;   it under the terms of the GNU General Public License as published by
+;;   the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+;;   Boston MA 02110-1301, USA; either version 2 of the License, or
+;;   (at your option) any later version; incorporated herein by reference.
+;;
+;; -----------------------------------------------------------------------
+
+;;
+;; timer.inc
+;;
+;; Very simple counting timer
+;;
+;; This lets us have a simple incrementing variable without worrying
+;; about the BIOS_timer variable wrapping around at "midnight" and other
+;; weird things.
+;;
+;; This also maintains a timer variable calibrated in milliseconds
+;; (wraparound time = 49.7 days!)
+;;
+
+		section .text16
+
+timer_init:
+		; Hook INT 1Ch
+		mov eax,[BIOS_timer_hook]
+		mov [BIOS_timer_next],eax
+		mov dword [BIOS_timer_hook],timer_irq
+		ret
+
+timer_cleanup:
+		; Unhook INT 1Ch
+		mov eax,[BIOS_timer_next]
+		mov [BIOS_timer_hook],eax
+		ret
+
+;
+; The specified frequency is 14.31818 MHz/12/65536; this turns out
+; to be a period of 54.92542 ms, or 0x36.ece8(187c) hexadecimal.
+;
+timer_irq:
+		inc dword [cs:__jiffies]
+		add word  [cs:__ms_timer_adj],0xece8
+		adc dword [cs:__ms_timer],0x36
+		jmp 0:0
+BIOS_timer_next	equ $-4
+
+		section .data16
+		alignz 4
+		global __jiffies, __ms_timer
+__jiffies	dd 0			; Clock tick timer
+__ms_timer	dd 0			; Millisecond timer
+__ms_timer_adj	dw 0			; Millisecond timer correction factor
diff --git a/contrib/syslinux-4.02/core/tracers.inc b/contrib/syslinux-4.02/core/tracers.inc
new file mode 100644
index 0000000..a51209f
--- /dev/null
+++ b/contrib/syslinux-4.02/core/tracers.inc
@@ -0,0 +1,40 @@
+;; -----------------------------------------------------------------------
+;;
+;;   Copyright 1994-2008 H. Peter Anvin - All Rights Reserved
+;;
+;;   This program is free software; you can redistribute it and/or modify
+;;   it under the terms of the GNU General Public License as published by
+;;   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
+;;   Boston MA 02111-1307, USA; either version 2 of the License, or
+;;   (at your option) any later version; incorporated herein by reference.
+;;
+;; -----------------------------------------------------------------------
+
+;;
+;; tracers.inc
+;;
+;; Debugging tracers
+;;
+
+%ifndef _TRACERS_INC
+%define _TRACERS_INC
+
+; Note: The Makefile builds one version with DEBUG_MESSAGES automatically.
+; %define DEBUG_TRACERS 1		; Uncomment to get debugging tracers
+; %define DEBUG_MESSAGES		; Uncomment to get debugging messages
+
+%ifdef DEBUG_TRACERS
+
+%macro TRACER	1
+	call debug_tracer
+	db %1
+%endmacro
+
+%else	; DEBUG_TRACERS
+
+%macro	TRACER	1
+%endmacro
+
+%endif	; DEBUG_TRACERS
+
+%endif ; _TRACERS_INC
diff --git a/contrib/syslinux-4.02/core/ui.inc b/contrib/syslinux-4.02/core/ui.inc
new file mode 100644
index 0000000..2d44447
--- /dev/null
+++ b/contrib/syslinux-4.02/core/ui.inc
@@ -0,0 +1,748 @@
+;; -----------------------------------------------------------------------
+;;
+;;   Copyright 1994-2009 H. Peter Anvin - All Rights Reserved
+;;   Copyright 2009-2010 Intel Corporation; author: H. Peter Anvin
+;;
+;;   This program is free software; you can redistribute it and/or modify
+;;   it under the terms of the GNU General Public License as published by
+;;   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
+;;   Boston MA 02111-1307, USA; either version 2 of the License, or
+;;   (at your option) any later version; incorporated herein by reference.
+;;
+;; -----------------------------------------------------------------------
+
+;
+; This file should be entered with the config file open (for getc)
+;
+load_config_file:
+		call parse_config		; Parse configuration file
+no_config_file:
+
+		call adv_init
+;
+; Check for an ADV boot-once entry
+;
+		mov dl,ADV_BOOTONCE
+		call adv_get
+		jcxz .no_bootonce
+
+.have_bootone:
+		; We apparently have a boot-once set; clear it and
+		; then execute the boot-once...
+
+		; Save the boot-once data; SI = data, CX = length
+		mov di,command_line
+		rep movsb
+		xor ax,ax
+		stosb
+
+		; Clear the boot-once data from the ADV
+		xor cx,cx			; Set to zero = delete
+		call adv_set
+		jc .err
+		call adv_write
+.err:		jmp load_kernel
+
+.no_bootonce:
+
+;
+; Check whether or not we are supposed to display the boot prompt.
+;
+check_for_key:
+		test byte [KbdFlags],5Bh	; Shift Alt Caps Scroll
+		jnz enter_command
+		cmp word [ForcePrompt],0	; Force prompt?
+		jz auto_boot
+		cmp word [DefaultLevel],1	; Active UI statement?
+		ja auto_boot
+
+enter_command:
+		cmp word [NoEscape],0		; If NOESCAPE, no prompt,
+		jne auto_boot			; always run default cmd
+
+		mov si,boot_prompt
+		call writestr
+
+		mov byte [FuncFlag],0		; <Ctrl-F> not pressed
+		mov di,command_line
+
+;
+; get the very first character -- we can either time
+; out, or receive a character press at this time.  Some dorky BIOSes stuff
+; a return in the buffer on bootup, so wipe the keyboard buffer first.
+;
+clear_buffer:	mov ah,11h			; Check for pending char
+		int 16h
+		jz get_char_time
+		mov ah,10h			; Get char
+		int 16h
+		jmp short clear_buffer
+
+		; For the first character, both KbdTimeout and
+		; TotalTimeout apply; after that, only TotalTimeout.
+
+get_char_time:
+		mov eax,[TotalTimeout]
+		mov [ThisTotalTo],eax
+		mov eax,[KbdTimeout]
+		mov [ThisKbdTo],eax
+
+get_char:
+		call getchar_timeout
+		and dword [ThisKbdTo],0		; For the next time...
+
+		and al,al
+		jz func_key
+
+got_ascii:	cmp al,7Fh			; <DEL> == <BS>
+		je backspace
+		cmp al,' '			; ASCII?
+		jb not_ascii
+		ja enter_char
+		cmp di,command_line		; Space must not be first
+		je short get_char
+enter_char:	test byte [FuncFlag],1
+		jnz ctrl_f			; Keystroke after <Ctrl-F>
+		cmp di,max_cmd_len+command_line ; Check there's space
+		jnb short get_char
+		stosb				; Save it
+		call writechr			; Echo to screen
+		jmp short get_char
+not_ascii:
+		cmp al,0Dh			; Enter
+		je command_done
+		cmp al,09h			; Tab
+		je display_labels
+		cmp al,'F' & 1Fh		; <Ctrl-F>
+		je set_func_flag
+%if IS_PXELINUX
+		cmp al,'N' & 1Fh		; <Ctrl-N>
+		je show_network_info
+%endif
+		cmp al,'U' & 1Fh		; <Ctrl-U>
+		je kill_command			; Kill input line
+		cmp al,'V' & 1Fh		; <Ctrl-V>
+		je print_version
+		cmp al,'X' & 1Fh		; <Ctrl-X>
+		je force_text_mode
+		cmp al,08h			; Backspace
+		jne get_char
+backspace:	cmp di,command_line		; Make sure there is anything
+		je get_char			; to erase
+		dec di				; Unstore one character
+		mov si,wipe_char		; and erase it from the screen
+		call writestr
+get_char_2:
+		jmp short get_char
+
+kill_command:
+		call crlf
+		jmp enter_command
+
+force_text_mode:
+		call vgaclearmode
+		jmp enter_command
+
+set_func_flag:
+		mov byte [FuncFlag],1
+		jmp short get_char_2
+
+display_labels:
+		cmp word [NoComplete],0		; Label completion enabled?
+		jne get_char_2
+		push di				; Save pointer
+		mov cx,di
+		sub cx,command_line
+		call crlf
+		mov esi,[HighMemSize]		; Start from top of memory
+.scan:
+		cmp esi,[VKernelEnd]
+		jbe .not_vk
+
+		push cx				; save command line size
+
+		mov edi,VKernelBuf
+		pm_call rllunpack
+		; ESI updated on return
+
+		sub di,cx			; Return to beginning of buf
+		pop cx				; restore command line size
+		push si				; save SI
+		cmp cx,0
+		jz .print
+		push di
+		push cx
+		mov si,command_line
+		es repe cmpsb
+		pop cx
+		pop di
+		jne .next
+.print:
+		mov al,' '
+		call writechr
+
+		mov si,di
+		call writestr
+.next:
+		pop si				; restore SI
+		jmp .scan
+.not_vk:
+		call crlf
+		jmp fk_wrcmd
+
+ctrl_f:
+		xor ah,ah
+		mov [FuncFlag],ah
+		cmp al,'0'
+		jb get_char_2
+		je .zero			; <Ctrl-F>0 = F10
+		or al,20h			; Lower case
+		cmp al,'9'
+		jna .digit
+		cmp al,'a'			; F10-F12 = <Ctrl-F>A, B, C
+		jb get_char_2
+		cmp al,'c'
+		ja get_char_2
+		sub al,'a'-10
+		jmp show_help
+.zero:
+		mov al,10
+		jmp show_help
+.digit:
+		sub al,'1'
+		jmp show_help
+
+func_key:
+		; AL = 0 if we get here
+		xchg al,ah
+		cmp al,44h			; F10
+		ja .f11_f12
+		sub al,3Bh			; F1
+		jb get_char_2
+		jmp show_help
+.f11_f12:
+		cmp al,85h			; F11
+		jb get_char_2
+		cmp al,86h			; F12
+		ja get_char_2
+		sub al,85h-10
+
+show_help:	; AX = func key # (0 = F1, 9 = F10, 11 = F12)
+		push di				; Save end-of-cmdline pointer
+		shl ax,FILENAME_MAX_LG2		; Convert to pointer
+		add ax,FKeyName
+		xchg di,ax
+		cmp byte [di+NULLOFFSET],NULLFILE
+		je short fk_nofile		; Undefined F-key
+		call core_open
+		jz short fk_nofile		; File not found
+		call crlf
+		call get_msg_file
+		jmp short fk_wrcmd
+
+print_version:
+		push di				; Command line write pointer
+		mov si,syslinux_banner
+		call writestr
+%ifdef HAVE_BIOSNAME
+		mov si,[BIOSName]
+		call writestr
+%endif
+		mov si,copyright_str
+		call writestr
+
+		; ... fall through ...
+
+		; Write the boot prompt and command line again and
+		; wait for input.  Note that this expects the cursor
+		; to already have been CRLF'd, and that the old value
+		; of DI (the command line write pointer) is on the stack.
+fk_wrcmd:
+		mov si,boot_prompt
+		call writestr
+		pop di				; Command line write pointer
+		push di
+		mov byte [di],0			; Null-terminate command line
+		mov si,command_line
+		call writestr			; Write command line so far
+fk_nofile:	pop di
+		jmp get_char
+
+;
+; Show network info (in the form of the ipappend strings)
+;
+%if IS_PXELINUX
+show_network_info:
+		push di				; Command line write pointer
+		call crlf
+		mov si,IPAppends		; See comboot.doc
+		mov cx,numIPAppends
+.loop:
+		lodsw
+		push si
+		mov si,ax
+		call writestr
+		call crlf
+		pop si
+		loop .loop
+		jmp fk_wrcmd
+%endif
+
+;
+; Jump here to run the default command line
+;
+auto_boot:
+		cmp word [DefaultLevel],0	; No UI or DEFAULT?
+		jne .have_default
+		mov si,no_default_msg
+		call writestr
+		cmp word [NoEscape],0		; NOESCAPE but no DEFAULT?
+		jne kaboom			; If so, we're stuck!
+		jmp enter_command
+
+.have_default:
+		mov si,default_cmd
+		mov di,command_line
+		mov cx,(max_cmd_len+4) >> 2
+		rep movsd
+		jmp short load_kernel
+
+		section .data16
+no_default_msg	db 'No DEFAULT or UI configuration directive found!'
+		db CR, LF, 0
+
+		section .text16
+
+;
+; Jump here when the command line is completed
+;
+command_done:
+		call crlf
+		cmp di,command_line		; Did we just hit return?
+		je auto_boot
+		xor al,al			; Store a final null
+		stosb
+
+load_kernel:					; Load the kernel now
+;
+; First we need to mangle the kernel name the way DOS would...
+;
+		mov si,command_line
+                mov di,KernelName
+                push si
+		pm_call pm_mangle_name
+                pop si
+;
+; Fast-forward to first option (we start over from the beginning, since
+; pm_mangle_name doesn't necessarily return a consistent ending state.)
+;
+clin_non_wsp:   lodsb
+                cmp al,' '
+                ja clin_non_wsp
+clin_is_wsp:    and al,al
+                jz clin_opt_ptr
+                lodsb
+                cmp al,' '
+                jbe clin_is_wsp
+clin_opt_ptr:   dec si                          ; Point to first nonblank
+                mov [CmdOptPtr],si		; Save ptr to first option
+;
+; If "allowoptions 0", put a null character here in order to ignore any
+; user-specified options.
+;
+		mov ax,[AllowOptions]
+		and ax,ax
+		jnz clin_opt_ok
+		mov [si],al
+clin_opt_ok:
+
+;
+; Now check if it is a "virtual kernel"
+;
+vk_check:
+		mov esi,[HighMemSize]		; Start from top of memory
+.scan:
+		cmp esi,[VKernelEnd]
+		jbe .not_vk
+
+		mov edi,VKernelBuf
+		pm_call rllunpack
+		; ESI updated on return
+
+		sub di,cx			; Return to beginning of buf
+		push si
+		mov si,command_line
+.loop:
+		lodsb
+		cmp al,' '
+		jbe .done
+		scasb
+		je .loop
+.nomatch:
+		pop si
+		jmp .scan
+.done:
+		cmp byte [di],0			; Must match end of string
+		jne .nomatch
+		pop si
+
+;
+; We *are* using a "virtual kernel"
+;
+.found:
+		push es
+		push word real_mode_seg
+		pop es
+		mov di,cmd_line_here
+		mov si,VKernelBuf+vk_append
+		mov cx,[VKernelBuf+vk_appendlen]
+		rep movsb
+		mov byte [es:di],cl		; Null-terminate
+		mov [CmdLinePtr],di		; Where to add rest of cmd
+		pop es
+		mov di,KernelName
+		push di
+		mov si,VKernelBuf+vk_rname
+		mov cx,FILENAME_MAX		; We need ECX == CX later
+		rep movsb
+		pop di
+%if IS_PXELINUX
+		mov al,[VKernelBuf+vk_ipappend]
+		mov [IPAppend],al
+%endif
+		xor bx,bx			; Try only one version
+
+		mov al,[VKernelBuf+vk_type]
+		mov [KernelType],al
+
+%if HAS_LOCALBOOT
+		; Is this a "localboot" pseudo-kernel?
+		cmp al,VK_LOCALBOOT		; al == KernelType
+		mov ax,[VKernelBuf+vk_rname]	; Possible localboot type
+		je local_boot
+%endif
+		jmp get_kernel
+
+.not_vk:
+;
+; Not a "virtual kernel" - check that's OK and construct the command line
+;
+                cmp word [AllowImplicit],byte 0
+                je bad_implicit
+                push es
+                push si
+                push di
+                mov di,real_mode_seg
+                mov es,di
+                mov si,AppendBuf
+                mov di,cmd_line_here
+                mov cx,[AppendLen]
+                rep movsb
+		mov byte [es:di],cl		; Null-terminate
+                mov [CmdLinePtr],di
+                pop di
+                pop si
+                pop es
+
+		mov [KernelType], cl		; CL == 0 here
+
+;
+; Find the kernel on disk
+;
+get_kernel:     mov byte [KernelName+FILENAME_MAX],0	; Zero-terminate filename/extension
+		mov di,KernelName
+		cmp byte [di],' '
+		jbe bad_kernel			; Missing kernel name
+		xor al,al
+		mov cx,FILENAME_MAX-5		; Need 4 chars + null
+		repne scasb			; Scan for final null
+		jne .no_skip
+		dec di				; Point to final null
+.no_skip:	mov [KernelExtPtr],di
+		mov bx,exten_table
+.search_loop:	push bx
+                mov di,KernelName		; Search on disk
+                pm_call pm_searchdir
+		pop bx
+                jnz kernel_good
+		mov eax,[bx]			; Try a different extension
+		mov si,[KernelExtPtr]
+		mov [si],eax
+		mov byte [si+4],0
+		add bx,byte 4
+		cmp bx,exten_table_end
+		jna .search_loop		; allow == case (final case)
+		; Fall into bad_kernel
+;
+; bad_kernel: Kernel image not found
+; bad_implicit: The user entered a nonvirtual kernel name, with "implicit 0"
+;
+bad_implicit:
+bad_kernel:
+		mov cx,[OnerrorLen]
+		and cx,cx
+		jnz on_error
+.really:
+		mov si,err_notfound		; Complain about missing kernel
+		call writestr
+		mov si,KernelName
+                call writestr
+                mov si,crlf_msg
+                jmp abort_load                  ; Ask user for clue
+
+;
+; on_error: bad kernel, but we have onerror set; CX = OnerrorLen
+;
+on_error:
+		mov si,Onerror
+		mov di,command_line
+		push si				; <A>
+		push di				; <B>
+		push cx				; <C>
+		push cx				; <D>
+		push di				; <E>
+		repe cmpsb
+		pop di				; <E> di == command_line
+		pop bx				; <D> bx == [OnerrorLen]
+		je bad_kernel.really		; Onerror matches command_line already
+		neg bx				; bx == -[OnerrorLen]
+		lea cx,[max_cmd_len+bx]
+		; CX == max_cmd_len-[OnerrorLen]
+		mov di,command_line+max_cmd_len-1
+		mov byte [di+1],0		; Enforce null-termination
+		lea si,[di+bx]
+		std
+		rep movsb			; Make space in command_line
+		cld
+		pop cx				; <C> cx == [OnerrorLen]
+		pop di				; <B> di == command_line
+		pop si				; <A> si  == Onerror
+		rep movsb
+		jmp load_kernel
+
+;
+; kernel_corrupt: Called if the kernel file does not seem healthy
+;
+kernel_corrupt: mov si,err_notkernel
+                jmp abort_load
+
+;
+; Get a key, observing ThisKbdTO and ThisTotalTO -- those are timeouts
+; which can be adjusted by the caller based on the corresponding
+; master variables; on return they're updated.
+;
+; This cheats.  If we say "no timeout" we actually get a timeout of
+; 7.5 years.
+;
+getchar_timeout:
+		call vgashowcursor
+		call reset_idle
+
+.loop:
+		push word [__jiffies]
+		call pollchar
+		jnz .got_char
+		call do_idle
+		pop ax
+		cmp ax,[__jiffies]		; Has the timer advanced?
+		je .loop
+
+		dec dword [ThisKbdTo]
+		jz .timeout
+		dec dword [ThisTotalTo]
+		jnz .loop
+
+.timeout:
+		; Timeout!!!!
+		pop cx				; Discard return address
+		call vgahidecursor
+		mov si,Ontimeout		; Copy ontimeout command
+		mov di,command_line
+		mov cx,[OntimeoutLen]		; if we have one...
+		rep movsb
+		jmp command_done
+
+.got_char:
+		pop cx				; Discard
+		call getchar
+		call vgahidecursor
+		ret
+
+;
+; This is it!  We have a name (and location on the disk)... let's load
+; that sucker!!  First we have to decide what kind of file this is; base
+; that decision on the file extension.  The following extensions are
+; recognized; case insensitive:
+;
+; .com	- COMBOOT image
+; .cbt	- COMBOOT image
+; .c32  - COM32 image
+; .bs	- Boot sector
+; .0	- PXE bootstrap program (PXELINUX only)
+; .bin  - Boot sector
+; .bss	- Boot sector, but transfer over DOS superblock (SYSLINUX only)
+; .img  - Floppy image (ISOLINUX only)
+;
+; Anything else is assumed to be a Linux kernel.
+;
+		section .bss16
+		alignb 4
+Kernel_EAX	resd 1
+Kernel_SI	resw 1
+
+		section .text16
+kernel_good_saved:
+		; Alternate entry point for which the return from
+		; searchdir is stored in memory.  This is used for
+		; COMBOOT function INT 22h, AX=0016h.
+		mov si,[Kernel_SI]
+		mov eax,[Kernel_EAX]
+
+kernel_good:
+		pushad
+		;
+		; Common initialization for all kernel types
+		;
+		xor ax,ax
+		mov [InitRDPtr],ax
+		mov [QuietBoot],al
+%if IS_PXELINUX
+		mov [KeepPXE],al
+%endif
+
+		; Default memory limit, can be overridden by image loaders
+		mov eax,[HighMemRsvd]
+		mov [MyHighMemSize],eax
+
+		popad
+
+		push di
+		push ax
+		mov di,KernelName
+		xor al,al
+		mov cx,FILENAME_MAX
+		repne scasb
+		jne .one_step
+		dec di
+.one_step:	mov ecx,[di-4]			; 4 bytes before end
+		pop ax
+		pop di
+
+;
+; At this point, EAX contains the size of the kernel, SI contains
+; the file handle/cluster pointer, and ECX contains the extension (if any.)
+;
+		movzx di,byte [KernelType]
+		add di,di
+		jmp [kerneltype_table+di]
+
+is_unknown_filetype:
+		or ecx,20202000h		; Force lower case (except dot)
+
+		cmp ecx,'.com'
+		je is_comboot_image
+		cmp ecx,'.cbt'
+		je is_comboot_image
+		cmp ecx,'.c32'
+		je is_com32_image
+%if IS_ISOLINUX
+		cmp ecx,'.img'
+		je is_disk_image
+%endif
+		cmp ecx,'.bss'
+		je is_bss_sector
+		cmp ecx,'.bin'
+		je is_bootsector
+		shr ecx,8
+		cmp ecx,'.bs'
+		je is_bootsector
+		shr ecx,8
+		cmp cx,'.0'
+		je is_bootsector
+
+		; Otherwise Linux kernel
+		jmp is_linux_kernel
+
+is_config_file:
+		push si
+		call make_plain_cmdline
+		pm_call pm_is_config_file
+		pop si
+		call openfd
+		call reset_config
+		jmp load_config_file
+
+; This is an image type we can't deal with
+is_bad_image:
+		mov si,err_badimage
+		call writestr
+		jmp enter_command
+
+%if IS_SYSLINUX
+		; ok
+%else
+is_bss_sector	equ is_bad_image
+%endif
+%if IS_ISOLINUX
+		; ok
+%else
+is_disk_image	equ is_bad_image
+%endif
+
+		section .data16
+boot_prompt	db 'boot: ', 0
+wipe_char	db BS, ' ', BS, 0
+err_badimage	db 'Invalid image type for this media type!', CR, LF, 0
+err_notfound	db 'Could not find kernel image: ',0
+err_notkernel	db CR, LF, 'Invalid or corrupt kernel image.', CR, LF, 0
+
+
+		alignz 2
+kerneltype_table:
+		dw is_unknown_filetype	; VK_KERNEL
+		dw is_linux_kernel	; VK_LINUX
+		dw is_bootsector	; VK_BOOT
+		dw is_bss_sector	; VK_BSS
+		dw is_bootsector	; VK_PXE
+		dw is_disk_image	; VK_FDIMAGE
+		dw is_comboot_image	; VK_COMBOOT
+		dw is_com32_image	; VK_COM32
+		dw is_config_file	; VK_CONFIG
+
+		section .bss16
+		alignb 4
+ThisKbdTo	resd 1			; Temporary holder for KbdTimeout
+ThisTotalTo	resd 1			; Temporary holder for TotalTimeout
+KernelExtPtr	resw 1			; During search, final null pointer
+CmdOptPtr       resw 1			; Pointer to first option on cmd line
+KbdFlags	resb 1			; Check for keyboard escapes
+FuncFlag	resb 1			; Escape sequences received from keyboard
+KernelType	resb 1			; Kernel type, from vkernel, if known
+
+		section .text16
+;
+; Linux kernel loading code is common.
+;
+%include "runkernel.inc"
+
+;
+; COMBOOT-loading code
+;
+%include "comboot.inc"
+%include "com32.inc"
+%include "cmdline.inc"
+
+;
+; Boot sector loading code
+;
+%include "bootsect.inc"
+
+;
+; Abort loading code
+;
+%include "abort.inc"
+
+;
+; Hardware cleanup common code
+;
+%include "cleanup.inc"
diff --git a/contrib/syslinux-4.02/core/writedec.inc b/contrib/syslinux-4.02/core/writedec.inc
new file mode 100644
index 0000000..bfac099
--- /dev/null
+++ b/contrib/syslinux-4.02/core/writedec.inc
@@ -0,0 +1,57 @@
+;; -----------------------------------------------------------------------
+;;
+;;   Copyright 1994-2008 H. Peter Anvin - All Rights Reserved
+;;
+;;   This program is free software; you can redistribute it and/or modify
+;;   it under the terms of the GNU General Public License as published by
+;;   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
+;;   Boston MA 02111-1307, USA; either version 2 of the License, or
+;;   (at your option) any later version; incorporated herein by reference.
+;;
+;; -----------------------------------------------------------------------
+
+;;
+;; writedec.inc
+;;
+;; Write decimal numbers to the console
+;;
+
+		section .text16
+;
+; writedec[bwl]: Write an unsigned decimal number in (AL, AX, EAX)
+;                to the console
+;
+writedecb:
+		pushad
+		movzx eax,al
+		jmp short writedec_common
+writedecw:
+		pushad
+		movzx eax,ax
+		jmp short writedec_common
+writedecl:
+		pushad
+writedec_common:
+		pushfd
+		mov ebx,10		; Conversion base
+		xor cx,cx		; Number of digits
+
+.cloop:
+		div ebx
+		inc cx
+		push dx
+		and eax,eax
+		jnz .cloop
+
+.dloop:
+		pop ax
+		add al,'0'
+		call writechr
+		loop .dloop
+
+		popfd
+		popad
+		ret
+
+writechr:
+		ret
diff --git a/contrib/syslinux-4.02/core/writehex.inc b/contrib/syslinux-4.02/core/writehex.inc
new file mode 100644
index 0000000..e2bf86b
--- /dev/null
+++ b/contrib/syslinux-4.02/core/writehex.inc
@@ -0,0 +1,52 @@
+;; -----------------------------------------------------------------------
+;;
+;;   Copyright 1994-2008 H. Peter Anvin - All Rights Reserved
+;;
+;;   This program is free software; you can redistribute it and/or modify
+;;   it under the terms of the GNU General Public License as published by
+;;   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
+;;   Boston MA 02111-1307, USA; either version 2 of the License, or
+;;   (at your option) any later version; incorporated herein by reference.
+;;
+;; -----------------------------------------------------------------------
+
+;;
+;; writehex.inc
+;;
+;; Write hexadecimal numbers to the console
+;;
+
+;
+; writehex[248]: Write a hex number in (AL, AX, EAX) to the console
+;
+writehex2:
+		pushfd
+		pushad
+		rol eax,24
+		mov cx,2
+		jmp short writehex_common
+writehex4:
+		pushfd
+		pushad
+		rol eax,16
+		mov cx,4
+		jmp short writehex_common
+writehex8:
+		pushfd
+		pushad
+		mov cx,8
+writehex_common:
+.loop:		rol eax,4
+		push eax
+		and al,0Fh
+		cmp al,10
+		jae .high
+.low:		add al,'0'
+		jmp short .ischar
+.high:		add al,'A'-10
+.ischar:	call writechr
+		pop eax
+		loop .loop
+		popad
+		popfd
+		ret
diff --git a/contrib/syslinux-4.02/core/writestr.inc b/contrib/syslinux-4.02/core/writestr.inc
new file mode 100644
index 0000000..9c11b32
--- /dev/null
+++ b/contrib/syslinux-4.02/core/writestr.inc
@@ -0,0 +1,47 @@
+;; -----------------------------------------------------------------------
+;;
+;;   Copyright 1994-2008 H. Peter Anvin - All Rights Reserved
+;;
+;;   This program is free software; you can redistribute it and/or modify
+;;   it under the terms of the GNU General Public License as published by
+;;   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
+;;   Boston MA 02111-1307, USA; either version 2 of the License, or
+;;   (at your option) any later version; incorporated herein by reference.
+;;
+;; -----------------------------------------------------------------------
+
+;;
+;; writestr.inc
+;;
+;; Code to write a simple string.
+;;
+
+;
+; crlf: Print a newline
+;
+crlf:		push ax
+		mov al,CR
+		call writechr
+		mov al,LF
+		call writechr
+		pop ax
+		ret
+
+;
+; writestr: write a null-terminated string to the console, saving
+;            registers on entry.
+;
+; Note: writestr_early and writestr are distinct in
+; SYSLINUX and EXTLINUX, but not PXELINUX and ISOLINUX
+;
+writestr:
+		pushfd
+                pushad
+.top:		lodsb
+		and al,al
+                jz .end
+		call writechr
+                jmp short .top
+.end:		popad
+		popfd
+                ret