🚀 go-pugleaf

Frank Sorenson wrote:
> -----BEGIN PGP SIGNED MESSAGE-----
> Hash: SHA1
>
> Pascal Bellard wrote:
>
>>Hello,
>>
>>Please find attached a patch to build i386/x86_64 kernel directly
>>bootable. It may be usefull for rescue floppies and installation
>>floppies.
>
>
> Pascal,
>
> In commit f8eeaaf4180334a8e5c3582fe62a5f8176a8c124, build.c has already
> changed, and I don't believe it's very compatible with this change.
>
> See
> http://www.kernel.org/git/?p=linux/kernel/git/torvalds/linux-2.6.git;a=commit;høeeaaf4180334a8e5c3582fe62a5f8176a8c124
>
> Also, we'll need to see comments from H. Peter Anvin on this patch.
> CC'ing him.
>

Geometry detection by looking for error returns is fundamentally broken.
  Way too many non-traditional floppies (USB, IDE...) do not handle this
at all, they will return successfully, with the data being the data from
a sector from another track, and thus you end up with aliasing and a
corrupt boot.  You can do it with fingerprinting, but that's complex and
error-prone.

In short, this made sense in 1991, but it hasn't made sense for a very
long time now.  Resurrecting bootsect.S is *NOT* a good idea.

	-hpa

This is a multi-part message in MIME format.
--------------050004020807060004040109
Content-Type: text/plain; charset=ISO-8859-1
Content-Transfer-Encoding: 7bit

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

Pascal Bellard wrote:
> Hello,
>
> Please find attached a patch to build i386/x86_64 kernel directly
> bootable. It may be usefull for rescue floppies and installation
> floppies.

Pascal,

In commit f8eeaaf4180334a8e5c3582fe62a5f8176a8c124, build.c has already
changed, and I don't believe it's very compatible with this change.

See
http://www.kernel.org/git/?p=linux/kernel/git/torvalds/linux-2.6.git;a=commit;høeeaaf4180334a8e5c3582fe62a5f8176a8c124

Also, we'll need to see comments from H. Peter Anvin on this patch.
CC'ing him.


> System sector count is updated by tools/bluid.c at offset 495. The
> system could be up to 32 Mb long.
>
> -- support any drive geometry --
>
> Disk geometry detection assumes that no error raises on first track.
> First track is read sector by sector and the first error determinates
> the sectors per track count. Next, reads are performed track by track.
> Tested on floppy H2/S18 and harddisk H16/S63. Should work on
> every exotic drive supporting Int13h CHS.
>
> -- cmdline support --
>
> If ram_size (offset 504) bit 13 is set, the kernel cmdline
> is load from the sector following the kernel image.
>
> If Ctrl, Alt, Shift or CapsLock is pressed the kernel cmdline is
> prompted until Enter key. BackSpace is supported.
>
> Regards,
>
> -pascal

Frank
- --
Frank Sorenson - KD7TZK
Systems Manager, Computer Science Department
Brigham Young University
frank@tuxrocks.com
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.2.6 (GNU/Linux)
Comment: Using GnuPG with Fedora - http://enigmail.mozdev.org

iD8DBQFDJyKhaI0dwg4A47wRAjMoAJ9laL5kvIzkbJAxigSJahqkdnmx8gCg6dOy
V6ML9fJQjmfjcdxNGnbSuZ0=7P9o
-----END PGP SIGNATURE-----

--------------050004020807060004040109
Content-Type: text/x-patch;
 name="linux-2_6_13-bootblock.patch"
Content-Transfer-Encoding: 7bit
Content-Disposition: inline;
 filename="linux-2_6_13-bootblock.patch"

diff -purN linux-2.6.13/arch/i386/boot/bootsect.S linux-2.6.13-bootblock/arch/i386/boot/bootsect.S
--- linux-2.6.13/arch/i386/boot/bootsect.S	2005-09-12 10:37:52.000000000 +0200
+++ linux-2.6.13-bootblock/arch/i386/boot/bootsect.S	2005-09-12 10:40:19.000000000 +0200
@@ -4,20 +4,31 @@
  *	modified by Drew Eckhardt
  *	modified by Bruce Evans (bde)
  *	modified by Chris Noe (May 1999) (as86 -> gas)
- *	gutted by H. Peter Anvin (Jan 2003)
+ *
+ *      rewritten to support up to 32Mb kernel, cmdline
+ *      and any disk geometry by <pascal.bellard@ads-lu.com>
  *
  * BIG FAT NOTE: We're in real mode using 64k segments.  Therefore segment
  * addresses must be multiplied by 16 to obtain their respective linear
  * addresses. To avoid confusion, linear addresses are written using leading
  * hex while segment addresses are written as segment:offset.
  *
+ * bde - should not jump blindly, there may be systems with only 512K low
+ * memory.  Use int 0x12 to get the top of memory, etc.
+ *
+ * It then loads 'setup' directly after itself (0x90200), and the system
+ * at 0x10000, using BIOS interrupts.
+ *
+ * The loader has been made as simple as possible, and continuous
+ * read errors will result in a unbreakable loop. Reboot by hand. It
+ * loads pretty fast by getting whole tracks at a time whenever possible.
  */

 #include <asm/boot.h>

 SETUPSECTS	= 4			/* default nr of setup-sectors */
 BOOTSEG		= 0x07C0		/* original address of boot-sector */
-INITSEG		= DEF_INITSEG		/* we move boot here - out of the way */
+INITSEG		= DEF_INITSEG		/* we load boot here - out of the way */
 SETUPSEG	= DEF_SETUPSEG		/* setup starts here */
 SYSSEG		= DEF_SYSSEG		/* system loaded at 0x10000 (65536) */
 SYSSIZE		= DEF_SYSSIZE		/* system size: # of 16-byte clicks */
@@ -25,6 +36,12 @@ SYSSIZE		= DEF_SYSSIZE		/* system size:
 ROOT_DEV	= 0 			/* ROOT_DEV is now written by "build" */
 SWAP_DEV	= 0			/* SWAP_DEV is now written by "build" */

+/* some extra features */
+#define DISPLAY_KERNEL_VERSION		as soon as possible
+#define	EDIT_CMDLINE			on hotkey
+#define	LOAD_CMDLINE			according to bit ramsize.13
+#define EXTRA_DEVICES			to fill root_device
+
 #ifndef SVGA_MODE
 #define SVGA_MODE ASK_VGA
 #endif
@@ -42,57 +59,470 @@ SWAP_DEV	= 0			/* SWAP_DEV is now writte

 .global _start
 _start:
+	cld				# assume nothing
+	movw	$INITSEG, %ax
+	movw	%ax, %es		# %ax = %es = INITSEG
+#if MOVE_BOOTSECTOR
+# First things first. Move ourself from 0x7C00 -> 0x90000 and jump there.
+	movw	$BOOTSEG, %cx
+	movw	%cx, %ds		# %ds = BOOTSEG
+	movb	$1, %ch			# %cx = 256
+	subw	%si, %si
+	subw	%di, %di
+	rep
+	movsw
+	ljmp	$INITSEG, $go
+go:
+#else
+	xorw	%cx, %cx		# %cx = 0
+#endif

-	# Normalize the start address
-	jmpl	$BOOTSEG, $start2
+# bde - changed 0xff00 to 0x4000 to use debugger at 0x6400 up (bde).  We
+# wouldn't have to worry about this if we checked the top of memory.  Also
+# my BIOS can be configured to put the wini drive tables in high memory
+# instead of in the vector table.  The old stack might have clobbered the
+# drive table.
+
+	movw	$0x4000-12, %di		# 0x4000 is an arbitrary value >+					# length of bootsect + length of
+					# setup + room for stack;
+					# 12 is disk parm size.
+					# gdt will heat 48 more bytes.
+	movw	%ax, %ss		# %ax and %es already contain INITSEG
+	movw	%di, %sp		# put stack at INITSEG:0x4000-12.
+
+# Many BIOS's default disk parameter tables will not recognize
+# multi-sector reads beyond the maximum sector number specified
+# in the default diskette parameter tables - this may mean 7
+# sectors in some cases.
+#
+# Since single sector reads are slow and out of the question,
+# we must take care of this by creating new parameter tables
+# (for the first disk) in RAM.  We can set the maximum sector
+# count to 36 - the most we will encounter on an ED 2.88.
+#
+# High doesn't hurt.  Low does.  Let's use the max: 63
+#
+# Segments are as follows: %es = %ss = INITSEG,
+# %fs and %gs are unused.
+
+	movw	$0x78, %bx		# %ds:%bx is parameter table address
+	movw	%cx, %ds		# %ds = 0
+	ldsw	(%bx), %si		# %ds:%si is source
+	movb	$6, %cl			# copy 12 bytes
+	rep				# don't worry about cld
+	movsw				# already done above
+	movw	%cx, %ds		# %ds = 0
+	movw	%sp, (%bx)		# %sp = 0x4000-12
+	movw	%es, 2(%bx)
+	pushw	%es
+	popw	%ds			# now %ds = %es = %ss = INITSEG
+	movb	$63, 0x4-12(%di)	# patch sector count, %di = 0x4000
+
+	cli
+	cbw				# %ax = 0 : geometry unknown yet
+	xorb	%dh, %dh		# head 0, current drive
+	incw	%cx			# cylinder 0, sector 1
+	movw	%cx, %di		# read 1 sector
+	call	read_first_sector	# read bootsector again to have
+					# access to data segment
+
+#ifndef	DISPLAY_KERNEL_VERSION
+	movw	$msg1, %si
+	call	puts
+#endif

-start2:
-	movw	%cs, %ax
-	movw	%ax, %ds
-	movw	%ax, %es
-	movw	%ax, %ss
-	movw	$0x7c00, %sp
-	sti
-	cld
+# Load the setup-sectors directly after the moved bootblock (at 0x90200).

-	movw	$bugger_off_msg, %si
+	movb	setup_sects, %al
+#ifdef CHECK_SETUP_SIZE
+	orb	%al, %al
+	jne	setup_size_ok
+	movb	$SETUPSECTS, %al
+setup_size_ok:
+#endif
+	cbw
+	xchg	%ax, %di
+	call	read_sectors		# read setup
+
+#ifdef	DISPLAY_KERNEL_VERSION
+#define kernel_version	0xE
+	movw	$0x200,%si
+	addw	kernel_version(%si),%si	# starting protocol 2.00, Kernel 1.3.73
+	call	puts			# show which kernel we are loading
+#endif

-msg_loop:
-	lodsb
-	andb	%al, %al
-	jz	die
-	movb	$0xe, %ah
-	movw	$7, %bx
-	int	$0x10
-	jmp	msg_loop
+# This routine loads the system at address SYSSEG, making sure
+# no 64kB boundaries are crossed. We try to load it as fast as
+# possible, loading whole tracks whenever we can.
+
+#ifdef __BIG_KERNEL__
+type_of_loader	=	528
+	movw	$24, %cx		# allocate 48 bytes in stack
+init_gdt:
+	push	$0			#   initialized with 0
+	loop	init_gdt
+	movw	%sp, %si		# for bootsect_gdt
+	movw	$0x9300+(SYSSEG/4096), %ax	# source = SYSSEG
+	cwd
+	movw	%ax, 20(%si)		# bootsect_src_base+2
+	movb	$0x10-1, %al		# destination = 0x100000
+	movw	%ax, 28(%si)		# bootsect_dst_base+2
+	movw	%dx, 16(%si)		# bootsect_src = 64Kb
+	movw	%dx, 24(%si)		# bootsect_dst = 64Kb
+	movb	%dl, type_of_loader	# loader type = 0xFF
+syslp:
+	movw	$SYSSEG, %ax
+	movw	%ax, %es
+	movw	$128,%di		# 64Kb in sectors
+	subw	%di, sys_sects
+	pushf
+	jnc	not_last
+	addw	sys_sects, %di
+not_last:
+	call	read_sectors
+	incw	28(%si)			# bootsect_dst_base+2
+	movw	$0x8000, %cx		# full 64K
+	movb	$0x87, %ah
+	push	%ss
+	pop	%es			# gdt in es:si
+	int	$0x15
+	popf
+	ja	syslp
+#else
+	movw	$SYSSEG, %ax
+	movw	%ax, %es
+syslp:
+	movw	$128*32,%ax		# 64Kb in paragraphs
+	subw	%ax, syssize
+	pushf
+	jnc	not_last
+	addw	syssize, %ax
+not_last:
+	movb	$5, %cl			# paragraphs -> sectors
+	shrw	%cl, %ax
+	xchg	%ax, %di
+	call	read_sectors
+	popf
+	ja	syslp
+#endif

-die:
-	# Allow the user to press a key, then reboot
-	xorw	%ax, %ax
-	int	$0x16
-	int	$0x19
+# After that we check which root-device to use. If the device is
+# defined (!= 0), nothing is done and the given device is used.
+# Otherwise, one of /dev/fd0H2880 (2,32) or /dev/PS0 (2,28) or /dev/at0 (2,8)
+# depending on the number of sectors we pretend to know we have.
+
+
+	movw	root_dev, %ax
+	orw	%ax, %ax
+	jnz	root_defined
+
+	movw	$floppy_table,%si
+scan_floppy_table:
+	lodsw
+	cmpb	limits, %ah
+	je	set_root
+	jno	scan_floppy_table
+set_root:
+	movb	$2, %ah
+	addb	%dl, %al		# add current (floppy) drive
+	movw	%ax, root_dev
+root_defined:
+
+#if defined(LOAD_CMDLINE) || defined(EDIT_CMDLINE)
+#define BUFFER	0x7F00
+	movw	$BUFFER, %si
+	movw	%si, (%si)		# default : no cmdline
+#endif

-	# int 0x19 should never return.  In case it does anyway,
-	# invoke the BIOS reset code...
-	ljmp	$0xf000,$0xfff0
+#ifdef	LOAD_CMDLINE
+	testb	$0x20,ram_size+1	# bit 11 to 13 where unused
+					# now bit 13 means: load cmdline
+	jz	nocmd
+	movw	$BUFFER/16+INITSEG, %ax
+	movw	%ax, %es
+	movw	$1, %di			# cmdline = 512 bytes max
+	call	read_sectors
+nocmd:
+#endif

+#define RSHFT   0x01
+#define LSHFT   0x02
+#define CTRL    0x04
+#define ALT     0x08
+#define SCRLCK  0x10
+#define NUMLCK  0x20
+#define CAPSLCK 0x40
+#define INSERT  0x80
+
+#ifdef	EDIT_CMDLINE
+# The cmdline can be entered and modifed on hot key.
+# Only characters before the cursor are passed to the kernel.
+	movb	$2, %ah			# get keyboard status
+	int	$0x16
+	testb	$RSHFT|LSHFT|CTRL|ALT|CAPSLCK, %al
+	jz	nocmdline
+	pushw	%si
+	call	puts			# set %ah and %bx
+cmdlp:
+# if 1
+	movb	$32, %al		# clear end of line
+	int	$0x10			#  with Space
+	movb	$8, %al			#   and BackSpace
+	int	$0x10
+# endif
+	decw	%si
+cmdget:
+	cbw				# %ah = 0, get keyboard character
+	int	$0x16
+	cmpb	$8, %al			# BackSpace ?
+	je	cmdbs
+	cbw
+	movw	%ax, (%si)		# store end of string too
+	incw	%si
+	incw	%si
+cmdbs:
+	cmpw	$BUFFER, %si		# lower limit is checked
+	je	cmdget			#   but upper limit not
+	call	putc
+	cmpb	$13, %al		# Enter ?
+	jne	cmdlp
+	popw	%si
+nocmdline:
+#endif

-bugger_off_msg:
-	.ascii	"Direct booting from floppy is no longer supported.\r\n"
-	.ascii	"Please use a boot loader program instead.\r\n"
-	.ascii	"\n"
-	.ascii	"Remove disk and press any key to reboot . . .\r\n"
-	.byte	0
+#if defined(LOAD_CMDLINE) || defined(EDIT_CMDLINE)
+#if 1
+cmd_line_magic	=	0x20
+cmd_line_offset	=	0x22
+	movw	$0xA33F, cmd_line_magic
+	movw	%si, cmd_line_offset
+#else
+# protocol >= 2.02, starting Kernel 2.4.0-test3-pre3
+cmd_line_ptr	=	0x228
+	movzx	%si, %eax
+	addl	$INITSEG*16, %eax
+	movl	%eax, cmd_line_ptr
+#endif
+emptycmdline:
+#endif
+
+# This procedure turns off the floppy drive motor, so
+# that we enter the kernel in a known state, and
+# don't have to worry about it later.
+
+#if 1
+kill_motor:
+	xorw	%ax, %ax		# reset FDC
+	int	$0x13
+#else
+kill_motor:
+	movw	$0x3f2, %dx
+	xorb	%al, %al
+	outb	%al, %dx
+#endif

+	call	print_nl

-	# Kernel attributes; used by setup
+# After that (everything loaded), we jump to the setup-routine
+# loaded directly after the bootblock:
+# Segments are as follows: %ds = %ss = INITSEG
+
+	ljmp	$SETUPSEG, $0
+
+# read_sectors reads %di sectors into %es:0 buffer.
+# %es:0 is updated to the next memory location.
+# First, sectors are read sector by sector until
+# sector per track count is known. Then they are
+# read track by track.
+# Assume no error on first track.
+
+#define TRACK_BY_TRACK	load as fast as possible !
+#define SHOW_REGS	show int13 status & parameters
+
+check_limits:
+        cmpb    %al, %cl		# max sector known ?
+        ja	next_head		#   no -> store it
+        cmpb    %ah, %dh		# max head known ?
+        ja	next_track		#   no -> store it
+	pusha				# save context
+#ifdef SHOW_REGS
+	pushw	%es			# print %es (named EX)
+	pushw	%dx			# print %dx
+	pushw	%cx			# print %cx
+	xorw	%cx, %cx
+	pushw	%cx			# print %bx
+# ifdef TRACK_BY_TRACK
+	movb	$2, %bh
+# endif
+	pushw	%bx			# print %ax
+	movb	$6,%cl
+	jmp	print_all		# print %bp (status)
+print_loop:
+	movb	$0x6 + 'A' - 1, %al
+	subb	%cl, %al
+	movw	$regs, %si		# caller %si is saved
+	call	putcs			# putc(%al) + puts(%si)
+# it will print out all of the registers.
+	popw	%bp			# load word into %bp
+print_all:
+	pushw	%cx			# save count remaining
+	movb	$4, %cl			# 4 hex digits
+print_digit:
+	rolw	$4, %bp			# rotate to use low 4 bits
+	movb	$0x0f, %al
+	andw	%bp, %ax		# %al = mask for nybble
+	addb	$0x90, %al		# convert %al to ascii hex
+	daa				# in only four instructions!
+	adcb	$0x40, %al
+	daa
+	call	putc			# set %ah and %bx
+	loop	print_digit
+	movb	$0x20, %al		# SPACE
+	int	$0x10
+	popw	%cx
+	loop	print_loop
+	xchg	%ax, %cx		# %ah = 0
+#else
+	cbw				# %ah = 0
+#endif
+        int     $0x13			# reset controler
+	popa				# restore context
+read_sectorslp:
+read_first_sector:
+        pushw   %di			# sector count
+        pushw   %ax			# limits
+        pushw   %dx
+        pushw   %cx
+	xorw	%bx, %bx
+#ifdef TRACK_BY_TRACK
+	subb	%cl, %al		# sectors remaining in track
+	ja	tolastsect
+	movb	$1, %al			# 1 sector mini
+tolastsect:
+	cbw
+	cmpw	%di, %ax
+	jb	more1trk
+	movw	%di, %ax		# sectors to read
+more1trk:
+	push	%ax
+	movb	$2, %ah			# cmd: read chs
+#else
+        movw    $0x201, %ax		# sector by sector
+	push	%ax
+#endif
+        int     $0x13
+	xchg	%ax, %bp		# status
+        popw    %bx			# %ax
+        popw    %cx
+        popw    %dx
+        popw    %ax			# limits
+        popw    %di			# sector count
+	jc	check_limits
+next_sector:
+#ifdef TRACK_BY_TRACK
+	subw	%bx,%di			# update sector counter
+	addw	%bx,%cx			# next sector
+	shlw	$5,%bx			# sectors -> paragraghs
+	movw	%es, %bp
+	addw	%bx, %bp
+#else
+	decw	%di			# update sector counter
+	incw	%cx			# next sector
+	movw	%es, %bp
+	addw	$32, %bp		# sector size in paragraghs
+#endif
+	movw	%bp, %es		# next location
+        cmpb    %al,%cl			# reach sector limit ?
+        jne     bdendlp
+next_head:
+        movb    %cl,%al
+        incb    %dh			# next head
+        movb    $1,%cl			# first sector
+        cmpb    %ah,%dh			# reach head limit ?
+        jne     bdendlp
+next_track:
+        movb    %dh,%ah
+        movb    $0,%dh			# first head
+# NOTE : support 256 cylinders max
+        incb    %ch			# next cylinder
+bdendlp:
+curdrive =	_start
+curdx	=	_start
+curcx	=	_start+2
+limits	=	_start+4
+	movw	%dx, curdx		# save disk state
+	movw	%cx, curcx
+	movw	%ax, limits
+read_sectors:
+	movw	curdx, %dx		# restore disk state
+	movw	curcx, %cx
+#   al is last sector+1
+#   ah is last head+1
+	movw	limits, %ax
+	orw	%di,%di
+        jne	read_sectorslp
+	movb	$0x2e, %al 		# loading... message 2e = .
+putc:
+	movb	$0xe, %ah
+	movw	$7, %bx			#   one dot each 64k
+ 	int	$0x10
+return:
+	ret
+
+print_nl:
+
+	movb	$0xd, %al		# CR
+	call	putc
+	movb	$0xa, %al		# LF
+	jmp	putc
+
+puts:
+	call	print_nl		# set %ah and %bx
+putslp:
+	lodsb
+	orb	%al,%al			# end of string is \0
+	jz	return
+putcs:
+	int	$0x10
+	jmp	putslp

-	.org 497
+floppy_table:
+#ifdef EXTRA_DEVICES
+		.byte	16,9			# /dev/fd0u720
+		.byte	12,10			# /dev/fd0u800
+		.byte	80,11			# /dev/fd0u880
+		.byte	125,20			# /dev/fd0u1600
+		.byte	44,21			# /dev/fd0u1680
+		.byte	96,22			# /dev/fd0u1760
+		.byte	116,23			# /dev/fd0u1840
+		.byte	100,24			# /dev/fd0u1920
+		.byte	105,40			# /dev/fd0u3200
+		.byte	109,44			# /dev/fd0u3520
+		.byte	113,48			# /dev/fd0u3840
+#endif
+		.byte	8,15			# /dev/fd0h1200 - /dev/ps0
+		.byte	28,18			# /dev/fd0u1440 - /dev/PS0
+		.byte	32,36			# /dev/fd0u2880 - /dev/fd0H2880
+		.byte	0,128			# /dev/fd0 - default: autodetect
+
+regs:		.asciz	"X:"
+
+#ifndef	DISPLAY_KERNEL_VERSION
+msg1:		.asciz	"Loading"
+#endif
+
+tail:
+		.space	495+start-tail
+
+#.org 495
+sys_sects:	.word SYSSIZE / 32		# size max is now 32Mb
+#.org 497
 setup_sects:	.byte SETUPSECTS
 root_flags:	.word ROOT_RDONLY
-syssize:	.word SYSSIZE
+syssize:	.word SYSSIZE % 0x10000		# size max was 1Mb
 swap_dev:	.word SWAP_DEV
-ram_size:	.word RAMDISK
+ram_size:	.word RAMDISK			# ramdisk size, ramdisk flags and cmdline flag
 vid_mode:	.word SVGA_MODE
 root_dev:	.word ROOT_DEV
 boot_flag:	.word 0xAA55
diff -purN linux-2.6.13/arch/i386/boot/tools/build.c linux-2.6.13-bootblock/arch/i386/boot/tools/build.c
--- linux-2.6.13/arch/i386/boot/tools/build.c	2005-09-12 10:38:52.000000000 +0200
+++ linux-2.6.13-bootblock/arch/i386/boot/tools/build.c	2005-09-12 10:46:25.000000000 +0200
@@ -168,10 +168,13 @@ int main(int argc, char ** argv)
 	}
 	close(fd);

-	if (lseek(1, 497, SEEK_SET) != 497)		    /* Write sizes to the bootsector */
+	if (lseek(1, 495, SEEK_SET) != 495)		    /* Write sizes to the bootsector */
 		die("Output: seek failed");
-	buf[0] = setup_sectors;
-	if (write(1, buf, 1) != 1)
+	sz = (sb.st_size + 511) / 512;
+	buf[0] = (sz & 0xff);
+	buf[1] = ((sz >> 8) & 0xff);
+	buf[2] = setup_sectors;
+	if (write(1, buf, 3) != 3)
 		die("Write of setup sector count failed");
 	if (lseek(1, 500, SEEK_SET) != 500)
 		die("Output: seek failed");
diff -purN linux-2.6.13/arch/i386/kernel/setup.c linux-2.6.13-bootblock/arch/i386/kernel/setup.c
--- linux-2.6.13/arch/i386/kernel/setup.c	2005-09-12 10:38:53.000000000 +0200
+++ linux-2.6.13-bootblock/arch/i386/kernel/setup.c	2005-09-12 10:57:01.000000000 +0200
@@ -156,6 +156,7 @@ unsigned long saved_videomode;
 #define RAMDISK_IMAGE_START_MASK  	0x07FF
 #define RAMDISK_PROMPT_FLAG		0x8000
 #define RAMDISK_LOAD_FLAG		0x4000
+#define CMDLINE_LOAD_FLAG		0x2000

 static char command_line[COMMAND_LINE_SIZE];

diff -purN linux-2.6.13/arch/x86_64/boot/bootsect.S linux-2.6.13-bootblock/arch/x86_64/boot/bootsect.S
--- linux-2.6.13/arch/x86_64/boot/bootsect.S	2005-09-12 10:37:58.000000000 +0200
+++ linux-2.6.13-bootblock/arch/x86_64/boot/bootsect.S	2005-09-12 10:58:07.000000000 +0200
@@ -4,20 +4,31 @@
  *	modified by Drew Eckhardt
  *	modified by Bruce Evans (bde)
  *	modified by Chris Noe (May 1999) (as86 -> gas)
- *	gutted by H. Peter Anvin (Jan 2003)
+ *
+ *      rewritten to support up to 32Mb kernel, cmdline
+ *      and any disk geometry by <pascal.bellard@ads-lu.com>
  *
  * BIG FAT NOTE: We're in real mode using 64k segments.  Therefore segment
  * addresses must be multiplied by 16 to obtain their respective linear
  * addresses. To avoid confusion, linear addresses are written using leading
  * hex while segment addresses are written as segment:offset.
  *
+ * bde - should not jump blindly, there may be systems with only 512K low
+ * memory.  Use int 0x12 to get the top of memory, etc.
+ *
+ * It then loads 'setup' directly after itself (0x90200), and the system
+ * at 0x10000, using BIOS interrupts.
+ *
+ * The loader has been made as simple as possible, and continuous
+ * read errors will result in a unbreakable loop. Reboot by hand. It
+ * loads pretty fast by getting whole tracks at a time whenever possible.
  */

 #include <asm/boot.h>

 SETUPSECTS	= 4			/* default nr of setup-sectors */
 BOOTSEG		= 0x07C0		/* original address of boot-sector */
-INITSEG		= DEF_INITSEG		/* we move boot here - out of the way */
+INITSEG		= DEF_INITSEG		/* we load boot here - out of the way */
 SETUPSEG	= DEF_SETUPSEG		/* setup starts here */
 SYSSEG		= DEF_SYSSEG		/* system loaded at 0x10000 (65536) */
 SYSSIZE		= DEF_SYSSIZE		/* system size: # of 16-byte clicks */
@@ -25,6 +36,12 @@ SYSSIZE		= DEF_SYSSIZE		/* system size:
 ROOT_DEV	= 0 			/* ROOT_DEV is now written by "build" */
 SWAP_DEV	= 0			/* SWAP_DEV is now written by "build" */

+/* some extra features */
+#define DISPLAY_KERNEL_VERSION		as soon as possible
+#define	EDIT_CMDLINE			on hotkey
+#define	LOAD_CMDLINE			according to bit ramsize.13
+#define EXTRA_DEVICES			to fill root_device
+
 #ifndef SVGA_MODE
 #define SVGA_MODE ASK_VGA
 #endif
@@ -42,57 +59,470 @@ SWAP_DEV	= 0			/* SWAP_DEV is now writte

 .global _start
 _start:
+	cld				# assume nothing
+	movw	$INITSEG, %ax
+	movw	%ax, %es		# %ax = %es = INITSEG
+#if MOVE_BOOTSECTOR
+# First things first. Move ourself from 0x7C00 -> 0x90000 and jump there.
+	movw	$BOOTSEG, %cx
+	movw	%cx, %ds		# %ds = BOOTSEG
+	movb	$1, %ch			# %cx = 256
+	subw	%si, %si
+	subw	%di, %di
+	rep
+	movsw
+	ljmp	$INITSEG, $go
+go:
+#else
+	xorw	%cx, %cx		# %cx = 0
+#endif

-	# Normalize the start address
-	jmpl	$BOOTSEG, $start2
+# bde - changed 0xff00 to 0x4000 to use debugger at 0x6400 up (bde).  We
+# wouldn't have to worry about this if we checked the top of memory.  Also
+# my BIOS can be configured to put the wini drive tables in high memory
+# instead of in the vector table.  The old stack might have clobbered the
+# drive table.
+
+	movw	$0x4000-12, %di		# 0x4000 is an arbitrary value >+					# length of bootsect + length of
+					# setup + room for stack;
+					# 12 is disk parm size.
+					# gdt will heat 48 more bytes.
+	movw	%ax, %ss		# %ax and %es already contain INITSEG
+	movw	%di, %sp		# put stack at INITSEG:0x4000-12.
+
+# Many BIOS's default disk parameter tables will not recognize
+# multi-sector reads beyond the maximum sector number specified
+# in the default diskette parameter tables - this may mean 7
+# sectors in some cases.
+#
+# Since single sector reads are slow and out of the question,
+# we must take care of this by creating new parameter tables
+# (for the first disk) in RAM.  We can set the maximum sector
+# count to 36 - the most we will encounter on an ED 2.88.
+#
+# High doesn't hurt.  Low does.  Let's use the max: 63
+#
+# Segments are as follows: %es = %ss = INITSEG,
+# %fs and %gs are unused.
+
+	movw	$0x78, %bx		# %ds:%bx is parameter table address
+	movw	%cx, %ds		# %ds = 0
+	ldsw	(%bx), %si		# %ds:%si is source
+	movb	$6, %cl			# copy 12 bytes
+	rep				# don't worry about cld
+	movsw				# already done above
+	movw	%cx, %ds		# %ds = 0
+	movw	%sp, (%bx)		# %sp = 0x4000-12
+	movw	%es, 2(%bx)
+	pushw	%es
+	popw	%ds			# now %ds = %es = %ss = INITSEG
+	movb	$63, 0x4-12(%di)	# patch sector count, %di = 0x4000
+
+	cli
+	cbw				# %ax = 0 : geometry unknown yet
+	xorb	%dh, %dh		# head 0, current drive
+	incw	%cx			# cylinder 0, sector 1
+	movw	%cx, %di		# read 1 sector
+	call	read_first_sector	# read bootsector again to have
+					# access to data segment
+
+#ifndef	DISPLAY_KERNEL_VERSION
+	movw	$msg1, %si
+	call	puts
+#endif

-start2:
-	movw	%cs, %ax
-	movw	%ax, %ds
-	movw	%ax, %es
-	movw	%ax, %ss
-	movw	$0x7c00, %sp
-	sti
-	cld
+# Load the setup-sectors directly after the moved bootblock (at 0x90200).

-	movw	$bugger_off_msg, %si
+	movb	setup_sects, %al
+#ifdef CHECK_SETUP_SIZE
+	orb	%al, %al
+	jne	setup_size_ok
+	movb	$SETUPSECTS, %al
+setup_size_ok:
+#endif
+	cbw
+	xchg	%ax, %di
+	call	read_sectors		# read setup
+
+#ifdef	DISPLAY_KERNEL_VERSION
+#define kernel_version	0xE
+	movw	$0x200,%si
+	addw	kernel_version(%si),%si	# starting protocol 2.00, Kernel 1.3.73
+	call	puts			# show which kernel we are loading
+#endif

-msg_loop:
-	lodsb
-	andb	%al, %al
-	jz	die
-	movb	$0xe, %ah
-	movw	$7, %bx
-	int	$0x10
-	jmp	msg_loop
+# This routine loads the system at address SYSSEG, making sure
+# no 64kB boundaries are crossed. We try to load it as fast as
+# possible, loading whole tracks whenever we can.
+
+#ifdef __BIG_KERNEL__
+type_of_loader	=	528
+	movw	$24, %cx		# allocate 48 bytes in stack
+init_gdt:
+	push	$0			#   initialized with 0
+	loop	init_gdt
+	movw	%sp, %si		# for bootsect_gdt
+	movw	$0x9300+(SYSSEG/4096), %ax	# source = SYSSEG
+	cwd
+	movw	%ax, 20(%si)		# bootsect_src_base+2
+	movb	$0x10-1, %al		# destination = 0x100000
+	movw	%ax, 28(%si)		# bootsect_dst_base+2
+	movw	%dx, 16(%si)		# bootsect_src = 64Kb
+	movw	%dx, 24(%si)		# bootsect_dst = 64Kb
+	movb	%dl, type_of_loader	# loader type = 0xFF
+syslp:
+	movw	$SYSSEG, %ax
+	movw	%ax, %es
+	movw	$128,%di		# 64Kb in sectors
+	subw	%di, sys_sects
+	pushf
+	jnc	not_last
+	addw	sys_sects, %di
+not_last:
+	call	read_sectors
+	incw	28(%si)			# bootsect_dst_base+2
+	movw	$0x8000, %cx		# full 64K
+	movb	$0x87, %ah
+	push	%ss
+	pop	%es			# gdt in es:si
+	int	$0x15
+	popf
+	ja	syslp
+#else
+	movw	$SYSSEG, %ax
+	movw	%ax, %es
+syslp:
+	movw	$128*32,%ax		# 64Kb in paragraphs
+	subw	%ax, syssize
+	pushf
+	jnc	not_last
+	addw	syssize, %ax
+not_last:
+	movb	$5, %cl			# paragraphs -> sectors
+	shrw	%cl, %ax
+	xchg	%ax, %di
+	call	read_sectors
+	popf
+	ja	syslp
+#endif

-die:
-	# Allow the user to press a key, then reboot
-	xorw	%ax, %ax
-	int	$0x16
-	int	$0x19
+# After that we check which root-device to use. If the device is
+# defined (!= 0), nothing is done and the given device is used.
+# Otherwise, one of /dev/fd0H2880 (2,32) or /dev/PS0 (2,28) or /dev/at0 (2,8)
+# depending on the number of sectors we pretend to know we have.
+
+
+	movw	root_dev, %ax
+	orw	%ax, %ax
+	jnz	root_defined
+
+	movw	$floppy_table,%si
+scan_floppy_table:
+	lodsw
+	cmpb	limits, %ah
+	je	set_root
+	jno	scan_floppy_table
+set_root:
+	movb	$2, %ah
+	addb	%dl, %al		# add current (floppy) drive
+	movw	%ax, root_dev
+root_defined:
+
+#if defined(LOAD_CMDLINE) || defined(EDIT_CMDLINE)
+#define BUFFER	0x7F00
+	movw	$BUFFER, %si
+	movw	%si, (%si)		# default : no cmdline
+#endif

-	# int 0x19 should never return.  In case it does anyway,
-	# invoke the BIOS reset code...
-	ljmp	$0xf000,$0xfff0
+#ifdef	LOAD_CMDLINE
+	testb	$0x20,ram_size+1	# bit 11 to 13 where unused
+					# now bit 13 means: load cmdline
+	jz	nocmd
+	movw	$BUFFER/16+INITSEG, %ax
+	movw	%ax, %es
+	movw	$1, %di			# cmdline = 512 bytes max
+	call	read_sectors
+nocmd:
+#endif

+#define RSHFT   0x01
+#define LSHFT   0x02
+#define CTRL    0x04
+#define ALT     0x08
+#define SCRLCK  0x10
+#define NUMLCK  0x20
+#define CAPSLCK 0x40
+#define INSERT  0x80
+
+#ifdef	EDIT_CMDLINE
+# The cmdline can be entered and modifed on hot key.
+# Only characters before the cursor are passed to the kernel.
+	movb	$2, %ah			# get keyboard status
+	int	$0x16
+	testb	$RSHFT|LSHFT|CTRL|ALT|CAPSLCK, %al
+	jz	nocmdline
+	pushw	%si
+	call	puts			# set %ah and %bx
+cmdlp:
+# if 1
+	movb	$32, %al		# clear end of line
+	int	$0x10			#  with Space
+	movb	$8, %al			#   and BackSpace
+	int	$0x10
+# endif
+	decw	%si
+cmdget:
+	cbw				# %ah = 0, get keyboard character
+	int	$0x16
+	cmpb	$8, %al			# BackSpace ?
+	je	cmdbs
+	cbw
+	movw	%ax, (%si)		# store end of string too
+	incw	%si
+	incw	%si
+cmdbs:
+	cmpw	$BUFFER, %si		# lower limit is checked
+	je	cmdget			#   but upper limit not
+	call	putc
+	cmpb	$13, %al		# Enter ?
+	jne	cmdlp
+	popw	%si
+nocmdline:
+#endif

-bugger_off_msg:
-	.ascii	"Direct booting from floppy is no longer supported.\r\n"
-	.ascii	"Please use a boot loader program instead.\r\n"
-	.ascii	"\n"
-	.ascii	"Remove disk and press any key to reboot . . .\r\n"
-	.byte	0
+#if defined(LOAD_CMDLINE) || defined(EDIT_CMDLINE)
+#if 1
+cmd_line_magic	=	0x20
+cmd_line_offset	=	0x22
+	movw	$0xA33F, cmd_line_magic
+	movw	%si, cmd_line_offset
+#else
+# protocol >= 2.02, starting Kernel 2.4.0-test3-pre3
+cmd_line_ptr	=	0x228
+	movzx	%si, %eax
+	addl	$INITSEG*16, %eax
+	movl	%eax, cmd_line_ptr
+#endif
+emptycmdline:
+#endif
+
+# This procedure turns off the floppy drive motor, so
+# that we enter the kernel in a known state, and
+# don't have to worry about it later.
+
+#if 1
+kill_motor:
+	xorw	%ax, %ax		# reset FDC
+	int	$0x13
+#else
+kill_motor:
+	movw	$0x3f2, %dx
+	xorb	%al, %al
+	outb	%al, %dx
+#endif

+	call	print_nl

-	# Kernel attributes; used by setup
+# After that (everything loaded), we jump to the setup-routine
+# loaded directly after the bootblock:
+# Segments are as follows: %ds = %ss = INITSEG
+
+	ljmp	$SETUPSEG, $0
+
+# read_sectors reads %di sectors into %es:0 buffer.
+# %es:0 is updated to the next memory location.
+# First, sectors are read sector by sector until
+# sector per track count is known. Then they are
+# read track by track.
+# Assume no error on first track.
+
+#define TRACK_BY_TRACK	load as fast as possible !
+#define SHOW_REGS	show int13 status & parameters
+
+check_limits:
+        cmpb    %al, %cl		# max sector known ?
+        ja	next_head		#   no -> store it
+        cmpb    %ah, %dh		# max head known ?
+        ja	next_track		#   no -> store it
+	pusha				# save context
+#ifdef SHOW_REGS
+	pushw	%es			# print %es (named EX)
+	pushw	%dx			# print %dx
+	pushw	%cx			# print %cx
+	xorw	%cx, %cx
+	pushw	%cx			# print %bx
+# ifdef TRACK_BY_TRACK
+	movb	$2, %bh
+# endif
+	pushw	%bx			# print %ax
+	movb	$6,%cl
+	jmp	print_all		# print %bp (status)
+print_loop:
+	movb	$0x6 + 'A' - 1, %al
+	subb	%cl, %al
+	movw	$regs, %si		# caller %si is saved
+	call	putcs			# putc(%al) + puts(%si)
+# it will print out all of the registers.
+	popw	%bp			# load word into %bp
+print_all:
+	pushw	%cx			# save count remaining
+	movb	$4, %cl			# 4 hex digits
+print_digit:
+	rolw	$4, %bp			# rotate to use low 4 bits
+	movb	$0x0f, %al
+	andw	%bp, %ax		# %al = mask for nybble
+	addb	$0x90, %al		# convert %al to ascii hex
+	daa				# in only four instructions!
+	adcb	$0x40, %al
+	daa
+	call	putc			# set %ah and %bx
+	loop	print_digit
+	movb	$0x20, %al		# SPACE
+	int	$0x10
+	popw	%cx
+	loop	print_loop
+	xchg	%ax, %cx		# %ah = 0
+#else
+	cbw				# %ah = 0
+#endif
+        int     $0x13			# reset controler
+	popa				# restore context
+read_sectorslp:
+read_first_sector:
+        pushw   %di			# sector count
+        pushw   %ax			# limits
+        pushw   %dx
+        pushw   %cx
+	xorw	%bx, %bx
+#ifdef TRACK_BY_TRACK
+	subb	%cl, %al		# sectors remaining in track
+	ja	tolastsect
+	movb	$1, %al			# 1 sector mini
+tolastsect:
+	cbw
+	cmpw	%di, %ax
+	jb	more1trk
+	movw	%di, %ax		# sectors to read
+more1trk:
+	push	%ax
+	movb	$2, %ah			# cmd: read chs
+#else
+        movw    $0x201, %ax		# sector by sector
+	push	%ax
+#endif
+        int     $0x13
+	xchg	%ax, %bp		# status
+        popw    %bx			# %ax
+        popw    %cx
+        popw    %dx
+        popw    %ax			# limits
+        popw    %di			# sector count
+	jc	check_limits
+next_sector:
+#ifdef TRACK_BY_TRACK
+	subw	%bx,%di			# update sector counter
+	addw	%bx,%cx			# next sector
+	shlw	$5,%bx			# sectors -> paragraghs
+	movw	%es, %bp
+	addw	%bx, %bp
+#else
+	decw	%di			# update sector counter
+	incw	%cx			# next sector
+	movw	%es, %bp
+	addw	$32, %bp		# sector size in paragraghs
+#endif
+	movw	%bp, %es		# next location
+        cmpb    %al,%cl			# reach sector limit ?
+        jne     bdendlp
+next_head:
+        movb    %cl,%al
+        incb    %dh			# next head
+        movb    $1,%cl			# first sector
+        cmpb    %ah,%dh			# reach head limit ?
+        jne     bdendlp
+next_track:
+        movb    %dh,%ah
+        movb    $0,%dh			# first head
+# NOTE : support 256 cylinders max
+        incb    %ch			# next cylinder
+bdendlp:
+curdrive =	_start
+curdx	=	_start
+curcx	=	_start+2
+limits	=	_start+4
+	movw	%dx, curdx		# save disk state
+	movw	%cx, curcx
+	movw	%ax, limits
+read_sectors:
+	movw	curdx, %dx		# restore disk state
+	movw	curcx, %cx
+#   al is last sector+1
+#   ah is last head+1
+	movw	limits, %ax
+	orw	%di,%di
+        jne	read_sectorslp
+	movb	$0x2e, %al 		# loading... message 2e = .
+putc:
+	movb	$0xe, %ah
+	movw	$7, %bx			#   one dot each 64k
+ 	int	$0x10
+return:
+	ret
+
+print_nl:
+
+	movb	$0xd, %al		# CR
+	call	putc
+	movb	$0xa, %al		# LF
+	jmp	putc
+
+puts:
+	call	print_nl		# set %ah and %bx
+putslp:
+	lodsb
+	orb	%al,%al			# end of string is \0
+	jz	return
+putcs:
+	int	$0x10
+	jmp	putslp

-	.org 497
+floppy_table:
+#ifdef EXTRA_DEVICES
+		.byte	16,9			# /dev/fd0u720
+		.byte	12,10			# /dev/fd0u800
+		.byte	80,11			# /dev/fd0u880
+		.byte	125,20			# /dev/fd0u1600
+		.byte	44,21			# /dev/fd0u1680
+		.byte	96,22			# /dev/fd0u1760
+		.byte	116,23			# /dev/fd0u1840
+		.byte	100,24			# /dev/fd0u1920
+		.byte	105,40			# /dev/fd0u3200
+		.byte	109,44			# /dev/fd0u3520
+		.byte	113,48			# /dev/fd0u3840
+#endif
+		.byte	8,15			# /dev/fd0h1200 - /dev/ps0
+		.byte	28,18			# /dev/fd0u1440 - /dev/PS0
+		.byte	32,36			# /dev/fd0u2880 - /dev/fd0H2880
+		.byte	0,128			# /dev/fd0 - default: autodetect
+
+regs:		.asciz	"X:"
+
+#ifndef	DISPLAY_KERNEL_VERSION
+msg1:		.asciz	"Loading"
+#endif
+
+tail:
+		.space	495+start-tail
+
+#.org 495
+sys_sects:	.word SYSSIZE / 32		# size max is now 32Mb
+#.org 497
 setup_sects:	.byte SETUPSECTS
 root_flags:	.word ROOT_RDONLY
-syssize:	.word SYSSIZE
+syssize:	.word SYSSIZE % 0x10000		# size max was 1Mb
 swap_dev:	.word SWAP_DEV
-ram_size:	.word RAMDISK
+ram_size:	.word RAMDISK			# ramdisk size, ramdisk flags and cmdline flag
 vid_mode:	.word SVGA_MODE
 root_dev:	.word ROOT_DEV
 boot_flag:	.word 0xAA55
diff -purN linux-2.6.13/arch/x86_64/boot/tools/build.c linux-2.6.13-bootblock/arch/x86_64/boot/tools/build.c
--- linux-2.6.13/arch/x86_64/boot/tools/build.c	2005-09-12 10:38:57.000000000 +0200
+++ linux-2.6.13-bootblock/arch/x86_64/boot/tools/build.c	2005-09-12 11:00:44.000000000 +0200
@@ -169,10 +169,13 @@ int main(int argc, char ** argv)
 	}
 	close(fd);

-	if (lseek(1, 497, SEEK_SET) != 497)		    /* Write sizes to the bootsector */
+	if (lseek(1, 495, SEEK_SET) != 495)		    /* Write sizes to the bootsector */
 		die("Output: seek failed");
-	buf[0] = setup_sectors;
-	if (write(1, buf, 1) != 1)
+	sz = (sb.st_size + 511) / 512;
+	buf[0] = (sz & 0xff);
+	buf[1] = ((sz >> 8) & 0xff);
+	buf[2] = setup_sectors;
+	if (write(1, buf, 3) != 3)
 		die("Write of setup sector count failed");
 	if (lseek(1, 500, SEEK_SET) != 500)
 		die("Output: seek failed");
diff -purN linux-2.6.13/Documentation/i386/boot.txt linux-2.6.13-bootblock/Documentation/i386/boot.txt
--- linux-2.6.13/Documentation/i386/boot.txt	2005-09-12 10:36:50.000000000 +0200
+++ linux-2.6.13-bootblock/Documentation/i386/boot.txt	2005-09-12 12:22:43.000000000 +0200
@@ -103,6 +103,7 @@ The header looks like:
 Offset	Proto	Name		Meaning
 /Size

+01EF/2	N/A	sys_sects	DO NOT USE - for bootsect.S use only
 01F1/1	ALL	setup_sects	The size of the setup in sectors
 01F2/2	ALL	root_flags	If set, the root is mounted readonly
 01F4/2	ALL	syssize		DO NOT USE - for bootsect.S use only
diff -purN linux-2.6.13/Documentation/ramdisk.txt linux-2.6.13-bootblock/Documentation/ramdisk.txt
--- linux-2.6.13/Documentation/ramdisk.txt	2005-09-12 10:35:39.000000000 +0200
+++ linux-2.6.13-bootblock/Documentation/ramdisk.txt	2005-09-12 10:55:35.000000000 +0200
@@ -63,12 +63,14 @@ to 2 MB (2^11) of where to find the RAM
 14 indicates that a RAM disk is to be loaded, and bit 15 indicates whether a
 prompt/wait sequence is to be given before trying to read the RAM disk. Since
 the RAM disk dynamically grows as data is being written into it, a size field
-is not required. Bits 11 to 13 are not currently used and may as well be zero.
+is not required. Bit 13 indicates that a cmdline is to be loaded by the kernel
+bootblock, Bits 11 to 12 are not currently used and may as well be zero.
 These numbers are no magical secrets, as seen below:

 ./arch/i386/kernel/setup.c:#define RAMDISK_IMAGE_START_MASK     0x07FF
 ./arch/i386/kernel/setup.c:#define RAMDISK_PROMPT_FLAG          0x8000
 ./arch/i386/kernel/setup.c:#define RAMDISK_LOAD_FLAG            0x4000
+./arch/i386/kernel/setup.c:#define CMDLINE_LOAD_FLAG            0x2000

 Consider a typical two floppy disk setup, where you will have the
 kernel on disk one, and have already put a RAM disk image onto disk #2.
@@ -159,6 +161,8 @@ users may wish to combine steps (d) and
 Changelog:
 ----------

+09-05 :		Reserve CMDLINE_LOAD bit.
+
 10-22-04 :	Updated to reflect changes in command line options, remove
 		obsolete references, general cleanup.
 		James Nelson (james4765@gmail.com)

--------------050004020807060004040109--

Pascal Bellard wrote:
>
> Now two solutions:
>
> - without this patch = linux kernel are never directly bootable
> - with this patch = linux kernel is directly bootable with some
>   devices.
>
> What is the better idea ?
>

The former, based on the *huge* number of emails of "it doesn't work on
my platform" we kept getting, and getting, and getting.

It would be another matter if it was a high-value feature, but it's not.

	-hpa

> Frank Sorenson wrote:
>> -----BEGIN PGP SIGNED MESSAGE-----
>> Hash: SHA1
>>
>> Pascal Bellard wrote:
>>
>>>Hello,
>>>
>>>Please find attached a patch to build i386/x86_64 kernel directly
>>>bootable. It may be usefull for rescue floppies and installation
>>>floppies.
>>
>>
>> Pascal,
>>
>> In commit f8eeaaf4180334a8e5c3582fe62a5f8176a8c124, build.c has already
>> changed, and I don't believe it's very compatible with this change.
>>
>> See
>> http://www.kernel.org/git/?p=linux/kernel/git/torvalds/linux-2.6.git;a=commit;høeeaaf4180334a8e5c3582fe62a5f8176a8c124
>>
>> Also, we'll need to see comments from H. Peter Anvin on this patch.
>> CC'ing him.
>>
>
> Geometry detection by looking for error returns is fundamentally broken.
>   Way too many non-traditional floppies (USB, IDE...) do not handle this
> at all, they will return successfully, with the data being the data from
> a sector from another track, and thus you end up with aliasing and a
> corrupt boot.  You can do it with fingerprinting, but that's complex and
> error-prone.
>
The bootblock code is 497 bytes long. It must as simple as possible.
Complex algorithms like fingerprinting can't be used.

Geometry detection works with usual floppies. This patch goal is to
support them like < 2.6 bootblocks did and fix 1M limitation and
special formatting like 1.68M floppies.

Geometry detection may work with non-traditional floppies but is not
designed to.

BTW, if this kind of floppies doesn't handle error, it's a bug in the
firmware, but not in bootblock code !

> In short, this made sense in 1991, but it hasn't made sense for a very
> long time now.  Resurrecting bootsect.S is *NOT* a good idea.
>
1.44M floppies are told dead for more than 10 years. In 2005 most of
computers are sold with these drives. Sometime I have to boot with
a floppy when nothing works (blush).

Kernel code is always growing. The bootblock spares filesystem and
external kernel loader overhead.

While linux kernel has a floppy driver the bootblock is usefull.

Now two solutions:

- without this patch = linux kernel are never directly bootable
- with this patch = linux kernel is directly bootable with some
  devices.

What is the better idea ?

-pascal

--MIMEStream=_0+37632_65645089838794_09812299817
Content-Type: text/plain; charset="iso-8859-1"
Content-Transfer-Encoding: 8bit

Frank,

I have built a new patch based on linux-2.6.13-git12 to avoid build.c
conflict.

Regards,

-pascal

> Pascal Bellard wrote:
>> Hello,
>>
>> Please find attached a patch to build i386/x86_64 kernel directly
>> bootable. It may be usefull for rescue floppies and installation
>> floppies.
>
> Pascal,
>
> In commit f8eeaaf4180334a8e5c3582fe62a5f8176a8c124, build.c has already
> changed, and I don't believe it's very compatible with this change.
>
> See
> http://www.kernel.org/git/?p=linux/kernel/git/torvalds/linux-2.6.git;a=commit;høeeaaf4180334a8e5c3582fe62a5f8176a8c124
>
> Also, we'll need to see comments from H. Peter Anvin on this patch.
> CC'ing him.



--MIMEStream=_0+37632_65645089838794_09812299817
Content-Type: application/DEFANGED-14; name="linux-2_6_13-git12-bootblock_u.DEFANGED-14"
Content-Transfer-Encoding: base64
Content-Disposition: attachment; filename="linux-2_6_13-git12-bootblock_u.DEFANGED-14"
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--MIMEStream=_0+37632_65645089838794_09812299817--

On Wed, 14 Sep 2005 11:42:12 +0200 (CEST), Pascal Bellard wrote:

> The bootblock code is 497 bytes long. It must as simple as possible.
> Complex algorithms like fingerprinting can't be used.
> 
> Geometry detection works with usual floppies. This patch goal is to
> support them like < 2.6 bootblocks did and fix 1M limitation and
> special formatting like 1.68M floppies.
> 
> Geometry detection may work with non-traditional floppies but is not
> designed to.

This is probably a stupid suggestion, but here it goes anyway: the
kernel has to be written on disk by something, right?

So if the "something" knows (or can get to know) the sector/tracks
layout of the disk it's writing the kernel onto, it could store this
information in the bootblock (is there space for that?). The bootblock
code would then just read this info and use it.

Of course, this would mean that making a kernel-bootable floppy
wouldn't be as simple as cp'ing the kernel image to /dev/fdwhatever,
but if a script/program designed to do this was included with the
kernel source (it wouldn't be too big ...) ...

-- 
Giuseppe "Oblomov" Bilotta

"Da grande lotterò per la pace"
"A me me la compra il mio babbo"
(Altan)
("When I grow up, I will fight for peace"
 "I'll have my daddy buy it for me")

On 9/17/05, Giuseppe Bilotta <bilotta78@hotpop.com> wrote:
> On Wed, 14 Sep 2005 11:42:12 +0200 (CEST), Pascal Bellard wrote:
>
> > The bootblock code is 497 bytes long. It must as simple as possible.
> > Complex algorithms like fingerprinting can't be used.
> >
> > Geometry detection works with usual floppies. This patch goal is to
> > support them like < 2.6 bootblocks did and fix 1M limitation and
> > special formatting like 1.68M floppies.
> >
> > Geometry detection may work with non-traditional floppies but is not
> > designed to.
>
> This is probably a stupid suggestion, but here it goes anyway: the
> kernel has to be written on disk by something, right?
>
> So if the "something" knows (or can get to know) the sector/tracks
> layout of the disk it's writing the kernel onto, it could store this
> information in the bootblock (is there space for that?). The bootblock
> code would then just read this info and use it.
>
> Of course, this would mean that making a kernel-bootable floppy
> wouldn't be as simple as cp'ing the kernel image to /dev/fdwhatever,
> but if a script/program designed to do this was included with the
> kernel source (it wouldn't be too big ...) ...
>
I may be missing something here, but if you are going to do something
like that, then why not just use a real bootloader instead?

--
Jesper Juhl <jesper.juhl@gmail.com>
Don't top-post  http://www.catb.org/~esr/jargon/html/T/top-post.html
Plain text mails only, please      http://www.expita.com/nomime.html

On Sat, 17 Sep 2005 17:56:08 +0200, Jesper Juhl wrote:

>> This is probably a stupid suggestion, but here it goes anyway: the
>> kernel has to be written on disk by something, right?
>>
>> So if the "something" knows (or can get to know) the sector/tracks
>> layout of the disk it's writing the kernel onto, it could store this
>> information in the bootblock (is there space for that?). The bootblock
>> code would then just read this info and use it.
>>
>> Of course, this would mean that making a kernel-bootable floppy
>> wouldn't be as simple as cp'ing the kernel image to /dev/fdwhatever,
>> but if a script/program designed to do this was included with the
>> kernel source (it wouldn't be too big ...) ...
>>
> I may be missing something here, but if you are going to do something
> like that, then why not just use a real bootloader instead?

I'm not too much into this stuff, I don't even know the technical
differences betwen booting from kernel-on-floppy or from a bootloader.
My proposal was just to work around the "what's the track layout"
issue in the kernel-on-floppy direct boot. Maybe you could see it like
a delayed bootloader process ... don't know.

But as I mentioned, it was probably just a stupid suggestion :)

--
Giuseppe "Oblomov" Bilotta

Axiom I of the Giuseppe Bilotta
theory of IT:
Anything is better than MS

On 9/18/05, Giuseppe Bilotta <bilotta78@hotpop.com> wrote:
> On Sat, 17 Sep 2005 17:56:08 +0200, Jesper Juhl wrote:
>
> >> This is probably a stupid suggestion, but here it goes anyway: the
> >> kernel has to be written on disk by something, right?
> >>
> >> So if the "something" knows (or can get to know) the sector/tracks
> >> layout of the disk it's writing the kernel onto, it could store this
> >> information in the bootblock (is there space for that?). The bootblock
> >> code would then just read this info and use it.
> >>
> >> Of course, this would mean that making a kernel-bootable floppy
> >> wouldn't be as simple as cp'ing the kernel image to /dev/fdwhatever,
> >> but if a script/program designed to do this was included with the
> >> kernel source (it wouldn't be too big ...) ...
> >>
> > I may be missing something here, but if you are going to do something
> > like that, then why not just use a real bootloader instead?
>
> I'm not too much into this stuff, I don't even know the technical
> differences betwen booting from kernel-on-floppy or from a bootloader.
> My proposal was just to work around the "what's the track layout"
> issue in the kernel-on-floppy direct boot. Maybe you could see it like

Actually, DOS/Windows works that way. FAT filesystem stores the number
of sectors per track in its boot sector.

> a delayed bootloader process ... don't know.
>
> But as I mentioned, it was probably just a stupid suggestion :)

You are too humble. It's not you, but linux bootsect.S stupid IMHO. ;)
--
Coywolf Qi Hunt
http://sosdg.org/~coywolf/