0.00-050613_head.s

 #  head.s contains the -bit startup code.
 #  Two L3 task multitasking. The code of tasks are in kernel area,
 #  just like the Linux. The kernel code is located at 0x10000.
 SCRN_SEL    = 0x18
 TSS0_SEL    = 0x20
 LDT0_SEL    = 0x28
 TSS1_SEL    = 0X30
 LDT1_SEL    = 0x38

 .text
 startup_32:
     movl $0x10,%eax
     mov %ax,%ds
 #    mov %ax,%es
     lss init_stack,%esp

 # setup base fields of descriptors.
     call setup_idt
     call setup_gdt
     movl $0x10,%eax        # reload all the segment registers
     mov %ax,%ds        # after changing gdt.
     mov %ax,%es
     mov %ax,%fs
     mov %ax,%gs
     lss init_stack,%esp

 # setup up timer  chip.
     movb $0x36, %al
     movl $0x43, %edx
     outb %al, %dx
     movl $, %eax        # timer frequency  HZ
     movl $0x40, %edx
     outb %al, %dx
     movb %ah, %al
     outb %al, %dx

 # setup timer & system call interrupt descriptors.
     movl $0x00080000, %eax
     movw $timer_interrupt, %ax
     movw $0x8E00, %dx
     movl $0x08, %ecx              # The PC default timer int.
     lea idt(,%ecx,), %esi
     movl %eax,(%esi)
     movl %edx,(%esi)
     movw $system_interrupt, %ax
     movw $0xef00, %dx
     movl $0x80, %ecx
     lea idt(,%ecx,), %esi
     movl %eax,(%esi)
     movl %edx,(%esi)

 # unmask the timer interrupt.
 #    movl $0x21, %edx
 #    inb %dx, %al
 #    andb $0xfe, %al
 #    outb %al, %dx

 # Move to user mode (task )
     pushfl
     andl $0xffffbfff, (%esp)
     popfl
     movl $TSS0_SEL, %eax
     ltr %ax
     movl $LDT0_SEL, %eax
     lldt %ax
     movl $, current
     sti
     pushl $0x17
     pushl $init_stack
     pushfl
     pushl $0x0f
     pushl $task0
     iret

 /****************************************/
 setup_gdt:
     lgdt lgdt_opcode
     ret

 setup_idt:
     lea ignore_int,%edx
     movl $0x00080000,%eax
     movw %dx,%ax        /* selector = 0x0008 = cs */
     movw $0x8E00,%dx    /* interrupt gate - dpl=, present */
     lea idt,%edi
     mov $,%ecx
 rp_sidt:
     movl %eax,(%edi)
     movl %edx,(%edi)
     addl $,%edi
     dec %ecx
     jne rp_sidt
     lidt lidt_opcode
     ret

 # -----------------------------------
 write_char:
     push %gs
     pushl %ebx
 #    pushl %eax
     mov $SCRN_SEL, %ebx
     mov %bx, %gs
     movl scr_loc, %bx
     shl $, %ebx
     movb %al, %gs:(%ebx)
     shr $, %ebx
     incl %ebx
     cmpl $, %ebx
     jb 1f
     movl $, %ebx
 :    movl %ebx, scr_loc
 #    popl %eax
     popl %ebx
     pop %gs
     ret

 /***********************************************/
 /* This is the default interrupt "handler" :-) */
 .align
 ignore_int:
     push %ds
     pushl %eax
     movl $0x10, %eax
     mov %ax, %ds
     movl $, %eax            /* print 'C' */
     call write_char
     popl %eax
     pop %ds
     iret

 /* Timer interrupt handler */
 .align
 timer_interrupt:
     push %ds
     pushl %eax
     movl $0x10, %eax
     mov %ax, %ds
     movb $0x20, %al
     outb %al, $0x20
     movl $, %eax
     cmpl %eax, current
     je 1f
     movl %eax, current
     ljmp $TSS1_SEL, $
     jmp 2f
 :    movl $, current
     ljmp $TSS0_SEL, $
 :    popl %eax
     pop %ds
     iret

 /* system call handler */
 .align
 system_interrupt:
     push %ds
     pushl %edx
     pushl %ecx
     pushl %ebx
     pushl %eax
     movl $0x10, %edx
     mov %dx, %ds
     call write_char
     popl %eax
     popl %ebx
     popl %ecx
     popl %edx
     pop %ds
     iret

 /*********************************************/
 current:.long
 scr_loc:.long 

 .align
 lidt_opcode:
     .word *-        # idt contains  entries
     .long idt        # This will be rewrite by code.
 lgdt_opcode:
     .word (end_gdt-gdt)-    # so does gdt
     .long gdt        # This will be rewrite by code.

     .align
 idt:    .fill ,,        # idt is uninitialized

 gdt:    .quad 0x0000000000000000    /* NULL descriptor */
     .quad 0x00c09a00000007ff    /* 8Mb 0x08, base = 0x00000 */
     .quad 0x00c09200000007ff    /* 8Mb 0x10 */
     .quad 0x00c0920b80000002    /* screen 0x18 - for display */

     .word 0x0068, tss0, 0xe900, 0x0    # TSS0 descr 0x20
     .word 0x0040, ldt0, 0xe200, 0x0    # LDT0 descr 0x28
     .word 0x0068, tss1, 0xe900, 0x0    # TSS1 descr 0x30
     .word 0x0040, ldt1, 0xe200, 0x0    # LDT1 descr 0x38
 end_gdt:
     .fill ,,
 init_stack:                          # Will be used as user stack for task0.
     .long init_stack
     .word 0x10

 /*************************************/
 .align
 ldt0:    .quad 0x0000000000000000
     .quad 0x00c0fa00000003ff    # 0x0f, base = 0x00000
     .quad 0x00c0f200000003ff    # 0x17

 tss0:    .long              /* back link */
     .long krn_stk0, 0x10        /* esp0, ss0 */
     .long , , , ,         /* esp1, ss1, esp2, ss2, cr3 */
     .long , , , ,         /* eip, eflags, eax, ecx, edx */
     .long , , , ,         /* ebx esp, ebp, esi, edi */
     .long , , , , ,          /* es, cs, ss, ds, fs, gs */
     .long LDT0_SEL, 0x8000000    /* ldt, trace bitmap */

     .fill ,,
 krn_stk0:
 #    .long 

 /************************************/
 .align
 ldt1:    .quad 0x0000000000000000
     .quad 0x00c0fa00000003ff    # 0x0f, base = 0x00000
     .quad 0x00c0f200000003ff    # 0x17

 tss1:    .long              /* back link */
     .long krn_stk1, 0x10        /* esp0, ss0 */
     .long , , , ,         /* esp1, ss1, esp2, ss2, cr3 */
     .long task1, 0x200        /* eip, eflags */
     .long , , ,         /* eax, ecx, edx, ebx */
     .long usr_stk1, , ,         /* esp, ebp, esi, edi */
     .long 0x17,0x0f,0x17,0x17,0x17,0x17 /* es, cs, ss, ds, fs, gs */
     .long LDT1_SEL, 0x8000000    /* ldt, trace bitmap */

     .fill ,,
 krn_stk1:

 /************************************/
 task0:
     movl $0x17, %eax
     movw %ax, %ds
     movl $, %al              /* print 'A' */
     int $0x80
     movl $0xfff, %ecx
 :    loop 1b
     jmp task0 

 task1:
     movl $0x17, %eax
     movw %ax, %ds
     movl $, %al              /* print 'B' */
     int $0x80
     movl $0xfff, %ecx
 :    loop 1b
     jmp task1

     .fill ,,
 usr_stk1:

C