WebSVN – Kolibri OS – Diff – /kernel/branches/net/core/sys32.inc


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2008. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;                                                              ;;
;;  MenuetOS process management, protected ring3                ;;
;;                                                              ;;
;;  Distributed under GPL. See file COPYING for details.        ;;
;;  Copyright 2003 Ville Turjanmaa                              ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 1206 $
 
 
align 4 ;3A08
build_interrupt_table:
        mov     edi, idts
        mov     esi, sys_int
        mov     ecx, 0x40
        mov     eax, (10001110b shl 24) + os_code
  @@:   movsw   ;low word of code-entry
        stosd   ;interrupt gate type : os_code selector
        movsw   ;high word of code-entry
        loop    @b
        movsd   ;copy low  dword of trap gate for int 0x40
        movsd   ;copy high dword of trap gate for int 0x40
        lidt    [esi]
        ret
 
iglobal
  align 4
  sys_int:
    ;exception handlers addresses (for interrupt gate construction)
        dd      e0,e1,e2,e3,e4,e5,e6,except_7 ; SEE: core/fpu.inc
        dd      e8,e9,e10,e11,e12,e13,page_fault_exc,e15
        dd      e16, e17,e18, e19
        times   12 dd unknown_interrupt ;int_20..int_31
 
    ;interrupt handlers addresses (for interrupt gate construction)
        dd      irq0, irq_serv.irq_1, irq_serv.irq_2
    if  USE_COM_IRQ
        dd      irq_serv.irq_3, irq_serv.irq_4
    else
        dd      p_irq3, p_irq4 ;??? íåñòûêîâêà
    end if
        dd      irq_serv.irq_5,  p_irq6,          irq_serv.irq_7
        dd      irq_serv.irq_8,  irq_serv.irq_9,  irq_serv.irq_10
        dd      irq_serv.irq_11, irq_serv.irq_12, irqD,p_irq14,p_irq15
        times   16 dd unknown_interrupt ;int_0x30..int_0x3F
 
    ;int_0x40 gate trap (for directly copied)
        dw      i40 and 0xFFFF, os_code, 11101111b shl 8, i40 shr 16
 
  idtreg: ; data for LIDT instruction (!!! must be immediately below sys_int data)
        dw      2*($-sys_int-4)-1
        dd      idts ;0x8000B100
        dw      0    ;ïðîñòî âûðàâíèâàíèå
 
  msg_fault_sel dd  msg_exc_8,msg_exc_u,msg_exc_a,msg_exc_b
                dd  msg_exc_c,msg_exc_d,msg_exc_e
 
  msg_exc_8     db "Double fault", 0
  msg_exc_u     db "Undefined Exception", 0
  msg_exc_a     db "Invalid TSS", 0
  msg_exc_b     db "Segment not present", 0
  msg_exc_c     db "Stack fault", 0
  msg_exc_d     db "General protection fault", 0
  msg_exc_e     db "Page fault", 0
 
  msg_sel_ker   db "kernel", 0
  msg_sel_app   db "application", 0
 
endg
 
macro save_ring3_context {
        pushad
}
macro restore_ring3_context {
        popad
}
macro exc_wo_code [num] {
  e#num :
        save_ring3_context
        mov     bl, num
        jmp     exc_c
} exc_wo_code   0,1,2,3,4,5,6,15,16,19
 
macro exc_w_code [num] {
  e#num :
        add     esp, 4
        save_ring3_context
        mov     bl, num
        jmp     exc_c
} exc_w_code    8,9,10,11,12,13,17,18
 
 
uglobal
  pf_err_code   dd ?
endg
 
page_fault_exc:                 ; äóðàêîóñòî÷èâîñòü: ñåëåêòîðû èñïîð÷åíû...
        pop     [ss:pf_err_code]; äåéñòâèòåëüíî äî ñëåäóþùåãî #PF
        save_ring3_context
        mov     bl,14
 
exc_c:                          ; èñêëþ÷åíèÿ (âñå, êðîìå 7-ãî - #NM)
; Ôðýéì ñòåêà ïðè èñêëþ÷åíèè/ïðåðûâàíèè èç 3-ãî êîëüöà + pushad (ò.å., èìåííî çäåñü)
  reg_ss        equ esp+0x30
  reg_esp3      equ esp+0x2C
  reg_eflags    equ esp+0x28
  reg_cs3       equ esp+0x24
  reg_eip       equ esp+0x20
 ; ýòî ôðýéì îò pushad
  reg_eax       equ esp+0x1C
  reg_ecx       equ esp+0x18
  reg_edx       equ esp+0x14
  reg_ebx       equ esp+0x10
  reg_esp0      equ esp+0x0C
  reg_ebp       equ esp+0x08
  reg_esi       equ esp+0x04
  reg_edi       equ esp+0x00
 
        Mov     ds,ax,app_data  ; çàãðóçèì ïðàâèëüíûå çíà÷åíèÿ
        mov     es,ax           ; â ñåãìåíòíûå ðåãèñòðû
        cld                     ; è ïðèâîäèì DF ê ñòàíäàðòó
        movzx   ebx,bl
; redirect to V86 manager? (EFLAGS & 0x20000) != 0?
        test    byte[reg_eflags+2],2
        jnz     v86_exc_c
        cmp     bl,14           ; #PF
        jne     @f
        call    page_fault_handler ; SEE: core/memory.inc
  @@:   mov     esi, [current_slot]
        btr     [esi+APPDATA.except_mask], ebx
        jnc     @f
        mov     eax,[esi+APPDATA.exc_handler]
        test    eax, eax
        jnz     IRetToUserHook
  @@:   cli
        mov     eax, [esi+APPDATA.debugger_slot]
        test    eax, eax
        jnz     .debug
        sti
; not debuggee => say error and terminate
        call    show_error_parameters ;; only ONE using, inline ???
       ;mov     edx, [TASK_BASE]
        mov     [edx + TASKDATA.state], byte 4 ; terminate
        jmp     change_task     ; stack - here it does not matter at all, SEE: core/shed.inc
.debug:
; we are debugged process, notify debugger and suspend ourself
; eax=debugger PID
        mov     ecx,1           ; debug_message code=other_exception
        cmp     bl,1            ; #DB
        jne     .notify         ; notify debugger and suspend ourself
        mov     ebx, dr6        ; debug_message data=DR6_image
        xor     edx, edx
        mov     dr6, edx
        mov     edx, dr7
        mov     cl, not 8
  .l1:  shl     dl,2
        jc      @f
        and     bl, cl
  @@:   sar     cl,1
        jc      .l1
        mov     cl, 3           ; debug_message code=debug_exception
.notify:
        push    ebx             ; debug_message data
        mov     ebx, [TASK_BASE]
        push    [ebx+TASKDATA.pid] ; PID
        push    ecx             ; debug_message code ((here: ecx==1/3))
        mov     cl, 12          ; debug_message size
        call    debugger_notify ;; only ONE using, inline ??? SEE: core/debug.inc
        add     esp,12
        mov     edx, [TASK_BASE]
        mov     byte [edx+TASKDATA.state], 1 ; suspended
        call    change_task     ; SEE: core/shed.inc
        restore_ring3_context
        iretd
 
IRetToUserHook:
        xchg    eax, [reg_eip]
        sub     dword[reg_esp3], 8
        mov     edi, [reg_esp3]
        stosd
        mov     [edi], ebx
        restore_ring3_context
unknown_interrupt:
        iretd
 
;-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
show_error_parameters:
        mov     edx,[TASK_BASE] ;not scratched below
        DEBUGF  1, "K : Process - forced terminate PID: %x\n", [edx+TASKDATA.pid]
        cmp     bl, 0x08
        jb      .l0
        cmp     bl, 0x0e
        jbe     .l1
  .l0:  mov     bl, 0x09
  .l1:  mov     eax,[msg_fault_sel+ebx*4 - 0x08*4]
        DEBUGF  1, "K : %s\n", eax
        mov     eax, [reg_cs3+4]
        mov     edi, msg_sel_app
        mov     ebx, [reg_esp3+4]
        cmp     eax, app_code
        je      @f
        mov     edi, msg_sel_ker
        mov     ebx, [reg_esp0+4]
    @@: DEBUGF  1, "K : EAX : %x EBX : %x ECX : %x\n", [reg_eax+4], [reg_ebx+4], [reg_ecx+4]
        DEBUGF  1, "K : EDX : %x ESI : %x EDI : %x\n", [reg_edx+4], [reg_esi+4], [reg_edi+4]
        DEBUGF  1, "K : EBP : %x EIP : %x ESP : %x\n", [reg_ebp+4], [reg_eip+4], ebx
        DEBUGF  1, "K : Flags : %x CS : %x (%s)\n", [reg_eflags+4], eax, edi
        ret
;-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 
  restore  reg_ss
  restore  reg_esp3
  restore  reg_eflags
  restore  reg_cs
  restore  reg_eip
  restore  reg_eax
  restore  reg_ecx
  restore  reg_edx
  restore  reg_ebx
  restore  reg_esp0
  restore  reg_ebp
  restore  reg_esi
  restore  reg_edi
 
; irq1  ->  hid/keyboard.inc
macro irqh [num] {
  p_irq#num :
        mov     edi, num
        jmp     irqhandler
}
 
 
 
p_irq6:
        save_ring3_context
        mov     ax, app_data  ;os_data
        mov     ds, ax
        mov     es, ax
        mov     edi, 6
        cmp     [v86_irqhooks+edi*8], 0
        jnz     v86_irq2
        call    fdc_irq
        call    ready_for_next_irq
        restore_ring3_context
        iret
 
 
p_irq14:
        save_ring3_context
        mov     ax, app_data  ;os_data
        mov     ds, ax
        mov     es, ax
        mov     edi, 14
        cmp     [v86_irqhooks+edi*8], 0
        jnz     v86_irq2
;       mov     byte [BOOT_VAR + 0x48E], 0xFF
        call    [irq14_func]
        call    ready_for_next_irq_1
        restore_ring3_context
        iret
p_irq15:
        save_ring3_context
        mov     ax, app_data  ;os_data
        mov     ds, ax
        mov     es, ax
        mov     edi, 15
        cmp     [v86_irqhooks+edi*8], 0
        jnz     v86_irq2
;       mov     byte [BOOT_VAR + 0x48E], 0xFF
        call    [irq15_func]
        call    ready_for_next_irq_1
        restore_ring3_context
        iret
 
ready_for_next_irq:
        mov     [check_idle_semaphore],5
        mov     al, 0x20
        out     0x20, al
        ret
 
ready_for_next_irq_1:
        mov     [check_idle_semaphore],5
        mov     al, 0x20
        out     0xa0,al
        out     0x20, al
        ret
 
irqD:
        push  eax
        mov   al,0
        out   0xf0,al
        mov   al,0x20
        out   0xa0,al
        out   0x20,al
        pop   eax
        iret
 
 
irqh 2,3,4,5,7,8,9,10,11
 
irqhandler:
 
     mov    esi,edi          ; 1
     shl    esi,6            ; 1
     add    esi,irq00read    ; 1
     shl    edi,12           ; 1
     add    edi,IRQ_SAVE
     mov    ecx,16
 
   irqnewread:
     dec    ecx
     js     irqover
 
     movzx  edx, word [esi]        ; 2+
 
     test   edx, edx               ; 1
     jz     irqover
 
 
     mov    ebx, [edi]             ; address of begin of buffer in edi      ; + 0x0 dword - data size
     mov    eax, 4000                                                       ; + 0x4 dword - data begin offset
     cmp    ebx, eax
     je     irqfull
     add    ebx, [edi + 0x4]       ; add data size to data begin offset
     cmp    ebx, eax               ; if end of buffer, begin cycle again
     jb     @f
 
     xor    ebx, ebx
 
  @@:
     add    ebx, edi
     movzx  eax, byte[esi + 3]     ; get type of data being received 1 - byte, 2 - word
     dec    eax
     jz     irqbyte
     dec    eax
     jnz    noirqword
 
     in     ax,dx
     cmp    ebx, 3999              ; check for address odd in the end of buffer
     jne    .odd
     mov    [ebx + 0x10], ax
     jmp    .add_size
  .odd:
     mov    [ebx + 0x10], al       ; I could make mistake here :)
     mov    [edi + 0x10], ah
  .add_size:
     add    dword [edi], 2
     jmp    nextport
 
 
  irqbyte:
     in     al,dx
     mov    [ebx + 0x10],al
     inc    dword [edi]
  nextport:
     add    esi,4
     jmp    irqnewread
 
 
   noirqword:
   irqfull:
   irqover:
 
     ret
 
 
 
set_application_table_status:
        push eax
 
        mov  eax,[CURRENT_TASK]
        shl  eax, 5
        add  eax,CURRENT_TASK+TASKDATA.pid
        mov  eax,[eax]
 
        mov  [application_table_status],eax
 
        pop  eax
 
        ret
 
 
clear_application_table_status:
        push eax
 
        mov  eax,[CURRENT_TASK]
        shl  eax, 5
        add  eax,CURRENT_TASK+TASKDATA.pid
        mov  eax,[eax]
 
        cmp  eax,[application_table_status]
        jne  apptsl1
        mov  [application_table_status],0
      apptsl1:
 
        pop  eax
 
        ret
 
sys_resize_app_memory:
        ; eax = 1 - resize
        ;     ebx = new amount of memory
 
        cmp    eax,1
        jne    .no_application_mem_resize
 
        stdcall new_mem_resize, ebx
        mov [esp+36], eax
        ret
 
.no_application_mem_resize:
        ret
 
sys_threads:
 
; eax=1 create thread
;
;   ebx=thread start
;   ecx=thread stack value
;
; on return : eax = pid
jmp new_sys_threads
 
iglobal
;  process_terminating  db 'K : Process - terminating',13,10,0
;  process_terminated   db 'K : Process - done',13,10,0
  msg_obj_destroy       db 'K : destroy app object',13,10,0
endg
 
; param
;  esi= slot
 
terminate: ; terminate application
 
           .slot equ esp   ;locals
 
           push   esi      ;save .slot
 
           shl esi, 8
           cmp [SLOT_BASE+esi+APPDATA.dir_table], 0
           jne @F
           pop    esi
           shl    esi, 5
           mov    [CURRENT_TASK+esi+TASKDATA.state], 9
           ret
@@:
           ;mov    esi,process_terminating
           ;call   sys_msg_board_str
@@:
           cli
           cmp   [application_table_status],0
           je    term9
           sti
           call  change_task
           jmp   @b
term9:
           call  set_application_table_status
 
; if the process is in V86 mode...
        mov     eax, [.slot]
        shl     eax, 8
        mov     esi, [eax+SLOT_BASE+APPDATA.pl0_stack]
        add     esi, RING0_STACK_SIZE
        cmp     [eax+SLOT_BASE+APPDATA.saved_esp0], esi
        jz      .nov86
; ...it has page directory for V86 mode
        mov     esi, [eax+SLOT_BASE+APPDATA.saved_esp0]
        mov     ecx, [esi+4]
        mov     [eax+SLOT_BASE+APPDATA.dir_table], ecx
; ...and I/O permission map for V86 mode
        mov     ecx, [esi+12]
        mov     [eax+SLOT_BASE+APPDATA.io_map], ecx
        mov     ecx, [esi+8]
        mov     [eax+SLOT_BASE+APPDATA.io_map+4], ecx
.nov86:
 
           mov esi, [.slot]
           shl esi,8
           add esi, SLOT_BASE+APP_OBJ_OFFSET
@@:
           mov eax, [esi+APPOBJ.fd]
           test eax, eax
           jz @F
 
           cmp eax, esi
           je @F
 
           push esi
           call [eax+APPOBJ.destroy]
           DEBUGF 1,"%s",msg_obj_destroy
           pop esi
           jmp @B
@@:
           mov eax, [.slot]
           shl eax, 8
           mov eax,[SLOT_BASE+eax+APPDATA.dir_table]
           stdcall destroy_app_space, eax
 
           mov esi, [.slot]
           cmp [fpu_owner],esi   ; if user fpu last -> fpu user = 1
           jne @F
 
           mov [fpu_owner],1
           mov eax, [256+SLOT_BASE+APPDATA.fpu_state]
           clts
           bt [cpu_caps], CAPS_SSE
           jnc .no_SSE
           fxrstor [eax]
           jmp @F
.no_SSE:
           fnclex
           frstor [eax]
@@:
 
    mov   [KEY_COUNT],byte 0           ; empty keyboard buffer
    mov   [BTN_COUNT],byte 0           ; empty button buffer
 
 
; remove defined hotkeys
        mov     eax, hotkey_list
.loop:
        cmp     [eax+8], esi
        jnz     .cont
        mov     ecx, [eax]
        jecxz   @f
        push    dword [eax+12]
        pop     dword [ecx+12]
@@:
        mov     ecx, [eax+12]
        push    dword [eax]
        pop     dword [ecx]
        xor     ecx, ecx
        mov     [eax], ecx
        mov     [eax+4], ecx
        mov     [eax+8], ecx
        mov     [eax+12], ecx
.cont:
        add     eax, 16
        cmp     eax, hotkey_list+256*16
        jb      .loop
; remove hotkeys in buffer
        mov     eax, hotkey_buffer
.loop2:
        cmp     [eax], esi
        jnz     .cont2
        and     dword [eax+4], 0
        and     dword [eax], 0
.cont2:
        add     eax, 8
        cmp     eax, hotkey_buffer+120*8
        jb      .loop2
 
    mov   ecx,esi                 ; remove buttons
  bnewba2:
    mov   edi,[BTN_ADDR]
    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   eax,[esi+WDATA.box.left]
    mov   [dlx],eax
    add   eax,[esi+WDATA.box.width]
    mov   [dlxe],eax
    mov   eax,[esi+WDATA.box.top]
    mov   [dly],eax
    add   eax,[esi+WDATA.box.height]
    mov   [dlye],eax
 
    xor   eax, eax
    mov   [esi+WDATA.box.left],eax
    mov   [esi+WDATA.box.width],eax
    mov   [esi+WDATA.box.top],eax
    mov   [esi+WDATA.box.height],eax
    mov   [esi+WDATA.cl_workarea],eax
    mov   [esi+WDATA.cl_titlebar],eax
    mov   [esi+WDATA.cl_frames],eax
    mov   dword [esi+WDATA.reserved],eax ; clear all flags: wstate, redraw, wdrawn
    lea   edi, [esi-window_data+draw_data]
    mov   ecx,32/4
    rep   stosd
    popa
 
; debuggee test
    pushad
    mov  edi, esi
    shl  edi, 5
    mov  eax, [SLOT_BASE+edi*8+APPDATA.debugger_slot]
    test eax, eax
    jz   .nodebug
    push 8
    pop  ecx
    push dword [CURRENT_TASK+edi+TASKDATA.pid]   ; PID
    push 2
    call debugger_notify
    pop  ecx
    pop  ecx
.nodebug:
    popad
 
           mov ebx, [.slot]
           shl ebx, 8
           push ebx
           mov ebx,[SLOT_BASE+ebx+APPDATA.pl0_stack]
 
           stdcall kernel_free, ebx
 
           pop ebx
           mov ebx,[SLOT_BASE+ebx+APPDATA.cur_dir]
           stdcall kernel_free, ebx
 
           mov edi, [.slot]
           shl edi,8
           add edi,SLOT_BASE
 
           mov eax, [edi+APPDATA.io_map]
           cmp eax, (tss._io_map_0-OS_BASE+PG_MAP)
           je @F
           call free_page
@@:
           mov eax, [edi+APPDATA.io_map+4]
           cmp eax, (tss._io_map_1-OS_BASE+PG_MAP)
           je @F
           call free_page
@@:
           mov eax, 0x20202020
           stosd
           stosd
           stosd
           mov ecx,244/4
           xor eax, eax
           rep stosd
 
  ; activate window
        movzx  eax, word [WIN_STACK + esi*2]
        cmp    eax, [TASK_COUNT]
        jne    .dont_activate
        pushad
 .check_next_window:
        dec    eax
        cmp    eax, 1
        jbe    .nothing_to_activate
        lea    esi, [WIN_POS+eax*2]
        movzx  edi, word [esi]               ; edi = process
        shl    edi, 5
        cmp    [CURRENT_TASK + edi + TASKDATA.state], byte 9  ; skip dead slots
        je     .check_next_window
        add    edi, window_data
; \begin{diamond}[19.09.2006]
; skip minimized windows
        test   [edi + WDATA.fl_wstate], WSTATE_MINIMIZED
        jnz    .check_next_window
; \end{diamond}
        call   waredraw
 .nothing_to_activate:
        popad
 .dont_activate:
 
        push    esi     ; remove hd1 & cd & flp reservation
        shl     esi, 5
        mov     esi, [esi+CURRENT_TASK+TASKDATA.pid]
        cmp     [hd1_status], esi
        jnz     @f
        call    free_hd_channel
        mov     [hd1_status], 0
@@:
        cmp     [cd_status], esi
        jnz     @f
        call    free_cd_channel
        mov     [cd_status], 0
@@:
        cmp     [flp_status], esi
        jnz     @f
        mov     [flp_status], 0
@@:
        pop     esi
        cmp     [bgrlockpid], esi
        jnz     @f
        and     [bgrlockpid], 0
        mov     [bgrlock], 0
@@:
 
    pusha ; remove all irq reservations
    mov   eax,esi
    shl   eax, 5
    mov   eax,[eax+CURRENT_TASK+TASKDATA.pid]
    mov   edi,irq_owner
    xor   ebx, ebx
    xor   edx, edx
  newirqfree:
    cmp   [edi + 4 * ebx], eax
    jne   nofreeirq
    mov   [edi + 4 * ebx], edx                          ; remove irq reservation
    mov   [irq_tab + 4 * ebx], edx                      ; remove irq handler
    mov   [irq_rights + 4 * ebx], edx                   ; set access rights to full access
  nofreeirq:
    inc   ebx
    cmp   ebx, 16
    jb    newirqfree
    popa
 
    pusha                     ; remove all port reservations
    mov   edx,esi
    shl   edx, 5
    add   edx,CURRENT_TASK
    mov   edx,[edx+TASKDATA.pid]
 
  rmpr0:
 
    mov   esi,[RESERVED_PORTS]
 
    cmp   esi,0
    je    rmpr9
 
  rmpr3:
 
    mov   edi,esi
    shl   edi,4
    add   edi,RESERVED_PORTS
 
    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 [RESERVED_PORTS]
 
    jmp   rmpr0
 
  rmpr9:
 
    popa
    mov  edi,esi         ; do not run this process slot
    shl  edi, 5
    mov  [edi+CURRENT_TASK + TASKDATA.state],byte 9
; debugger test - terminate all debuggees
    mov  eax, 2
    mov  ecx, SLOT_BASE+2*0x100+APPDATA.debugger_slot
.xd0:
    cmp  eax, [TASK_COUNT]
    ja   .xd1
    cmp  dword [ecx], esi
    jnz  @f
    and  dword [ecx], 0
    pushad
    xchg eax, ecx
    mov  ebx, 2
    call sys_system
    popad
@@:
    inc  eax
    add  ecx, 0x100
    jmp  .xd0
.xd1:
;    call  systest
    sti  ; .. and life goes on
 
    mov   eax, [dlx]
    mov   ebx, [dly]
    mov   ecx, [dlxe]
    mov   edx, [dlye]
    call  calculatescreen
    xor   eax, eax
    xor   esi, esi
    call  redrawscreen
 
    mov   [MOUSE_BACKGROUND],byte 0  ; no mouse background
    mov   [DONT_DRAW_MOUSE],byte 0  ; draw mouse
 
    mov   [application_table_status],0
    ;mov   esi,process_terminated
    ;call  sys_msg_board_str
    add esp, 4
    ret
restore .slot
 
iglobal
  boot_sched_1    db   'Building gdt tss pointer',0
  boot_sched_2    db   'Building IDT table',0
endg
 
 
build_scheduler:
 
        mov    esi,boot_sched_1
        call   boot_log
  ;      call   build_process_gdt_tss_pointer
 
  ;      mov    esi,boot_sched_2
  ;      call   boot_log
 
        ret

Rev 1198	Rev 1206
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2008. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2008. All rights reserved. ;;
4	;; Distributed under terms of the GNU General Public License ;;	4	;; Distributed under terms of the GNU General Public License ;;
5	;; ;;	5	;; ;;
6	;; ;;	6	;; ;;
7	;; MenuetOS process management, protected ring3 ;;	7	;; MenuetOS process management, protected ring3 ;;
8	;; ;;	8	;; ;;
9	;; Distributed under GPL. See file COPYING for details. ;;	9	;; Distributed under GPL. See file COPYING for details. ;;
10	;; Copyright 2003 Ville Turjanmaa ;;	10	;; Copyright 2003 Ville Turjanmaa ;;
11	;; ;;	11	;; ;;
12	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	12	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
13		13
14	$Revision: 982 $	14	$Revision: 1206 $
15		15
16		16
17	align 4 ;3A08	17	align 4 ;3A08
18	build_interrupt_table:	18	build_interrupt_table:
19	mov edi, idts	19	mov edi, idts
20	mov esi, sys_int	20	mov esi, sys_int
21	mov ecx, 0x40	21	mov ecx, 0x40
22	mov eax, (10001110b shl 24) + os_code	22	mov eax, (10001110b shl 24) + os_code
23	@@: movsw ;low word of code-entry	23	@@: movsw ;low word of code-entry
24	stosd ;interrupt gate type : os_code selector	24	stosd ;interrupt gate type : os_code selector
25	movsw ;high word of code-entry	25	movsw ;high word of code-entry
26	loop @b	26	loop @b
27	movsd ;copy low dword of trap gate for int 0x40	27	movsd ;copy low dword of trap gate for int 0x40
28	movsd ;copy high dword of trap gate for int 0x40	28	movsd ;copy high dword of trap gate for int 0x40
29	lidt [esi]	29	lidt [esi]
30	ret	30	ret
31		31
32	iglobal	32	iglobal
33	align 4	33	align 4
34	sys_int:	34	sys_int:
35	;exception handlers addresses (for interrupt gate construction)	35	;exception handlers addresses (for interrupt gate construction)
36	dd e0,e1,e2,e3,e4,e5,e6,except_7 ; SEE: core/fpu.inc	36	dd e0,e1,e2,e3,e4,e5,e6,except_7 ; SEE: core/fpu.inc
37	dd e8,e9,e10,e11,e12,e13,page_fault_exc,e15	37	dd e8,e9,e10,e11,e12,e13,page_fault_exc,e15
38	dd e16, e17,e18, e19	38	dd e16, e17,e18, e19
39	times 12 dd unknown_interrupt ;int_20..int_31	39	times 12 dd unknown_interrupt ;int_20..int_31
40		40
41	;interrupt handlers addresses (for interrupt gate construction)	41	;interrupt handlers addresses (for interrupt gate construction)
42	dd irq0, irq_serv.irq_1, irq_serv.irq_2	42	dd irq0, irq_serv.irq_1, irq_serv.irq_2
43	if USE_COM_IRQ	43	if USE_COM_IRQ
44	dd irq_serv.irq_3, irq_serv.irq_4	44	dd irq_serv.irq_3, irq_serv.irq_4
45	else	45	else
46	dd p_irq3, p_irq4 ;??? íåñòûêîâêà	46	dd p_irq3, p_irq4 ;??? íåñòûêîâêà
47	end if	47	end if
48	dd irq_serv.irq_5, p_irq6, irq_serv.irq_7	48	dd irq_serv.irq_5, p_irq6, irq_serv.irq_7
49	dd irq_serv.irq_8, irq_serv.irq_9, irq_serv.irq_10	49	dd irq_serv.irq_8, irq_serv.irq_9, irq_serv.irq_10
50	dd irq_serv.irq_11, irq_serv.irq_12, irqD,p_irq14,p_irq15	50	dd irq_serv.irq_11, irq_serv.irq_12, irqD,p_irq14,p_irq15
51	times 16 dd unknown_interrupt ;int_0x30..int_0x3F	51	times 16 dd unknown_interrupt ;int_0x30..int_0x3F
52		52
53	;int_0x40 gate trap (for directly copied)	53	;int_0x40 gate trap (for directly copied)
54	dw i40 and 0xFFFF, os_code, 11101111b shl 8, i40 shr 16	54	dw i40 and 0xFFFF, os_code, 11101111b shl 8, i40 shr 16
55		55
56	idtreg: ; data for LIDT instruction (!!! must be immediately below sys_int data)	56	idtreg: ; data for LIDT instruction (!!! must be immediately below sys_int data)
57	dw 2*($-sys_int-4)-1	57	dw 2*($-sys_int-4)-1
58	dd idts ;0x8000B100	58	dd idts ;0x8000B100
59	dw 0 ;ïðîñòî âûðàâíèâàíèå	59	dw 0 ;ïðîñòî âûðàâíèâàíèå
60		60
61	msg_fault_sel dd msg_exc_8,msg_exc_u,msg_exc_a,msg_exc_b	61	msg_fault_sel dd msg_exc_8,msg_exc_u,msg_exc_a,msg_exc_b
62	dd msg_exc_c,msg_exc_d,msg_exc_e	62	dd msg_exc_c,msg_exc_d,msg_exc_e
63		63
64	msg_exc_8 db "Double fault", 0	64	msg_exc_8 db "Double fault", 0
65	msg_exc_u db "Undefined Exception", 0	65	msg_exc_u db "Undefined Exception", 0
66	msg_exc_a db "Invalid TSS", 0	66	msg_exc_a db "Invalid TSS", 0
67	msg_exc_b db "Segment not present", 0	67	msg_exc_b db "Segment not present", 0
68	msg_exc_c db "Stack fault", 0	68	msg_exc_c db "Stack fault", 0
69	msg_exc_d db "General protection fault", 0	69	msg_exc_d db "General protection fault", 0
70	msg_exc_e db "Page fault", 0	70	msg_exc_e db "Page fault", 0
71		71
72	msg_sel_ker db "kernel", 0	72	msg_sel_ker db "kernel", 0
73	msg_sel_app db "application", 0	73	msg_sel_app db "application", 0
74		74
75	endg	75	endg
76		76
77	macro save_ring3_context {	77	macro save_ring3_context {
78	pushad	78	pushad
79	}	79	}
80	macro restore_ring3_context {	80	macro restore_ring3_context {
81	popad	81	popad
82	}	82	}
83	macro exc_wo_code [num] {	83	macro exc_wo_code [num] {
84	e#num :	84	e#num :
85	save_ring3_context	85	save_ring3_context
86	mov bl, num	86	mov bl, num
87	jmp exc_c	87	jmp exc_c
88	} exc_wo_code 0,1,2,3,4,5,6,15,16,19	88	} exc_wo_code 0,1,2,3,4,5,6,15,16,19
89		89
90	macro exc_w_code [num] {	90	macro exc_w_code [num] {
91	e#num :	91	e#num :
92	add esp, 4	92	add esp, 4
93	save_ring3_context	93	save_ring3_context
94	mov bl, num	94	mov bl, num
95	jmp exc_c	95	jmp exc_c
96	} exc_w_code 8,9,10,11,12,13,17,18	96	} exc_w_code 8,9,10,11,12,13,17,18
97		97
98		98
99	uglobal	99	uglobal
100	pf_err_code dd ?	100	pf_err_code dd ?
101	endg	101	endg
102		102
103	page_fault_exc: ; äóðàêîóñòî÷èâîñòü: ñåëåêòîðû èñïîð÷åíû...	103	page_fault_exc: ; äóðàêîóñòî÷èâîñòü: ñåëåêòîðû èñïîð÷åíû...
104	pop [ss:pf_err_code]; äåéñòâèòåëüíî äî ñëåäóþùåãî #PF	104	pop [ss:pf_err_code]; äåéñòâèòåëüíî äî ñëåäóþùåãî #PF
105	save_ring3_context	105	save_ring3_context
106	mov bl,14	106	mov bl,14
107		107
108	exc_c: ; èñêëþ÷åíèÿ (âñå, êðîìå 7-ãî - #NM)	108	exc_c: ; èñêëþ÷åíèÿ (âñå, êðîìå 7-ãî - #NM)
109	; Ôðýéì ñòåêà ïðè èñêëþ÷åíèè/ïðåðûâàíèè èç 3-ãî êîëüöà + pushad (ò.å., èìåííî çäåñü)	109	; Ôðýéì ñòåêà ïðè èñêëþ÷åíèè/ïðåðûâàíèè èç 3-ãî êîëüöà + pushad (ò.å., èìåííî çäåñü)
110	reg_ss equ esp+0x30	110	reg_ss equ esp+0x30
111	reg_esp3 equ esp+0x2C	111	reg_esp3 equ esp+0x2C
112	reg_eflags equ esp+0x28	112	reg_eflags equ esp+0x28
113	reg_cs3 equ esp+0x24	113	reg_cs3 equ esp+0x24
114	reg_eip equ esp+0x20	114	reg_eip equ esp+0x20
115	; ýòî ôðýéì îò pushad	115	; ýòî ôðýéì îò pushad
116	reg_eax equ esp+0x1C	116	reg_eax equ esp+0x1C
117	reg_ecx equ esp+0x18	117	reg_ecx equ esp+0x18
118	reg_edx equ esp+0x14	118	reg_edx equ esp+0x14
119	reg_ebx equ esp+0x10	119	reg_ebx equ esp+0x10
120	reg_esp0 equ esp+0x0C	120	reg_esp0 equ esp+0x0C
121	reg_ebp equ esp+0x08	121	reg_ebp equ esp+0x08
122	reg_esi equ esp+0x04	122	reg_esi equ esp+0x04
123	reg_edi equ esp+0x00	123	reg_edi equ esp+0x00
124		124
125	Mov ds,ax,app_data ; çàãðóçèì ïðàâèëüíûå çíà÷åíèÿ	125	Mov ds,ax,app_data ; çàãðóçèì ïðàâèëüíûå çíà÷åíèÿ
126	mov es,ax ; â ñåãìåíòíûå ðåãèñòðû	126	mov es,ax ; â ñåãìåíòíûå ðåãèñòðû
127	cld ; è ïðèâîäèì DF ê ñòàíäàðòó	127	cld ; è ïðèâîäèì DF ê ñòàíäàðòó
128	movzx ebx,bl	128	movzx ebx,bl
129	; redirect to V86 manager? (EFLAGS & 0x20000) != 0?	129	; redirect to V86 manager? (EFLAGS & 0x20000) != 0?
130	test byte[reg_eflags+2],2	130	test byte[reg_eflags+2],2
131	jnz v86_exc_c	131	jnz v86_exc_c
132	cmp bl,14 ; #PF	132	cmp bl,14 ; #PF
133	jne @f	133	jne @f
134	call page_fault_handler ; SEE: core/memory.inc	134	call page_fault_handler ; SEE: core/memory.inc
135	@@: mov esi, [current_slot]	135	@@: mov esi, [current_slot]
136	btr [esi+APPDATA.except_mask], ebx	136	btr [esi+APPDATA.except_mask], ebx
137	jnc @f	137	jnc @f
138	mov eax,[esi+APPDATA.exc_handler]	138	mov eax,[esi+APPDATA.exc_handler]
139	test eax, eax	139	test eax, eax
140	jnz IRetToUserHook	140	jnz IRetToUserHook
141	@@: cli	141	@@: cli
142	mov eax, [esi+APPDATA.debugger_slot]	142	mov eax, [esi+APPDATA.debugger_slot]
143	test eax, eax	143	test eax, eax
144	jnz .debug	144	jnz .debug
145	sti	145	sti
146	; not debuggee => say error and terminate	146	; not debuggee => say error and terminate
147	call show_error_parameters ;; only ONE using, inline ???	147	call show_error_parameters ;; only ONE using, inline ???
148	;mov edx, [TASK_BASE]	148	;mov edx, [TASK_BASE]
149	mov [edx + TASKDATA.state], byte 4 ; terminate	149	mov [edx + TASKDATA.state], byte 4 ; terminate
150	jmp change_task ; stack - here it does not matter at all, SEE: core/shed.inc	150	jmp change_task ; stack - here it does not matter at all, SEE: core/shed.inc
151	.debug:	151	.debug:
152	; we are debugged process, notify debugger and suspend ourself	152	; we are debugged process, notify debugger and suspend ourself
153	; eax=debugger PID	153	; eax=debugger PID
154	mov ecx,1 ; debug_message code=other_exception	154	mov ecx,1 ; debug_message code=other_exception
155	cmp bl,1 ; #DB	155	cmp bl,1 ; #DB
156	jne .notify ; notify debugger and suspend ourself	156	jne .notify ; notify debugger and suspend ourself
157	mov ebx, dr6 ; debug_message data=DR6_image	157	mov ebx, dr6 ; debug_message data=DR6_image
158	xor edx, edx	158	xor edx, edx
159	mov dr6, edx	159	mov dr6, edx
160	mov edx, dr7	160	mov edx, dr7
161	mov cl, not 8	161	mov cl, not 8
162	.l1: shl dl,2	162	.l1: shl dl,2
163	jc @f	163	jc @f
164	and bl, cl	164	and bl, cl
165	@@: sar cl,1	165	@@: sar cl,1
166	jc .l1	166	jc .l1
167	mov cl, 3 ; debug_message code=debug_exception	167	mov cl, 3 ; debug_message code=debug_exception
168	.notify:	168	.notify:
169	push ebx ; debug_message data	169	push ebx ; debug_message data
170	mov ebx, [TASK_BASE]	170	mov ebx, [TASK_BASE]
171	push [ebx+TASKDATA.pid] ; PID	171	push [ebx+TASKDATA.pid] ; PID
172	push ecx ; debug_message code ((here: ecx==1/3))	172	push ecx ; debug_message code ((here: ecx==1/3))
173	mov cl, 12 ; debug_message size	173	mov cl, 12 ; debug_message size
174	call debugger_notify ;; only ONE using, inline ??? SEE: core/debug.inc	174	call debugger_notify ;; only ONE using, inline ??? SEE: core/debug.inc
175	add esp,12	175	add esp,12
176	mov edx, [TASK_BASE]	176	mov edx, [TASK_BASE]
177	mov byte [edx+TASKDATA.state], 1 ; suspended	177	mov byte [edx+TASKDATA.state], 1 ; suspended
178	call change_task ; SEE: core/shed.inc	178	call change_task ; SEE: core/shed.inc
179	restore_ring3_context	179	restore_ring3_context
180	iretd	180	iretd
181		181
182	IRetToUserHook:	182	IRetToUserHook:
183	xchg eax, [reg_eip]	183	xchg eax, [reg_eip]
184	sub dword[reg_esp3], 8	184	sub dword[reg_esp3], 8
185	mov edi, [reg_esp3]	185	mov edi, [reg_esp3]
186	stosd	186	stosd
187	mov [edi], ebx	187	mov [edi], ebx
188	restore_ring3_context	188	restore_ring3_context
189	unknown_interrupt:	189	unknown_interrupt:
190	iretd	190	iretd
191		191
192	;-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=	192	;-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
193	show_error_parameters:	193	show_error_parameters:
194	mov edx,[TASK_BASE] ;not scratched below	194	mov edx,[TASK_BASE] ;not scratched below
195	DEBUGF 1, "K : Process - forced terminate PID: %x\n", [edx+TASKDATA.pid]	195	DEBUGF 1, "K : Process - forced terminate PID: %x\n", [edx+TASKDATA.pid]
196	cmp bl, 0x08	196	cmp bl, 0x08
197	jb .l0	197	jb .l0
198	cmp bl, 0x0e	198	cmp bl, 0x0e
199	jbe .l1	199	jbe .l1
200	.l0: mov bl, 0x09	200	.l0: mov bl, 0x09
201	.l1: mov eax,[msg_fault_sel+ebx4 - 0x084]	201	.l1: mov eax,[msg_fault_sel+ebx4 - 0x084]
202	DEBUGF 1, "K : %s\n", eax	202	DEBUGF 1, "K : %s\n", eax
203	mov eax, [reg_cs3+4]	203	mov eax, [reg_cs3+4]
204	mov edi, msg_sel_app	204	mov edi, msg_sel_app
205	mov ebx, [reg_esp3+4]	205	mov ebx, [reg_esp3+4]
206	cmp eax, app_code	206	cmp eax, app_code
207	je @f	207	je @f
208	mov edi, msg_sel_ker	208	mov edi, msg_sel_ker
209	mov ebx, [reg_esp0+4]	209	mov ebx, [reg_esp0+4]
210	@@: DEBUGF 1, "K : EAX : %x EBX : %x ECX : %x\n", [reg_eax+4], [reg_ebx+4], [reg_ecx+4]	210	@@: DEBUGF 1, "K : EAX : %x EBX : %x ECX : %x\n", [reg_eax+4], [reg_ebx+4], [reg_ecx+4]
211	DEBUGF 1, "K : EDX : %x ESI : %x EDI : %x\n", [reg_edx+4], [reg_esi+4], [reg_edi+4]	211	DEBUGF 1, "K : EDX : %x ESI : %x EDI : %x\n", [reg_edx+4], [reg_esi+4], [reg_edi+4]
212	DEBUGF 1, "K : EBP : %x EIP : %x ESP : %x\n", [reg_ebp+4], [reg_eip+4], ebx	212	DEBUGF 1, "K : EBP : %x EIP : %x ESP : %x\n", [reg_ebp+4], [reg_eip+4], ebx
213	DEBUGF 1, "K : Flags : %x CS : %x (%s)\n", [reg_eflags+4], eax, edi	213	DEBUGF 1, "K : Flags : %x CS : %x (%s)\n", [reg_eflags+4], eax, edi
214	ret	214	ret
215	;-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=	215	;-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
216		216
217	restore reg_ss	217	restore reg_ss
218	restore reg_esp3	218	restore reg_esp3
219	restore reg_eflags	219	restore reg_eflags
220	restore reg_cs	220	restore reg_cs
221	restore reg_eip	221	restore reg_eip
222	restore reg_eax	222	restore reg_eax
223	restore reg_ecx	223	restore reg_ecx
224	restore reg_edx	224	restore reg_edx
225	restore reg_ebx	225	restore reg_ebx
226	restore reg_esp0	226	restore reg_esp0
227	restore reg_ebp	227	restore reg_ebp
228	restore reg_esi	228	restore reg_esi
229	restore reg_edi	229	restore reg_edi
230		230
231	; irq1 -> hid/keyboard.inc	231	; irq1 -> hid/keyboard.inc
232	macro irqh [num] {	232	macro irqh [num] {
233	p_irq#num :	233	p_irq#num :
234	mov edi, num	234	mov edi, num
235	jmp irqhandler	235	jmp irqhandler
236	}	236	}
237		237
238		238
239		239
240	p_irq6:	240	p_irq6:
241	save_ring3_context	241	save_ring3_context
242	mov ax, app_data ;os_data	242	mov ax, app_data ;os_data
243	mov ds, ax	243	mov ds, ax
244	mov es, ax	244	mov es, ax
245	mov edi, 6	245	mov edi, 6
246	cmp [v86_irqhooks+edi*8], 0	246	cmp [v86_irqhooks+edi*8], 0
247	jnz v86_irq2	247	jnz v86_irq2
248	call fdc_irq	248	call fdc_irq
249	call ready_for_next_irq	249	call ready_for_next_irq
250	restore_ring3_context	250	restore_ring3_context
251	iret	251	iret
252		252
253		253
254	p_irq14:	254	p_irq14:
255	save_ring3_context	255	save_ring3_context
256	mov ax, app_data ;os_data	256	mov ax, app_data ;os_data
257	mov ds, ax	257	mov ds, ax
258	mov es, ax	258	mov es, ax
259	mov edi, 14	259	mov edi, 14
260	cmp [v86_irqhooks+edi*8], 0	260	cmp [v86_irqhooks+edi*8], 0
261	jnz v86_irq2	261	jnz v86_irq2
262	; mov byte [BOOT_VAR + 0x48E], 0xFF	262	; mov byte [BOOT_VAR + 0x48E], 0xFF
263	call [irq14_func]	263	call [irq14_func]
264	call ready_for_next_irq_1	264	call ready_for_next_irq_1
265	restore_ring3_context	265	restore_ring3_context
266	iret	266	iret
267	p_irq15:	267	p_irq15:
268	save_ring3_context	268	save_ring3_context
269	mov ax, app_data ;os_data	269	mov ax, app_data ;os_data
270	mov ds, ax	270	mov ds, ax
271	mov es, ax	271	mov es, ax
272	mov edi, 15	272	mov edi, 15
273	cmp [v86_irqhooks+edi*8], 0	273	cmp [v86_irqhooks+edi*8], 0
274	jnz v86_irq2	274	jnz v86_irq2
275	; mov byte [BOOT_VAR + 0x48E], 0xFF	275	; mov byte [BOOT_VAR + 0x48E], 0xFF
276	call [irq15_func]	276	call [irq15_func]
277	call ready_for_next_irq_1	277	call ready_for_next_irq_1
278	restore_ring3_context	278	restore_ring3_context
279	iret	279	iret
280		280
281	ready_for_next_irq:	281	ready_for_next_irq:
282	mov [check_idle_semaphore],5	282	mov [check_idle_semaphore],5
283	mov al, 0x20	283	mov al, 0x20
284	out 0x20, al	284	out 0x20, al
285	ret	285	ret
286		286
287	ready_for_next_irq_1:	287	ready_for_next_irq_1:
288	mov [check_idle_semaphore],5	288	mov [check_idle_semaphore],5
289	mov al, 0x20	289	mov al, 0x20
290	out 0xa0,al	290	out 0xa0,al
291	out 0x20, al	291	out 0x20, al
292	ret	292	ret
293		293
294	irqD:	294	irqD:
295	push eax	295	push eax
296	mov al,0	296	mov al,0
297	out 0xf0,al	297	out 0xf0,al
298	mov al,0x20	298	mov al,0x20
299	out 0xa0,al	299	out 0xa0,al
300	out 0x20,al	300	out 0x20,al
301	pop eax	301	pop eax
302	iret	302	iret
303		303
304		304
305	irqh 2,3,4,5,7,8,9,10,11	305	irqh 2,3,4,5,7,8,9,10,11
306		306
307	irqhandler:	307	irqhandler:
308		308
309	mov esi,edi ; 1	309	mov esi,edi ; 1
310	shl esi,6 ; 1	310	shl esi,6 ; 1
311	add esi,irq00read ; 1	311	add esi,irq00read ; 1
312	shl edi,12 ; 1	312	shl edi,12 ; 1
313	add edi,IRQ_SAVE	313	add edi,IRQ_SAVE
314	mov ecx,16	314	mov ecx,16
315		315
316	irqnewread:	316	irqnewread:
317	dec ecx	317	dec ecx
318	js irqover	318	js irqover
319		319
320	movzx edx, word [esi] ; 2+	320	movzx edx, word [esi] ; 2+
321		321
322	test edx, edx ; 1	322	test edx, edx ; 1
323	jz irqover	323	jz irqover
324		324
325		325
326	mov ebx, [edi] ; address of begin of buffer in edi ; + 0x0 dword - data size	326	mov ebx, [edi] ; address of begin of buffer in edi ; + 0x0 dword - data size
327	mov eax, 4000 ; + 0x4 dword - data begin offset	327	mov eax, 4000 ; + 0x4 dword - data begin offset
328	cmp ebx, eax	328	cmp ebx, eax
329	je irqfull	329	je irqfull
330	add ebx, [edi + 0x4] ; add data size to data begin offset	330	add ebx, [edi + 0x4] ; add data size to data begin offset
331	cmp ebx, eax ; if end of buffer, begin cycle again	331	cmp ebx, eax ; if end of buffer, begin cycle again
332	jb @f	332	jb @f
333		333
334	xor ebx, ebx	334	xor ebx, ebx
335		335
336	@@:	336	@@:
337	add ebx, edi	337	add ebx, edi
338	movzx eax, byte[esi + 3] ; get type of data being received 1 - byte, 2 - word	338	movzx eax, byte[esi + 3] ; get type of data being received 1 - byte, 2 - word
339	dec eax	339	dec eax
340	jz irqbyte	340	jz irqbyte
341	dec eax	341	dec eax
342	jnz noirqword	342	jnz noirqword
343		343
344	in ax,dx	344	in ax,dx
345	cmp ebx, 3999 ; check for address odd in the end of buffer	345	cmp ebx, 3999 ; check for address odd in the end of buffer
346	jne .odd	346	jne .odd
347	mov [ebx + 0x10], ax	347	mov [ebx + 0x10], ax
348	jmp .add_size	348	jmp .add_size
349	.odd:	349	.odd:
350	mov [ebx + 0x10], al ; I could make mistake here :)	350	mov [ebx + 0x10], al ; I could make mistake here :)
351	mov [edi + 0x10], ah	351	mov [edi + 0x10], ah
352	.add_size:	352	.add_size:
353	add dword [edi], 2	353	add dword [edi], 2
354	jmp nextport	354	jmp nextport
355		355
356		356
357	irqbyte:	357	irqbyte:
358	in al,dx	358	in al,dx
359	mov [ebx + 0x10],al	359	mov [ebx + 0x10],al
360	inc dword [edi]	360	inc dword [edi]
361	nextport:	361	nextport:
362	add esi,4	362	add esi,4
363	jmp irqnewread	363	jmp irqnewread
364		364
365		365
366	noirqword:	366	noirqword:
367	irqfull:	367	irqfull:
368	irqover:	368	irqover:
369		369
370	ret	370	ret
371		371
372		372
373		373
374	set_application_table_status:	374	set_application_table_status:
375	push eax	375	push eax
376		376
377	mov eax,[CURRENT_TASK]	377	mov eax,[CURRENT_TASK]
378	shl eax, 5	378	shl eax, 5
379	add eax,CURRENT_TASK+TASKDATA.pid	379	add eax,CURRENT_TASK+TASKDATA.pid
380	mov eax,[eax]	380	mov eax,[eax]
381		381
382	mov [application_table_status],eax	382	mov [application_table_status],eax
383		383
384	pop eax	384	pop eax
385		385
386	ret	386	ret
387		387
388		388
389	clear_application_table_status:	389	clear_application_table_status:
390	push eax	390	push eax
391		391
392	mov eax,[CURRENT_TASK]	392	mov eax,[CURRENT_TASK]
393	shl eax, 5	393	shl eax, 5
394	add eax,CURRENT_TASK+TASKDATA.pid	394	add eax,CURRENT_TASK+TASKDATA.pid
395	mov eax,[eax]	395	mov eax,[eax]
396		396
397	cmp eax,[application_table_status]	397	cmp eax,[application_table_status]
398	jne apptsl1	398	jne apptsl1
399	mov [application_table_status],0	399	mov [application_table_status],0
400	apptsl1:	400	apptsl1:
401		401
402	pop eax	402	pop eax
403		403
404	ret	404	ret
405		405
406	sys_resize_app_memory:	406	sys_resize_app_memory:
407	; eax = 1 - resize	407	; eax = 1 - resize
408	; ebx = new amount of memory	408	; ebx = new amount of memory
409		409
410	cmp eax,1	410	cmp eax,1
411	jne .no_application_mem_resize	411	jne .no_application_mem_resize
412		412
413	stdcall new_mem_resize, ebx	413	stdcall new_mem_resize, ebx
414	mov [esp+36], eax	414	mov [esp+36], eax
415	ret	415	ret
416		416
417	.no_application_mem_resize:	417	.no_application_mem_resize:
418	ret	418	ret
419		419
420	sys_threads:	420	sys_threads:
421		421
422	; eax=1 create thread	422	; eax=1 create thread
423	;	423	;
424	; ebx=thread start	424	; ebx=thread start
425	; ecx=thread stack value	425	; ecx=thread stack value
426	;	426	;
427	; on return : eax = pid	427	; on return : eax = pid
428	jmp new_sys_threads	428	jmp new_sys_threads
429		429
430	iglobal	430	iglobal
431	; process_terminating db 'K : Process - terminating',13,10,0	431	; process_terminating db 'K : Process - terminating',13,10,0
432	; process_terminated db 'K : Process - done',13,10,0	432	; process_terminated db 'K : Process - done',13,10,0
433	msg_obj_destroy db 'K : destroy app object',13,10,0	433	msg_obj_destroy db 'K : destroy app object',13,10,0
434	endg	434	endg
435		435
436	; param	436	; param
437	; esi= slot	437	; esi= slot
438		438
439	terminate: ; terminate application	439	terminate: ; terminate application
440		440
441	.slot equ esp ;locals	441	.slot equ esp ;locals
442		442
443	push esi ;save .slot	443	push esi ;save .slot
444		444
445	shl esi, 8	445	shl esi, 8
446	cmp [SLOT_BASE+esi+APPDATA.dir_table], 0	446	cmp [SLOT_BASE+esi+APPDATA.dir_table], 0
447	jne @F	447	jne @F
448	pop esi	448	pop esi
449	shl esi, 5	449	shl esi, 5
450	mov [CURRENT_TASK+esi+TASKDATA.state], 9	450	mov [CURRENT_TASK+esi+TASKDATA.state], 9
451	ret	451	ret
452	@@:	452	@@:
453	;mov esi,process_terminating	453	;mov esi,process_terminating
454	;call sys_msg_board_str	454	;call sys_msg_board_str
455	@@:	455	@@:
456	cli	456	cli
457	cmp [application_table_status],0	457	cmp [application_table_status],0
458	je term9	458	je term9
459	sti	459	sti
460	call change_task	460	call change_task
461	jmp @b	461	jmp @b
462	term9:	462	term9:
463	call set_application_table_status	463	call set_application_table_status
464		464
465	; if the process is in V86 mode...	465	; if the process is in V86 mode...
466	mov eax, [.slot]	466	mov eax, [.slot]
467	shl eax, 8	467	shl eax, 8
468	mov esi, [eax+SLOT_BASE+APPDATA.pl0_stack]	468	mov esi, [eax+SLOT_BASE+APPDATA.pl0_stack]
469	add esi, RING0_STACK_SIZE	469	add esi, RING0_STACK_SIZE
470	cmp [eax+SLOT_BASE+APPDATA.saved_esp0], esi	470	cmp [eax+SLOT_BASE+APPDATA.saved_esp0], esi
471	jz .nov86	471	jz .nov86
472	; ...it has page directory for V86 mode	472	; ...it has page directory for V86 mode
473	mov esi, [eax+SLOT_BASE+APPDATA.saved_esp0]	473	mov esi, [eax+SLOT_BASE+APPDATA.saved_esp0]
474	mov ecx, [esi+4]	474	mov ecx, [esi+4]
475	mov [eax+SLOT_BASE+APPDATA.dir_table], ecx	475	mov [eax+SLOT_BASE+APPDATA.dir_table], ecx
476	; ...and I/O permission map for V86 mode	476	; ...and I/O permission map for V86 mode
477	mov ecx, [esi+12]	477	mov ecx, [esi+12]
478	mov [eax+SLOT_BASE+APPDATA.io_map], ecx	478	mov [eax+SLOT_BASE+APPDATA.io_map], ecx
479	mov ecx, [esi+8]	479	mov ecx, [esi+8]
480	mov [eax+SLOT_BASE+APPDATA.io_map+4], ecx	480	mov [eax+SLOT_BASE+APPDATA.io_map+4], ecx
481	.nov86:	481	.nov86:
482		482
483	mov esi, [.slot]	483	mov esi, [.slot]
484	shl esi,8	484	shl esi,8
485	add esi, SLOT_BASE+APP_OBJ_OFFSET	485	add esi, SLOT_BASE+APP_OBJ_OFFSET
486	@@:	486	@@:
487	mov eax, [esi+APPOBJ.fd]	487	mov eax, [esi+APPOBJ.fd]
488	test eax, eax	488	test eax, eax
489	jz @F	489	jz @F
490		490
491	cmp eax, esi	491	cmp eax, esi
492	je @F	492	je @F
493		493
494	push esi	494	push esi
495	call [eax+APPOBJ.destroy]	495	call [eax+APPOBJ.destroy]
496	DEBUGF 1,"%s",msg_obj_destroy	496	DEBUGF 1,"%s",msg_obj_destroy
497	pop esi	497	pop esi
498	jmp @B	498	jmp @B
499	@@:	499	@@:
500	mov eax, [.slot]	500	mov eax, [.slot]

Subversion Repositories Kolibri OS

(root)/kernel/branches/net/core/sys32.inc – Rev 1198 → 1206