？21，
#  head.s contains the 32-bit startup code.
#  head.s 是32位的启动代码

#  Two L3 task multitasking. The code of tasks are in kernel area,
# 有两个L3（Level 3，即第三特权级，IA32提供给用户0-3，四个特权级，但是Linux0.11只使用了
# 0和3这两个特权级，表示用户态程序和内核态程序，内核-kernel）的多任务

#  just like the Linux. The kernel code is located at 0x10000.
# ……内核代码在0x10000，在boot.s中已经确定了呦~

#大家可能发现boot.s和head.s的代码有一点点不一样，这是因为boot.s使用的是as86汇编器
#而head.s使用的是GNU as汇编器，具体表现在
#    1~movl等操作的出现：当然还是mov的意思，l表示双字，w表示单字，b表示字节
#    2~movl等操作的源操作数和目的操作数位置，源在前而目的在后，与boot.s中的mov操作是相反的
#    3~立即数前必须加$,寄存器前必须加%
#    4~待续

.code32
# CODE32伪指令通知编译器，其后的指令序列为 32 位的 ARM 指令
SCRN_SEL    = 0x18
TSS0_SEL    = 0x20
LDT0_SEL    = 0x28
TSS1_SEL    = 0X30
LDT1_SEL    = 0x38

.global startup_32
.text
#.text表示文本段，通常包含可执行代码
startup_32:
    movl $0x10,%eax
    mov %ax,%ds
    # 将0x0010赋给ds
#    mov %ax,%es
    # 将0x0010赋给es，可是为啥被注释掉了呢……
    lss init_stack,%esp
    # lss mem,reg（ mem低字->reg，mem高字->ss），这句的意思就是指让ss:esp指向init_stack
    # 我们不妨去看看init_stack到底存了一些什么东西：
    #    .long init_stack 表示了init_stack这个数据的地址
    #    .word 0x10 给ss赋值了
# 那么现在问题来了0x10是什么，是段选择符：0x10000，右移三位后正好选定gdt中的第2项。内核数据段。
# setup base fields of descriptors.
# 装载基本的域和描述符
    call setup_idt
        # 跳转到setup_idt去执行，请直接去setup_idt那里看后续注释
        # 普及一下call 和 jmp 两条指令的差别吧，call相当于这三条指令的连续作用“push cs”，“push eip” 和“jmp XXX”
        # 所以由call跳转过去执行的代码最后一定要用ret的方式回来
    call setup_gdt
        # 好的，我们回到这里了！
        # idt设置完了，我们去设置gdt，显然我们也要类比一下idt的设置方法来讨论gdt的设置方法
        # 我们猜测gdt需要做这几件事：1~ 填满gdt，2~ 构建gdtr应该有的值，然后一个lgdt指令，完事儿！
        # 好，我们进入setup_idt看看
    movl $0x10,%eax        # reload all the segment registers
        # 在改变gdt后，重新设置全部的段寄存器
    mov %ax,%ds        # after changing gdt.
    mov %ax,%es
    mov %ax,%fs
    mov %ax,%gs
    lss init_stack,%esp   
        # 把初始栈地址放给 ss:esp

# setup up timer 8253 chip.
    # 设置8253芯片，这个芯片具体的工作原理请看这里：http://baike.baidu.com/view/1684875.htm
    # 这个芯片就像我们小学期设计的CPU里的那个节拍发生器
    # 这一段的作用是让8253芯片每隔10ms就向CPU发送一个时钟中断请求
    movb $0x36, %al
    movl $0x43, %edx
    outb %al, %dx
    # 向%dx所示端口输出一个字节（b），值为%al中数据
    movl $11930, %eax        # timer frequency 100 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
        # 这两条指令就把 %eax设置成了 0x0008~timer_interrupt（请把“~”看成是地址的链接符……）的地址，
        # 还是代码段中偏移为timer_interrupt的地方
        # 但是究竟0x0008和0x0010有什么区别呢？
        # 显然我们知道0x0008和0x0010分别是代码段和数据段的段选择符，可是代码段和数据段分别在哪里？
        # 去gdt看看，跳到gdt去~
        # ok可以回来了！现在我们继续，去看看timer_interrupt是干什么的？
    movw $0x8E00, %dx
        # 将%dx置为0x8E00
    movl $0x08, %ecx              # The PC default timer int.
        # 将%ecx置为0x08，Linus注释说是PC的默认时钟中断
        # 还不清楚是啥意思……等一会再看……
    lea idt(,%ecx,8), %esi
        # 这条指令是什么意思呢，是将%ecx*8+idt的地址放入%esi中去
    movl %eax,(%esi)
        # 再把%eax的值放入%esi所指的内存区域
        # %eax里面是什么呢？是0x0008~timer_interrupt的地址
    movl %edx,4(%esi)
        # 把%edx放在这个中断描述符的高八位
    movw $system_interrupt, %ax
        # 设置完了时钟中断之后，我们再去设置系统中断
    movw $0xef00, %dx
    movl $0x80, %ecx
        # 0x80是什么！？系统调用的中断号……
    lea idt(,%ecx,8), %esi
    movl %eax,(%esi)
    movl %edx,4(%esi)
        # 上面的几个步骤跟设置时钟中断的方式是一样的

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

# Move to user mode (task 0)
    # 然后就要跳转到用户态去执行了
    pushfl
        # pushfl是push flags long的简写，将标志寄存器压栈，双字四字节
    andl $0xffffbfff, (%esp)
        # 1111111111111111 1011 1111 1111 1111
        # andl指令专门用来清零特定的位
        # 这里它的用处我猜不透啊……在完全剖析那本书上也没写……
    popfl
        # 然后又pop了标志位，难道andl操作会改变标志位？
    movl $TSS0_SEL, %eax
        # $TSS0_SEL是在一开始就设定好的，它的值是0x20
    ltr %ax
        # ltr--load task register，装载任务寄存器
        # 那么现在是装载了任务0的，段选择符0x20，右移三位变成二进制的100，表示gdt表的第4项
    movl $LDT0_SEL, %eax
        # 想执行任务0，除了要设置tr以外还要设置ldt
    lldt %ax
        # 好的，这里就设置完成了。
    movl $0, current
        # 把一个叫做current的变量设置成0
    sti
        # 在head.s中关闭的中断终于可以打开了
        # 现在栈里有什么？什么都没有。
    pushl $0x17
    pushl $init_stack
    pushfl
    pushl $0x0f
    pushl $task0
        # 好，这里我们在栈中push了很多东西，分别来看一看
        # 栈顶项 $task0的地址
        # 第二项 0x0f（这是什么？）
        # 第三项 全部标志寄存器
        # 第四项 初始栈的地址
        # 第五项 0x17（这又是什么？）
    iret
        # 借鉴一个网上的博客对这个指令的解释，他先引用了IA32手册上对IRET指令的解释:
            # the IRET instruction pops the return instruction pointer, return code segment selector,
            # 译：IRET指令一一对应地弹出IP指令指针和CS代码段选择符
            # and EFLAGS image from the stack to the EIP, CS, and EFLAGS registers, respectively,
            # 译：以及EFLAGS的值到EIP，CS和EFLAGS寄存器中
            # and then resumes execution of the interrupted program or procedure.
            # 译：然后继续执行中断的程序
            # If the return is to another privilege level, the IRET instruction also pops the stack pointer and SS from the stack,
            # 译：如果返回到另一个特权级，那么这个指令再继续执行前还要弹出栈指针和SS寄存器
            # before resuming program execution.
        # 显然，这里要转换特权级，就要弹出五项，一一对应
        # EIP -> $task0的地址
        # CS -> 0x0f (00001111)，特权级3的ldt的第一项，任务0
        # EFLAGS -> EFLAGS 这个不用变
        # ESP -> $init_stack的地址
        # SS -> 0x17 (00010111)，特权级3的ldt的第二项，数据段，也做堆栈段的选择符
        # 到这里，就跳到任务0去执行了……我们直接去任务0！
/****************************************/
setup_gdt:
    # 惊呆了有木有，好短啊……然后我们看看这个lgdt_opcode可能会提供给我们什么信息！
    # 我们刚刚的猜测第二步已经有了，lgdt指令就在这里。我们还是先猜测lgdt_opcode里有啥？
    # 无非就是长度，基址呗~ 去看看。
    lgdt lgdt_opcode
    ret

setup_idt:
    lea ignore_int,%edx
        # lea：load effective address，将变量的地址从内存中取出并放入寄存器
    movl $0x00080000,%eax
    movw %dx,%ax        /* selector = 0x0008 = cs */
        #将%eax设置为0x0008-ignore_int地址
    movw $0x8E00,%dx    /* interrupt gate - dpl=0, present */
        #中断门类型，dpl设置为0
    lea idt,%edi
        # 将idt的地址存入%edi中去
    mov $256,%ecx
        # %ecx通常在程序中充当循环语句执行次数计数器的角色，
        # 比如 loop指令和rep指令每次执行时都要%ecx减一，%ecx为零时停止循环
        # 所以当遇到%ecx时，可以考虑它是不是又来当循环计数器了，结果在dec那一句可以看到
rp_sidt:
    movl %eax,(%edi)
        # 将%edi地址中的数据改为%eax中的数据，就是这个ignore_int代码标记的地址，
        # 也就是每一个idt项的低四位
    movl %edx,4(%edi)
        # 首先说一下4(%edi)的意思是[%edi+4]这个内存地址里的数据，
        # 其次，这表示与上面同一个idt描述项的高四位。
        # 这一通循环的目的是把256个idt描述项都设置成一样的，即都是由ignore_int来处理。
        # 剧透，怎么处理？看名字可以知道：ignore_int——通过ignore的方式来处理……
    addl $8,%edi
        # 然后%edi加8，进入下一个idt描述符表去修改
    dec %ecx
        # 每执行一次都要修改%ecx，dec的意思是%ecx减一
    jne rp_sidt
        # %ecx 若不为零，则跳回rp_sidt继续执行，rp_sidt（repeat setup idt）
    lidt lidt_opcode
        # 当256项都执行完了，所有中断处理程序全部指向ignore_int了之后，高高兴兴地把lidt_opcode置成idtr
        # lidt_opcode把长度啊，基地址啥的都设好了
    ret
        # 执行完了这一通，可以回去了到call setup_idt这条之后的那一条去执行了
        # 那么回去之前，我们考虑一下究竟这个setup_idt都做了些什么呢？
        # 1~ 256个entries的表统统都填写上了这个ignore_int的处理函数
        # 2~ 把lidt_opcode置给了idtr，然后高高兴兴地ret了……

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

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

/* Timer interrupt handler */
.align 2
timer_interrupt:
    push %ds
    pushl %eax
    movl $0x10, %eax
    mov %ax, %ds
        # 将%ds设置为0x10
    movb $0x20, %al
        # 将%al设置为0x20
    outb %al, $0x20
    movl $1, %eax
        # 将%eax置为1
    cmpl %eax, current
        # 将current与%eax进行比较，如果相等则跳转到1去执行
    je 1f
    movl %eax, current
        # 若不相等，证明目前current为0，那么就去跳转到TSS0那里去执行
    ljmp $TSS1_SEL, $0
    jmp 2f
1:    movl $0, current
        #在这里将current设置为0
    ljmp $TSS0_SEL, $0
        # ljmp的意思是跳转到段选择子，段内偏移
        # jmpi的意思是跳转到段内偏移，段选择子
        # 这里的意思是跳转到TSS0那里去执行
2:    popl %eax
    pop %ds
        # 最后无论如何都会pop，完事儿~
    iret
        # 这里才是真的完事儿了~
        # 用一个最可爱的IRET指令标志注释的结束，再见观众朋友们~

/* system call handler */
.align 2
system_interrupt:
# 系统中断
    push %ds
    pushl %edx
    pushl %ecx
    pushl %ebx
    pushl %eax
        # 保存寄存器
    movl $0x10, %edx
    mov %dx, %ds
        # 将%ds置0x10
    call write_char
        # 调用这个write_char函数，我们不去分析write_char是干啥的了，
        # 根据名称可知，是写一个字符
    popl %eax
    popl %ebx
    popl %ecx
    popl %edx
    pop %ds
        # 弹出各个寄存器
    iret
        # 中断返回
# 可见，这个系统中断做的事情就是把当前任务对应的字符打印出来，
# task0打印“A”，task1打印“B”
# 但是一开始我们看到的是task0是一个死循环，task1还没有执行过？
# 似乎……只有时钟中断可以让task1得到执行了！

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

.align 2
lidt_opcode:
    .word 256*8-1        # idt contains 256 entries
    .long idt        # This will be rewrite by code.
lgdt_opcode:
    # 长度16位，在这里，end_gdt标签位置减去gdt标签位置再加1。
    .word (end_gdt-gdt)-1    # so does gdt
    # 基址32位，gdt的基址就叫gdt。好，我们去看看写了什么……
    .long gdt        # This will be rewrite by code.

.align 8
    # 这个指令我们汇编课上学过，忘记的去百度一下哦~
idt:    .fill 256,8,0        # idt is uninitialized
# fill伪指令：.fill repeat,size,value 本命令生成size个字节的repeat个副本。
# 各个副本中的内容取自一个8字节长的数。最高4个字节为零，最低的4个字节是value，
# 那么这个指令的意思就是复制256个8字节大小的量，每项都填充成为0
# 看完后面那通代码可知，这里的fill指令纯粹就是为了占位置的，嗯对一定是这样。

gdt:    .quad 0x0000000000000000    /* NULL descriptor */
        # 出现了一个我们没有见过的伪指令，但是它的意思跟 .word是一类的，表示定义一个多长的空间
        # quad是多长呢？联想“quadra kill”……肯定跟四什么什么有关，
        # 再看后面串的长度，可见这个四是四个字的意思。.quad就是规定了后面的八个字节（四个字）的数据的伪指令
    .quad 0x00c09a00000007ff    /* 8Mb 0x08, base = 0x00000 */
        # 这个0x00c09a00000007ff是怎么组成的呢？
        # 显然从左到右是从高到低，我们按照每二位16进制数一拆分
        # 0x  00               c09a            00
        #     基地址的31-24位  一些状态标识位  基地址的23-16位
        #     0000               07ff
        #     基地址的15-0位   段限长，2047个字节
        # 可见这个基地址是0x00000000，与下面这个表项所示一样，说明代码段和数据段是重叠的~
    .quad 0x00c09200000007ff    /* 8Mb 0x10 */
    .quad 0x00c0920b80000002    /* screen 0x18 - for display */
        # 上面一共有四项，gdt第一项还是照例空缺
        # 第四项是显示内存段的描述符，段选择符是0x18……怎么算的就不讲了~
    .word 0x0068, tss0, 0xe900, 0x0    # TSS0 descr 0x20
        # 任务0的TSS段，段选择符0x20
    .word 0x0040, ldt0, 0xe200, 0x0    # LDT0 descr 0x28
        # 任务0的LDT段，段选择符0x28
    .word 0x0068, tss1, 0xe900, 0x0    # TSS1 descr 0x30
        # 任务1的TSS段，段选择符0x30
    .word 0x0040, ldt1, 0xe200, 0x0    # LDT1 descr 0x38
        # 任务1的LDT段，段选择符0x38
end_gdt:
    .fill 128,4,0
        # 哦最后这个是做啥的？
        # 猜~
    # 好的看到这里我们可以回去了，回到call setup_gdt那里！
init_stack:                          # Will be used as user stack for task0.
    .long init_stack
    .word 0x10

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

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

.fill 128,4,0
krn_stk0:
#    .long 0

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

tss1:    .long 0             /* back link */
    .long krn_stk1, 0x10        /* esp0, ss0 */
    .long 0, 0, 0, 0, 0        /* esp1, ss1, esp2, ss2, cr3 */
    .long task1, 0x200        /* eip, eflags */
    .long 0, 0, 0, 0        /* eax, ecx, edx, ebx */
    .long usr_stk1, 0, 0, 0        /* 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 128,4,0
krn_stk1:

/************************************/
task0:
    movl $0x17, %eax
    movw %ax, %ds
        # %ds置为0x17,
    movb $65, %al              /* print 'A' */
        # %al置为ASCII码的65号，“A”
    int $0x80
        # 调用int $0x80，这个中断在之前就已经写好了，
        # 我们可以去看看system_interrupt，这个就是0x80中断的处理程序，
        # 为什么？在上面写了，请好好的找一找~
        # 然后我们就去这个处理程序看看去，我们目前知道的是，ds为0x17，al为65
        #？？？
    movl $0xfff, %ecx
        # 将%ecx改为0xfff，意思是一直执行这个task0，因为loop没执行一次会减ecx的值
1:    loop 1b
        # b和f的意思分别是向前跳转和向后跳转的意思
    jmp task0
# 先在我们只看到task0的工作，那么task1何时工作呢？
# 在前面我们记得时钟中断在每10ms时8253芯片会发送一个时钟中断，
# 我们还没有分析这个时钟中断是做什么的。
task1:
    movl $0x17, %eax
    movw %ax, %ds
    movb $66, %al              /* print 'B' */
    int $0x80
    movl $0xfff, %ecx
1:    loop 1b
    jmp task1
    # 不解释……跟task0差不多……
    .fill 128,4,0
usr_stk1: