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


$Revision: 506 $
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
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 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
           DEBUGF 1,"%s",new_process_loading
 
.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
           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
 
           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:
.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]
 
; \begin{diamond}[20.08.2006]
; sanity check (functions 19,58 load app_i_end bytes and that must
; fit in allocated memory to prevent kernel faults)
           cmp  edx,[APP_HEADER_01.i_end]
           jb   .fail
; \end{diamond}[20.08.2006]
 
           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)
           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 edi, [tmp_task_pdir]
           mov ecx, (OS_BASE shr 20)/4
           xor eax, eax
           cld
           rep stosd
 
           mov ecx, (OS_BASE shr 20)/4
           mov esi, sys_pgdir+(OS_BASE shr 20)
           rep movsd
 
           mov eax, [dir_addr]
           or eax, PG_SW
           mov [edi-4096+(page_tabs shr 20)], eax
 
           and eax, -4096
           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 ebx, [current_slot]
           mov [ebx+APPDATA.dir_table], 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]
           mov edi, (OS_BASE shr 20)/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
           DEBUGF 1,"%s",new_process_loading
.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_slot]
           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
           DEBUGF 1,"%s",new_process_running
 
           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
 
EFL_IF      equ 0x0200
EFL_IOPL1   equ 0x1000
EFL_IOPL2   equ 0x2000
EFL_IOPL3   equ 0x3000
 
 
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, RING0_STACK_SIZE+512
           mov [pl0_stack], eax
 
           lea edi, [eax+RING0_STACK_SIZE]
 
           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
 
;set default io permission map
           mov [eax+SLOT_BASE+APPDATA.io_map],\
                  (tss._io_map_0-OS_BASE+PG_MAP)
           mov [eax+SLOT_BASE+APPDATA.io_map+4],\
                  (tss._io_map_1-OS_BASE+PG_MAP)
 
           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
 
           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
           stdcall k_strncpy, edx, [app_path], 1024
@@:
           mov    ebx,[slot]
           mov    eax,ebx
           shl    ebx,5
           lea    ecx,[draw_data+ebx]  ;ecx - pointer to draw data
 
; 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
 
;set draw data to full screen
 
           mov    [ecx+0],dword 0
           mov    [ecx+4],dword 0
           mov    eax,[ScreenWidth]
           mov    [ecx+8],eax
           mov    eax,[ScreenHeight]
           mov    [ecx+12],eax
 
           mov ebx, [pl0_stack]
           mov esi,[params]
           lea ecx, [ebx+REG_EIP]
           xor eax, eax
 
           mov [ebx+REG_RET], dword irq0.return
           mov [ebx+REG_EDI], eax
           mov [ebx+REG_ESI], eax
           mov [ebx+REG_EBP], eax
           mov [ebx+REG_ESP], ecx   ;ebx+REG_EIP
           mov [ebx+REG_EBX], eax
           mov [ebx+REG_EDX], eax
           mov [ebx+REG_ECX], eax
           mov [ebx+REG_EAX], eax
 
           mov eax, [esi+0x08]       ;app_eip
           mov [ebx+REG_EIP],  eax   ;app_entry
           mov [ebx+REG_CS], dword app_code
           mov [ebx+REG_EFLAGS], dword EFL_IOPL1+EFL_IF
 
           mov eax, [esi+0x0C]       ;app_esp
           mov [ebx+REG_APP_ESP], eax    ;app_stack
           mov [ebx+REG_SS], dword app_data
 
           lea ecx, [ebx+REG_RET]
           mov ebx, [slot]
           shl ebx, 8
           mov [ebx+SLOT_BASE+APPDATA.saved_esp], ecx
 
;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
           DEBUGF 1,"%s",new_process_running
           ret
endp
 
include "debug.inc"
>

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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/taskman.inc – Rev 465 → 506