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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 2010 $
 
 
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
fs_execute_from_sysdir_param:
    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
 
 
align 4
 
get_stack_base:
       mov eax,[current_slot]
       mov eax,[eax+APPDATA.pl0_stack]
       ret
 
 
include "debug.inc"
>

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

Subversion Repositories Kolibri OS

(root)/kernel/branches/Kolibri-acpi/core/taskman.inc – Rev 1635 → 2010