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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 1376 $
 
 
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
 
.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]
       test eax, eax
       jnz .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
 
       xor edx, edx
       cmp word [6], '02'
       jne @f
 
       not edx
@@:
       mov   [ebx+APPDATA.tls_base],edx
 
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
       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'
       je @f
       cmp [eax+6], word '02'
       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
       rep stosd
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], 0
@@:
       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
           test eax, 1 shl 9
           jnz .next                      ;skip shared pages
       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, dlls_list:dword
 
       xor   edx,edx
       push  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
       add   ecx,SLOT_BASE
       cmp   [ecx+APPDATA.dir_table],ebx   ;compare page directory addresses
       jnz   @f
       mov   [ebp-4],ecx
       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
       pop   ecx
       cmp   edx,1
       jg    .ret
;if there isn't threads then clear memory.
       mov esi, [dlls_list]
       call destroy_all_hdlls
 
       mov ebx, pg_data.pg_mutex
       call wait_mutex   ;ebx
 
       mov eax, [pg_dir]
       and eax, not 0xFFF
       stdcall map_page,[tmp_task_pdir],eax,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,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],0,PG_UNMAP
       stdcall map_page,[tmp_task_pdir],0,PG_UNMAP
       dec [pg_data.pg_mutex]
.ret:
       ret
endp
 
align 4
get_pid:
       mov eax, [TASK_BASE]
       mov eax, [eax+TASKDATA.pid]
       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:
;  esi - start of buffer
;  edx - 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
;  esi - start of buffer
;  edx - size of buffer
;result:
;  eax = 1 region lays in app memory
;  eax = 0 region don't lays in app memory
 
     test edx,edx
     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
;  ecx - buffer address
;  edx - buffer size
;  esi - 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], ecx
       and [r_count], 0
       mov [tmp_r_cnt], edx
       mov [offset], esi
 
       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 ebx, [offset]
 
       push ecx
       stdcall map_memEx, [proc_mem_map],\
                  [slot], ebx, ecx, PG_MAP
       pop ecx
 
       mov esi, [offset]
       and esi, 0xfff
       sub eax, esi
       jbe .ret
       cmp ecx, eax
       jbe @f
       mov ecx, eax
       mov [tmp_r_cnt], eax
@@:
       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
.ret:
       popad
       mov eax, [r_count]
       ret
endp
 
align 4
proc write_process_memory
;Input:
;  eax - process slot
;  ecx - buffer address
;  edx - buffer size
;  esi - 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], ecx
       and [w_count], 0
       mov [tmp_w_cnt], edx
       mov [offset], esi
 
       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 ebx, [offset]
      ;     add ebx, new_app_base
       push ecx
       stdcall map_memEx, [proc_mem_map],\
                  [slot], ebx, ecx, PG_SW
       pop ecx
 
       mov edi, [offset]
       and edi, 0xfff
       sub eax, edi
       jbe .ret
       cmp ecx, eax
       jbe @f
       mov ecx, eax
       mov [tmp_w_cnt], eax
@@:
       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
.ret:
       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 ebx,1
       jne .failed          ;other subfunctions
 
       xor  eax,eax
       mov [app_eip], ecx
       mov [app_cmdline], eax
       mov [app_esp], edx
       mov [app_path], eax
       ;mov    esi,new_process_loading
       ;call   sys_msg_board_str
.wait_lock:
       cmp [application_table_status],0
       je .get_lock
       call   change_task
       jmp .wait_lock
 
.get_lock:
       mov eax, 1
       xchg eax, [application_table_status]
       test eax, eax
       jnz .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
 
       mov eax,[ebx+APPDATA.dlls_list_ptr]
       mov [edx+APPDATA.dlls_list_ptr],eax
 
       mov eax, [ebx+APPDATA.tls_base]
       test eax, eax
       jz @F
 
       push edx
       stdcall user_alloc, 4096
       pop edx
       test eax, eax
       jz .failed1	;eax=0
@@:
       mov [edx+APPDATA.tls_base], eax
 
       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
       xor    eax,eax
       mov    [application_table_status],eax	;unlock application_table_status mutex
       mov    eax,[process_number]          	;set result
       ret
.failed:
       xor    eax,eax
.failed1:
       mov    [application_table_status],eax
       dec    eax	;-1
       ret
endp
 
; param
;  ebx=mutex
 
align 4
wait_mutex:
;;Maxis use atomic bts for mutex 4.4.2009
       push eax
       push ebx
.do_wait:
           bts dword [ebx],0
           jnc .locked
       call change_task
       jmp .do_wait
.locked:
       pop ebx
       pop eax
       ret
 
align 4
tls_app_entry:
 
        call init_heap
        stdcall user_alloc, 4096
 
        mov edx, [current_slot]
        mov [edx+APPDATA.tls_base], eax
        mov [tls_data_l+2],ax
        shr eax,16
        mov [tls_data_l+4],al
        mov [tls_data_l+7],ah
        mov dx, app_tls
        mov fs, dx
        popad
        iretd
 
 
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.exc_handler], 0
       mov [eax+SLOT_BASE+APPDATA.except_mask], 0
 
;set default io permission map
       mov ecx, [SLOT_BASE+256+APPDATA.io_map]
       mov [eax+SLOT_BASE+APPDATA.io_map], ecx
       mov ecx, [SLOT_BASE+256+APPDATA.io_map+4]
       mov [eax+SLOT_BASE+APPDATA.io_map+4], ecx
 
       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
 
       mov edx, irq0.return
       cmp [ebx*8+SLOT_BASE+APPDATA.tls_base], -1
       jne @F
       mov edx, tls_app_entry
@@:
; 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
       xor    eax,eax
       mov    [ecx+0],dword eax
       mov    [ecx+4],dword eax
       mov    eax,[Screen_Max_X]
       mov    [ecx+8],eax
       mov    eax,[Screen_Max_Y]
       mov    [ecx+12],eax
 
       mov ebx, [pl0_stack]
       mov esi,[params]
       lea ecx, [ebx+REG_EIP]
       xor eax, eax
 
       mov [ebx+REG_RET], edx
       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
       ret
endp
 
include "debug.inc"
>

Rev 1369	Rev 1376
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: 1369 $	8	$Revision: 1376 $
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		116
117	.namecopied:	117	.namecopied:
118		118
119	mov [cmdline], ebx	119	mov [cmdline], ebx
120	test ebx, ebx	120	test ebx, ebx
121	jz @F	121	jz @F
122		122
123	lea eax, [cmdline]	123	lea eax, [cmdline]
124	mov dword [eax+252], 0	124	mov dword [eax+252], 0
125	stdcall strncpy, eax, ebx, 255	125	stdcall strncpy, eax, ebx, 255
126	@@:	126	@@:
127	lea eax, [filename]	127	lea eax, [filename]
128	stdcall load_file, eax	128	stdcall load_file, eax
129	mov ecx, -ERROR_FILE_NOT_FOUND	129	mov ecx, -ERROR_FILE_NOT_FOUND
130	test eax, eax	130	test eax, eax
131	jz .err_file	131	jz .err_file
132		132
133	mov [file_base], eax	133	mov [file_base], eax
134	mov [file_size], ebx	134	mov [file_size], ebx
135		135
136	lea ebx, [hdr_cmdline]	136	lea ebx, [hdr_cmdline]
137	call test_app_header	137	call test_app_header
138	mov ecx, -0x1F	138	mov ecx, -0x1F
139	test eax, eax	139	test eax, eax
140	jz .err_hdr	140	jz .err_hdr
141		141
142	;mov esi, new_process_loading	142	;mov esi, new_process_loading
143	;call sys_msg_board_str ; write message to message board	143	;call sys_msg_board_str ; write message to message board
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	test eax, eax	154	test eax, eax
155	jnz .wait_lock	155	jnz .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	xor edx, edx	205	xor edx, edx
206	cmp word [6], '02'	206	cmp word [6], '02'
207	jne @f	207	jne @f
208		208
209	not edx	209	not edx
210	@@:	210	@@:
211	mov [ebx+APPDATA.tls_base],edx	211	mov [ebx+APPDATA.tls_base],edx
212		212
213	if GREEDY_KERNEL	213	if GREEDY_KERNEL
214	else	214	else
215	mov ecx, [hdr_mem]	215	mov ecx, [hdr_mem]
216	mov edi, [file_size]	216	mov edi, [file_size]
217	add edi, 4095	217	add edi, 4095
218	and edi, not 4095	218	and edi, not 4095
219	sub ecx, edi	219	sub ecx, edi
220	jna @F	220	jna @F
221		221
222	xor eax, eax	222	xor eax, eax
223	cld	223	cld
224	rep stosb	224	rep stosb
225	@@:	225	@@:
226	end if	226	end if
227		227
228	; release only virtual space, not phisical memory	228	; release only virtual space, not phisical memory
229		229
230	stdcall free_kernel_space, [file_base]	230	stdcall free_kernel_space, [file_base]
231	lea eax, [hdr_cmdline]	231	lea eax, [hdr_cmdline]
232	lea ebx, [cmdline]	232	lea ebx, [cmdline]
233	lea ecx, [filename]	233	lea ecx, [filename]
234	stdcall set_app_params ,[slot],eax,ebx,ecx,[flags]	234	stdcall set_app_params ,[slot],eax,ebx,ecx,[flags]
235		235
236	mov eax, [save_cr3]	236	mov eax, [save_cr3]
237	call set_cr3	237	call set_cr3
238		238
239	xor ebx, ebx	239	xor ebx, ebx
240	mov [application_table_status],ebx ;unlock application_table_status mutex	240	mov [application_table_status],ebx ;unlock application_table_status mutex
241	mov eax,[process_number] ;set result	241	mov eax,[process_number] ;set result
242	ret	242	ret
243	.failed:	243	.failed:
244	mov eax, [save_cr3]	244	mov eax, [save_cr3]
245	call set_cr3	245	call set_cr3
246	.err:	246	.err:
247	.err_hdr:	247	.err_hdr:
248	stdcall kernel_free,[file_base]	248	stdcall kernel_free,[file_base]
249	.err_file:	249	.err_file:
250	xor eax, eax	250	xor eax, eax
251	mov [application_table_status],eax	251	mov [application_table_status],eax
252	mov eax, ecx	252	mov eax, ecx
253	ret	253	ret
254	endp	254	endp
255		255
256	align 4	256	align 4
257	test_app_header:	257	test_app_header:
258	virtual at eax	258	virtual at eax
259	APP_HEADER_00 APP_HEADER_00	259	APP_HEADER_00 APP_HEADER_00
260	end virtual	260	end virtual
261	virtual at eax	261	virtual at eax
262	APP_HEADER_01 APP_HEADER_01	262	APP_HEADER_01 APP_HEADER_01
263	end virtual	263	end virtual
264		264
265	cmp dword [eax], 'MENU'	265	cmp dword [eax], 'MENU'
266	jne .fail	266	jne .fail
267	cmp word [eax+4],'ET'	267	cmp word [eax+4],'ET'
268	jne .fail	268	jne .fail
269		269
270	cmp [eax+6], word '00'	270	cmp [eax+6], word '00'
271	jne .check_01_header	271	jne .check_01_header
272		272
273	mov ecx,[APP_HEADER_00.start]	273	mov ecx,[APP_HEADER_00.start]
274	mov [ebx+0x08], ecx ;app_eip	274	mov [ebx+0x08], ecx ;app_eip
275	mov edx,[APP_HEADER_00.mem_size]	275	mov edx,[APP_HEADER_00.mem_size]
276	mov [ebx+0x10], edx ;app_mem	276	mov [ebx+0x10], edx ;app_mem
277	shr edx,1	277	shr edx,1
278	sub edx,0x10	278	sub edx,0x10
279	mov [ebx+0x0C], edx ;app_esp	279	mov [ebx+0x0C], edx ;app_esp
280	mov ecx,[APP_HEADER_00.i_param]	280	mov ecx,[APP_HEADER_00.i_param]
281	mov [ebx], ecx ;app_cmdline	281	mov [ebx], ecx ;app_cmdline
282	mov [ebx+4], dword 0 ;app_path	282	mov [ebx+4], dword 0 ;app_path
283	mov edx, [APP_HEADER_00.i_end]	283	mov edx, [APP_HEADER_00.i_end]
284	mov [ebx+0x14], edx	284	mov [ebx+0x14], edx
285	ret	285	ret
286		286
287	.check_01_header:	287	.check_01_header:
288		288
289	cmp [eax+6], word '01'	289	cmp [eax+6], word '01'
290	je @f	290	je @f
291	cmp [eax+6], word '02'	291	cmp [eax+6], word '02'
292	jne .fail	292	jne .fail
293	@@:	293	@@:
294	mov ecx,[APP_HEADER_01.start]	294	mov ecx,[APP_HEADER_01.start]
295	mov [ebx+0x08], ecx ;app_eip	295	mov [ebx+0x08], ecx ;app_eip
296	mov edx,[APP_HEADER_01.mem_size]	296	mov edx,[APP_HEADER_01.mem_size]
297		297
298	; \begin{diamond}[20.08.2006]	298	; \begin{diamond}[20.08.2006]
299	; sanity check (functions 19,58 load app_i_end bytes and that must	299	; sanity check (functions 19,58 load app_i_end bytes and that must
300	; fit in allocated memory to prevent kernel faults)	300	; fit in allocated memory to prevent kernel faults)
301	cmp edx,[APP_HEADER_01.i_end]	301	cmp edx,[APP_HEADER_01.i_end]
302	jb .fail	302	jb .fail
303	; \end{diamond}[20.08.2006]	303	; \end{diamond}[20.08.2006]
304		304
305	mov [ebx+0x10], edx ;app_mem	305	mov [ebx+0x10], edx ;app_mem
306	mov ecx,[APP_HEADER_01.stack_top]	306	mov ecx,[APP_HEADER_01.stack_top]
307	mov [ebx+0x0C], ecx ;app_esp	307	mov [ebx+0x0C], ecx ;app_esp
308	mov edx,[APP_HEADER_01.i_param]	308	mov edx,[APP_HEADER_01.i_param]
309	mov [ebx], edx ;app_cmdline	309	mov [ebx], edx ;app_cmdline
310	mov ecx,[APP_HEADER_01.i_icon]	310	mov ecx,[APP_HEADER_01.i_icon]
311	mov [ebx+4], ecx ;app_path	311	mov [ebx+4], ecx ;app_path
312	mov edx, [APP_HEADER_01.i_end]	312	mov edx, [APP_HEADER_01.i_end]
313	mov [ebx+0x14], edx	313	mov [ebx+0x14], edx
314	ret	314	ret
315	.fail:	315	.fail:
316	xor eax, eax	316	xor eax, eax
317	ret	317	ret
318		318
319	align 4	319	align 4
320	proc get_new_process_place	320	proc get_new_process_place
321	;input:	321	;input:
322	; none	322	; none
323	;result:	323	;result:
324	; eax=[new_process_place]<>0 - ok	324	; eax=[new_process_place]<>0 - ok
325	; 0 - failed.	325	; 0 - failed.
326	;This function find least empty slot.	326	;This function find least empty slot.
327	;It doesn't increase [TASK_COUNT]!	327	;It doesn't increase [TASK_COUNT]!
328	mov eax,CURRENT_TASK	328	mov eax,CURRENT_TASK
329	mov ebx,[TASK_COUNT]	329	mov ebx,[TASK_COUNT]
330	inc ebx	330	inc ebx
331	shl ebx,5	331	shl ebx,5
332	add ebx,eax ;ebx - address of process information for (last+1) slot	332	add ebx,eax ;ebx - address of process information for (last+1) slot
333	.newprocessplace:	333	.newprocessplace:
334	;eax = address of process information for current slot	334	;eax = address of process information for current slot
335	cmp eax,ebx	335	cmp eax,ebx
336	jz .endnewprocessplace ;empty slot after high boundary	336	jz .endnewprocessplace ;empty slot after high boundary
337	add eax,0x20	337	add eax,0x20
338	cmp word [eax+0xa],9 ;check process state, 9 means that process slot is empty	338	cmp word [eax+0xa],9 ;check process state, 9 means that process slot is empty
339	jnz .newprocessplace	339	jnz .newprocessplace
340	.endnewprocessplace:	340	.endnewprocessplace:
341	mov ebx,eax	341	mov ebx,eax
342	sub eax,CURRENT_TASK	342	sub eax,CURRENT_TASK
343	shr eax,5 ;calculate slot index	343	shr eax,5 ;calculate slot index
344	cmp eax,256	344	cmp eax,256
345	jge .failed ;it should be <256	345	jge .failed ;it should be <256
346	mov word [ebx+0xa],9 ;set process state to 9 (for slot after hight boundary)	346	mov word [ebx+0xa],9 ;set process state to 9 (for slot after hight boundary)
347	ret	347	ret
348	.failed:	348	.failed:
349	xor eax,eax	349	xor eax,eax
350	ret	350	ret
351	endp	351	endp
352		352
353	align 4	353	align 4
354	proc create_app_space stdcall, app_size:dword,img_base:dword,img_size:dword	354	proc create_app_space stdcall, app_size:dword,img_base:dword,img_size:dword
355	locals	355	locals
356	app_pages dd ?	356	app_pages dd ?
357	img_pages dd ?	357	img_pages dd ?
358	dir_addr dd ?	358	dir_addr dd ?
359	app_tabs dd ?	359	app_tabs dd ?
360	endl	360	endl
361		361
362	mov ebx, pg_data.pg_mutex	362	mov ebx, pg_data.pg_mutex
363	call wait_mutex ;ebx	363	call wait_mutex ;ebx
364		364
365	xor eax, eax	365	xor eax, eax
366	mov [dir_addr], eax	366	mov [dir_addr], eax
367		367
368	mov eax, [app_size]	368	mov eax, [app_size]
369	add eax, 4095	369	add eax, 4095
370	and eax, NOT(4095)	370	and eax, NOT(4095)
371	mov [app_size], eax	371	mov [app_size], eax
372	mov ebx, eax	372	mov ebx, eax
373	shr eax, 12	373	shr eax, 12
374	mov [app_pages], eax	374	mov [app_pages], eax
375		375
376	add ebx, 0x3FFFFF	376	add ebx, 0x3FFFFF
377	and ebx, NOT(0x3FFFFF)	377	and ebx, NOT(0x3FFFFF)
378	shr ebx, 22	378	shr ebx, 22
379	mov [app_tabs], ebx	379	mov [app_tabs], ebx
380		380
381	mov ecx, [img_size]	381	mov ecx, [img_size]
382	add ecx, 4095	382	add ecx, 4095
383	and ecx, NOT(4095)	383	and ecx, NOT(4095)
384		384
385	mov [img_size], ecx	385	mov [img_size], ecx
386	shr ecx, 12	386	shr ecx, 12
387	mov [img_pages], ecx	387	mov [img_pages], ecx
388		388
389	if GREEDY_KERNEL	389	if GREEDY_KERNEL
390	lea eax, [ecx+ebx+2] ;only image size	390	lea eax, [ecx+ebx+2] ;only image size
391	else	391	else
392	lea eax, [eax+ebx+2] ;all requested memory	392	lea eax, [eax+ebx+2] ;all requested memory
393	end if	393	end if
394	cmp eax, [pg_data.pages_free]	394	cmp eax, [pg_data.pages_free]
395	ja .fail	395	ja .fail
396		396
397	call alloc_page	397	call alloc_page
398	test eax, eax	398	test eax, eax
399	jz .fail	399	jz .fail
400	mov [dir_addr], eax	400	mov [dir_addr], eax
401	stdcall map_page,[tmp_task_pdir],eax,dword PG_SW	401	stdcall map_page,[tmp_task_pdir],eax,dword PG_SW
402		402
403	mov edi, [tmp_task_pdir]	403	mov edi, [tmp_task_pdir]
404	mov ecx, (OS_BASE shr 20)/4	404	mov ecx, (OS_BASE shr 20)/4
405	xor eax, eax	405	xor eax, eax
406	cld	406	cld
407	rep stosd	407	rep stosd
408		408
409	mov ecx, (OS_BASE shr 20)/4	409	mov ecx, (OS_BASE shr 20)/4
410	mov esi, sys_pgdir+(OS_BASE shr 20)	410	mov esi, sys_pgdir+(OS_BASE shr 20)
411	rep movsd	411	rep movsd
412		412
413	mov eax, [dir_addr]	413	mov eax, [dir_addr]
414	or eax, PG_SW	414	or eax, PG_SW
415	mov [edi-4096+(page_tabs shr 20)], eax	415	mov [edi-4096+(page_tabs shr 20)], eax
416		416
417	and eax, -4096	417	and eax, -4096
418	call set_cr3	418	call set_cr3
419		419
420	mov edx, [app_tabs]	420	mov edx, [app_tabs]
421	mov edi, new_app_base	421	mov edi, new_app_base
422	@@:	422	@@:
423	call alloc_page	423	call alloc_page
424	test eax, eax	424	test eax, eax
425	jz .fail	425	jz .fail
426		426
427	stdcall map_page_table, edi, eax	427	stdcall map_page_table, edi, eax
428	add edi, 0x00400000	428	add edi, 0x00400000
429	dec edx	429	dec edx
430	jnz @B	430	jnz @B
431		431
432	mov edi, new_app_base	432	mov edi, new_app_base
433	shr edi, 10	433	shr edi, 10
434	add edi, page_tabs	434	add edi, page_tabs
435		435
436	mov ecx, [app_tabs]	436	mov ecx, [app_tabs]
437	shl ecx, 10	437	shl ecx, 10
438	xor eax, eax	438	xor eax, eax
439	rep stosd	439	rep stosd
440		440
441	mov ecx, [img_pages]	441	mov ecx, [img_pages]
442	mov ebx, PG_UW	442	mov ebx, PG_UW
443	mov edx, new_app_base	443	mov edx, new_app_base
444	mov esi, [img_base]	444	mov esi, [img_base]
445	mov edi, new_app_base	445	mov edi, new_app_base
446	shr esi, 10	446	shr esi, 10
447	shr edi, 10	447	shr edi, 10
448	add esi, page_tabs	448	add esi, page_tabs
449	add edi, page_tabs	449	add edi, page_tabs
450	.remap:	450	.remap:
451	lodsd	451	lodsd
452	or eax, ebx ; force user level r/w access	452	or eax, ebx ; force user level r/w access
453	stosd	453	stosd
454	add edx, 0x1000	454	add edx, 0x1000
455	dec [app_pages]	455	dec [app_pages]
456	dec ecx	456	dec ecx
457	jnz .remap	457	jnz .remap
458		458
459	mov ecx, [app_pages]	459	mov ecx, [app_pages]
460	test ecx, ecx	460	test ecx, ecx
461	jz .done	461	jz .done
462		462
463	if GREEDY_KERNEL	463	if GREEDY_KERNEL
464	mov eax, 0x02	464	mov eax, 0x02
465	rep stosd	465	rep stosd
466	else	466	else
467		467
468	.alloc:	468	.alloc:
469	call alloc_page	469	call alloc_page
470	test eax, eax	470	test eax, eax
471	jz .fail	471	jz .fail
472		472
473	stdcall map_page,edx,eax,dword PG_UW	473	stdcall map_page,edx,eax,dword PG_UW
474	add edx, 0x1000	474	add edx, 0x1000
475	dec [app_pages]	475	dec [app_pages]
476	jnz .alloc	476	jnz .alloc
477	end if	477	end if
478		478
479	.done:	479	.done:
480	stdcall map_page,[tmp_task_pdir],dword 0,dword PG_UNMAP	480	stdcall map_page,[tmp_task_pdir],dword 0,dword PG_UNMAP
481		481
482	dec [pg_data.pg_mutex]	482	dec [pg_data.pg_mutex]
483	mov eax, [dir_addr]	483	mov eax, [dir_addr]
484	ret	484	ret
485	.fail:	485	.fail:
486	dec [pg_data.pg_mutex]	486	dec [pg_data.pg_mutex]
487	cmp [dir_addr], 0	487	cmp [dir_addr], 0
488	je @f	488	je @f
489	stdcall destroy_app_space, [dir_addr], 0	489	stdcall destroy_app_space, [dir_addr], 0
490	@@:	490	@@:
491	xor eax, eax	491	xor eax, eax
492	ret	492	ret
493	endp	493	endp
494		494
495	align 4	495	align 4
496	set_cr3:	496	set_cr3:
497		497
498	mov ebx, [current_slot]	498	mov ebx, [current_slot]
499	mov [ebx+APPDATA.dir_table], eax	499	mov [ebx+APPDATA.dir_table], eax
500	mov cr3, eax	500	mov cr3, eax

Subversion Repositories Kolibri OS

(root)/kernel/branches/net/core/taskman.inc – Rev 1369 → 1376