linux0.01 boot.s转AT&T语法

/*
 *	boot.s
 *
 * boot.s is loaded at 0x7c00 by the bios-startup routines, and moves itself
 * out of the way to address 0x90000, and jumps there.
 *
 * It then loads the system at 0x10000, using BIOS interrupts. Thereafter
 * it disables all interrupts, moves the system down to 0x0000, changes
 * to protected mode, and calls the start of system. System then must
 * RE-initialize the protected mode in it's own tables, and enable
 * interrupts as needed.
 *
 * NOTE! currently system is at most 8 *65536 bytes long. This should be no
 * problem, even in the future. I want to keep it simple. This 512 kB
 * kernel size should be enough - in fact more would mean we'd have to move
 * not just these start-up routines, but also do something about the cache-
 * memory (block IO devices). The area left over in the lower 640 kB is meant
 * for these. No other memory is assumed to be "physical", ie all memory
 * over 1Mb is demand-paging. All addresses under 1Mb are guaranteed to match
 * their physical addresses.
 *
 * NOTE1 abouve is no longer valid in it's entirety. cache-memory is allocated
 * above the 1Mb mark as well as below. Otherwise it is mainly correct.
 *
 * NOTE 2! The boot disk type must be set at compile-time, by setting
 * the following equ. Having the boot-up procedure hunt for the right
 * disk type is severe brain-damage.
 * The loader has been made as simple as possible (had to, to get it
 * in 512 bytes with the code to move to protected mode), and continuos
 * read errors will result in a unbreakable loop. Reboot by hand. It
 * loads pretty fast by getting whole sectors at a time whenever possible.
 */
.code16
# 1.44Mb disks:
sectors = 18
# 1.2Mb disks:
# sectors = 15
# 720kB disks:
# sectors = 9

.globl  _start, begtext, begdata, begbss, endtext, enddata, endbss
.text
begtext:
.data
begdata:
.bss
begbss:
.text

BOOTSEG = 0x07c0
INITSEG = 0x9000
SYSSEG  = 0x1000			# system loaded at 0x10000 (65536).
ENDSEG	= SYSSEG + SYSSIZE

_start:
	movw	$BOOTSEG,%ax
	movw	%ax,%ds
	movw	$INITSEG,%ax
	movw	%ax,%es
	movw	$256,%cx
	sub	%si,%si
	sub	%di,%di
	rep
	movsw
	ljmp	$INITSEG,$go

go:	movw	%cs,%ax
	movw	%ax,%ds
	movw	%ax,%es
	movw	%ax,%ss
	movw	$0x400,%sp	# arbitrary value >>512

	movb	$0x03,%ah	# read cursor pos
	xorb	%bh,%bh
	int	$0x10
	
	movw	$24,%cx
	movw	$0x0007,%bx	# page 0, attribute 7 (normal)
	movw	$msg1,%bp
	movw	$0x1301,%ax	# write string, move cursor
	int	$0x10

# ok, we've written the message, now
# we want to load the system (at 0x10000)

	movw	$SYSSEG,%ax
	movw	%ax,%es		# segment of 0x010000

	call	read_it
	call	kill_motor

# if the read went well we get current cursor position ans save it for
# posterity.

	mov	$0x03,%ah	# read cursor pos
	xor	%bh,%bh
	int	$0x10		# save it in known place, con_init fetches
	mov	%dx,(510)	# it from 0x90510.
		
# now we want to move to protected mode ...

	cli			# no interrupts allowed !

# first we move the system to it's rightful place

	mov	$0x0000,%ax
	cld			# 'direction'=0, movs moves forward
do_move:
	mov	%ax,%es		# destination segment
	add	$0x1000,%ax
	cmp	$0x9000,%ax
	jz	end_move
	mov	%ax,%ds		# source segment
	sub	%di,%di
	sub	%si,%si
	mov 	$0x8000,%cx
	rep
	movsw
	jmp	do_move

# then we load the segment descriptors

end_move:

	mov	%cs,%ax		# right, forgot this at first. didn't work :-)
	mov	%ax,%ds
	lidt	idt_48		# load idt with 0,0
	lgdt	gdt_48		# load gdt with whatever appropriate

# that was painless, now we enable A20

	call	empty_8042
	mov	$0xD1,%al		# command write
	out	%al,$0x64
	call	empty_8042
	mov	$0xDF,%al		# A20 on
	out	%al,$0x60
	call	empty_8042

# well, that went ok, I hope. Now we have to reprogram the interrupts :-(
# we put them right after the intel-reserved hardware interrupts, at
# int 0x20-0x2F. There they won't mess up anything. Sadly IBM really
# messed this up with the original PC, and they haven't been able to
# rectify it afterwards. Thus the bios puts interrupts at 0x08-0x0f,
# which is used for the internal hardware interrupts as well. We just
# have to reprogram the 8259's, and it isn't fun.

	mov	$0x11,%al		# initialization sequence
	out	%al,$0x20		# send it to 8259A-1
	.word	0x00eb,0x00eb		# jmp $+2, jmp $+2
	out	%al,$0xA0		# and to 8259A-2
	.word	0x00eb,0x00eb
	mov	$0x20,%al		# start of hardware int's (0x20)
	out	%al,$0x21
	.word	0x00eb,0x00eb
	mov	$0x28,%al		# start of hardware int's 2 (0x28)
	out	%al,$0xA1
	.word	0x00eb,0x00eb
	mov	$0x04,%al		# 8259-1 is master
	out	%al,$0x21
	.word	0x00eb,0x00eb
	mov	$0x02,%al		# 8259-2 is slave
	out	%al,$0xA1
	.word	0x00eb,0x00eb
	mov	$0x01,%al		# 8086 mode for both
	out	%al,$0x21
	.word	0x00eb,0x00eb
	out	%al,$0xA1
	.word	0x00eb,0x00eb
	mov	$0xFF,%al		# mask off all interrupts for now
	out	%al,$0x21
	.word	0x00eb,0x00eb
	out	%al,$0xA1

# well, that certainly wasn't fun :-(. Hopefully it works, and we don't
# need no steenking BIOS anyway (except for the initial loading :-).
# The BIOS-routine wants lots of unnecessary data, and it's less
# "interesting" anyway. This is how REAL programmers do it.
#
# Well, now's the time to actually move into protected mode. To make
# things as simple as possible, we do no register set-up or anything,
# we let the gnu-compiled 32-bit programs do that. We just jump to
# absolute address 0x00000, in 32-bit protected mode.

	mov	$0x0001,%ax	# protected mode (PE) bit
	lmsw	%ax		# This is it!
	###jmpi	0,8		# jmp offset 0 of segment 8 (cs)
	ljmp	$8,$0



# This routine checks that the keyboard command queue is empty
# No timeout is used - if this hangs there is something wrong with
# the machine, and we probably couldn't proceed anyway.
empty_8042:
	.word	0x00eb,0x00eb
	in	$0x64,%al	# 8042 status port
	test	$2,%al		# is input buffer full?
	jnz	empty_8042	# yes - loop
	ret

# This routine loads the system at address 0x10000, making sure
# no 64kB boundaries are crossed. We try to load it as fast as
# possible, loading whole tracks whenever we can.
#
# in:	es - starting address segment (normally 0x1000)
#
# This routine has to be recompiled to fit another drive type,
# just change the "sectors" variable at the start of the file
# (originally 18, for a 1.44Mb drive)
#
sread:	.word 1			# sectors read of current track
head:	.word 0			# current head
track:	.word 0			# current track
read_it:
	mov %es,%ax
	test $0x0fff,%ax
die:	jne die			# es must be at 64kB boundary
	xor %bx,%bx		# bx is starting address within segment
rp_read:
	mov %es,%ax
	cmp $ENDSEG,%ax		# have we loaded all yet?
	jb ok1_read
	ret
ok1_read:
	mov $sectors,%ax
	sub sread,%ax
	mov %ax,%cx
	shl $9,%cx
	add %bx,%cx
	jnc ok2_read
	je ok2_read
	xor %ax,%ax
	sub %bx,%ax
	shr $9,%ax
ok2_read:
	call read_track
	mov %ax,%cx
	add sread,%ax
	cmp $sectors,%ax
	jne ok3_read
	mov $1,%ax
	sub head,%ax
	jne ok4_read
	###inc track
	push %bx
	mov track,%bx
	inc %bx
	mov %bx,track
	pop %bx
ok4_read:
	mov %ax,head
	xor %ax,%ax
ok3_read:
	mov %ax,sread
	shl $9,%cx
	add %cx,%bx
	jnc rp_read
	mov %es,%ax
	add $0x1000,%ax
	mov %ax,%es
	xor %bx,%bx
	jmp rp_read

read_track:
	push %ax
	push %bx
	push %cx
	push %dx
	mov track,%dx
	mov sread,%cx
	inc %cx
	mov %dl,%ch
	mov head,%dx
	mov %dl,%dh
	mov $0,%dl
	and $0x0100,%dx
	mov $2,%ah
	int $0x13
	jc bad_rt
	pop %dx
	pop %cx
	pop %bx
	pop %ax
	ret
bad_rt:	mov $0,%ax
	mov $0,%dx
	int $0x13
	pop %dx
	pop %cx
	pop %bx
	pop %ax
	jmp read_track

/*
 * 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.
 */
kill_motor:
	push %dx
	mov $0x3f2,%dx
	mov $0,%al
	out %al,%dx
	pop %dx
	ret

gdt:
	.word	0,0,0,0		# dummy

	.word	0x07FF		# 8Mb - limit=2047 (2048*4096=8Mb)
	.word	0x0000		# base address=0
	.word	0x9A00		# code read/exec
	.word	0x00C0		# granularity=4096, 386

	.word	0x07FF		# 8Mb - limit=2047 (2048*4096=8Mb)
	.word	0x0000		# base address=0
	.word	0x9200		# data read/write
	.word	0x00C0		# granularity=4096, 386

idt_48:
	.word	0			# idt limit=0
	.word	0,0			# idt base=0L

gdt_48:
	.word	0x800		# gdt limit=2048, 256 GDT entries
	.word	gdt,0x9		# gdt base = 0X9xxxx
	
msg1:
	.byte 13,10
	.ascii "Loading system ..."
	.byte 13,10,13,10

.org 510
.word 0xAA55

.text
endtext:
.data
enddata:
.bss
endbss:

编译：

as  boot.s -o boot.o
ld  boot.o -o boot.bin --oformat binary -Ttext 0x0

测试：

dd if=/dev/zero of=a.img bs=1024 count=1440
dd if=./boot.bin of=./a.img bs=512 conv=notrunc
dd if=./system of=./a.img seek=1 skip=2 bs=512 conv=notrunc

bochs设置a.img为启动盘