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


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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/taskman.inc – Rev 593 → 709