系统的简单注解



该文件包括了系统进程的创建、用户进程的安装、进程控制块链表的控制（运行链表、休眠链表）、进程窗口的绘制、硬盘扇区的读取。

 

Set_TSS_sel：安装TSS段；

Set_LDT_sel：安装LDT段；

Load_core_task：创建系统进程（权限0）；

Load_usr_task：创建用户进程（权限3）；

mount_task_running_que：将进程结构安装到运行队列中；

mount_task_run_to_pend_que：将进程结构从运行队列放入暂停队列；

mount_task_pend_to_run_que：将进程结构从暂停队列放入运行队列；

switch_task2：轮转切换当前执行的进程；

wakeup_task：检查进程休眠时间是否到时，并唤醒；

draw_task_window：绘制用户进程窗口；

read_hard_disk_0：从硬盘读取一个逻辑扇区；

 

代码中的SYS_PROC、USR1_PROC、USR2_PROC分别保存了系统进程、用户进程1、用户进程2的控制块。

;===============================================================================
;=== 本程序包括了进程管理的主要功能：                                        ===
;=== 1.进程结构初始化                                                        ===
;=== 2.进程的安装、启动、唤醒、睡眠                                          ===
;===============================================================================

;-------------------------------------------------------------------------------
Set_TSS_sel:                              ;安装TSS段
                                          ;输入参数: eax-—TSS段基地址
                                          ;输出参数: cx—-gdt中的选择子
 
     push edx                              ;保存edx

     xor ecx, ecx                          ;ecx清零
     sgdt [pgdt]                           ;获取gdt表长度和基址
     mov cx, word [pgdt]                   ;段界限
     mov edx, dword [pgdt+2]               ;段基址
     inc cx                                ;gdt表长度
     add edx, ecx                          ;安装地址       
     mov word [edx], 103                   ;TSS段长度的低16位
     mov word [edx+2], ax                  ;TSS段基址的低16位
     shr eax, 16                           ;TSS段基址右移16位
     mov byte [edx+4], al                  ;TSS段基址的中8位
     mov byte [edx+7], ah                  ;TSS段基址的高8位
     mov byte [edx+5], 1_00_0_1001B        ;P-1,TYPE-9(可用386TSS段)
     mov byte [edx+6], 0_1_0_0_0000B       ;G-0,X-1,limit-0
     add word [pgdt], 8                    ;gdt表长度增加8字节
     lgdt [pgdt]                           ;重新安装gdt表到系统

     pop edx                               ;弹出edx

  ret

;-------------------------------------------------------------------------------
Set_LDT_sel:                               ;安装LDT段
                                           ;输入参数: eax-—LDT段基地址
                                           ;输出参数: cx—-gdt中的选择子
 
     push edx                              ;保存edx

     xor ecx, ecx                          ;ecx清零
     sgdt [pgdt]                           ;获取gdt表长度和基址
     mov cx, word [pgdt]                   ;段界限
     mov edx, dword [pgdt+2]               ;段基址
     inc cx                                ;gdt表长度
     add edx, ecx                          ;安装地址       
     mov word [edx], 15                    ;LDT段长度的低16位
     mov word [edx+2], ax                  ;LDT段基址的低16位
     shr eax, 16                           ;LDT段基址右移16位
     mov byte [edx+4], al                  ;LDT段基址的中8位
     mov byte [edx+7], ah                  ;LDT段基址的高8位
     mov byte [edx+5], 1_11_0_0010B        ;P-1,DPL=3,TYPE-2(LDT段)
     mov byte [edx+6], 0_1_0_0_0000B       ;G-0,X-1,limit-0
     add word [pgdt], 8                    ;gdt表长度增加8字节
     lgdt [pgdt]                           ;重新安装gdt表到系统

     pop edx                               ;弹出edx

     ret

;-------------------------------------------------------------------------------
Load_core_task:                           ;创建系统进程（权限0）
 
     pushad
 
     ;内核任务的TSS段填写，清空缓冲区，使段内所有保留位置0
     mov eax, SYS_PROC + proc_ctrl.tss
     mov ecx, 104
_init_tss:
     mov byte [eax], 0x0
     inc eax
     loop _init_tss
 
     mov eax, SYS_PROC + proc_ctrl.tss
     mov ecx, cr3
     mov dword [eax + 0x1c], ecx        ;此处的CR3的写入必须要有，因为Set_TSS_sel不会主动加入页目录！！！
 
     ;在gdt中写入tss段描述符
     call Set_TSS_sel                   ;安装TSS，段首地址在eax中
     mov [SYS_PROC + proc_ctrl.task_sel], cx
     ltr cx                             ;将内核任务写入系统
 
     mov eax, SYS_PROC
     mov [SYS_PROC + proc_ctrl.pre_task], eax   ;系统进程的前一进程指向自己
     mov [SYS_PROC + proc_ctrl.next_task], eax ;系统进程的后一进程也指向自己
 
     ;记录当前工作进程
     mov eax, SYS_PROC
     mov [_task_now], eax               ;当前工作进程为系统进程
     add eax, proc_ctrl.next_task
     mov dword [eax], SYS_PROC          ;系统进程控制结构的下一个进程地址 指向自己
     mov eax, SYS_PROC
     add eax, proc_ctrl.state
     mov word [eax], task_running     ;工作进程状态为 正在运行

     popad
 
     ret
 
;-------------------------------------------------------------------------------
Load_usr_task:                            ;创建用户进程（权限3）
                                          ;输入参数: eax--用户进程的起始扇区号
            ;输入参数: ebx--用户进程扇区个数
            ;输入参数: ecx--进程PROC_CTRL结构的偏移地址
                                          ;输出参数: cx—-用户进程TSS段在gdt中的选择子         

     push eax                             ;[ebp + 24] 起始扇区号
     push ebx                           ;[ebp + 20] 扇区个数
     push ecx                             ;[ebp + 16] 进程控制结构proc_ctrl的偏移

     ;用户内存区分配用户“页目录”、“页表1”、“app页”、“用户堆栈esp3”三页
     call Alloc_usr_page
     push eax                           ;[ebp + 12] 页目录页
     call Alloc_usr_page
     push eax                             ;[ebp + 8] 页表1
     call Alloc_usr_page
     push eax                             ;[ebp + 4] app页
     call Alloc_usr_page
     push eax                             ;[ebp] 用户堆栈
     mov ebp, esp
 
     ;将用户页目录、页表1、app页映射到系统进程的前三页
     mov eax, [ebp + 12]
     or eax, 0x7
     mov dword [0xffc00000], eax
     mov eax, [ebp + 8]
     or eax, 0x7
     mov dword [0xffc00004], eax
     mov eax, [ebp + 4]
     or eax, 0x7
     mov dword [0xffc00008], eax
 
     ;拷贝系统页目录到用户页目录
     mov ecx, 1024
     xor edx, edx
_dir_cpy:
     mov eax, dword [0xfffff000 + edx]
     mov dword [edx], eax
     add edx, 4
     loop _dir_cpy

     ;用户页目录最后一项指向自己
     mov eax, [ebp + 12]
     or eax, 0x7
     mov dword [4092], eax
     ;用户页目录第一项指向页表1
     mov eax, [ebp + 8]
     or eax, 0x7
     mov dword [0], eax
     ;用户页表1第一项指向用户app页（对应线性地址：0x0-0x1000）
     mov eax, [ebp + 4]
     or eax, 0x7
     mov dword [0x1000], eax
     ;用户页表1第二项指向权限3堆栈（对应线性地址：0x1000-0x2000）
     mov eax, [ebp]
     or eax, 0x7
     mov dword [0x1004], eax
     ;将用户进程数据从逻辑扇区拷贝到到用户app页中
     mov eax, [ebp + 24]
     mov ebx, 0x2000
     mov ecx, [ebp + 20]

_cpy_disk:
     call read_hard_disk_0
     inc eax
     loop _cpy_disk
 
     ;将调用门信息写入用户进程
     mov ax, word [far_caller_1 + 4]
     mov [0x2004], ax
     mov ax, word [far_caller_2 + 4]
     mov [0x200a], ax
     mov ax, word [far_caller_3 + 4]
     mov [0x2010], ax
     mov ax, word [far_caller_4 + 4]
     mov [0x2016], ax
     mov ax, word [far_caller_5 + 4]
     mov [0x201c], ax
 
     ;初始化用户ldt段(代码段、数据段)
     mov eax, [ebp + 16]
     add eax, proc_ctrl.ldt
     mov dword [eax], ldt_code_low_dd
     mov dword [eax + 4], ldt_code_high_dd
     mov dword [eax + 8], ldt_data_low_dd
     mov dword [eax + 0x0c], ldt_data_high_dd
 
     ;将用户ldt段加入gdt
     call Set_LDT_sel
     mov eax, [ebp + 16]
     add eax, proc_ctrl.ldt_sel
     mov [eax], cx

     ;初始化用户进程TSS页，段内所有保留位都清空
     mov eax, [ebp + 16]
     add eax, proc_ctrl.tss
     push eax
     mov ecx, 26
     xor edx, edx
_init_usr_tss:
     mov dword [eax + edx], 0x0
     add edx, 4
     loop _init_usr_tss
 
     ;逐项填写TSS段
     call Alloc_sys_page                       ;分配用户进程使用的R0权限下的堆栈页
     mov edx, eax
     add edx, 4092                             ;esp0指针指向页的最后
     pop eax                                   ;恢复指向tss段的首地址
     mov dword [eax+0x4], edx                  ;esp0
     mov word [eax+0x8], flat_mode_data        ;ss0
     mov ebx, [ebp + 12]
     mov dword [eax+0x1c], ebx                 ;cr3
     mov dword [eax+0x20], 48                  ;eip
     pushfd
     pop ebx
     mov dword [eax+0x24], ebx                 ;eflag
     mov dword [eax+0x38], 0x2000-4            ;esp
     mov dword [eax+0x4c], 0x7                 ;cs(list-0,TI-1,RPL-3)
     mov dword [eax+0x50], 0x0f                ;ss(list-1,TI-1,RPL-3)
     mov dword [eax+0x54], 0x0f                ;ds(list-1,TI-1,RPL-3)
     mov ebx, [ebp + 16]
     add ebx, proc_ctrl.ldt_sel 
     mov cx, [ebx]
     mov word [eax+0x60], cx                   ;ldt选择子
     mov word [eax+0x66], 103                  ;TSS段长度

     ;将用户tss写入gdt
     call Set_TSS_sel
 
     ;修改进程状态为 正在运行
     mov eax, [ebp + 16]                       ;进程控制段
     add eax, proc_ctrl.state                  ;进程状态字段
     mov word [eax], task_running              ;进程状态字段设置为 正在运行             
 
     ;将进程控制段放入进程链表
     mov edx, [ebp + 16] 
     call mount_task_running_que
 
  ;将进程在gdt中的选择子写入进程结构进行保存
     mov edx, [ebp + 16] 
     mov [edx + proc_ctrl.task_sel], cx 
 
     ;绘制用户进程窗口 
     mov edx, [ebp + 16] 
     call draw_task_window
 
     add esp, 28    
 
     ret
 
;------------------------------------------------------------------------------- 
mount_task_running_que:                   ;将进程结构安装到运行队列中
                                          ;输入参数: edx--进程PROC_CTRL结构的偏移地址           
     cli                                  ;关中断
     pushad
    
     mov eax, [SYS_PROC + proc_ctrl.pre_task]  ;前一个进程结构地址
     mov [eax + proc_ctrl.next_task], edx      ;前一个进程的next指向新进程结构
     mov [SYS_PROC + proc_ctrl.pre_task], edx  ;系统进程的pre指向新进程结构
     mov [edx + proc_ctrl.pre_task], eax       ;新进程的pre指向前一个进程结构
     mov ebx, SYS_PROC                         ;新进程的next指向系统进程
     mov [edx + proc_ctrl.next_task], ebx     
 
     popad
     sti                                  ;开中断
     ret

;------------------------------------------------------------------------------- 
mount_task_run_to_pend_que:               ;将进程结构从就绪队列放入暂停队列 （在这里，由于系统进程不休眠，只有两个用户进程休眠，所以下面的代码偷懒了）           
                                          ;输入参数: edx--进程PROC_CTRL结构的偏移地址           
     cli                                  ;关中断
     pushad
     
     ;将进程结构从队列中取出
     mov eax, [edx + proc_ctrl.pre_task]  ;进程所在队列的前一个结构
     mov ebx, [edx + proc_ctrl.next_task] ;进程所在队列的后一个结构
     mov [_task_next], ebx                ;记录下一个进程结构地址
     mov [eax + proc_ctrl.next_task], ebx ;前一个结构的next指向后一个结构
     mov [ebx + proc_ctrl.pre_task], eax  ;后一个结构的pre指向前一个结构

     ;将进程结构放入pending队列
     cmp dword [_task_pend_que], 0x0      ;暂停队列是否为空
     jnz _chg_pnd_que1                    ;如果包含进程结构
     mov [_task_pend_que], edx            ;暂定队列头部指向该进程结构
     mov [edx + proc_ctrl.pre_task], edx  ;该进程结构的pre指向自己
     mov [edx + proc_ctrl.next_task], edx ;该进程结构的next指向自己
     jmp _chg_pnd_que2                    ;退出函数
 
_chg_pnd_que1:                            ;在这里，先被唤醒的放队列的前面，后被唤醒的放后面
     mov eax, dword[_task_pend_que]       ;eax指向暂定队列头部
     mov ecx, [edx + proc_ctrl.wakeup]    ;ecx指向新进程被唤醒的时刻值
     cmp ecx, [eax + proc_ctrl.wakeup]    ;和暂停队列头部比较唤醒时间大小
     jb _insert_head                      ;如果暂停时间小于头部时间，就插入暂停队列头部  
 
  ;插入暂停队列尾部
     mov ebx, [eax + proc_ctrl.pre_task]  ;ebx指向暂定队列的最后一个结构
     mov [ebx + proc_ctrl.next_task], edx ;队列最后一个结构的next指向本进程结构
     mov [eax + proc_ctrl.pre_task], edx  ;暂定队列头部的pre指向本进程结构
     mov [edx + proc_ctrl.pre_task], ebx  ;本进程结构的pre指向原队列最后一个结构
     mov [edx + proc_ctrl.next_task], eax ;本进程结构的next指向队列头部
     jmp _chg_pnd_que2

     ;插入暂停队列头部
_insert_head:
     mov eax, [_task_pend_que]            ;eax指向暂停队列头部
     mov [edx + proc_ctrl.next_task], eax ;本进程的next指向队列头部
     mov ebx, [eax + proc_ctrl.pre_task]  ;ebx指向暂定队列的最后一个结构
     mov [edx + proc_ctrl.pre_task], ebx
     mov [ebx + proc_ctrl.next_task], edx
     mov [eax + proc_ctrl.pre_task], edx
     mov [_task_pend_que], edx            ;暂停队列头部指向本结构

_chg_pnd_que2: 
     popad
     sti                                  ;开中断
 
     ;跳转到下一个就绪进程执行
     mov eax, [_task_next]                ;下一个进程结构地址
     mov [_task_now], eax                 ;当前进程
     add eax, proc_ctrl.task_rsvr
     jmp far [eax]                        ;跳转到新的进程执行
 
     ret

;------------------------------------------------------------------------------- 
mount_task_pend_to_run_que:               ;将进程结构从暂停队列放入就绪队列（就绪队列头部永远指向系统进程）            
                                          ;输入参数: edx--进程PROC_CTRL结构的偏移地址
     ;cli                                 ;关中断
     pushad

  ;先将进程结构从暂定队列取出
     mov edx, [_task_pend_que]            ;首先判断暂定队列是否只有一个结构
     mov eax, [edx + proc_ctrl.next_task] ;eax指向暂停队列头部的下一个结构
     cmp eax, edx                         ;如果暂停队列头部结构的next指向自己，暂停队列只有一个结构
     jnz _fix_pend_que_head 
     xor eax, eax
     mov [_task_pend_que], eax            ;暂停队列头部清空
     jmp _mount_to_run_que

_fix_pend_que_head:                       ;将暂停队列头部结构取出
     mov ebx, [edx + proc_ctrl.pre_task]  ;ebx指向暂停队列的尾部
     mov [ebx + proc_ctrl.next_task], eax ;尾部结构的next指向原队列的第二个结构
     mov [eax + proc_ctrl.pre_task], ebx  ;原队列的第二个结构的pre指向队列尾部结构
     mov [_task_pend_que], eax            ;暂停队列头部修改为原第二个结构地址

_mount_to_run_que: 
  ;将进程结构放入就绪队列
     mov eax, SYS_PROC                    ;eax指向系统进程
     mov ebx, [eax + proc_ctrl.pre_task]  ;ebx指向就绪队列最后一个结构
     mov [eax + proc_ctrl.pre_task], edx  ;系统进程的pre指向该进程结构
     mov [ebx + proc_ctrl.next_task], edx ;就绪队列最后一个结构的next指向该进程结构
     mov [edx + proc_ctrl.pre_task], ebx  ;该进程的pre指向队列原最后一个结构
     mov [edx + proc_ctrl.next_task], eax ;该进程的next指向系统进程结构 
 
     popad
     ;sti                                 ;开中断    
     ret 
 
;------------------------------------------------------------------------------- 
switch_task2:                               ;轮转切换当前执行的进程
    
     mov eax, [_task_now]                     ;eax指向当前进程
     mov ebx, [eax + proc_ctrl.next_task]     ;ebx指向下一个进程
     cmp eax, ebx                             ;是否是同一个进程
     je _switch_task_ok                       ;如果是同一个进程，无需切换
     mov [_task_now], ebx                     ;更新当前进程记录
     add ebx, proc_ctrl.task_rsvr
     jmp far [ebx]                            ;跳转到新的进程执行

_switch_task_ok:
     ret

;------------------------------------------------------------------------------- 
wakeup_task:                               ;检查进程休眠时间是否到时，并唤醒(在中断中处理，无需关中断)
    
     pushad 
     mov eax, [_task_pend_que]                ;eax指向休眠队列头部
     cmp eax, 0x0                             ;休眠队列是否为空
     jz wakeup_task_finished                  ;如果为空，直接跳出

     mov ebx, [sys_click]                     ;当前的系统时间
     mov ecx, [eax + proc_ctrl.wakeup]        ;ecx为进程被唤醒时间
     cmp ebx, ecx                             ;如果系统时间大于等于进程的唤醒时间
     jb wakeup_task_finished

     mov edx, eax                             ;调用时，edx指向被调整的进程地址
     call mount_task_pend_to_run_que        ;将进程结构从暂定队列放入就绪队列
   
wakeup_task_finished:
     popad
     ret 

;-------------------------------------------------------------------------------
draw_task_window:                             ;绘制用户进程窗口(窗口横梁宽度为5个点，其余都为一个点)
                                              ;输入：edx - 进程PROC_CTRL结构的偏移地址
     pushad
    
     ;窗口横梁，6个点宽
     xor eax, eax
     mov ax, 5                                ;eax高16位是y的高度
     shl eax, 16 
     mov ax, [edx + proc_ctrl.left_y]         ;eax低16位是y的值  
     xor ebx, ebx
     mov bx, [edx + proc_ctrl.len_x]          ;ebx高16位是x的宽度
     shl ebx, 16
     mov bx, [edx + proc_ctrl.left_x]         ;ebx低16位是x的值
     mov cl, 8
     call draw_rectangle                      ;画一个矩形
 
     ;窗口下梁，1个点宽
     xor eax, eax 
     mov ax, [edx + proc_ctrl.left_x]
     shl eax, 16 
     mov ax, [edx + proc_ctrl.left_y]
     add ax, [edx + proc_ctrl.len_y]
     xor ebx, ebx
     mov bx, [edx + proc_ctrl.len_x]
     mov cl, 8
     call draw_line 

     ;窗口左柱，1个点宽 
     xor eax, eax 
     mov ax, [edx + proc_ctrl.left_x]
     shl eax, 16 
     mov ax, [edx + proc_ctrl.left_y]
     xor ebx, ebx
     mov bx, [edx + proc_ctrl.len_y]
     mov cl, 8
     call draw_long_string 

     ;窗口右柱，1个点宽 
     xor eax, eax 
     mov ax, [edx + proc_ctrl.left_x]
     add ax, [edx + proc_ctrl.len_x]
     shl eax, 16 
     mov ax, [edx + proc_ctrl.left_y]
     xor ebx, ebx
     mov bx, [edx + proc_ctrl.len_y]
     inc bx
     mov cl, 8
     call draw_long_string
 
     ;窗口的退出按钮，大小为3×3的矩形
     xor eax, eax
     mov ax, 3                                ;eax高16位是y的高度
     shl eax, 16 
     mov ax, [edx + proc_ctrl.left_y]         ;eax低16位是y的值
     inc ax  
     xor ebx, ebx
     mov bx, 3                                ;ebx高16位是x的宽度
     shl ebx, 16
     mov bx, [edx + proc_ctrl.left_x]         ;ebx低16位是x的值
     add bx, [edx + proc_ctrl.len_x]
     sub bx, 4
     mov cl, 10                               ;暗绿
     call draw_rectangle                      ;画一个矩形     
    
     popad  
     ret            
 
;-------------------------------------------------------------------------------
read_hard_disk_0:                       ;从硬盘读取一个逻辑扇区（平坦模型）
          ;EAX=逻辑扇区号
          ;EBX=目标缓冲区线性地址
          ;返回：EBX=EBX+512
  cli
 
  push eax
  push ecx
  push edx
 
  push eax
 
  mov dx,0x1f2
  mov al,1
  out dx,al                          ;读取的扇区数

  inc dx                             ;0x1f3
  pop eax
  out dx,al                          ;LBA地址7~0

  inc dx                             ;0x1f4
  mov cl,8
  shr eax,cl
  out dx,al                          ;LBA地址15~8

  inc dx                             ;0x1f5
  shr eax,cl
  out dx,al                          ;LBA地址23~16

  inc dx                             ;0x1f6
  shr eax,cl
  or al,0xe0                         ;第一硬盘  LBA地址27~24
  out dx,al

  inc dx                             ;0x1f7
  mov al,0x20                        ;读命令
  out dx,al

.waits:
  in al,dx
  and al,0x88
  cmp al,0x08
  jnz .waits                         ;不忙，且硬盘已准备好数据传输

  mov ecx,256                        ;总共要读取的字数
  mov dx,0x1f0
.readw:
  in ax,dx
  mov [ebx],ax
  add ebx,2
  loop .readw

  pop edx
  pop ecx
  pop eax
 
  sti
 
  ret     

;--------------------------------全局变量---------------------------------------
align 4 
     _task_now        dd 0                    ;当前工作进程控制结构地址
     _task_next       dd 0                    ;当前工作进程的下一个结构
     _task_pend_que   dd 0x0                  ;暂停进程队列头
     _task_stop_que   dd 0x0                  ;停止进程队列头
     _task_old        dd 0                    ;保存上一个进程的控制结构地址 
     ;_task_window     dd 0                    ;按照顺序分配窗口(0-左下；1-右下；2-右上；左上角的窗口留给系统进程) 
 
SYS_PROC: 
     istruc proc_ctrl 
       at proc_ctrl.num,        resw    0 
       at proc_ctrl.state,      resw    0
       at proc_ctrl.wakeup,     resd    0
       at proc_ctrl.pre_task,   resd    0   
       at proc_ctrl.next_task,  resd    0   
       at proc_ctrl.task_rsvr,  resd    0
       at proc_ctrl.task_sel,   resw    0
       at proc_ctrl.ldt_rsvr,   resd    0
       at proc_ctrl.ldt_sel,    resw    0
       at proc_ctrl.ldt,        times   16 db 0
       at proc_ctrl.tss,     times   104 db 0
       at proc_ctrl.cmd,        times   8 db 0
       at proc_ctrl.sys_page,   resd    0
       at proc_ctrl.usr_page,   times   8 dd 0    
       at proc_ctrl.left_x,     resw    0
       at proc_ctrl.left_y,     resw    0
       at proc_ctrl.len_x,      resw    0
       at proc_ctrl.len_y,      resw    0   
     iend   
USR1_PROC: 
     istruc proc_ctrl 
       at proc_ctrl.num,        resw    0 
       at proc_ctrl.state,      resw    0
       at proc_ctrl.wakeup,     resd    0
       at proc_ctrl.pre_task,   resd    0   
       at proc_ctrl.next_task,  resd    0
       at proc_ctrl.task_rsvr,  resd    0
       at proc_ctrl.task_sel,   resw    0
       at proc_ctrl.ldt_rsvr,   resd    0
       at proc_ctrl.ldt_sel,    resw    0
       at proc_ctrl.ldt,        times   16 db 0
       at proc_ctrl.tss,     times   104 db 0
       at proc_ctrl.cmd,        times   8 db 0
       at proc_ctrl.sys_page,   resd    0
       at proc_ctrl.usr_page,   times   8 dd 0    
       at proc_ctrl.left_x,     resw    0
       at proc_ctrl.left_y,     resw    0
       at proc_ctrl.len_x,      resw    0
       at proc_ctrl.len_y,      resw    0
     iend
USR2_PROC: 
     istruc proc_ctrl 
       at proc_ctrl.num,        resw    0 
       at proc_ctrl.state,      resw    0
       at proc_ctrl.wakeup,     resd    0
       at proc_ctrl.pre_task,   resd    0   
       at proc_ctrl.next_task,  resd    0   
       at proc_ctrl.task_rsvr,  resd    0
       at proc_ctrl.task_sel,   resw    0
       at proc_ctrl.ldt_rsvr,   resd    0
       at proc_ctrl.ldt_sel,    resw    0
       at proc_ctrl.ldt,        times   16 db 0
       at proc_ctrl.tss,     times   104 db 0
       at proc_ctrl.cmd,        times   8 db 0
       at proc_ctrl.sys_page,   resd    0
       at proc_ctrl.usr_page,   times   8 dd 0    
       at proc_ctrl.left_x,     resw    0
       at proc_ctrl.left_y,     resw    0
       at proc_ctrl.len_x,      resw    0
       at proc_ctrl.len_y,      resw    0
     iend

align 4