WebSVN – Kolibri OS – Diff – /kernel/trunk/core/taskman.inc


GREEDY_KERNEL  equ 0
 
 
struc APP_HEADER_00
{ .banner      dq ?
  .version     dd ?    ;+8
  .start       dd ?    ;+12
  .i_end       dd ?    ;+16
  .mem_size    dd ?    ;+20
  .i_param     dd ?    ;+24
}
 
struc APP_HEADER_01
{ .banner      dq ?
  .version     dd ?    ;+8
  .start       dd ?    ;+12
  .i_end       dd ?    ;+16
  .mem_size    dd ?    ;+20
  .stack_top   dd ?    ;+24
  .i_param     dd ?    ;+28
  .i_icon      dd ?    ;+32
}
 
struc TSS
{
  ._back   rw 2
  ._esp0   rd 1
  ._ss0    rw 2
  ._esp1   rd 1
  ._ss1    rw 2
  ._esp2   rd 1
  ._ss2    rw 2
  ._cr3    rd 1
  ._eip    rd 1
  ._eflags rd 1
  ._eax    rd 1
  ._ecx    rd 1
  ._edx    rd 1
  ._ebx    rd 1
  ._esp    rd 1
  ._ebp    rd 1
  ._esi    rd 1
  ._edi    rd 1
  ._es     rw 2
  ._cs     rw 2
  ._ss     rw 2
  ._ds     rw 2
  ._fs     rw 2
  ._gs     rw 2
  ._ldt    rw 2
  ._trap   rw 1
  ._io     rw 1
}
 
virtual at 0
  TSS  TSS
end virtual
 
struc APP_PARAMS
{ .app_cmdline   ;0x00
  .app_path      ;0x04
  .app_eip       ;0x08
  .app_esp       ;0x0C
  .app_mem       ;0x10
}
 
macro _clear_ op
{  mov ecx, op/4
   xor eax, eax
   cld
   rep stosd
}
 
 
align 4
proc fs_execute
 
;fn_read:dword, file_size:dword, cluster:dword
 
; ebx - cmdline
; edx - flags
; ebp - full filename
; [esp+4] = procedure DoRead, [esp+8] = filesize & [esp+12]... - arguments for it
 
           locals
             cmdline       rd 64        ;256/4
             filename      rd 256       ;1024/4
             flags         dd ?
 
             save_cr3      dd ?
             slot          dd ?
             slot_base     dd ?
             file_base     dd ?
             file_size     dd ?
                                          ;app header data
             hdr_cmdline   dd ? ;0x00
             hdr_path      dd ? ;0x04
             hdr_eip       dd ? ;0x08
             hdr_esp       dd ? ;0x0C
             hdr_mem       dd ? ;0x10
             hdr_i_end     dd ? ;0x14
           endl
 
           pushad
 
           mov [cmdline], ebx
           mov [flags], edx
 
; [ebp]  pointer to filename
 
           lea eax, [filename]
           mov dword [eax+1020],0              ;force terminate
                                               ;string
           stdcall k_strncpy, eax, [ebp], 1023
 
           lea eax, [cmdline]
           mov dword [eax+252], 0
           stdcall k_strncpy, eax, [cmdline], 255
 
           lea eax, [filename]
           stdcall load_file, eax
           mov  ecx, -ERROR_FILE_NOT_FOUND
           test eax, eax
           jz .err_file
 
           mov [file_base], eax
           mov [file_size], ebx
 
           lea ebx, [hdr_cmdline]
           call test_app_header
           mov ecx, -0x1F
           test eax, eax
           jz .err_hdr
 
           mov esi, new_process_loading
           call sys_msg_board_str       ; write message to message board
 
.wait_lock:
           cmp [application_table_status],0
           je .get_lock
           call   change_task
           jmp .wait_lock
 
.get_lock:
           mov eax, 1
           xchg eax, [application_table_status]
           cmp eax, 0
           jne .wait_lock
 
;           pushfd
;           cli
 
           call set_application_table_status
 
           call get_new_process_place
           test eax, eax
           mov ecx, -0x20      ; too many processes
           jz .err
 
           mov [slot], eax
           shl eax, 8
           add eax, SLOT_BASE
           mov [slot_base], eax
           mov edi, eax
           _clear_ 256     ;clean extended information about process
 
; write application name
           lea edi, [filename]
           mov al, '/'
           call k_strrchr  ; now eax points to name without path
 
           lea esi, [eax+1]
           test eax, eax
           jnz @F
           lea esi, [filename]
@@:
           mov ecx, 8  ; 8 chars for name
           mov edi, [slot_base]
.copy_process_name_loop:
           lodsb
           cmp al, '.'
           jz .copy_process_name_done
           test al, al
           jz .copy_process_name_done
           stosb
           loop .copy_process_name_loop
.copy_process_name_done:
 
           mov ebx, cr3
           mov [save_cr3], ebx
 
           stdcall create_app_space,[hdr_mem],[file_base],[file_size]
           mov ecx, -30  ; no memory
           test eax, eax
           jz .failed
 
           mov   ebx,[slot_base]
           mov   [ebx+APPDATA.dir_table],eax
           mov   eax,[hdr_mem]
           mov   [ebx+APPDATA.mem_size],eax
 
if GREEDY_KERNEL
else
           mov ecx, [hdr_mem]
           mov edi, [file_size]
           add edi, 4095
           and edi, not 4095
           sub ecx, edi
           jna @F
 
           xor eax, eax
           add edi, new_app_base
           cld
           rep stosb
@@:
end if
 
; release only virtual space, not phisical memory
 
           stdcall free_kernel_space, [file_base]
           lea eax, [hdr_cmdline]
           lea ebx, [cmdline]
           lea ecx, [filename]
           stdcall set_app_params ,[slot],eax,ebx,ecx,[flags]
 
           mov eax, [save_cr3]
           call set_cr3
 
 ;          popfd
           xor ebx, ebx
           mov [application_table_status],ebx ;unlock application_table_status mutex
           mov eax,[process_number]  ;set result
           ret
.failed:
           mov eax, [save_cr3]
           call set_cr3
.err:
 ;          popfd
.err_hdr:
           stdcall kernel_free,[file_base]
.err_file:
           xor eax, eax
           mov [application_table_status],eax
           mov eax, ecx
           ret
endp
 
align 4
test_app_header:
           virtual at eax
             APP_HEADER_00 APP_HEADER_00
           end virtual
           virtual at eax
             APP_HEADER_01 APP_HEADER_01
           end virtual
 
           cmp dword [eax], 'MENU'
           jne .fail
           cmp word [eax+4],'ET'
           jne .fail
 
           cmp [eax+6], word '00'
           jne  .check_01_header
 
           mov  ecx,[APP_HEADER_00.start]
           mov  [ebx+0x08], ecx                ;app_eip
           mov  edx,[APP_HEADER_00.mem_size]
           mov  [ebx+0x10], edx                ;app_mem
           shr  edx,1
           sub  edx,0x10
           mov  [ebx+0x0C], edx                ;app_esp
           mov  ecx,[APP_HEADER_00.i_param]
           mov  [ebx], ecx                     ;app_cmdline
           mov  [ebx+4], dword 0               ;app_path
           mov  edx, [APP_HEADER_00.i_end]
           mov  [ebx+0x14], edx
           ret
 
 .check_01_header:
 
           cmp  [eax+6],word '01'
           jne  .fail
 
           mov  ecx,[APP_HEADER_01.start]
           mov  [ebx+0x08], ecx                ;app_eip
           mov  edx,[APP_HEADER_01.mem_size]
           mov  [ebx+0x10], edx                ;app_mem
           mov  ecx,[APP_HEADER_01.stack_top]
           mov  [ebx+0x0C], ecx                ;app_esp
           mov  edx,[APP_HEADER_01.i_param]
           mov  [ebx], edx                     ;app_cmdline
           mov  ecx,[APP_HEADER_01.i_icon]
           mov  [ebx+4], ecx                   ;app_path
           mov  edx, [APP_HEADER_01.i_end]
           mov  [ebx+0x14], edx
           ret
.fail:
           xor eax, eax
           ret
 
align 4
proc get_new_process_place
;input:
;  none
;result:
;  eax=[new_process_place]<>0 - ok
;      0 - failed.
;This function find least empty slot.
;It doesn't increase [TASK_COUNT]!
           mov    eax,CURRENT_TASK
           mov    ebx,[TASK_COUNT]
           inc    ebx
           shl    ebx,5
           add    ebx,eax               ;ebx - address of process information for (last+1) slot
.newprocessplace:
;eax = address of process information for current slot
           cmp    eax,ebx
           jz     .endnewprocessplace   ;empty slot after high boundary
           add    eax,0x20
           cmp    word [eax+0xa],9      ;check process state, 9 means that process slot is empty
           jnz    .newprocessplace
.endnewprocessplace:
           mov    ebx,eax
           sub    eax,CURRENT_TASK
           shr    eax,5                 ;calculate slot index
           cmp    eax,256
           jge    .failed               ;it should be <256
           mov    word [ebx+0xa],9      ;set process state to 9 (for slot after hight boundary)
        ;   mov [new_process_place], eax
           ret
 
.failed:
           xor    eax,eax
           ret
endp
 
align 4
proc create_app_space stdcall, app_size:dword,img_base:dword,img_size:dword
           locals
             app_pages   dd ?
             img_pages   dd ?
             dir_addr    dd ?
             app_tabs    dd ?
           endl
 
           mov ebx, pg_data.pg_mutex
           call wait_mutex   ;ebx
 
           xor eax, eax
           mov [dir_addr], eax
 
           mov eax, [app_size]
           add eax, 4095
           and eax, NOT(4095)
           mov [app_size], eax
           mov ebx, eax
           shr eax, 12
           mov [app_pages], eax
 
           add ebx, 0x3FFFFF
           and ebx, NOT(0x3FFFFF)
           shr ebx, 22
           mov [app_tabs], ebx
 
           mov ecx, [img_size]
           add ecx, 4095
           and ecx, NOT(4095)
 
           mov [img_size], ecx
           shr ecx, 12
           mov [img_pages], ecx
 
     if GREEDY_KERNEL
           lea eax, [ecx+ebx+2]    ;only image size
     else
           lea eax, [eax+ebx+2]    ;all requested memory
     end if
           cmp eax, [pg_data.pages_free]
           ja .fail
 
           call alloc_page
           test eax, eax
           jz .fail
           mov [dir_addr], eax
           stdcall map_page,[tmp_task_pdir],eax,dword PG_SW
 
           mov esi, sys_pgdir
           mov edi, [tmp_task_pdir]
           mov ecx, (page_tabs shr 20)/4
           cld
           rep movsd
 
           mov eax, [dir_addr]
           or eax, PG_SW
           stosd                 ; [(page_tabs shr 20)]= eax
 
           mov ecx, 0x800/4
           xor eax, eax
           rep stosd
 
           mov eax, [dir_addr]
           call set_cr3
 
           mov edx, [app_tabs]
           mov edi, new_app_base
@@:
           call alloc_page
           test eax, eax
           jz .fail
 
           stdcall map_page_table, edi, eax
           add edi, 0x00400000
           dec edx
           jnz @B
 
           mov edi, new_app_base
           shr edi, 10
           add edi, page_tabs
 
           mov ecx, [app_tabs]
           shl ecx, 10
           xor eax, eax
           rep stosd
 
           mov ecx, [img_pages]
           mov ebx, PG_UW
           mov edx, new_app_base
           mov esi, [img_base]
           mov edi, new_app_base
           shr esi, 10
           shr edi, 10
           add esi, page_tabs
           add edi, page_tabs
.remap:
           lodsd
           or eax, ebx      ; force user level r/w access
           stosd
           add edx, 0x1000
           dec [app_pages]
           dec ecx
           jnz .remap
 
           mov ecx, [app_pages]
           test ecx, ecx
           jz .done
 
if GREEDY_KERNEL
           mov eax, 0x02
.reserve:
           stosd
           invlpg [edx]
           add edx, 4096
           dec ecx
           jnz .reserve
else
 
.alloc:
           call alloc_page
           test eax, eax
           jz .fail
 
           stdcall map_page,edx,eax,dword PG_UW
           add edx, 0x1000
           dec [app_pages]
           jnz .alloc
 
end if
 
.done:
           stdcall map_page,[tmp_task_pdir],dword 0,dword PG_UNMAP
 
           dec [pg_data.pg_mutex]
           mov eax, [dir_addr]
           ret
.fail:
           dec [pg_data.pg_mutex]
           cmp [dir_addr], 0
           je @f
           stdcall destroy_app_space, [dir_addr]
@@:
           xor eax, eax
           ret
endp
 
align 4
set_cr3:
           mov esi, [CURRENT_TASK]
           mov ebx, esi
           shl esi,8
           mov [SLOT_BASE+esi+0xB8],eax
           imul   ebx,tss_step
           add    ebx,tss_data
           mov [ebx+28], eax
           mov cr3, eax
           ret
 
align 4
proc destroy_page_table stdcall, pg_tab:dword
 
           push esi
 
           mov esi, [pg_tab]
           mov ecx, 1024
.free:
           mov eax, [esi]
           test eax, 1
           jz .next
           call free_page
.next:
           add esi, 4
           dec ecx
           jnz .free
           pop esi
           ret
endp
 
align 4
proc destroy_app_space stdcall, pg_dir:dword
 
           mov ebx, pg_data.pg_mutex
           call wait_mutex   ;ebx
 
           xor   edx,edx
           mov   eax,0x2
           mov ebx, [pg_dir]
 
.loop:
;eax = current slot of process
           mov   ecx,eax
           shl   ecx,5
           cmp   byte [CURRENT_TASK+ecx+0xa],9  ;if process running?
           jz    @f                              ;skip empty slots
           shl   ecx,3
           cmp   [SLOT_BASE+ecx+0xB8],ebx       ;compare page directory addresses
           jnz   @f
           inc   edx                            ;thread found
@@:
           inc   eax
           cmp   eax,[TASK_COUNT]               ;exit loop if we look through all processes
           jle   .loop
 
;edx = number of threads
;our process is zombi so it isn't counted
           cmp   edx,1
           jg    .exit
;if there isn't threads then clear memory.
 
           mov eax, [pg_dir]
           and eax, not 0xFFF
           stdcall map_page,[tmp_task_pdir],eax,dword PG_SW
           mov esi, [tmp_task_pdir]
           add esi, 0x800
           mov edi, 0x800/4
.destroy:
           mov eax, [esi]
           test eax, 1
           jz .next
           and eax, not 0xFFF
           stdcall map_page,[tmp_task_ptab],eax,dword PG_SW
           stdcall destroy_page_table, [tmp_task_ptab]
           mov eax, [esi]
           call free_page
.next:
           add esi, 4
           dec edi
           jnz .destroy
 
           mov eax, [pg_dir]
           call free_page
.exit:
           stdcall map_page,[tmp_task_ptab],dword 0,dword PG_UNMAP
           stdcall map_page,[tmp_task_pdir],dword 0,dword PG_UNMAP
           dec [pg_data.pg_mutex]
           ret
endp
 
pid_to_slot:
;Input:
;  eax - pid of process
;Output:
;  eax - slot of process or 0 if process don't exists
;Search process by PID.
    push   ebx
    push   ecx
    mov    ebx,[TASK_COUNT]
    shl    ebx,5
    mov    ecx,2*32
 
.loop:
;ecx=offset of current process info entry
;ebx=maximum permitted offset
    cmp    byte [CURRENT_TASK+ecx+0xa],9
    jz     .endloop              ;skip empty slots
    cmp    [CURRENT_TASK+ecx+0x4],eax ;check PID
    jz     .pid_found
.endloop:
    add    ecx,32
    cmp    ecx,ebx
    jle    .loop
 
    pop    ecx
    pop    ebx
    xor    eax,eax
    ret
 
.pid_found:
    shr    ecx,5
    mov    eax,ecx               ;convert offset to index of slot
    pop    ecx
    pop    ebx
    ret
 
check_region:
;input:
;  ebx - start of buffer
;  ecx - size of buffer
;result:
;  eax = 1 region lays in app memory
;  eax = 0 region don't lays in app memory
     mov  eax,[CURRENT_TASK]
     jmp  check_process_region
;-----------------------------------------------------------------------------
check_process_region:
;input:
;  eax - slot
;  ebx - start of buffer
;  ecx - size of buffer
;result:
;  eax = 1 region lays in app memory
;  eax = 0 region don't lays in app memory
 
     test ecx,ecx
     jle  .ok
     shl  eax,5
     cmp  word [CURRENT_TASK+eax+0xa],0
     jnz  .failed
     shl  eax,3
     mov  eax,[SLOT_BASE+eax+0xb8]
     test eax,eax
     jz   .failed
 
     mov  eax,1
     ret
 
 
;    call MEM_Get_Linear_Address
;    push ebx
;    push ecx
;    push edx
;    mov  edx,ebx
;    and  edx,not (4096-1)
;    sub  ebx,edx
;    add  ecx,ebx
;    mov  ebx,edx
;    add  ecx,(4096-1)
;    and  ecx,not (4096-1)
;.loop:
;;eax - linear address of page directory
;;ebx - current page
;;ecx - current size
;    mov  edx,ebx
;    shr  edx,22
;    mov  edx,[eax+4*edx]
;    and  edx,not (4096-1)
;    test edx,edx
;    jz   .failed1
;    push eax
;    mov  eax,edx
;    call MEM_Get_Linear_Address
;    mov  edx,ebx
;    shr  edx,12
;    and  edx,(1024-1)
;    mov  eax,[eax+4*edx]
;    and  eax,not (4096-1)
;    test eax,eax
;    pop  eax
;    jz   .failed1
;    add  ebx,4096
;    sub  ecx,4096
;    jg   .loop
;    pop  edx
;    pop  ecx
;    pop  ebx
.ok:
    mov  eax,1
    ret
;
;.failed1:
;    pop  edx
;    pop  ecx
;    pop  ebx
.failed:
    xor  eax,eax
    ret
 
align 4
proc read_process_memory
;Input:
;  eax - process slot
;  ebx - buffer address
;  ecx - buffer size
;  edx - start address in other process
;Output:
;  eax - number of bytes read.
           locals
             slot       dd ?
             buff       dd ?
             r_count    dd ?
             offset     dd ?
             tmp_r_cnt  dd ?
           endl
 
           mov [slot], eax
           mov [buff], ebx
           mov [r_count], ecx
           mov [tmp_r_cnt], ecx
           mov [offset], edx
 
           pushad
.read_mem:
           mov edx, [offset]
           mov ebx, [tmp_r_cnt]
 
           mov ecx, 0x400000
           and edx, 0x3FFFFF
           sub ecx, edx
           cmp ecx, ebx
           jbe @f
           mov ecx, ebx
@@:
           cmp ecx, 0x8000
           jna @F
           mov ecx, 0x8000
@@:
           mov eax, [slot]
           shl  eax,8
           mov ebx, [offset]
           add ebx, new_app_base
           push ecx
           stdcall map_memEx, [proc_mem_map],\
                              [SLOT_BASE+eax+0xB8],\
                              ebx, ecx
           pop ecx
 
           mov esi, [offset]
           and esi, 0xfff
           add esi, [proc_mem_map]
           mov edi, [buff]
           mov edx, ecx
           rep movsb
 
           add [offset], edx
           sub [tmp_r_cnt], edx
           jnz .read_mem
 
           popad
           mov eax, [r_count]
           ret
endp
 
align 4
proc write_process_memory
;Input:
;  eax - process slot
;  ebx - buffer address
;  ecx - buffer size
;  edx - start address in other process
;Output:
;  eax - number of bytes written
 
           locals
             slot       dd ?
             buff       dd ?
             w_count    dd ?
             offset     dd ?
             tmp_w_cnt  dd ?
           endl
 
           mov [slot], eax
           mov [buff], ebx
           mov [w_count], ecx
           mov [tmp_w_cnt], ecx
           mov [offset], edx
 
           pushad
.read_mem:
           mov edx, [offset]
           mov ebx, [tmp_w_cnt]
 
           mov ecx, 0x400000
           and edx, 0x3FFFFF
           sub ecx, edx
           cmp ecx, ebx
           jbe @f
           mov ecx, ebx
@@:
           cmp ecx, 0x8000
           jna @F
           mov ecx, 0x8000
@@:
           mov eax, [slot]
           shl  eax,8
           mov ebx, [offset]
           add ebx, new_app_base
           push ecx
           stdcall map_memEx, [proc_mem_map],\
                              [SLOT_BASE+eax+0xB8],\
                              ebx, ecx
           pop ecx
 
           mov edi, [offset]
           and edi, 0xfff
           add edi, [proc_mem_map]
           mov esi, [buff]
           mov edx, ecx
           rep movsb
 
           add [offset], edx
           sub [tmp_w_cnt], edx
           jnz .read_mem
 
           popad
           mov eax, [w_count]
           ret
endp
 
align 4
proc new_sys_threads
           locals
             slot          dd ?
             app_cmdline   dd ? ;0x00
             app_path      dd ? ;0x04
             app_eip       dd ? ;0x08
             app_esp       dd ? ;0x0C
             app_mem       dd ? ;0x10
           endl
 
           cmp eax,1
           jne .failed                  ;other subfunctions
 
           xor  eax,eax
           mov [app_cmdline], eax
           mov [app_path], eax
           mov [app_eip], ebx
           mov [app_esp], ecx
 
           mov    esi,new_process_loading
           call   sys_msg_board_str
.wait_lock:
           cmp [application_table_status],0
           je .get_lock
           call   change_task
           jmp .wait_lock
 
.get_lock:
           mov eax, 1
           xchg eax, [application_table_status]
           cmp eax, 0
           jne .wait_lock
 
           call   set_application_table_status
 
           call get_new_process_place
           test eax, eax
           jz .failed
 
           mov [slot], eax
 
           mov    esi,[CURRENT_TASK]
           shl    esi,8
           add    esi,SLOT_BASE
           mov    ebx,esi             ;ebx=esi - pointer to extended information about current thread
 
           mov    edi, eax
           shl    edi,8
           add    edi,SLOT_BASE
           mov    edx,edi             ;edx=edi - pointer to extended infomation about new thread
           mov    ecx,256/4
           xor eax, eax
           cld
           rep    stosd               ;clean extended information about new thread
           mov    esi,ebx
           mov    edi,edx
           mov    ecx,11
           rep    movsb               ;copy process name
 
           mov eax,[ebx+APPDATA.heap_base]
           mov [edx+APPDATA.heap_base], eax
 
           mov ecx,[ebx+APPDATA.heap_top]
           mov [edx+APPDATA.heap_top], ecx
 
           mov eax,[ebx+APPDATA.mem_size]
           mov [edx+APPDATA.mem_size], eax
 
           mov ecx,[ebx+APPDATA.dir_table]
           mov [edx+APPDATA.dir_table],ecx      ;copy page directory
 
           lea eax, [app_cmdline]
           stdcall set_app_params ,[slot],eax,dword 0,\
                                         dword 0,dword 0
 
           mov    esi,new_process_running
           call   sys_msg_board_str     ;output information about succefull startup
 
           mov    [application_table_status],0 ;unlock application_table_status mutex
           mov    eax,[process_number]  ;set result
           ret
.failed:
           mov    [application_table_status],0
           mov    eax,-1
           ret
endp
 
; param
;  ebx=mutex
 
align 4
wait_mutex:
           push eax
           push ebx
.do_wait:
           cmp dword [ebx],0
           je .get_lock
           call change_task
           jmp .do_wait
.get_lock:
           mov eax, 1
           xchg eax, [ebx]
           test eax, eax
           jnz .do_wait
           pop ebx
           pop eax
           ret
 
align 4
proc set_app_params stdcall,slot:dword, params:dword,\
                        cmd_line:dword, app_path:dword, flags:dword
 
           locals
             pl0_stack dd ?
           endl
 
           stdcall kernel_alloc, 0x2000
           mov [pl0_stack], eax
 
           lea edi, [eax+0x2000-512]
 
           mov eax, [slot]
           mov ebx, eax
 
           shl eax, 8
           mov [eax+SLOT_BASE+APPDATA.fpu_state], edi
           mov [eax+SLOT_BASE+APPDATA.fpu_handler], 0
           mov [eax+SLOT_BASE+APPDATA.sse_handler], 0
 
           mov esi, fpu_data
           mov ecx, 512/4
           rep movsd
 
           cmp    ebx,[TASK_COUNT]
           jle    .noinc
           inc    dword [TASK_COUNT]       ;update number of processes
.noinc:
           shl ebx,8
           lea edx, [ebx+SLOT_BASE+APP_EV_OFFSET]
           mov [SLOT_BASE+APPDATA.fd_ev+ebx],edx
           mov [SLOT_BASE+APPDATA.bk_ev+ebx],edx
 
           add edx, APP_OBJ_OFFSET-APP_EV_OFFSET
           mov [SLOT_BASE+APPDATA.fd_obj+ebx],edx
           mov [SLOT_BASE+APPDATA.bk_obj+ebx],edx
 
           mov ecx, [def_cursor]
           mov [SLOT_BASE+APPDATA.cursor+ebx],ecx
           mov eax, [pl0_stack]
           mov [SLOT_BASE+APPDATA.pl0_stack+ebx],eax
 
           shr ebx,3
           mov eax, new_app_base
           mov dword [CURRENT_TASK+ebx+0x10],eax
 
.add_command_line:
           mov edx,[params]
           mov edx,[edx]           ;app_cmdline
           test edx,edx
           jz @F                   ;application don't need parameters
 
           mov     eax, edx
           add     eax, 256
           jc      @f
 
           cmp     eax, [SLOT_BASE+APPDATA.mem_size+ebx*8]
           ja      @f
 
           add edx, new_app_base
           stdcall k_strncpy, edx, [cmd_line], 256
@@:
           mov edx,[params]
           mov edx, [edx+4]        ;app_path
           test edx,edx
           jz @F                   ;application don't need path of file
        mov     eax, edx
        add     eax, 1024
        jc      @f
        cmp     eax, [SLOT_BASE+APPDATA.mem_size+ebx*8]
        ja      @f
           add edx, new_app_base
           stdcall k_strncpy, edx, [app_path], 1024
@@:
           mov    ebx,[slot]
           mov    eax,ebx
           shl    ebx,5
; set window state to 'normal' (non-minimized/maximized/rolled-up) state
           mov     [ebx+window_data+WDATA.fl_wstate], WSTATE_NORMAL
           mov     [ebx+window_data+WDATA.fl_redraw], 1
           add    ebx,CURRENT_TASK            ;ebx - pointer to information about process
           mov    [ebx+TASKDATA.wnd_number],al;set window number on screen = process slot
 
           mov    [ebx+TASKDATA.event_mask],dword 1+2+4 ;set default event flags (see 40 function)
 
           inc    dword [process_number]
           mov    eax,[process_number]
           mov    [ebx+4],eax           ;set PID
 
           mov    ecx,ebx
           add    ecx,(draw_data-CURRENT_TASK)  ;ecx - pointer to draw data
;set draw data to full screen
 
           mov    [ecx+0],dword 0
           mov    [ecx+4],dword 0
           mov    eax,[SCR_X_SIZE]
           mov    [ecx+8],eax
           mov    eax,[SCR_Y_SIZE]
           mov    [ecx+12],eax
 
           mov edi,[slot]
           imul edi,tss_step
           add edi,tss_data
           mov ecx,128/4
           xor eax, eax
           cld
           rep stosd
;Add IO access table - bit array of permitted ports
           not eax
           mov ecx,2048
           rep stosd                 ; access to 4096*8=65536 ports
           sub edi, tss_step
 
;set cr3 register in TSS of application
           mov ecx, [slot]
           shl ecx, 8
           mov eax,[SLOT_BASE+ecx+APPDATA.dir_table]
           mov [edi+TSS._cr3],eax
 
           mov esi,[params]
           mov eax, [esi+0x08]       ;app_eip
           mov [edi+TSS._eip],eax    ;set eip in TSS
           mov eax, [esi+0x0C]       ;app_esp
           mov [edi+TSS._esp],eax    ;set stack in TSS
           mov [edi+TSS._eflags],dword 0x1202
 
           mov [edi+TSS._cs],app_code  ;selector of code segment
           mov [edi+TSS._ss],app_data
           mov [edi+TSS._ds],app_data
           mov [edi+TSS._es],app_data
           mov [edi+TSS._fs],app_data
           mov [edi+TSS._gs],graph_data ;selector of graphic segment
           mov [edi+TSS._io],word 128
           mov [edi+TSS._ss0], os_data
           mov ebx, [pl0_stack]
           add ebx, 0x2000-512
           mov [edi+TSS._esp0],ebx
 
           mov ecx, edi    ;ecx - address of application TSS
           mov ebx,[slot]
           shl ebx,3
;set TSS descriptor
           mov [ebx+gdts+tss0+0],word tss_step ;limit (size)
           mov [ebx+gdts+tss0+2],cx  ;part of offset
           shr ecx,16
           mov [ebx+gdts+tss0+4],cl  ;part of offset
           mov [ebx+gdts+tss0+7],ch  ;part of offset
           mov [ebx+gdts+tss0+5],word 01010000b*256+11101001b ;system flags
 
;flush keyboard and buttons queue
           mov    [KEY_COUNT],byte 0
           mov    [BTN_COUNT],byte 0
 
           mov    edi,[slot]
           shl    edi,5
           add    edi,window_data
           mov    ebx,[slot]
           movzx  esi,word [WIN_STACK+ebx*2]
           lea    esi,[WIN_POS+esi*2]
           call   windowactivate        ;gui initialization
 
           mov    ebx,[slot]
           shl    ebx,5
           mov    [CURRENT_TASK+ebx+0xa],byte 0 ;set process state - running
; set if debuggee
           mov eax, [flags]
           test byte [flags], 1
           jz   .no_debug
           mov  [CURRENT_TASK+ebx+0xa],byte 1 ;set process state - suspended
           mov  eax,[CURRENT_TASK]
           mov  [SLOT_BASE+ebx*8+0xac],eax ;set debugger PID - current
.no_debug:
           mov    esi,new_process_running
           call   sys_msg_board_str     ;output information about succefull startup
           ret
endp
 
 
 
include "debug.inc"
 
iglobal
    new_process_loading db 'K : New Process - loading',13,10,0
    new_process_running db 'K : New Process - done',13,10,0
    start_not_enough_memory db 'K : New Process - not enough memory',13,10,0
endg
>

Rev 378	Rev 380
1	GREEDY_KERNEL equ 0	1	GREEDY_KERNEL equ 0
2		2
3		3
4	struc APP_HEADER_00	4	struc APP_HEADER_00
5	{ .banner dq ?	5	{ .banner dq ?
6	.version dd ? ;+8	6	.version dd ? ;+8
7	.start dd ? ;+12	7	.start dd ? ;+12
8	.i_end dd ? ;+16	8	.i_end dd ? ;+16
9	.mem_size dd ? ;+20	9	.mem_size dd ? ;+20
10	.i_param dd ? ;+24	10	.i_param dd ? ;+24
11	}	11	}
12		12
13	struc APP_HEADER_01	13	struc APP_HEADER_01
14	{ .banner dq ?	14	{ .banner dq ?
15	.version dd ? ;+8	15	.version dd ? ;+8
16	.start dd ? ;+12	16	.start dd ? ;+12
17	.i_end dd ? ;+16	17	.i_end dd ? ;+16
18	.mem_size dd ? ;+20	18	.mem_size dd ? ;+20
19	.stack_top dd ? ;+24	19	.stack_top dd ? ;+24
20	.i_param dd ? ;+28	20	.i_param dd ? ;+28
21	.i_icon dd ? ;+32	21	.i_icon dd ? ;+32
22	}	22	}
23		23
24	struc TSS	24	struc TSS
25	{	25	{
26	._back rw 2	26	._back rw 2
27	._esp0 rd 1	27	._esp0 rd 1
28	._ss0 rw 2	28	._ss0 rw 2
29	._esp1 rd 1	29	._esp1 rd 1
30	._ss1 rw 2	30	._ss1 rw 2
31	._esp2 rd 1	31	._esp2 rd 1
32	._ss2 rw 2	32	._ss2 rw 2
33	._cr3 rd 1	33	._cr3 rd 1
34	._eip rd 1	34	._eip rd 1
35	._eflags rd 1	35	._eflags rd 1
36	._eax rd 1	36	._eax rd 1
37	._ecx rd 1	37	._ecx rd 1
38	._edx rd 1	38	._edx rd 1
39	._ebx rd 1	39	._ebx rd 1
40	._esp rd 1	40	._esp rd 1
41	._ebp rd 1	41	._ebp rd 1
42	._esi rd 1	42	._esi rd 1
43	._edi rd 1	43	._edi rd 1
44	._es rw 2	44	._es rw 2
45	._cs rw 2	45	._cs rw 2
46	._ss rw 2	46	._ss rw 2
47	._ds rw 2	47	._ds rw 2
48	._fs rw 2	48	._fs rw 2
49	._gs rw 2	49	._gs rw 2
50	._ldt rw 2	50	._ldt rw 2
51	._trap rw 1	51	._trap rw 1
52	._io rw 1	52	._io rw 1
53	}	53	}
54		54
55	virtual at 0	55	virtual at 0
56	TSS TSS	56	TSS TSS
57	end virtual	57	end virtual
58		58
59	struc APP_PARAMS	59	struc APP_PARAMS
60	{ .app_cmdline ;0x00	60	{ .app_cmdline ;0x00
61	.app_path ;0x04	61	.app_path ;0x04
62	.app_eip ;0x08	62	.app_eip ;0x08
63	.app_esp ;0x0C	63	.app_esp ;0x0C
64	.app_mem ;0x10	64	.app_mem ;0x10
65	}	65	}
66		66
67	macro _clear_ op	67	macro _clear_ op
68	{ mov ecx, op/4	68	{ mov ecx, op/4
69	xor eax, eax	69	xor eax, eax
70	cld	70	cld
71	rep stosd	71	rep stosd
72	}	72	}
73		73
74		74
75	align 4	75	align 4
76	proc fs_execute	76	proc fs_execute
77		77
78	;fn_read:dword, file_size:dword, cluster:dword	78	;fn_read:dword, file_size:dword, cluster:dword
79		79
80	; ebx - cmdline	80	; ebx - cmdline
81	; edx - flags	81	; edx - flags
82	; ebp - full filename	82	; ebp - full filename
83	; [esp+4] = procedure DoRead, [esp+8] = filesize & [esp+12]... - arguments for it	83	; [esp+4] = procedure DoRead, [esp+8] = filesize & [esp+12]... - arguments for it
84		84
85	locals	85	locals
86	cmdline rd 64 ;256/4	86	cmdline rd 64 ;256/4
87	filename rd 256 ;1024/4	87	filename rd 256 ;1024/4
88	flags dd ?	88	flags dd ?
89		89
90	save_cr3 dd ?	90	save_cr3 dd ?
91	slot dd ?	91	slot dd ?
92	slot_base dd ?	92	slot_base dd ?
93	file_base dd ?	93	file_base dd ?
94	file_size dd ?	94	file_size dd ?
95	;app header data	95	;app header data
96	hdr_cmdline dd ? ;0x00	96	hdr_cmdline dd ? ;0x00
97	hdr_path dd ? ;0x04	97	hdr_path dd ? ;0x04
98	hdr_eip dd ? ;0x08	98	hdr_eip dd ? ;0x08
99	hdr_esp dd ? ;0x0C	99	hdr_esp dd ? ;0x0C
100	hdr_mem dd ? ;0x10	100	hdr_mem dd ? ;0x10
101	hdr_i_end dd ? ;0x14	101	hdr_i_end dd ? ;0x14
102	endl	102	endl
103		103
104	pushad	104	pushad
105		105
106	mov [cmdline], ebx	106	mov [cmdline], ebx
107	mov [flags], edx	107	mov [flags], edx
108		108
109	; [ebp] pointer to filename	109	; [ebp] pointer to filename
110		110
111	lea eax, [filename]	111	lea eax, [filename]
112	mov dword [eax+1020],0 ;force terminate	112	mov dword [eax+1020],0 ;force terminate
113	;string	113	;string
114	stdcall k_strncpy, eax, [ebp], 1023	114	stdcall k_strncpy, eax, [ebp], 1023
115		115
116	lea eax, [cmdline]	116	lea eax, [cmdline]
117	mov dword [eax+252], 0	117	mov dword [eax+252], 0
118	stdcall k_strncpy, eax, [cmdline], 255	118	stdcall k_strncpy, eax, [cmdline], 255
119		119
120	lea eax, [filename]	120	lea eax, [filename]
121	stdcall load_file, eax	121	stdcall load_file, eax
122	mov ecx, -ERROR_FILE_NOT_FOUND	122	mov ecx, -ERROR_FILE_NOT_FOUND
123	test eax, eax	123	test eax, eax
124	jz .err_file	124	jz .err_file
125		125
126	mov [file_base], eax	126	mov [file_base], eax
127	mov [file_size], ebx	127	mov [file_size], ebx
128		128
129	lea ebx, [hdr_cmdline]	129	lea ebx, [hdr_cmdline]
130	call test_app_header	130	call test_app_header
131	mov ecx, -0x1F	131	mov ecx, -0x1F
132	test eax, eax	132	test eax, eax
133	jz .err_hdr	133	jz .err_hdr
134		134
135	mov esi, new_process_loading	135	mov esi, new_process_loading
136	call sys_msg_board_str ; write message to message board	136	call sys_msg_board_str ; write message to message board
137		137
138	.wait_lock:	138	.wait_lock:
139	cmp [application_table_status],0	139	cmp [application_table_status],0
140	je .get_lock	140	je .get_lock
141	call change_task	141	call change_task
142	jmp .wait_lock	142	jmp .wait_lock
143		143
144	.get_lock:	144	.get_lock:
145	mov eax, 1	145	mov eax, 1
146	xchg eax, [application_table_status]	146	xchg eax, [application_table_status]
147	cmp eax, 0	147	cmp eax, 0
148	jne .wait_lock	148	jne .wait_lock
149		149
150	; pushfd	150	; pushfd
151	; cli	151	; cli
152		152
153	call set_application_table_status	153	call set_application_table_status
154		154
155	call get_new_process_place	155	call get_new_process_place
156	test eax, eax	156	test eax, eax
157	mov ecx, -0x20 ; too many processes	157	mov ecx, -0x20 ; too many processes
158	jz .err	158	jz .err
159		159
160	mov [slot], eax	160	mov [slot], eax
161	shl eax, 8	161	shl eax, 8
162	add eax, PROC_BASE	162	add eax, SLOT_BASE
163	mov [slot_base], eax	163	mov [slot_base], eax
164	mov edi, eax	164	mov edi, eax
165	_clear_ 256 ;clean extended information about process	165	_clear_ 256 ;clean extended information about process
166		166
167	; write application name	167	; write application name
168	lea edi, [filename]	168	lea edi, [filename]
169	mov al, '/'	169	mov al, '/'
170	call k_strrchr ; now eax points to name without path	170	call k_strrchr ; now eax points to name without path
171		171
172	lea esi, [eax+1]	172	lea esi, [eax+1]
173	test eax, eax	173	test eax, eax
174	jnz @F	174	jnz @F
175	lea esi, [filename]	175	lea esi, [filename]
176	@@:	176	@@:
177	mov ecx, 8 ; 8 chars for name	177	mov ecx, 8 ; 8 chars for name
178	mov edi, [slot_base]	178	mov edi, [slot_base]
179	.copy_process_name_loop:	179	.copy_process_name_loop:
180	lodsb	180	lodsb
181	cmp al, '.'	181	cmp al, '.'
182	jz .copy_process_name_done	182	jz .copy_process_name_done
183	test al, al	183	test al, al
184	jz .copy_process_name_done	184	jz .copy_process_name_done
185	stosb	185	stosb
186	loop .copy_process_name_loop	186	loop .copy_process_name_loop
187	.copy_process_name_done:	187	.copy_process_name_done:
188		188
189	mov ebx, cr3	189	mov ebx, cr3
190	mov [save_cr3], ebx	190	mov [save_cr3], ebx
191		191
192	stdcall create_app_space,[hdr_mem],[file_base],[file_size]	192	stdcall create_app_space,[hdr_mem],[file_base],[file_size]
193	mov ecx, -30 ; no memory	193	mov ecx, -30 ; no memory
194	test eax, eax	194	test eax, eax
195	jz .failed	195	jz .failed
196		196
197	mov ebx,[slot_base]	197	mov ebx,[slot_base]
198	mov [ebx+APPDATA.dir_table],eax	198	mov [ebx+APPDATA.dir_table],eax
199	mov eax,[hdr_mem]	199	mov eax,[hdr_mem]
200	mov [ebx+APPDATA.mem_size],eax	200	mov [ebx+APPDATA.mem_size],eax
201		201
202	if GREEDY_KERNEL	202	if GREEDY_KERNEL
203	else	203	else
204	mov ecx, [hdr_mem]	204	mov ecx, [hdr_mem]
205	mov edi, [file_size]	205	mov edi, [file_size]
206	add edi, 4095	206	add edi, 4095
207	and edi, not 4095	207	and edi, not 4095
208	sub ecx, edi	208	sub ecx, edi
209	jna @F	209	jna @F
210		210
211	xor eax, eax	211	xor eax, eax
212	add edi, new_app_base	212	add edi, new_app_base
213	cld	213	cld
214	rep stosb	214	rep stosb
215	@@:	215	@@:
216	end if	216	end if
217		217
218	; release only virtual space, not phisical memory	218	; release only virtual space, not phisical memory
219		219
220	stdcall free_kernel_space, [file_base]	220	stdcall free_kernel_space, [file_base]
221	lea eax, [hdr_cmdline]	221	lea eax, [hdr_cmdline]
222	lea ebx, [cmdline]	222	lea ebx, [cmdline]
223	lea ecx, [filename]	223	lea ecx, [filename]
224	stdcall set_app_params ,[slot],eax,ebx,ecx,[flags]	224	stdcall set_app_params ,[slot],eax,ebx,ecx,[flags]
225		225
226	mov eax, [save_cr3]	226	mov eax, [save_cr3]
227	call set_cr3	227	call set_cr3
228		228
229	; popfd	229	; popfd
230	xor ebx, ebx	230	xor ebx, ebx
231	mov [application_table_status],ebx ;unlock application_table_status mutex	231	mov [application_table_status],ebx ;unlock application_table_status mutex
232	mov eax,[process_number] ;set result	232	mov eax,[process_number] ;set result
233	ret	233	ret
234	.failed:	234	.failed:
235	mov eax, [save_cr3]	235	mov eax, [save_cr3]
236	call set_cr3	236	call set_cr3
237	.err:	237	.err:
238	; popfd	238	; popfd
239	.err_hdr:	239	.err_hdr:
240	stdcall kernel_free,[file_base]	240	stdcall kernel_free,[file_base]
241	.err_file:	241	.err_file:
242	xor eax, eax	242	xor eax, eax
243	mov [application_table_status],eax	243	mov [application_table_status],eax
244	mov eax, ecx	244	mov eax, ecx
245	ret	245	ret
246	endp	246	endp
247		247
248	align 4	248	align 4
249	test_app_header:	249	test_app_header:
250	virtual at eax	250	virtual at eax
251	APP_HEADER_00 APP_HEADER_00	251	APP_HEADER_00 APP_HEADER_00
252	end virtual	252	end virtual
253	virtual at eax	253	virtual at eax
254	APP_HEADER_01 APP_HEADER_01	254	APP_HEADER_01 APP_HEADER_01
255	end virtual	255	end virtual
256		256
257	cmp dword [eax], 'MENU'	257	cmp dword [eax], 'MENU'
258	jne .fail	258	jne .fail
259	cmp word [eax+4],'ET'	259	cmp word [eax+4],'ET'
260	jne .fail	260	jne .fail
261		261
262	cmp [eax+6], word '00'	262	cmp [eax+6], word '00'
263	jne .check_01_header	263	jne .check_01_header
264		264
265	mov ecx,[APP_HEADER_00.start]	265	mov ecx,[APP_HEADER_00.start]
266	mov [ebx+0x08], ecx ;app_eip	266	mov [ebx+0x08], ecx ;app_eip
267	mov edx,[APP_HEADER_00.mem_size]	267	mov edx,[APP_HEADER_00.mem_size]
268	mov [ebx+0x10], edx ;app_mem	268	mov [ebx+0x10], edx ;app_mem
269	shr edx,1	269	shr edx,1
270	sub edx,0x10	270	sub edx,0x10
271	mov [ebx+0x0C], edx ;app_esp	271	mov [ebx+0x0C], edx ;app_esp
272	mov ecx,[APP_HEADER_00.i_param]	272	mov ecx,[APP_HEADER_00.i_param]
273	mov [ebx], ecx ;app_cmdline	273	mov [ebx], ecx ;app_cmdline
274	mov [ebx+4], dword 0 ;app_path	274	mov [ebx+4], dword 0 ;app_path
275	mov edx, [APP_HEADER_00.i_end]	275	mov edx, [APP_HEADER_00.i_end]
276	mov [ebx+0x14], edx	276	mov [ebx+0x14], edx
277	ret	277	ret
278		278
279	.check_01_header:	279	.check_01_header:
280		280
281	cmp [eax+6],word '01'	281	cmp [eax+6],word '01'
282	jne .fail	282	jne .fail
283		283
284	mov ecx,[APP_HEADER_01.start]	284	mov ecx,[APP_HEADER_01.start]
285	mov [ebx+0x08], ecx ;app_eip	285	mov [ebx+0x08], ecx ;app_eip
286	mov edx,[APP_HEADER_01.mem_size]	286	mov edx,[APP_HEADER_01.mem_size]
287	mov [ebx+0x10], edx ;app_mem	287	mov [ebx+0x10], edx ;app_mem
288	mov ecx,[APP_HEADER_01.stack_top]	288	mov ecx,[APP_HEADER_01.stack_top]
289	mov [ebx+0x0C], ecx ;app_esp	289	mov [ebx+0x0C], ecx ;app_esp
290	mov edx,[APP_HEADER_01.i_param]	290	mov edx,[APP_HEADER_01.i_param]
291	mov [ebx], edx ;app_cmdline	291	mov [ebx], edx ;app_cmdline
292	mov ecx,[APP_HEADER_01.i_icon]	292	mov ecx,[APP_HEADER_01.i_icon]
293	mov [ebx+4], ecx ;app_path	293	mov [ebx+4], ecx ;app_path
294	mov edx, [APP_HEADER_01.i_end]	294	mov edx, [APP_HEADER_01.i_end]
295	mov [ebx+0x14], edx	295	mov [ebx+0x14], edx
296	ret	296	ret
297	.fail:	297	.fail:
298	xor eax, eax	298	xor eax, eax
299	ret	299	ret
300		300
301	align 4	301	align 4
302	proc get_new_process_place	302	proc get_new_process_place
303	;input:	303	;input:
304	; none	304	; none
305	;result:	305	;result:
306	; eax=[new_process_place]<>0 - ok	306	; eax=[new_process_place]<>0 - ok
307	; 0 - failed.	307	; 0 - failed.
308	;This function find least empty slot.	308	;This function find least empty slot.
309	;It doesn't increase [TASK_COUNT]!	309	;It doesn't increase [TASK_COUNT]!
310	mov eax,CURRENT_TASK	310	mov eax,CURRENT_TASK
311	mov ebx,[TASK_COUNT]	311	mov ebx,[TASK_COUNT]
312	inc ebx	312	inc ebx
313	shl ebx,5	313	shl ebx,5
314	add ebx,eax ;ebx - address of process information for (last+1) slot	314	add ebx,eax ;ebx - address of process information for (last+1) slot
315	.newprocessplace:	315	.newprocessplace:
316	;eax = address of process information for current slot	316	;eax = address of process information for current slot
317	cmp eax,ebx	317	cmp eax,ebx
318	jz .endnewprocessplace ;empty slot after high boundary	318	jz .endnewprocessplace ;empty slot after high boundary
319	add eax,0x20	319	add eax,0x20
320	cmp word [eax+0xa],9 ;check process state, 9 means that process slot is empty	320	cmp word [eax+0xa],9 ;check process state, 9 means that process slot is empty
321	jnz .newprocessplace	321	jnz .newprocessplace
322	.endnewprocessplace:	322	.endnewprocessplace:
323	mov ebx,eax	323	mov ebx,eax
324	sub eax,CURRENT_TASK	324	sub eax,CURRENT_TASK
325	shr eax,5 ;calculate slot index	325	shr eax,5 ;calculate slot index
326	cmp eax,256	326	cmp eax,256
327	jge .failed ;it should be <256	327	jge .failed ;it should be <256
328	mov word [ebx+0xa],9 ;set process state to 9 (for slot after hight boundary)	328	mov word [ebx+0xa],9 ;set process state to 9 (for slot after hight boundary)
329	; mov [new_process_place], eax	329	; mov [new_process_place], eax
330	ret	330	ret
331		331
332	.failed:	332	.failed:
333	xor eax,eax	333	xor eax,eax
334	ret	334	ret
335	endp	335	endp
336		336
337	align 4	337	align 4
338	proc create_app_space stdcall, app_size:dword,img_base:dword,img_size:dword	338	proc create_app_space stdcall, app_size:dword,img_base:dword,img_size:dword
339	locals	339	locals
340	app_pages dd ?	340	app_pages dd ?
341	img_pages dd ?	341	img_pages dd ?
342	dir_addr dd ?	342	dir_addr dd ?
343	app_tabs dd ?	343	app_tabs dd ?
344	endl	344	endl
345		345
346	mov ebx, pg_data.pg_mutex	346	mov ebx, pg_data.pg_mutex
347	call wait_mutex ;ebx	347	call wait_mutex ;ebx
348		348
349	xor eax, eax	349	xor eax, eax
350	mov [dir_addr], eax	350	mov [dir_addr], eax
351		351
352	mov eax, [app_size]	352	mov eax, [app_size]
353	add eax, 4095	353	add eax, 4095
354	and eax, NOT(4095)	354	and eax, NOT(4095)
355	mov [app_size], eax	355	mov [app_size], eax
356	mov ebx, eax	356	mov ebx, eax
357	shr eax, 12	357	shr eax, 12
358	mov [app_pages], eax	358	mov [app_pages], eax
359		359
360	add ebx, 0x3FFFFF	360	add ebx, 0x3FFFFF
361	and ebx, NOT(0x3FFFFF)	361	and ebx, NOT(0x3FFFFF)
362	shr ebx, 22	362	shr ebx, 22
363	mov [app_tabs], ebx	363	mov [app_tabs], ebx
364		364
365	mov ecx, [img_size]	365	mov ecx, [img_size]
366	add ecx, 4095	366	add ecx, 4095
367	and ecx, NOT(4095)	367	and ecx, NOT(4095)
368		368
369	mov [img_size], ecx	369	mov [img_size], ecx
370	shr ecx, 12	370	shr ecx, 12
371	mov [img_pages], ecx	371	mov [img_pages], ecx
372		372
373	if GREEDY_KERNEL	373	if GREEDY_KERNEL
374	lea eax, [ecx+ebx+2] ;only image size	374	lea eax, [ecx+ebx+2] ;only image size
375	else	375	else
376	lea eax, [eax+ebx+2] ;all requested memory	376	lea eax, [eax+ebx+2] ;all requested memory
377	end if	377	end if
378	cmp eax, [pg_data.pages_free]	378	cmp eax, [pg_data.pages_free]
379	ja .fail	379	ja .fail
380		380
381	call alloc_page	381	call alloc_page
382	test eax, eax	382	test eax, eax
383	jz .fail	383	jz .fail
384	mov [dir_addr], eax	384	mov [dir_addr], eax
385	stdcall map_page,[tmp_task_pdir],eax,dword PG_SW	385	stdcall map_page,[tmp_task_pdir],eax,dword PG_SW
386		386
387	mov esi, sys_pgdir	387	mov esi, sys_pgdir
388	mov edi, [tmp_task_pdir]	388	mov edi, [tmp_task_pdir]
389	mov ecx, (page_tabs shr 20)/4	389	mov ecx, (page_tabs shr 20)/4
390	cld	390	cld
391	rep movsd	391	rep movsd
392		392
393	mov eax, [dir_addr]	393	mov eax, [dir_addr]
394	or eax, PG_SW	394	or eax, PG_SW
395	stosd ; [(page_tabs shr 20)]= eax	395	stosd ; [(page_tabs shr 20)]= eax
396		396
397	mov ecx, 0x800/4	397	mov ecx, 0x800/4
398	xor eax, eax	398	xor eax, eax
399	rep stosd	399	rep stosd
400		400
401	mov eax, [dir_addr]	401	mov eax, [dir_addr]
402	call set_cr3	402	call set_cr3
403		403
404	mov edx, [app_tabs]	404	mov edx, [app_tabs]
405	mov edi, new_app_base	405	mov edi, new_app_base
406	@@:	406	@@:
407	call alloc_page	407	call alloc_page
408	test eax, eax	408	test eax, eax
409	jz .fail	409	jz .fail
410		410
411	stdcall map_page_table, edi, eax	411	stdcall map_page_table, edi, eax
412	add edi, 0x00400000	412	add edi, 0x00400000
413	dec edx	413	dec edx
414	jnz @B	414	jnz @B
415		415
416	mov edi, new_app_base	416	mov edi, new_app_base
417	shr edi, 10	417	shr edi, 10
418	add edi, page_tabs	418	add edi, page_tabs
419		419
420	mov ecx, [app_tabs]	420	mov ecx, [app_tabs]
421	shl ecx, 10	421	shl ecx, 10
422	xor eax, eax	422	xor eax, eax
423	rep stosd	423	rep stosd
424		424
425	mov ecx, [img_pages]	425	mov ecx, [img_pages]
426	mov ebx, PG_UW	426	mov ebx, PG_UW
427	mov edx, new_app_base	427	mov edx, new_app_base
428	mov esi, [img_base]	428	mov esi, [img_base]
429	mov edi, new_app_base	429	mov edi, new_app_base
430	shr esi, 10	430	shr esi, 10
431	shr edi, 10	431	shr edi, 10
432	add esi, page_tabs	432	add esi, page_tabs
433	add edi, page_tabs	433	add edi, page_tabs
434	.remap:	434	.remap:
435	lodsd	435	lodsd
436	or eax, ebx ; force user level r/w access	436	or eax, ebx ; force user level r/w access
437	stosd	437	stosd
438	add edx, 0x1000	438	add edx, 0x1000
439	dec [app_pages]	439	dec [app_pages]
440	dec ecx	440	dec ecx
441	jnz .remap	441	jnz .remap
442		442
443	mov ecx, [app_pages]	443	mov ecx, [app_pages]
444	test ecx, ecx	444	test ecx, ecx
445	jz .done	445	jz .done
446		446
447	if GREEDY_KERNEL	447	if GREEDY_KERNEL
448	mov eax, 0x02	448	mov eax, 0x02
449	.reserve:	449	.reserve:
450	stosd	450	stosd
451	invlpg [edx]	451	invlpg [edx]
452	add edx, 4096	452	add edx, 4096
453	dec ecx	453	dec ecx
454	jnz .reserve	454	jnz .reserve
455	else	455	else
456		456
457	.alloc:	457	.alloc:
458	call alloc_page	458	call alloc_page
459	test eax, eax	459	test eax, eax
460	jz .fail	460	jz .fail
461		461
462	stdcall map_page,edx,eax,dword PG_UW	462	stdcall map_page,edx,eax,dword PG_UW
463	add edx, 0x1000	463	add edx, 0x1000
464	dec [app_pages]	464	dec [app_pages]
465	jnz .alloc	465	jnz .alloc
466		466
467	end if	467	end if
468		468
469	.done:	469	.done:
470	stdcall map_page,[tmp_task_pdir],dword 0,dword PG_UNMAP	470	stdcall map_page,[tmp_task_pdir],dword 0,dword PG_UNMAP
471		471
472	dec [pg_data.pg_mutex]	472	dec [pg_data.pg_mutex]
473	mov eax, [dir_addr]	473	mov eax, [dir_addr]
474	ret	474	ret
475	.fail:	475	.fail:
476	dec [pg_data.pg_mutex]	476	dec [pg_data.pg_mutex]
477	cmp [dir_addr], 0	477	cmp [dir_addr], 0
478	je @f	478	je @f
479	stdcall destroy_app_space, [dir_addr]	479	stdcall destroy_app_space, [dir_addr]
480	@@:	480	@@:
481	xor eax, eax	481	xor eax, eax
482	ret	482	ret
483	endp	483	endp
484		484
485	align 4	485	align 4
486	set_cr3:	486	set_cr3:
487	mov esi, [CURRENT_TASK]	487	mov esi, [CURRENT_TASK]
488	mov ebx, esi	488	mov ebx, esi
489	shl esi,8	489	shl esi,8
490	mov [PROC_BASE+esi+0xB8],eax	490	mov [SLOT_BASE+esi+0xB8],eax
491	imul ebx,tss_step	491	imul ebx,tss_step
492	add ebx,tss_data	492	add ebx,tss_data
493	mov [ebx+28], eax	493	mov [ebx+28], eax
494	mov cr3, eax	494	mov cr3, eax
495	ret	495	ret
496		496
497	align 4	497	align 4
498	proc destroy_page_table stdcall, pg_tab:dword	498	proc destroy_page_table stdcall, pg_tab:dword
499		499
500	push esi	500	push esi

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/taskman.inc – Rev 378 → 380