;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                               ;;
;;  MenuetOS process management, protected ring3                 ;;
;;                                                               ;;
;;  Distributed under GPL. See file COPYING for details.         ;;
;;  Copyright 2003 Ville Turjanmaa                               ;;
;;                                                               ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

align 32

; GDT TABLE

gdts:

        dw     gdte-$-1
        dd     gdts
        dw     0

int_code_l:
os_code_l:

        dw     0xffff
        dw     0x0000
        db     0x00
        dw     11011111b *256 +10011010b
        db     0x00

int_data_l:
os_data_l:

        dw     0xffff
        dw     0x0000
        db     0x00
        dw     11011111b *256 +10010010b
        db     0x00

graph_data_l:

        dw     0x3ff
        dw     0x0000
        db     0x00
        dw     11010000b *256 +11110010b
        db     0x00

tss0_l:
      times (max_processes+10) dd 0,0

tss0i_l:
      times 0x41 dq 0 ;(256+10) dd 0,0

app_code_l:
      times (max_processes+10) dd 0,0

app_data_l:
      times (max_processes+10) dd 0,0

tss0sys_l:
      times (max_processes+10) dd 0,0

gdte:



; <IP 05.02.2005>
idtreg:
     dw   8*0x41-1
     dd   idts+8

label idts at 0xB100-8
;idte = idts + 8 + 0x60

; </IP> ; old code below:


;align 32

;idts:
;      dw  idte-$-1
;      dd  idts+8
;      dw  0

;      times 0x62 dd 0,0

;idte:

build_process_gdt_tss_pointer:

        mov    ecx,tss_data
        mov    edi,0
      setgdtl2:
        mov    [edi+gdts+ tss0 +0], word tss_step
        mov    [edi+gdts+ tss0 +2], cx
        mov    eax,ecx
        shr    eax,16
        mov    [edi+gdts+ tss0 +4], al
        mov    [edi+gdts+ tss0 +7], ah
        mov    [edi+gdts+ tss0 +5], word 01010000b *256 +11101001b
        add    ecx,tss_step
        add    edi,8
        cmp    edi,8*(max_processes+5)
        jbe    setgdtl2

        ret

;build_process_gdt_gate_pointer:

;        mov    edi,0
;        mov    dx,tss0
;      setidtl1:
;        mov    ecx,[esi]
;        mov    [edi+gdts+ tss0t +0], word 0
;        mov    [edi+gdts+ tss0t +2], dx
;        mov    [edi+gdts+ tss0t +4], word 11100101b*256
;        mov    [edi+gdts+ tss0t +6], word 0
;        add    dx,8
;        add    edi,8
;        cmp    edi,8*(max_processes+5)
;        jb     setidtl1

;        ret

build_interrupt_table:

        mov  [l.eflags],dword 0x11002
        mov  [l.ss0], int_data
        ;mov  [l.ss1], ring1_data
        ;mov  [l.ss2], ring2_data
        mov  [l.esp0], 0x52000
        mov  [l.esp1], 0x53000
        mov  [l.esp2], 0x54000

        mov  eax,cr3
        mov  [l.cr3],eax
        mov  [l.cs],int_code
        mov  [l.ss],int_data
        mov  [l.ds],int_data
        mov  [l.es],int_data
        mov  [l.fs],int_data
        mov  [l.gs],int_data

        mov  eax,sys_int
        mov  [l.esp],0x720000
        mov  edi,0x290000

     newint:
        push edi
        mov  ebx,[eax]
        mov  [l.eip],ebx
        mov  esi,tss_sceleton
        mov  ecx,120/4
        cld
        rep  movsd
        pop  edi

        add  edi,128
        add  [l.esp],1024
        add  eax,4

        cmp  eax,sys_int+4*0x40 ;0x60
        jbe  newint  ;jb

;;

        mov    esi,boot_sched_3_2
        call   boot_log

        mov    ecx,0x290000
        mov    edi,0
      setgdtl2i:
        mov    [edi+gdts+ tss0i +0], word 128
        mov    [edi+gdts+ tss0i +2], cx
        mov    eax,ecx
        shr    eax,16
        mov    [edi+gdts+ tss0i +4], al
        mov    [edi+gdts+ tss0i +7], ah
        mov    [edi+gdts+ tss0i +5], word 01010000b *256 +11101001b
        add    ecx,128
        add    edi,8
        cmp    edi,8*0x40 ;0x60
        jbe    setgdtl2i

;;

        mov    esi,boot_sched_3_3
        call   boot_log

        mov    edi,0
        mov    edx,tss0i
      setidtl2:
        mov    [edi+idts+ 8 +0], word 0
        mov    [edi+idts+ 8 +2], dx
        mov    [edi+idts+ 8 +4], word 10000101b*256 ; task gate DPL=0
;        cmp    edi,0x40*8
;        jne    no_sw_int
;        mov    [edi+idts+ 8 +4], word 11100101b*256 ; task gate DPL=3
;      no_sw_int:
        mov    [edi+idts+ 8 +6], word 0
        add    edx,8
        add    edi,8

        cmp    edi,8*0x40 ;0x60
        jbe    setidtl2 ;jb

; <Ivan Poddubny 06.02.2005>
; THIS CODE WON'T WORK ;-(
; because each process's 0-level stack points to the same area
; and if task switch occurs and another process is being interrupted
; a stack overflow happens
; The only way to solve that problem is to disable interrupts
; while 0x40-handler is working
; Then we have to make all entries in the IDT INTERRUPT gates, not TASK
;        mov    edi, idts+8
;        mov    esi, sys_int
;        mov    ecx, 32
;     @@:
;        mov    eax, [esi]
;        mov    [edi],   ax           ; lower part of offset
;        mov    [edi+2], word os_code ; segment selector
;        shr    eax, 16
;        mov    [edi+4], word 10001110b shl 8 ; interrupt descriptor
;        mov    [edi+6], ax
;        add    esi, 4
;        add    edi, 8
;        dec    ecx
;        jnz    @b
; </Ivan Poddubny>

        ret

build_syscall_interrupt_table:

        mov  [l.eflags],dword 0x11002
        mov  [l.ss0], int_data   ;code
        ;mov  [l.ss1], ring1_data ;code
        ;mov  [l.ss2], ring2_data ;code
        mov  [l.esp0], 0x52000
        mov  [l.esp1], 0x53000
        mov  [l.esp2], 0x54000

        mov  eax,cr3
        mov  [l.cr3],eax
        mov  [l.cs],int_code
        mov  [l.ss],int_data
        mov  [l.ds],int_data
        mov  [l.es],int_data
        mov  [l.fs],int_data
        mov  [l.gs],int_data

        mov  [l.esp],sysint_stack_data
        mov  edi,0x298000

     newint2:
        push edi
        mov  ebx,i40
        mov  [l.eip],ebx
        mov  esi,tss_sceleton
        mov  ecx,120/4
        cld
        rep  movsd
        pop  edi

        add  [l.esp],4096
        add  edi,128
        ;add  eax,4

        cmp  edi,0x298000+128*(max_processes+5)
        jb   newint2

;;

        mov    ecx,0x298000
        mov    edi,0
      setgdtl2i2:
        mov    [edi+gdts+ tss0sys +0], word 128
        mov    [edi+gdts+ tss0sys +2], cx
        mov    eax,ecx
        shr    eax,16
        mov    [edi+gdts+ tss0sys +4], al
        mov    [edi+gdts+ tss0sys +7], ah
        mov    [edi+gdts+ tss0sys +5], word 01010000b *256 +11101001b
        add    ecx,128
        add    edi,8
        cmp    edi,8*(max_processes+5)
        jbe    setgdtl2i2

;;

        ;mov    dx,tss0sys
        mov    edi,8*0x40+idts+8
        mov    [edi + 0], word 0
        mov    [edi + 2], word tss0sys ;dx
        mov    [edi + 4], word 11100101b*256
        mov    [edi + 6], word 0

        mov    edi,8*0x38+idts+8
        mov    eax, i38
        mov    [edi],   ax           ; lower part of offset
        mov    [edi+2], word os_code ; segment selector
        shr    eax, 16
        mov    [edi+4], word 11101110b shl 8 ; 32-bit interrupt gate, DPL 3
        mov    [edi+6], ax

        ret


align 4
i38:
        ; load data selectors
        pushfd
        push    ds es
        push    eax
        mov     ax, os_data
        mov     ds, ax
        mov     es, ax
        pop     eax

        pushad
        push    edi
        mov     edi, eax
        mov     eax, ebx
        mov     ebx, ecx
        mov     ecx, edx
        mov     esi, [esp]
        and     edi, 0xFF
        call    dword [servetable+edi*4]
        add     esp, 4
        popad
        pop     es ds
        popfd
iret


iglobal
  sys_int:
    dd   s0,s1,s2,s3,s4,s5,s6,s7,s8,s9,sa,sb,sc,sd,se,sf

    dd   s10        ,s11      ;  ,i_unknown12,i_unknown13
;    dd   i_unknown14,i_unknown15,i_unknown16,i_unknown17
;    dd   i_unknown18,i_unknown19,i_unknown1a,i_unknown1b
;    dd   i_unknown1c,i_unknown1d,i_unknown1e,i_unknown1f
    times 14 dd unknown_interrupt

    dd   irq0  ,irq1  ,p_irq2 ,p_irq3 ,p_irq4 ,p_irq5,p_irq6 ,p_irq7
    dd   p_irq8,p_irq9,p_irq10,p_irq11,p_irq12,irqD  ,p_irq14,p_irq15

    ;dd   i_unknown30,i_unknown31,i_unknown32,i_unknown33
    ;dd   i_unknown34,i_unknown35,i_unknown36,i_unknown37
    ;dd   i_unknown38,i_unknown39,i_unknown3a,i_unknown3b
    ;dd   i_unknown3c,i_unknown3d,i_unknown3e,i_unknown3f
    times 16 dd unknown_interrupt

    dd   i40
endg

uglobal
 tss_sceleton:
  l.back   dw 0,0
  l.esp0   dd 0
  l.ss0    dw 0,0
  l.esp1   dd 0
  l.ss1    dw 0,0
  l.esp2   dd 0
  l.ss2    dw 0,0
  l.cr3    dd 0
  l.eip    dd 0
  l.eflags dd 0
  l.eax    dd 0
  l.ecx    dd 0
  l.edx    dd 0
  l.ebx    dd 0
  l.esp    dd 0
  l.ebp    dd 0
  l.esi    dd 0
  l.edi    dd 0
  l.es     dw 0,0
  l.cs     dw 0,0
  l.ss     dw 0,0
  l.ds     dw 0,0
  l.fs     dw 0,0
  l.gs     dw 0,0
  l.ldt    dw 0,0
  l.trap   dw 0
  l.io     dw 0
endg

s0:
        cli

        mov   [error_interrupt],0x0
        mov   [error_interrupt_entry],dword s0

        call  show_error_parameters

        mov   edx,[0x3010]
        mov   [edx+0xa],byte 4

        jmp   change_task


s1:
        cli

        mov   [error_interrupt],0x1
        mov   [error_interrupt_entry],dword s1

        call  show_error_parameters

        mov   edx,[0x3010]
        mov   [edx+0xa],byte 4

        jmp   change_task

s2:
        cli

        mov   [error_interrupt],0x2
        mov   [error_interrupt_entry],dword s2

        call  show_error_parameters

        mov   edx,[0x3010]
        mov   [edx+0xa],byte 4

        jmp   change_task

s3:
        cli

        mov   [error_interrupt],0x3
        mov   [error_interrupt_entry],dword s3

        call  show_error_parameters

        mov   edx,[0x3010]
        mov   [edx+0xa],byte 4

        jmp   change_task

s4:
        cli

        mov   [error_interrupt],0x4
        mov   [error_interrupt_entry],dword s4

        call  show_error_parameters

        mov   edx,[0x3010]
        mov   [edx+0xa],byte 4

        jmp   change_task

s5:
        cli

        mov   [error_interrupt],0x5
        mov   [error_interrupt_entry],dword s5

        call  show_error_parameters

        mov   edx,[0x3010]
        mov   [edx+0xa],byte 4

        jmp   change_task

s6:
        cli

        mov   [error_interrupt],0x6
        mov   [error_interrupt_entry],dword s6

        call  show_error_parameters

        mov   edx,[0x3010]
        mov   [edx+0xa],byte 4

        jmp   change_task


;;;;;;;;;;;;;;;;;;;;;;;
;; FPU ERROR HANDLER ;;
;;;;;;;;;;;;;;;;;;;;;;;

align 4
s7:
        ; <IP 05.02.2004>
        cli
        ; </IP>
        mov    edi, 7*8
        mov    [edi+gdts+ tss0i +5], word 01010000b *256 +11101001b

        mov    edi,[0x3000]
        shl    edi, 3
        mov    [edi+gdts+ tss0 +5], word 01010000b *256 +11101001b


        ; save a copy of current task's TSS to fpu_tss
        mov    esi,[0x3000]
        imul   esi,tss_step
        add    esi,tss_data
        mov    edi,fpu_tss
        mov    ecx,120/4
        cld
        rep    movsd

        ; get base address of our TSS and...
        mov    esi,[0x3000]
        imul   esi,tss_step
        add    esi,tss_data

        ; ...init segments, stack, eip, flags
        mov    word [esi+l.cs-tss_sceleton],int_code
        mov    word [esi+l.ss-tss_sceleton],int_data
        mov    word [esi+l.ds-tss_sceleton],int_data
        mov    word [esi+l.es-tss_sceleton],int_data
        mov    word [esi+l.fs-tss_sceleton],int_data
        mov    word [esi+l.gs-tss_sceleton],int_data
        mov    dword [esi+l.esp-tss_sceleton],fpu_stack+4*8
        mov    dword [esi+l.eip-tss_sceleton],fpu_handler
        mov    dword [esi+l.eflags-tss_sceleton],0x11002

        ; then execute this task
        mov    ebx, [0x3000]
        shl    ebx,3
        add    ebx, tss0 ;t
        mov    [0xB004], bx

        jmp    pword [0xB000]

        jmp    s7

s8:
        cli

        mov   [error_interrupt],0x8
        mov   [error_interrupt_entry],dword s8

        call  show_error_parameters

        mov   edx,[0x3010]
        mov   [edx+0xa],byte 4

        jmp   change_task

s9:
        cli

        mov   [error_interrupt],0x9
        mov   [error_interrupt_entry],dword s9

        call  show_error_parameters

        mov   edx,[0x3010]
        mov   [edx+0xa],byte 4

        jmp   change_task

sa:
        cli

        mov   [error_interrupt],0xa
        mov   [error_interrupt_entry],dword sa

        call  show_error_parameters

        mov   edx,[0x3010]
        mov   [edx+0xa],byte 4

        jmp   change_task

sb:
        cli

        mov   [error_interrupt],0xb
        mov   [error_interrupt_entry],dword sb

        call  show_error_parameters

        mov   edx,[0x3010]
        mov   [edx+0xa],byte 4

        jmp   change_task

sc:
        cli

        mov   [error_interrupt],0xc
        mov   [error_interrupt_entry],dword sc

        call  show_error_parameters

        mov   edx,[0x3010]
        mov   [edx+0xa],byte 4

        jmp   change_task

sd:
        cli

        mov   [error_interrupt],0xd
        mov   [error_interrupt_entry],dword sd

        call  show_error_parameters

        mov   edx,[0x3010]
        mov   [edx+0xa],byte 4

        jmp   change_task

se:
        cli

        mov   [error_interrupt],0xe
        mov   [error_interrupt_entry],dword se

        call  show_error_parameters

        mov   edx,[0x3010]
        mov   [edx+0xa],byte 4

        jmp   change_task

sf:
        cli

        mov   [error_interrupt],0xf
        mov   [error_interrupt_entry],dword sf

        call  show_error_parameters

        mov   edx,[0x3010]
        mov   [edx+0xa],byte 4

        jmp   change_task

s10:
        cli

        mov   [error_interrupt],0x10
        mov   [error_interrupt_entry],dword s10

        call  show_error_parameters

        mov   edx,[0x3010]
        mov   [edx+0xa],byte 4

        jmp   change_task

s11:
        cli

        mov   [error_interrupt],0x11
        mov   [error_interrupt_entry],dword s11

        call  show_error_parameters

        mov   edx,[0x3010]
        mov   [edx+0xa],byte 4

        jmp   change_task

writehex:

      pusha

      mov  ecx,eax
      mov  ax,word [printerrorat]
      shl  eax,16
      mov  ax,[esp+32+4]
      sub  ax,60
      mov  edx,1
      mov  esi,8
      mov  ebx,0xffffff
    whl1:
      push ecx
      and  ecx,0xf
      add  ecx,hexletters
      mov  edi,1

      mov  cl,[ecx]
      mov  edi,[write_error_to]
      mov  [edi],cl
      dec  [write_error_to]

      pop  ecx
      shr  ecx,4
      sub  eax,6*65536
      dec  esi
      jnz  whl1

      popa
      ret

iglobal
  hexletters  db '0123456789ABCDEF'

  error_interrupt         dd  -1
  error_interrupt_entry   dd  -1

  printerrorat            dd 300

  process_error  db 'K : Process - forced terminate INT: 00000000',13,10,0
  process_pid    db 'K : Process - forced terminate PID: 00000000',13,10,0
  process_eip    db 'K : Process - forced terminate EIP: 00000000',13,10,0
  system_error   db 'K : Kernel error',13,10,0
endg

uglobal
  write_error_to  dd  0x0
endg

show_error_parameters:
        
        mov    [write_error_to],process_pid+43
        mov    eax,[0x3000]
        shl    eax, 5
        mov    eax,[0x3000+4+eax]
        call   writehex
        
        mov    [write_error_to],process_error+43
        mov    eax,[error_interrupt]
        call   writehex
        
        mov    eax,[0x3000]
        shl    eax,8
        cmp    [0x80000+eax+0xB0],dword 0
        jnz    .system_error

        mov    eax,[0x3000]
        imul   eax,tss_step
        mov    eax,[eax+tss_data+l.eip-tss_sceleton]
.out_eip:        
        mov    [write_error_to],process_eip+43
        call   writehex

        mov    esi,process_error
        call   sys_msg_board_str

        mov    esi,process_pid
        call   sys_msg_board_str

        mov    esi,process_eip
        call   sys_msg_board_str

        ret
        
.system_error:
        mov    esi,system_error
        call   sys_msg_board_str
        mov    eax,[0x3000]
        shl    eax,7
        mov    eax,[eax+0x298000+l.eip-tss_sceleton]
        jmp    .out_eip        


irq5:

     call   restore_caller

     mov    dx,word [sb16]
     add    dx,0xe
     in     al,dx

;     mov    byte [SB16_Status],0

     mov    [check_idle_semaphore],5

     mov    al,0x20
     out    0x20,al

     call  return_to_caller

     jmp   irq5

irqD:

     call   restore_caller

     mov   dx,0xf0
     mov   al,0
     out   dx,al

     mov   dx,0xa0
     mov   al,0x20
     out   dx,al
     mov   dx,0x20
     out   dx,al

     mov   ds,cx
     mov   es,cx
     mov   fs,cx

     call  return_to_caller

     jmp   irqD

p_irq2:

     call  restore_caller

     mov   edi,2               ; 1
     call  irqhandler          ; 2/5

     call  return_to_caller

     jmp   p_irq2

p_irq3:

     call  restore_caller

     mov   edi,3
     call  irqhandler

     call  return_to_caller

     jmp   p_irq3

p_irq4:

     call  restore_caller

     mov   edi,4
     call  irqhandler

     call  return_to_caller

     jmp   p_irq4

p_irq5:

     call  restore_caller

     mov   edi,5
     call  irqhandler

     call  return_to_caller

     jmp   p_irq5

p_irq6:

     call  restore_caller

     call  fdc_irq

     mov   edi,6
     call  irqhandler

     call  return_to_caller

     jmp   p_irq6

p_irq7:

     call  restore_caller

     mov   edi,7
     call  irqhandler

     call  return_to_caller

     jmp   p_irq7

p_irq8:

     call  restore_caller

     mov   edi,8
     call  irqhandler

     call  return_to_caller

     jmp   p_irq8

p_irq9:

     call  restore_caller

     mov   edi,9
     call  irqhandler

     call  return_to_caller

     jmp   p_irq9

p_irq10:

     call  restore_caller

     mov   edi,10
     call  irqhandler

     call  return_to_caller

     jmp   p_irq10

p_irq11:

     call  restore_caller

     mov   edi,11
     call  irqhandler

     call  return_to_caller

     jmp   p_irq11

p_irq12:

      call  restore_caller

      mov   edi,12
      call  irqhandler

      call  return_to_caller

      jmp   p_irq12

p_irq13:

     call  restore_caller

     mov   edi,13
     call  irqhandler

     call  return_to_caller

     jmp   p_irq13

p_irq14:

     call  restore_caller
     
     mov   edi,14
     call  irqhandler

     call  return_to_caller

     jmp   p_irq14

p_irq15:

     call  restore_caller

     mov   edi,15
     call  irqhandler

     call  return_to_caller

     jmp   p_irq15



align 4
restore_caller:

      mov    edi,[0x3000]
      shl    edi, 3
      mov    [edi+gdts+ tss0 +5], word 01010000b *256 +11101001b

      ret

align 4
return_to_caller:

      mov   ebx,[0x3000]
      shl   bx,3
      add   bx,tss0;t
      mov   [tss_irq12],bx

           db    0xea
           dd    0
tss_irq12  dw    tss0;t

           ret

uglobal
  irqh dd 0x0
endg

irqhandler:

     push   edi

     mov    esi,edi          ; 1
     shl    esi,6            ; 1
     add    esi,irq00read    ; 1
     shl    edi,12           ; 1
     add    edi,0x2E0000

     mov    [check_idle_semaphore],5

   irqnewread:

     mov    dx,[esi]         ; 2+

     cmp    dx,0             ; 1
     jz     irqover
     cmp    [esi+3],byte 1   ; 2     ; byte read
     jne    noirqbyte        ; 4-11

     in     al,dx

     mov    edx,[edi]
     cmp    edx,4000
     je     irqfull
     mov    ebx,edi
     add    ebx,0x10
     add    ebx,edx
     mov    [ebx],al
     inc    edx
     mov    [edi],edx

     add    esi,4
     jmp    irqnewread

   noirqbyte:


     cmp    [esi+3],byte 2     ; word read
     jne    noirqword

     in     ax,dx

     mov    edx,[edi]
     cmp    edx,4000
     je     irqfull
     mov    ebx,edi
     add    ebx,0x10
     add    ebx,edx
     mov    [ebx],ax
     add    edx,2
     mov    [edi],edx
     add    esi,4
     jmp    irqnewread

   noirqword:
   irqfull:
   irqover:

     mov    al,0x20            ; ready for next irq
     out    0x20,al

     pop    ebx
     cmp    ebx,7
     jbe    noa0
     out    0xa0,al
   noa0:

     ret


; this code should never get control!
; applications can use only 0x40 interrupt
unknown_interrupt:
 @@: call   change_task
     jmp    @b



compare_to_thread:

         push ebx

         mov  eax,edx
         shl  eax, 3
         add  eax,gdts+ app_code-3
         mov  ebx,[eax]
         cmp  ebx,[old_code_0]
         jne  ctt0
         mov  ebx,[eax+4]
         cmp  ebx,[old_code_1]
         jne  ctt0

         pop  ebx
         mov  eax,1
         ret

       ctt0:

         pop  ebx
         mov  eax,0
         ret



check_for_thread_mem:

         pusha

         mov  ecx,[0x3004]
       cftm0:
         mov  eax,ecx
         shl  eax, 8
         add  eax,gdts+ app_code-3
         mov  ebx,[eax]
         cmp  ebx,[old_code_0]
         jne  cftm1
         mov  ebx,[eax+4]
         cmp  ebx,[old_code_1]
         jne  cftm1

         mov  eax,ecx  ; new code segments
         shl  eax, 3 ;imul eax,8
         add  eax,gdts+ app_code-3

         mov  ebx,[new_code_0]
         mov  [eax],ebx
         mov  ebx,[new_code_1]
         mov  [eax+4],ebx

         mov  eax,ecx  ; new data segments
         shl  eax, 3

         add  eax,gdts+ app_data-3

         mov  ebx,[new_data_0]
         mov  [eax],ebx
         mov  ebx,[new_data_1]
         mov  [eax+4],ebx

         cmp  [new_pos],0   ; new memory position segments
         je   no_new_postition_for_thread
         mov  eax,ecx
         shl  eax, 5
         add  eax,0x3000
         mov  ebx,[new_pos]
         mov  [eax+0x10],ebx
       no_new_postition_for_thread:

         mov  eax,ecx       ; new amount of memory
         shl  eax, 8
         add  eax,0x80000
         mov  ebx,[new_amount]
         mov  [eax+0x8C],ebx

       cftm1:

         dec  ecx
         jnz  cftm0

         popa

         ret


save_for_thread_check:

        ; save for thread check

        pusha
        mov    esi,[0x3000]
        ;imul   esi,8
        shl    esi, 3
        add    esi,gdts+ app_code-3 +0
        mov    edi,old_code_0
        mov    ecx,8
        cld
        rep    movsb
        popa

        ret


save_new_position_for_threads:

        ; new code segment for thread check
        pusha
        mov    esi,[0x3000]
        ;imul   esi,8
        shl    esi, 3
        add    esi,gdts+ app_code-3 +0
        mov    edi,new_code_0
        mov    ecx,8
        cld
        rep    movsb
        popa

        ; new data segment for thread check
        pusha
        mov    esi,[0x3000]
        ;imul   esi,8
        shl    esi, 3
        add    esi,gdts+ app_data-3 +0
        mov    edi,new_data_0
        mov    ecx,8
        cld
        rep    movsb
        popa

        ret

set_application_table_status:
        push eax

        mov  eax,[0x3000]
        ;imul eax,32
        shl  eax, 5
        add  eax,0x3000+4
        mov  eax,[eax]

        mov  [application_table_status],eax

        pop  eax

        ret


clear_application_table_status:
        push eax

        mov  eax,[0x3000]
        ;imul eax,32
        shl  eax, 5
        add  eax,0x3000+4
        mov  eax,[eax]

        cmp  eax,[application_table_status]
        jne  apptsl1
        mov  [application_table_status],0
      apptsl1:

        pop  eax

        ret

uglobal
  old_code_0 dd 0x0
  old_code_1 dd 0x0

  ;

  new_code_0 dd 0x0
  new_code_1 dd 0x0

  new_data_0 dd 0x0
  new_data_1 dd 0x0

  new_pos    dd 0x0
  new_amount dd 0x0
endg


sys_resize_app_memory:
        ; eax = 1 - resize
        ;     ebx = new amount of memory

        cmp    eax,1
        jne    no_application_mem_resize
        
        mov    eax,[0x3010]
        cmp    dword [eax+0x10],std_application_base_address
        jz     new_mem_resize ;resize for new type of processes

        add    ebx,4095
        shr    ebx,12
        shl    ebx,12
        mov    ebp,ebx

        ; wait for process table to be free

      rsm0:

        cli
        cmp   [application_table_status],0
        je    rsm1
        sti
        call  change_task
        jmp   rsm0

      rsm1:

        call  set_application_table_status
        sti

        cmp    ebx,0 ; other than zero
        je     mem_resize_unsuccess

        call   save_for_thread_check

        ; find a free place

        mov    esi,[0xfe84]  ; application memory start
        mov    edi,ebp
        add    edi,esi
        dec    edi

      rfgdt:

        mov    edx,2

      rfindgdtl1:

        call   compare_to_thread
        cmp    eax,1
        je     rfindfl3

        mov    ecx,edx
        shl    ecx,3

        ; eax run base -> ebx limit

        mov    al,[ecx+gdts+ app_code-3 +4]
        mov    ah,[ecx+gdts+ app_code-3 +7]
        shl    eax,16
        mov    ax,[ecx+gdts+ app_code-3 +2]
        
;!!mem
        cmp    eax,std_application_base_address
        jz     rfindfl3
;!!mem

        movzx  ebx,word [ecx+gdts+ app_code-3 +0]
        shl    ebx,12
        add    ebx,eax

        cmp    eax,edi
        jg     rfindfl3
        cmp    ebx,esi
        jb     rfindfl3

        add    esi,4096
        add    edi,4096

        cmp    edi,[0xfe8c]        ; < c_memory
        jbe    rfgdt

        jmp    rfind_free_ret_2   ;; not enough memory

      rfindfl3:

        inc    edx
        cmp    edx,[0x3004]
        jbe    rfindgdtl1

     rfindfl1:
     rthread_c:

        mov    ecx,[0x3000]
        shl    ecx,3

        inc    edi
        sub    edi,esi
        add    edi,4095
        shr    edi,12
        dec    edi

        ; code

        mov    eax,esi
        mov    ebx,edi

        mov    [ecx+gdts+ app_code-3 +2], ax              ;  base  0:15
        shr    eax,16
        mov    [ecx+gdts+ app_code-3 +4], al              ;  base  23:16
        mov    [ecx+gdts+ app_code-3 +7], ah              ;  base  31:24
        mov    [ecx+gdts+ app_code-3 +0], bx              ;  limit

        ; data

        mov    eax,esi
        mov    [ecx+gdts+ app_data-3 +2], ax              ;  base  0:15
        shr    eax,16
        mov    [ecx+gdts+ app_data-3 +4], al              ;  base  23:16
        mov    [ecx+gdts+ app_data-3 +7], ah              ;  base  31:24

        movzx  edx,word [ecx+gdts+ app_code-3 +0]         ;  save limit

        mov    [ecx+gdts+ app_data-3 +0], bx              ;  limit

        and    ebx,0xffff

        cmp    ebx,edx  ; copy smaller from memory sizes
        jge    noedxebxxchg
        mov    edx,ebx
      noedxebxxchg:

        movzx  ecx,dx
        shl    ecx,12
        add    ecx,4096

        mov    edi,esi

        mov    eax,[0x3010]
        mov    esi,[eax+0x10]

        mov    [eax+0x10],edi  ; new memory position

        mov    eax,[0x3000]    ; new memory size
        shl    eax,8
        add    eax,0x80000
        mov    [eax+0x8c],ebp

        mov    [new_pos],edi    ; new position for threads
        mov    [new_amount],ebp ; new amount of mem for threads

        cmp    esi,edi
        je     no_app_move

        cld
        rep    movsb           ; move the app image to the new position

      no_app_move:

        call   save_new_position_for_threads
        call   check_for_thread_mem

        mov    [application_table_status],0

        mov    [esp+36],dword 0 ; eax <- 0 ; successfull

        ret

     rfind_free_ret_2:

     mem_resize_unsuccess:

        mov    [application_table_status],0

        mov    [esp+36],dword 1 ; eax <- 1 ; unsuccessfull

        ret

     no_application_mem_resize:


        ret


align 4
find_free_mem:

        push   eax
        push   ebx
        push   ecx
        push   edx
        push   edi

        call   find_free_process_slot
        mov    eax,[new_process_place]

        cmp    eax,max_processes
        jg     find_free_ret_2

        cmp    [thread_create],1
        je     thread_c

        mov    esi,[0xfe84]
        add    edi,esi
        dec    edi

        mov    eax,2
        cmp    dword [0x3004],1
        je     findf4

     fgdt:

        mov    edx,2

      findgdtl1:

        mov    ecx,edx
        shl    ecx,3

        ; eax run base -> ebx limit

        mov    al,[ecx+gdts+ app_code-3 +4]
        mov    ah,[ecx+gdts+ app_code-3 +7]
        shl    eax,16
        mov    ax,[ecx+gdts+ app_code-3 +2]
;!!mem
        cmp    eax,std_application_base_address
        jz     findfl3
;!!mem

        movzx  ebx,word [ecx+gdts+ app_code-3 +0]
        shl    ebx,12
        add    ebx,eax

        cmp    eax,edi
        jg     findfl3
        cmp    ebx,esi
        jb     findfl3

        add    esi,4096
        add    edi,4096

        cmp    edi,[0xfe8c]        ; < c_memory
        jbe    fgdt

        jmp    find_free_ret_2

      findfl3:

        inc    edx
        cmp    edx,[check_processes]
        jbe    findgdtl1

     findfl1:
     thread_c:

         mov    eax,[new_process_place]

     findf4:

        mov    [first_gdt_search],eax
        mov    [gdt_place],eax

        mov    ecx,eax
        shl    ecx,3

        inc    edi
        sub    edi,esi
        add    edi,4095
        shr    edi,12
        dec    edi

        ; code

        mov    eax,esi
        mov    ebx,edi

        mov    [ecx+gdts+ app_code-3 +2], ax                   ;  base  0:15
        shr    eax,16
        mov    [ecx+gdts+ app_code-3 +4], al                   ;  base  23:16
        mov    [ecx+gdts+ app_code-3 +7], ah                   ;  base  31:24
        mov    [ecx+gdts+ app_code-3 +0], bx                   ;  limit
        mov    [ecx+gdts+ app_code-3 +5], word 11010000b *256 +11111010b

        ; data

        mov    eax,esi
        mov    [ecx+gdts+ app_data-3 +2], ax                   ;  base  0:15
        shr    eax,16
        mov    [ecx+gdts+ app_data-3 +4], al                   ;  base  23:16
        mov    [ecx+gdts+ app_data-3 +7], ah                   ;  base  31:24
        mov    [ecx+gdts+ app_data-3 +0], bx                   ;  limit
        mov    [ecx+gdts+ app_data-3 +5], word 11010000b *256 +11110010b

        push   esi
        mov    esi,process_loading
        call   sys_msg_board_str
        pop    esi

      find_free_ret:

        pop    edi
        pop    edx
        pop    ecx
        pop    ebx
        pop    eax
        ret

      find_free_ret_2:

        cmp    [dec3004],0
        je     no3004inc
        dec    dword [0x3004]
      no3004inc:

        pop    edi
        pop    edx
        pop    ecx
        pop    ebx
        pop    eax
        mov    esi,0
        ret


get_app_params:

    push eax

    cmp  [0x90000+6],word '00'
    jne  no_00_header

    mov  eax,[0x90000+12]
    mov  [app_start],eax
    mov  eax,[0x90000+16]
    mov  [app_i_end],eax
    mov  eax,[0x90000+20]
    mov  [app_mem],eax
    shr  eax,1
    sub  eax,0x10
    mov  [app_esp],eax
    mov  eax,[0x90000+24]
    mov  [app_i_param],eax
    mov  [app_i_icon],dword 0

    pop  eax
    mov  esi,1
    ret

  no_00_header:


    cmp  [0x90000+6],word '01'
    jne  no_01_header

    mov  eax,[0x90000+12]
    mov  [app_start],eax
    mov  eax,[0x90000+16]
    mov  [app_i_end],eax
    mov  eax,[0x90000+20]
    mov  [app_mem],eax
    mov  eax,[0x90000+24]
    mov  [app_esp],eax
    mov  eax,[0x90000+28]
    mov  [app_i_param],eax
    mov  eax,[0x90000+32]
    mov  [app_i_icon],eax

    pop  eax
    mov  esi,1
    ret

   no_01_header:

    pop  eax
    mov  esi,0
    ret


start_application_fl:
    jmp new_start_application_fl

;************************************************************************

start_application_floppy:
    jmp  new_start_application_floppy

;********************************************************************

start_application_hd:
    jmp   new_start_application_hd

uglobal
  threadstring       dd  0x0
  new_process_place  dd  0x0
  check_processes    dd  0x0
  dec3004            db  0x0
  app_start    dd  0x0
  app_i_end    dd  0x0
  app_mem      dd  0x0
  app_esp      dd  0x0
  app_i_param  dd  0x0
  app_i_icon   dd  0x0
  app_mem_pos  dd  0x0
  thread_create    dd 0x0
  gdt_place        dd 0x0
endg

iglobal
  hd_app_string      db  'HDAPP       '
  process_loading    db 'K : Process - loading ',13,10,0
  process_running    db 'K : Process - done',13,10,0
  first_gdt_search   dd 0x2
endg


sys_threads:

; eax=1 create thread
;
;   ebx=thread start
;   ecx=thread stack value
;
; on return : eax = pid
jmp new_sys_threads
    cli
    cmp   [application_table_status],0
    je    stth9
    sti
    call  change_task
    jmp   sys_threads
  stth9:

    call  set_application_table_status

    sti

    cmp  eax,1
    jne  no_sys_thread_create
    cli

    mov  eax,[0x3010]
    mov  eax,[eax+0x10]
    mov  [app_mem_pos],eax

    mov  [app_i_param],0
    mov  [app_i_icon],0

    mov  [app_start],ebx
    mov  [app_esp],ecx

    mov  ebx,[0x3000]
    shl  ebx,8
    add  ebx,0x80000
    mov  [threadstring],ebx
    mov  ebx,[ebx+0x8c]
    mov  [app_mem],ebx

    mov  esi,[app_mem_pos]
    mov  edi,[app_mem]
    add  edi,esi
    dec  edi
    mov  [thread_create],1
    call find_free_mem
    cmp  esi,0
    jne  th_cr1
    mov  [application_table_status],0
    mov  eax,1   ; no free memory
    sti
    ret
  th_cr1:
    push dword 0
    push dword [threadstring]
    jmp  add_app_parameters
  no_sys_thread_create:

    mov  eax,-1
    mov  [application_table_status],0
    ret


find_free_process_slot:

    pusha

    mov   ebx,[0x3004]
    mov   [check_processes],ebx
    inc   ebx
    mov   [new_process_place],ebx

    mov   ebx,2

  newfps:

    mov   eax,ebx
    ;imul  eax,0x20
    shl   eax, 5
    add   eax,0x3000+0xa
    cmp   [eax],byte 9
    je    ffpl

    inc   ebx
    cmp   ebx,[0x3004]
    jbe   newfps

    ;mov   [dec3004],0
    mov   [dec3004],1
    shl   ebx,5
    mov   [0x3000+0xa+ebx],byte 9
    inc   dword [0x3004]

    popa
    ret

  ffpl:

    ;mov   [dec3004],1
    ;dec   dword [0x3004]
    mov   [dec3004],0
    mov   [new_process_place],ebx

    popa
    ret


add_app_parameters:
; returns:  eax = pid or -1 if unsuccesfull
    cmp   [app_i_param],dword 0     ; parameter
    jz    no_app_params
    xor   eax, eax
    mov   edi,[app_i_param]
    add   edi,[app_mem_pos]
    mov   ecx,256/4
    cld
    rep   stosd
    mov   esi,[esp+4]
    test  esi, esi
    jz    no_app_params
    mov   eax,[app_i_param]
    add   eax,[app_mem_pos]
    mov   edi,eax
    mov   ecx,256
    cld
  app_new_param:
    cmp   [esi],byte 0
    jz    no_app_params
    movsb
    loop  app_new_param
  no_app_params:

    ;inc   dword [0x3004]            ; increase number of processes
    mov   ebx,[new_process_place]

    mov   edi,ebx                   ; clear 0x80000 (256 bytes)
    shl   edi,8
    add   edi,0x80000
    mov   ecx,256 / 4
    mov   eax,0
    cld
    rep   stosd

    shl   ebx,5                     ; * 32 +0x3000
    add   ebx,0x3000

    mov   al,byte [new_process_place] ; screen id ?
    mov   [ebx+0xe],al

    mov   [ebx],dword 1+2+4         ; report events: windowdraw, key, button

    inc   dword [process_number]    ; process id number
    mov   eax,[process_number]
    mov   [ebx+4],eax

    mov   ecx,ebx                   ; set draw limits
    add   ecx,draw_data-0x3000
    mov   [ecx+0],dword 0
    mov   [ecx+4],dword 0
    mov   eax,[0xfe00]
    mov   [ecx+8],eax
    mov   eax,[0xfe04]
    mov   [ecx+12],eax

    mov   eax,[app_mem_pos]        ; position in memory
    mov   [ebx+0x10],eax

    ; TSS
    xor   ebx,ebx
    cmp   [thread_create],ebx
    jnz   clone_cr3_table
    mov   eax,[new_process_place]
    call  create_app_cr3_table
    jmp   set_cr3
clone_cr3_table:
;    mov   eax,[new_process_place]
;    mov   ebx,[0x3000]
;    call  addreference_app_cr3_table
    mov   eax,[0x3000]
    call  get_cr3_table
set_cr3:
    add   eax,8+16
    mov   [l.cr3],eax
    
    mov   eax,[app_start]
    mov   [l.eip],eax
    mov   eax,[app_esp]
    mov   [l.esp],eax

    mov   ebx,[new_process_place]              ; gdt's
    shl   ebx,3

    mov   ax,app_code
    add   ax,bx
    mov   [l.cs],ax
    mov   ax,app_data
    add   ax,bx
    mov   [l.ss],ax
    mov   [l.ds],ax
    mov   [l.es],ax
    mov   [l.fs],ax
    mov   ax,graph_data
    mov   [l.gs],ax
    mov   [l.io],word 128
    mov   [l.eflags],dword 0x11202
    mov   [l.ss0], os_data
    ;mov   [l.ss1], ring1_data
    ;mov   [l.ss2], ring2_data
    ; [Ivan 07.03.2005]
    mov   [l.esp0], 0x8000 ;0x55000 ; used by i38 handler
    ; [/Ivan 07.03.2005]
    mov   [l.esp1], 0x56000
    mov   [l.esp2], 0x57000

    mov   eax,tss_sceleton          ; move tss to tss_data+
    mov   ebx,[new_process_place]
    imul  ebx,tss_step
    add   ebx,tss_data
    mov   ecx,120
    call  memmove


    ; Add IO access table

    or   eax, -1
    mov  edi, [new_process_place]
    imul edi, tss_step
    add  edi, tss_data + 128
    mov  ecx, 2048 ; for 2048 * 4 * 8 bits = 65536 ports
    cld
    rep  stosd

    ; make sure gdt is pointing to the process
    ; and not to i40 handler

    mov   ecx,ebx
    mov   edi,[new_process_place]
;    imul  edi,8
    shl   edi, 3

    mov   [edi+gdts+ tss0 +0], word tss_step     ; limit 0:15
    mov   [edi+gdts+ tss0 +2], cx                ; base  0:15
    mov   eax,ecx
    shr   eax,16
    mov   [edi+gdts+ tss0 +4], al                ; base  23:16
    mov   [edi+gdts+ tss0 +7], ah                ; base  31:24
    mov   [edi+gdts+ tss0 +5], word 01010000b *256 +11101001b

    pop   eax
    pop   ebx

    mov   ebx,[new_process_place]              ; save name of the process
    shl   ebx,8
    add   ebx,0x80000
    mov   ecx,11
    call  memmove

    mov   ebx,[new_process_place]              ; save image size
    shl   ebx,8
    add   ebx,0x80000+0x8C
    mov   eax,[app_mem]
    mov   [ebx],eax

    mov   [0xf400],byte 0           ; empty keyboard buffer
    mov   [0xf500],byte 0           ; empty button buffer

    mov   [application_table_status],0
    mov   eax,[process_number]

    mov   ebx,[new_process_place]
    shl   ebx, 5 ;imul  ebx,0x20
    mov   [0x3000+ebx+0xa],byte 0

    mov   edi,[new_process_place]
    shl   edi,5
    add   edi,window_data

    mov   ebx,[new_process_place]
    movzx  esi, word [0xC000 + ebx*2]
    lea    esi, [0xC400 + esi*2]
    call   windowactivate

    sti

    push   esi
    mov    esi,process_running
    call   sys_msg_board_str
    pop    esi

    ret

iglobal
  process_terminating   db 'K : Process - terminating',13,10,0
  process_terminated    db 'K : Process - done',13,10,0
endg


terminate: ; terminate application
    push   esi
    mov    esi,process_terminating
    call   sys_msg_board_str
    pop    esi
;start memory manager code    
;    mov    eax,esi
;    call   MEM_Heap_Clean
;end memory manager code
    

    cli
    cmp   [application_table_status],0
    je    term9
    sti
    call  change_task
    jmp   terminate
  term9:

    call  set_application_table_status
    
    mov    eax,esi
    call   dispose_app_cr3_table

    mov   [first_gdt_search],0x2   ; start gdt search from beginning

    cmp   [prev_user_of_fpu],esi   ; if user fpu last -> fpu user = 1
    jne   fpu_ok_1
    mov   [prev_user_of_fpu],1
  fpu_ok_1:

    mov   [0xf400],byte 0           ; empty keyboard buffer
    mov   [0xf500],byte 0           ; empty button buffer

    mov   ecx,esi                               ; clear memory reserv.
    shl   ecx,3
    mov   [ecx+gdts+ app_code-3 +0],dword 0
    mov   [ecx+gdts+ app_code-3 +4],dword 0
    mov   [ecx+gdts+ app_data-3 +0],dword 0
    mov   [ecx+gdts+ app_data-3 +4],dword 0

    mov   edi, esi
;    shl   edi, 5
;    add   edi, 0x3000
;    cmp   [edi+0xa],byte 3  ; if normal terminate then clear int40 handler
;    jne   nocl40

;    mov   edi,esi   ; free the used interrupt 0x40 handler
;    shl   edi, 8 ;imul  edi,256
;    mov   eax,[edi+0x80000+0xb0]

;    cmp   eax,0     ; is application using a systemcall interrupt  ?
;    je    nocl40

    mov   [usedi40+eax],byte 0

;    mov   edi,8
;    imul  edi,eax
    mov   edi, eax
    shl   edi, 3
    mov   [edi+tss0sys_l +5], word 01010000b *256 +11101001b

;    mov   edi,128
;    imul  edi,eax
    mov   edi, eax
    shl   edi, 7
    mov   [edi+0x298000+l.eip-tss_sceleton],dword i40
    mov   [edi+0x298000+l.eflags-tss_sceleton],dword 0x11002

    mov   ebx,eax
    shl   ebx, 12 ;imul  ebx,4096
    add   ebx,sysint_stack_data
    mov   [edi+0x298000+l.esp-tss_sceleton],ebx

  nocl40:

    mov   ecx,esi                 ; remove buttons
  bnewba2:
    mov   edi,[0xfe88]
    mov   eax,edi
    cld
    movzx ebx,word [edi]
    inc   bx
  bnewba:
    dec   bx
    jz    bnmba
    add   eax,0x10
    cmp   cx,[eax]
    jnz   bnewba
    pusha
    mov   ecx,ebx
    inc   ecx
    shl   ecx,4
    mov   ebx,eax
    add   eax,0x10
    call  memmove
    dec   dword [edi]
    popa
    jmp   bnewba2
  bnmba:

    pusha     ; save window coordinates for window restoring
    cld
    shl   esi,5
    add   esi,window_data
    mov   ax,[esi+0]
    mov   word [dlx],ax
    mov   bx,[esi+8]
    add   ax,bx
    mov   word [dlxe],ax
    mov   ax,[esi+4]
    mov   word [dly],ax
    mov   bx,[esi+12]
    add   ax,bx
    mov   word [dlye],ax
    mov   [esi+0],word 0
    mov   [esi+8],word 5
    mov   ax,[0xFE04]
    mov   [esi+4],ax
    mov   [esi+12],word 5
    xor   eax, eax
    mov   [esi+16],eax;dword 0
    mov   [esi+20],eax;dword 0
    mov   [esi+24],eax;dword 0
    mov   [esi+28],eax;dword 0
    popa

    pusha
    mov   edi,esi
    shl   edi,5
    add   edi,window_data
    mov   ecx,32/4
    xor   eax, eax
  ;  cld
    rep   stosd

    mov   eax,[0xFE04]      ; set window to start from maxy+1
    add   eax,2

    mov   edi,esi
    shl   edi,5
    add   edi,window_data
    mov   [edi+4],eax

    popa

    pusha
    mov   edi,esi
    shl   edi,5
    add   edi,draw_data
    mov   ecx,32/4
    xor   eax, eax
  ;  cld
    rep   stosd
    popa

    pusha         ; at 0x80000+
    mov   edi,esi
    shl   edi,8
    add   edi,0x80000
    mov   ecx,256/4
    xor   eax, eax
  ;  cld
    rep   stosd
    popa

    pusha          ; name to spaces
    mov   edi,esi
    shl   edi,8
    add   edi,0x80000
    mov   ecx,11
    mov   eax,' '
  ;  cld
    rep   stosb
    popa

    pusha                ; C000 --> C400
    mov   eax, 0xc000
    mov   esi, 0
  nlc40:
    add   eax, 2
    inc   esi
    cmp   esi, [0x3004]
    jae   nlc41
    movzx ecx, word [eax]
    mov   [0xC400 + ecx*2], si
    jmp   nlc40
  nlc41:
 ; ivan 08.12.2004 begin
    ;mov   ebx, [0x3004]
    ;dec   ebx
    ;lea   esi, [0xC400 + ebx*2]
    ;call  windowactivate
 ; ivan 08.12.2004 end
    popa

    pusha ; remove hd1 reservation
    mov   edx,esi
    shl   edx, 5 ;imul  edx,0x20
    add   edx,0x3000
    mov   edx,[edx+4]
    cmp   [hd1_status],edx
    jne   no_hd1_s_remove
    mov   [hd1_status],0
  no_hd1_s_remove:
    popa

    pusha ; remove all irq reservations
    mov   edx,esi
    shl   edx, 5 ;imul  edx,0x20
    add   edx,0x3000
    mov   edx,[edx+4]
    mov   edi,irq_owner
    mov   ecx,16
  newirqfree:
    cmp   [edi],edx
    jne   nofreeirq
    mov   [edi],dword 0
  nofreeirq:
    add    edi,4
    loop   newirqfree
    popa


    pusha                     ; remove all port reservations

    mov   edx,esi
    shl   edx, 5 ;imul  edx,0x20
    add   edx,0x3000
    mov   edx,[edx+4]

  rmpr0:

    mov   esi,[0x2d0000]

    cmp   esi,0
    je    rmpr9

  rmpr3:

    mov   edi,esi
    shl   edi,4
    add   edi,0x2d0000

    cmp   edx,[edi]
    je    rmpr4

    dec   esi
    jnz   rmpr3

    jmp   rmpr9

  rmpr4:

    mov   ecx,256
    sub   ecx,esi
    shl   ecx,4

    mov   esi,edi
    add   esi,16
    cld
    rep   movsb

    dec   dword [0x2d0000]

    jmp   rmpr0

  rmpr9:

    popa
    mov  edi,esi         ; do not run this process slot
    shl  edi, 5 ;imul edi,0x20
;    add  edi,0x3000
    mov  [edi+0x300A],byte 9
;    call  systest
    sti  ; .. and life goes on

;    movzx eax,word [dlx]
;    movzx ebx,word [dly]
;    movzx ecx,word [dlxe]
;    movzx edx,word [dlye]
    call  calculatescreen

    xor   eax, eax
    xor   esi, esi
    call  redrawscreen

    mov   [0xfff4],byte 0  ; no mouse background
    mov   [0xfff5],byte 0  ; draw mouse

    mov   [application_table_status],0

    mov   esi,process_terminated
    call  sys_msg_board_str

;* start code - fix error redraw for terminate (2) - Mario79
;     cmp  [draw_present],1
;     je  no_draw_background_temp
;     mov   [0xfff0],byte 1
;no_draw_background_temp:
;    mov   [draw_present],0
    ret
;draw_present db 0
;* end code - fix error redraw for terminate (2) - Mario79

iglobal
  boot_sched_1    db   'Building gdt tss pointer',0
  ;boot_sched_2    db   'Building gdt gate pointer',0
  boot_sched_3    db   'Building interrupt table - TSS',0
  boot_sched_3_2  db   'Building interrupt table - GDT',0
  boot_sched_3_3  db   'Building interrupt table - IDT',0
  boot_sched_4    db   'Building syscall interrupt table',0
endg


build_scheduler:
      ; { Ivan 06.03.2005
        mov    edi, usedi40
        mov    ecx, 256/4
        xor    eax, eax
        rep    stosd
      ; } Ivan 06.03.2005

        mov    esi,boot_sched_1
        call   boot_log
        call   build_process_gdt_tss_pointer

;        mov    esi,boot_sched_2
;        call   boot_log
;        call   build_process_gdt_gate_pointer

        mov    esi,boot_sched_3
        call   boot_log
        call   build_interrupt_table

        mov    esi,boot_sched_4
        call   boot_log
        call   build_syscall_interrupt_table

        ret