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: 1206 $
 
 
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]
       cmp eax, 0
       jne .wait_lock
 
       call set_application_table_status
 
       call get_new_process_place
       test eax, eax
       mov ecx, -0x20      ; too many processes
       jz .err
 
       mov [slot], eax
       shl eax, 8
       add eax, SLOT_BASE
       mov [slot_base], eax
       mov edi, eax
       _clear_ 256     ;clean extended information about process
 
; write application name
       lea eax, [filename]
       stdcall strrchr,  eax, '/'  ; now eax points to name without path
 
       lea esi, [eax+1]
       test eax, eax
       jnz @F
       lea esi, [filename]
@@:
       mov ecx, 8  ; 8 chars for name
       mov edi, [slot_base]
.copy_process_name_loop:
       lodsb
       cmp al, '.'
       jz .copy_process_name_done
       test al, al
       jz .copy_process_name_done
       stosb
       loop .copy_process_name_loop
.copy_process_name_done:
 
       mov ebx, cr3
       mov [save_cr3], ebx
 
       stdcall create_app_space,[hdr_mem],[file_base],[file_size]
       mov ecx, -30  ; no memory
       test eax, eax
       jz .failed
 
       mov   ebx,[slot_base]
       mov   [ebx+APPDATA.dir_table],eax
       mov   eax,[hdr_mem]
       mov   [ebx+APPDATA.mem_size],eax
 
if GREEDY_KERNEL
else
       mov ecx, [hdr_mem]
       mov edi, [file_size]
       add edi, 4095
       and edi, not 4095
       sub ecx, edi
       jna @F
 
       xor eax, eax
           cld
       rep stosb
@@:
end if
 
; release only virtual space, not phisical memory
 
       stdcall free_kernel_space, [file_base]
       lea eax, [hdr_cmdline]
       lea ebx, [cmdline]
       lea ecx, [filename]
       stdcall set_app_params ,[slot],eax,ebx,ecx,[flags]
 
       mov eax, [save_cr3]
       call set_cr3
 
       xor ebx, ebx
       mov [application_table_status],ebx ;unlock application_table_status mutex
       mov eax,[process_number]  ;set result
       ret
.failed:
       mov eax, [save_cr3]
       call set_cr3
.err:
.err_hdr:
       stdcall kernel_free,[file_base]
.err_file:
       xor eax, eax
       mov [application_table_status],eax
       mov eax, ecx
       ret
endp
 
align 4
test_app_header:
       virtual at eax
         APP_HEADER_00 APP_HEADER_00
       end virtual
       virtual at eax
         APP_HEADER_01 APP_HEADER_01
       end virtual
 
       cmp dword [eax], 'MENU'
       jne .fail
       cmp word [eax+4],'ET'
       jne .fail
 
       cmp [eax+6], word '00'
       jne  .check_01_header
 
       mov  ecx,[APP_HEADER_00.start]
       mov  [ebx+0x08], ecx            ;app_eip
       mov  edx,[APP_HEADER_00.mem_size]
       mov  [ebx+0x10], edx            ;app_mem
       shr  edx,1
       sub  edx,0x10
       mov  [ebx+0x0C], edx            ;app_esp
       mov  ecx,[APP_HEADER_00.i_param]
       mov  [ebx], ecx             ;app_cmdline
       mov  [ebx+4], dword 0           ;app_path
       mov  edx, [APP_HEADER_00.i_end]
       mov  [ebx+0x14], edx
       ret
 
 .check_01_header:
 
       cmp  [eax+6],word '01'
       jne  .fail
 
       mov  ecx,[APP_HEADER_01.start]
       mov  [ebx+0x08], ecx            ;app_eip
       mov  edx,[APP_HEADER_01.mem_size]
 
; \begin{diamond}[20.08.2006]
; sanity check (functions 19,58 load app_i_end bytes and that must
; fit in allocated memory to prevent kernel faults)
       cmp  edx,[APP_HEADER_01.i_end]
       jb   .fail
; \end{diamond}[20.08.2006]
 
       mov  [ebx+0x10], edx            ;app_mem
       mov  ecx,[APP_HEADER_01.stack_top]
       mov  [ebx+0x0C], ecx            ;app_esp
       mov  edx,[APP_HEADER_01.i_param]
       mov  [ebx], edx             ;app_cmdline
       mov  ecx,[APP_HEADER_01.i_icon]
       mov  [ebx+4], ecx               ;app_path
       mov  edx, [APP_HEADER_01.i_end]
       mov  [ebx+0x14], edx
       ret
.fail:
       xor eax, eax
       ret
 
align 4
proc get_new_process_place
;input:
;  none
;result:
;  eax=[new_process_place]<>0 - ok
;      0 - failed.
;This function find least empty slot.
;It doesn't increase [TASK_COUNT]!
       mov    eax,CURRENT_TASK
       mov    ebx,[TASK_COUNT]
       inc    ebx
       shl    ebx,5
       add    ebx,eax       ;ebx - address of process information for (last+1) slot
.newprocessplace:
;eax = address of process information for current slot
       cmp    eax,ebx
       jz     .endnewprocessplace   ;empty slot after high boundary
       add    eax,0x20
       cmp    word [eax+0xa],9  ;check process state, 9 means that process slot is empty
       jnz    .newprocessplace
.endnewprocessplace:
       mov    ebx,eax
       sub    eax,CURRENT_TASK
       shr    eax,5         ;calculate slot index
       cmp    eax,256
       jge    .failed       ;it should be <256
       mov    word [ebx+0xa],9  ;set process state to 9 (for slot after hight boundary)
       ret
.failed:
       xor    eax,eax
       ret
endp
 
align 4
proc create_app_space stdcall, app_size:dword,img_base:dword,img_size:dword
       locals
         app_pages   dd ?
         img_pages   dd ?
         dir_addr    dd ?
         app_tabs    dd ?
       endl
 
       mov ebx, pg_data.pg_mutex
       call wait_mutex   ;ebx
 
       xor eax, eax
       mov [dir_addr], eax
 
       mov eax, [app_size]
       add eax, 4095
       and eax, NOT(4095)
       mov [app_size], eax
       mov ebx, eax
       shr eax, 12
       mov [app_pages], eax
 
       add ebx, 0x3FFFFF
       and ebx, NOT(0x3FFFFF)
       shr ebx, 22
       mov [app_tabs], ebx
 
       mov ecx, [img_size]
       add ecx, 4095
       and ecx, NOT(4095)
 
       mov [img_size], ecx
       shr ecx, 12
       mov [img_pages], ecx
 
     if GREEDY_KERNEL
       lea eax, [ecx+ebx+2]    ;only image size
     else
       lea eax, [eax+ebx+2]    ;all requested memory
     end if
       cmp eax, [pg_data.pages_free]
       ja .fail
 
       call alloc_page
       test eax, eax
       jz .fail
       mov [dir_addr], eax
       stdcall map_page,[tmp_task_pdir],eax,dword PG_SW
 
       mov edi, [tmp_task_pdir]
       mov ecx, (OS_BASE shr 20)/4
       xor eax, eax
       cld
       rep stosd
 
       mov ecx, (OS_BASE shr 20)/4
       mov esi, sys_pgdir+(OS_BASE shr 20)
       rep movsd
 
       mov eax, [dir_addr]
       or eax, PG_SW
       mov [edi-4096+(page_tabs shr 20)], eax
 
       and eax, -4096
       call set_cr3
 
       mov edx, [app_tabs]
       mov edi, new_app_base
@@:
       call alloc_page
       test eax, eax
       jz .fail
 
       stdcall map_page_table, edi, eax
       add edi, 0x00400000
       dec edx
       jnz @B
 
       mov edi, new_app_base
       shr edi, 10
       add edi, page_tabs
 
       mov ecx, [app_tabs]
       shl ecx, 10
       xor eax, eax
       rep stosd
 
       mov ecx, [img_pages]
       mov ebx, PG_UW
       mov edx, new_app_base
       mov esi, [img_base]
       mov edi, new_app_base
       shr esi, 10
       shr edi, 10
       add esi, page_tabs
       add edi, page_tabs
.remap:
       lodsd
       or eax, ebx      ; force user level r/w access
       stosd
       add edx, 0x1000
       dec [app_pages]
       dec ecx
       jnz .remap
 
       mov ecx, [app_pages]
       test ecx, ecx
       jz .done
 
if GREEDY_KERNEL
       mov eax, 0x02
           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]
@@:
       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
 
       mov ebx, pg_data.pg_mutex
       call wait_mutex   ;ebx
 
       xor   edx,edx
       mov   eax,0x2
       mov ebx, [pg_dir]
.loop:
;eax = current slot of process
       mov   ecx,eax
       shl   ecx,5
       cmp   byte [CURRENT_TASK+ecx+0xa],9  ;if process running?
       jz    @f              ;skip empty slots
       shl   ecx,3
       cmp   [SLOT_BASE+ecx+0xB8],ebx   ;compare page directory addresses
       jnz   @f
       inc   edx                ;thread found
@@:
       inc   eax
       cmp   eax,[TASK_COUNT]       ;exit loop if we look through all processes
       jle   .loop
 
;edx = number of threads
;our process is zombi so it isn't counted
       cmp   edx,1
       jg    .exit
;if there isn't threads then clear memory.
 
       mov eax, [pg_dir]
       and eax, not 0xFFF
       stdcall map_page,[tmp_task_pdir],eax,dword PG_SW
       mov esi, [tmp_task_pdir]
       mov edi, (OS_BASE shr 20)/4
.destroy:
       mov eax, [esi]
       test eax, 1
       jz .next
       and eax, not 0xFFF
       stdcall map_page,[tmp_task_ptab],eax,dword PG_SW
       stdcall destroy_page_table, [tmp_task_ptab]
       mov eax, [esi]
       call free_page
.next:
       add esi, 4
       dec edi
       jnz .destroy
 
       mov eax, [pg_dir]
       call free_page
.exit:
       stdcall map_page,[tmp_task_ptab],dword 0,dword PG_UNMAP
       stdcall map_page,[tmp_task_pdir],dword 0,dword PG_UNMAP
       dec [pg_data.pg_mutex]
       ret
endp
 
align 4
get_pid:
       mov eax, [TASK_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:
;  ebx - start of buffer
;  ecx - size of buffer
;result:
;  eax = 1 region lays in app memory
;  eax = 0 region don't lays in app memory
     mov  eax,[CURRENT_TASK]
     jmp  check_process_region
;-----------------------------------------------------------------------------
check_process_region:
;input:
;  eax - slot
;  ebx - start of buffer
;  ecx - size of buffer
;result:
;  eax = 1 region lays in app memory
;  eax = 0 region don't lays in app memory
 
     test ecx,ecx
     jle  .ok
     shl  eax,5
     cmp  word [CURRENT_TASK+eax+0xa],0
     jnz  .failed
     shl  eax,3
     mov  eax,[SLOT_BASE+eax+0xb8]
     test eax,eax
     jz   .failed
 
     mov  eax,1
     ret
 
 
;    call MEM_Get_Linear_Address
;    push ebx
;    push ecx
;    push edx
;    mov  edx,ebx
;    and  edx,not (4096-1)
;    sub  ebx,edx
;    add  ecx,ebx
;    mov  ebx,edx
;    add  ecx,(4096-1)
;    and  ecx,not (4096-1)
;.loop:
;;eax - linear address of page directory
;;ebx - current page
;;ecx - current size
;    mov  edx,ebx
;    shr  edx,22
;    mov  edx,[eax+4*edx]
;    and  edx,not (4096-1)
;    test edx,edx
;    jz   .failed1
;    push eax
;    mov  eax,edx
;    call MEM_Get_Linear_Address
;    mov  edx,ebx
;    shr  edx,12
;    and  edx,(1024-1)
;    mov  eax,[eax+4*edx]
;    and  eax,not (4096-1)
;    test eax,eax
;    pop  eax
;    jz   .failed1
;    add  ebx,4096
;    sub  ecx,4096
;    jg   .loop
;    pop  edx
;    pop  ecx
;    pop  ebx
.ok:
    mov  eax,1
    ret
;
;.failed1:
;    pop  edx
;    pop  ecx
;    pop  ebx
.failed:
    xor  eax,eax
    ret
 
align 4
proc read_process_memory
;Input:
;  eax - process slot
;  ebx - buffer address
;  ecx - buffer size
;  edx - start address in other process
;Output:
;  eax - number of bytes read.
       locals
         slot   dd ?
         buff   dd ?
         r_count    dd ?
         offset dd ?
         tmp_r_cnt  dd ?
       endl
 
       mov [slot], eax
       mov [buff], ebx
       and [r_count], 0
       mov [tmp_r_cnt], ecx
       mov [offset], edx
 
       pushad
.read_mem:
       mov edx, [offset]
       mov ebx, [tmp_r_cnt]
 
       mov ecx, 0x400000
       and edx, 0x3FFFFF
       sub ecx, edx
       cmp ecx, ebx
       jbe @f
       mov ecx, ebx
@@:
       cmp ecx, 0x8000
       jna @F
       mov ecx, 0x8000
@@:
       mov eax, [slot]
       shl  eax,8
       mov ebx, [offset]
     ;      add ebx, new_app_base
       push ecx
       stdcall map_memEx, [proc_mem_map],\
                  [SLOT_BASE+eax+0xB8],\
                  ebx, ecx
       pop ecx
 
       mov esi, [offset]
       and esi, 0xfff
       add esi, [proc_mem_map]
       mov edi, [buff]
       mov edx, ecx
       rep movsb
       add [r_count], edx
 
       add [offset], edx
       sub [tmp_r_cnt], edx
       jnz .read_mem
 
       popad
       mov eax, [r_count]
       ret
endp
 
align 4
proc write_process_memory
;Input:
;  eax - process slot
;  ebx - buffer address
;  ecx - buffer size
;  edx - start address in other process
;Output:
;  eax - number of bytes written
 
       locals
         slot   dd ?
         buff   dd ?
         w_count    dd ?
         offset dd ?
         tmp_w_cnt  dd ?
       endl
 
       mov [slot], eax
       mov [buff], ebx
       and [w_count], 0
       mov [tmp_w_cnt], ecx
       mov [offset], edx
 
       pushad
.read_mem:
       mov edx, [offset]
       mov ebx, [tmp_w_cnt]
 
       mov ecx, 0x400000
       and edx, 0x3FFFFF
       sub ecx, edx
       cmp ecx, ebx
       jbe @f
       mov ecx, ebx
@@:
       cmp ecx, 0x8000
       jna @F
       mov ecx, 0x8000
@@:
       mov eax, [slot]
       shl  eax,8
       mov ebx, [offset]
      ;     add ebx, new_app_base
       push ecx
       stdcall map_memEx, [proc_mem_map],\
                  [SLOT_BASE+eax+0xB8],\
                  ebx, ecx
       pop ecx
 
       mov edi, [offset]
       and edi, 0xfff
       add edi, [proc_mem_map]
       mov esi, [buff]
       mov edx, ecx
       rep movsb
 
       add [w_count], edx
       add [offset], edx
       sub [tmp_w_cnt], edx
       jnz .read_mem
 
       popad
       mov eax, [w_count]
       ret
endp
 
align 4
proc new_sys_threads
       locals
         slot      dd ?
         app_cmdline   dd ? ;0x00
         app_path      dd ? ;0x04
         app_eip       dd ? ;0x08
         app_esp       dd ? ;0x0C
         app_mem       dd ? ;0x10
       endl
 
       cmp eax,1
       jne .failed          ;other subfunctions
 
       xor  eax,eax
       mov [app_cmdline], eax
       mov [app_path], eax
       mov [app_eip], ebx
       mov [app_esp], ecx
 
       ;mov    esi,new_process_loading
       ;call   sys_msg_board_str
.wait_lock:
       cmp [application_table_status],0
       je .get_lock
       call   change_task
       jmp .wait_lock
 
.get_lock:
       mov eax, 1
       xchg eax, [application_table_status]
       cmp eax, 0
       jne .wait_lock
 
       call   set_application_table_status
 
       call get_new_process_place
       test eax, eax
       jz .failed
 
       mov [slot], eax
 
       mov    esi,[current_slot]
       mov    ebx,esi         ;ebx=esi - pointer to extended information about current thread
 
       mov    edi, eax
       shl    edi,8
       add    edi,SLOT_BASE
       mov    edx,edi         ;edx=edi - pointer to extended infomation about new thread
       mov    ecx,256/4
       xor eax, eax
       cld
       rep    stosd           ;clean extended information about new thread
       mov    esi,ebx
       mov    edi,edx
       mov    ecx,11
       rep    movsb           ;copy process name
 
       mov eax,[ebx+APPDATA.heap_base]
       mov [edx+APPDATA.heap_base], eax
 
       mov ecx,[ebx+APPDATA.heap_top]
       mov [edx+APPDATA.heap_top], ecx
 
       mov eax,[ebx+APPDATA.mem_size]
       mov [edx+APPDATA.mem_size], eax
 
       mov ecx,[ebx+APPDATA.dir_table]
       mov [edx+APPDATA.dir_table],ecx  ;copy page directory
 
       lea eax, [app_cmdline]
       stdcall set_app_params ,[slot],eax,dword 0,\
                     dword 0,dword 0
 
       ;mov    esi,new_process_running
       ;call   sys_msg_board_str     ;output information about succefull startup
 
       mov    [application_table_status],0 ;unlock application_table_status mutex
       mov    eax,[process_number]  ;set result
       ret
.failed:
       mov    [application_table_status],0
       mov    eax,-1
       ret
endp
 
; param
;  ebx=mutex
 
align 4
wait_mutex:
;;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
 
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 [eax+SLOT_BASE+APPDATA.io_map],\
          (tss._io_map_0-OS_BASE+PG_MAP)
       mov [eax+SLOT_BASE+APPDATA.io_map+4],\
          (tss._io_map_1-OS_BASE+PG_MAP)
 
       mov esi, fpu_data
       mov ecx, 512/4
       rep movsd
 
       cmp    ebx,[TASK_COUNT]
       jle    .noinc
       inc    dword [TASK_COUNT]       ;update number of processes
.noinc:
       shl ebx,8
       lea edx, [ebx+SLOT_BASE+APP_EV_OFFSET]
       mov [SLOT_BASE+APPDATA.fd_ev+ebx],edx
       mov [SLOT_BASE+APPDATA.bk_ev+ebx],edx
 
       add edx, APP_OBJ_OFFSET-APP_EV_OFFSET
       mov [SLOT_BASE+APPDATA.fd_obj+ebx],edx
       mov [SLOT_BASE+APPDATA.bk_obj+ebx],edx
 
       mov ecx, [def_cursor]
       mov [SLOT_BASE+APPDATA.cursor+ebx],ecx
       mov eax, [pl0_stack]
       mov [SLOT_BASE+APPDATA.pl0_stack+ebx],eax
       add eax, RING0_STACK_SIZE
       mov [SLOT_BASE+APPDATA.saved_esp0+ebx], eax
 
       push ebx
       stdcall kernel_alloc, 0x1000
       pop ebx
       mov esi,[current_slot]
       mov esi,[esi+APPDATA.cur_dir]
       mov ecx,0x1000/4
       mov edi,eax
       mov [ebx+SLOT_BASE+APPDATA.cur_dir],eax
       rep movsd
 
       shr ebx,3
       mov eax, new_app_base
       mov dword [CURRENT_TASK+ebx+0x10],eax
 
.add_command_line:
       mov edx,[params]
       mov edx,[edx]       ;app_cmdline
       test edx,edx
       jz @f           ;application doesn't need parameters
 
       mov     eax, edx
       add     eax, 256
       jc      @f
 
       cmp     eax, [SLOT_BASE+APPDATA.mem_size+ebx*8]
       ja      @f
 
       mov     byte [edx], 0   ;force empty string if no cmdline given
       mov     eax, [cmd_line]
       test    eax, eax
       jz      @f
       stdcall strncpy, edx, eax, 256
@@:
       mov edx,[params]
       mov edx, [edx+4]    ;app_path
       test edx,edx
       jz @F           ;application don't need path of file
       mov     eax, edx
       add     eax, 1024
       jc      @f
       cmp     eax, [SLOT_BASE+APPDATA.mem_size+ebx*8]
       ja      @f
       stdcall strncpy, edx, [app_path], 1024
@@:
       mov    ebx,[slot]
       mov    eax,ebx
       shl    ebx,5
       lea    ecx,[draw_data+ebx]  ;ecx - pointer to draw data
 
; set window state to 'normal' (non-minimized/maximized/rolled-up) state
       mov     [ebx+window_data+WDATA.fl_wstate], WSTATE_NORMAL
       mov     [ebx+window_data+WDATA.fl_redraw], 1
       add    ebx,CURRENT_TASK        ;ebx - pointer to information about process
       mov    [ebx+TASKDATA.wnd_number],al;set window number on screen = process slot
 
       mov    [ebx+TASKDATA.event_mask],dword 1+2+4 ;set default event flags (see 40 function)
 
       inc    dword [process_number]
       mov    eax,[process_number]
       mov    [ebx+4],eax       ;set PID
 
;set draw data to full screen
 
       mov    [ecx+0],dword 0
       mov    [ecx+4],dword 0
       mov    eax,[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], dword irq0.return
       mov [ebx+REG_EDI], eax
       mov [ebx+REG_ESI], eax
       mov [ebx+REG_EBP], eax
       mov [ebx+REG_ESP], ecx   ;ebx+REG_EIP
       mov [ebx+REG_EBX], eax
       mov [ebx+REG_EDX], eax
       mov [ebx+REG_ECX], eax
       mov [ebx+REG_EAX], eax
 
       mov eax, [esi+0x08]       ;app_eip
       mov [ebx+REG_EIP],  eax   ;app_entry
       mov [ebx+REG_CS], dword app_code
       mov [ebx+REG_EFLAGS], dword EFL_IOPL1+EFL_IF
 
       mov eax, [esi+0x0C]       ;app_esp
       mov [ebx+REG_APP_ESP], eax    ;app_stack
       mov [ebx+REG_SS], dword app_data
 
       lea ecx, [ebx+REG_RET]
       mov ebx, [slot]
       shl ebx, 5
       mov [ebx*8+SLOT_BASE+APPDATA.saved_esp], ecx
 
       xor  ecx, ecx    ; process state - running
; set if debuggee
       test byte [flags], 1
       jz   .no_debug
       inc  ecx     ; process state - suspended
       mov  eax,[CURRENT_TASK]
       mov  [SLOT_BASE+ebx*8+APPDATA.debugger_slot],eax
.no_debug:
       mov  [CURRENT_TASK+ebx+TASKDATA.state], cl
       ;mov    esi,new_process_running
       ;call   sys_msg_board_str     ;output information about succefull startup
       ret
endp
 
include "debug.inc"
>

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

Subversion Repositories Kolibri OS

(root)/kernel/branches/net/core/taskman.inc – Rev 1198 → 1206