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


GREEDY_KERNEL  equ 0; 1
 
 
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
}
 
align 4
proc test_app_header stdcall, header:dword
           virtual at ebx
             APP_HEADER_00 APP_HEADER_00
           end virtual
 
           mov ebx, [header]
           cmp [ebx+6], word '00'
           jne  .check_01_header
 
           mov  eax,[APP_HEADER_00.start]
           mov  [app_start],eax
           mov  eax,[APP_HEADER_00.i_end]
           mov  [app_i_end],eax
           mov  eax,[APP_HEADER_00.mem_size]
           mov  [app_mem],eax
           shr  eax,1
           sub  eax,0x10
           mov  [app_esp],eax
           mov  eax,[APP_HEADER_00.i_param]
           mov  [app_i_param],eax
           mov  [app_i_icon],dword 0
 
           mov  eax,1
           ret
 
 .check_01_header:
           virtual at ebx
             APP_HEADER_01 APP_HEADER_01
           end virtual
 
           cmp  [ebx+6],word '01'
           jne  .no_01_header
 
           mov  eax,[APP_HEADER_01.start]
           mov  [app_start],eax
           mov  eax,[APP_HEADER_01.i_end]
           mov  [app_i_end],eax
           mov  eax,[APP_HEADER_01.mem_size]
           mov  [app_mem],eax
           mov  eax,[APP_HEADER_01.stack_top]
           mov  [app_esp],eax
           mov  eax,[APP_HEADER_01.i_param]
           mov  [app_i_param],eax
           mov  eax,[APP_HEADER_01.i_icon]
           mov  [app_i_icon],eax
 
           mov  eax,1
           ret
 
.no_01_header:
 
           xor eax, eax
           ret
endp
 
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)
        ;   mov [new_process_place], eax
           ret
 
.failed:
           xor    eax,eax
           ret
endp
 
align 4
proc create_app_space stdcall, app_size:dword,img_size:dword
           locals
             app_pages   dd ?
             img_pages   dd ?
             dir_addr    dd ?
             master_addr dd ?
             app_tabs    dd ?
           endl
 
           stdcall wait_mutex, pg_data.pg_mutex
 
           xor eax, eax
           mov [dir_addr], eax
           mov [master_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 esi, sys_pgdir
           mov edi, [tmp_task_pdir]
           mov ecx, 384
           cld
           rep movsd
 
           mov ecx, 384
           xor eax, eax
           cld
           rep stosd
 
           mov ecx, 256
           mov esi, sys_pgdir+0xc00
           rep movsd
 
           call alloc_page
           test eax, eax
           jz .fail
           mov [master_addr], eax
           stdcall map_page,[tmp_task_ptab],eax,dword PG_SW
 
           mov ecx, 384
           mov edi, [tmp_task_ptab]
           mov esi, master_tab
           cld
           rep movsd
 
           mov ecx, 384
           xor eax, eax
           rep stosd
 
           mov ecx, 256
           mov esi, master_tab+0xc00
           rep movsd
 
           mov eax, [master_addr]
           or eax, PG_SW
           mov ebx, [tmp_task_pdir]
           mov [ebx+0x600], eax
           mov ecx, [tmp_task_ptab]
           mov [ecx+0x600],eax
 
           mov eax, [dir_addr]
           call set_cr3
 
           mov edx, [app_tabs]
           mov edi, new_app_base
@@:
           call alloc_page
           test eax, eax
           jz .fail
 
           stdcall map_page_table,[tmp_task_pdir], edi, eax
           add edi, 0x00400000
           dec edx
           jnz @B
 
           mov edi, new_app_base
           shr edi, 10
           add edi, pages_tab
           mov ecx, [app_tabs]
           shl ecx, 10
           xor eax, eax
           rep stosd
 
           mov edx, new_app_base
 
.alloc:
           call alloc_page
           test eax, eax
           jz .fail
 
           stdcall map_page,edx,eax,dword PG_UW
           add edx, 0x1000
           sub [app_pages], 1
           sub [img_pages], 1
           jnz .alloc
 
           mov ecx, [app_pages]
           and ecx, ecx
           jz .next
 
           mov ebx, edx
           shr edx, 12
.reserve:
           mov dword [pages_tab+edx*4], 0x02
           invlpg [ebx]
           inc edx
           dec ecx
           jnz .reserve
.next:
           mov edi, new_app_base
           mov ecx, [img_size]
           shr ecx, 2
           xor eax, eax
           cld
           rep stosd
 
           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]
           mov eax, [dir_addr]
           ret
.fail:
           dec [pg_data.pg_mutex]
           cmp [dir_addr], 0
           jz @f
           stdcall destroy_app_space, [dir_addr]
@@:
           xor eax, eax
           ret
endp
 
align 4
set_cr3:
           mov esi, [CURRENT_TASK]
           mov ebx, esi
           shl esi,8
           mov [PROC_BASE+esi+0xB8],eax
           imul   ebx,tss_step
           add    ebx,tss_data
           mov [ebx+28], eax
           mov cr3, eax
           ret
 
align 4
proc destroy_page_table stdcall, pg_tab:dword
 
           push esi
 
           mov esi, [pg_tab]
           mov ecx, 1024
.free:
           mov eax, [esi]
           test eax, 1
           jz .next
           call free_page
.next:
           add esi, 4
           dec ecx
           jnz .free
           pop esi
           ret
endp
 
align 4
proc destroy_app_space stdcall, pg_dir:dword
 
           stdcall wait_mutex, pg_data.pg_mutex
 
           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   [PROC_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]
           add esi, 0x600
           mov eax, [esi]
           call free_page   ;destroy master table
           add esi, 4
           mov edi, 383
.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
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    dd ?
             flags      dd ?
             filename   dd ?
             retval     dd ?
           endl
 
           pushad
 
           mov [cmdline], ebx
           mov [flags], edx
           mov eax, [ebp]
           mov [filename], eax
 
           stdcall wait_mutex, pg_data.tmp_task_mutex
 
           mov edi, [tmp_task_data]
           mov ecx, (2048+256)/4
           xor eax, eax
           rep stosd
 
           mov esi, [filename]
           mov edi, [tmp_task_data]
           add edi, TMP_FILE_NAME
           mov ecx, 1024
           rep movsb
 
           mov esi, [filename]
           mov edi, [tmp_task_data]
           add edi, TMP_ICON_OFFS
           mov ecx, 1024
           rep movsb
 
           mov esi, [cmdline]
           test esi, esi
           jz @f
           mov edi, [tmp_task_data]
           add edi, TMP_CMD_LINE
           mov ecx, 256
           rep movsb
@@:
           mov eax, TMP_FILE_NAME
           add eax, [tmp_task_data]
           mov ebx, [tmp_task_data]    ;cmd line
           add ebx, TMP_CMD_LINE
 
           stdcall fs_exec, eax, ebx, [flags], [ebp+8],\
                            [ebp+12], [ebp+16],[ebp+20]
           mov [retval], eax
           popad
           mov [pg_data.tmp_task_mutex], 0
           mov eax, [retval]
           ret
 
endp
 
align 4
proc fs_exec stdcall file_name:dword, cmd_line:dword, flags:dword,\
                       fn_read:dword, file_size:dword,\
                       cluster:dword, some_data:dword
 
           locals
             slot          dd ?
             app_path_size dd ?
             save_cr3      dd ?
             img_size      dd ?
           endl
 
; check filename length - with terminating NULL must be no more than 1024 symbols
 
           mov edi, [file_name]
           mov ecx, 1024
           xor eax, eax
           repnz scasb
           jz @f
           mov     eax, -ERROR_FILE_NOT_FOUND
           ret
@@:
           sub edi, [file_name]
           mov [app_path_size], edi
 
           mov esi, new_process_loading
           call sys_msg_board_str       ; write message to message board
 
           pushfd
           cli
 
.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
 
           mov    edi,eax
           shl    edi,8
           add    edi,PROC_BASE
           mov    ecx,256/4
           xor    eax,eax
           cld
           rep    stosd              ;clean extended information about process
 
; write application name
 
           mov edi, [file_name]
           mov ecx, [app_path_size]
           add edi, ecx
           dec edi
           std
           mov al, '/'
           repnz scasb
           cld
           jnz @f
           inc edi
@@:
           inc edi
; now edi points to name without path
 
           mov esi, edi
           mov ecx, 8  ; 8 chars for name
           mov edi, [slot]
           shl edi, cl
           add edi, PROC_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 al, ' '
           rep stosb
           pop eax
           mov cl, 3   ; 3 chars for extension
           dec esi
@@:
           dec eax
           cmp eax, esi
           jbe .copy_process_ext_done
           cmp byte [eax], '.'
           jnz @b
           lea esi, [eax+1]
.copy_process_ext_loop:
           lodsb
           test al, al
           jz  .copy_process_ext_done
           stosb
           loop .copy_process_ext_loop
.copy_process_ext_done:
           mov al, ' '
           rep stosb
 
; read header
           lea  eax, [file_size]
           mov ebx, [eax]
           mov [img_size], ebx
           mov  edi, TMP_BUFF
           call [fn_read]
 
           test eax, eax
           jnz .err
 
; check menuet signature
 
           mov ecx, -0x1F
;check MENUET signature
           cmp    [TMP_BUFF],dword 'MENU'
           jnz    .err
           cmp    [TMP_BUFF+4],word 'ET'
           jnz    .err
 
           stdcall test_app_header, TMP_BUFF
           test eax, eax
           jz .err
 
           mov eax, cr3
           mov [save_cr3], eax
     if GREEDY_KERNEL
           stdcall create_app_space,[app_mem],[img_size]
     else
           stdcall create_app_space,[app_mem],[app_mem]
     end if
           test eax, eax
           jz .failed
 
           mov    ebx,[slot]
           shl   ebx,8
           mov   [PROC_BASE+ebx+0xB8],eax
 
           mov esi, TMP_BUFF
           mov edi, new_app_base
           mov ecx, 512/4
           cld
           rep movsd
 
;read file
@@:
           lea  eax, [file_size]
           cmp dword [eax], 0
           jz .done
           push edi
           call [fn_read]
           pop edi
           add edi, 512
           test eax, eax
           jz  @b
           cmp ebx, 6
           jne .failed
.done:
           stdcall add_app_parameters, [slot], new_app_base,\
                                       [cmd_line],[file_name],[flags]
 
           mov eax, [save_cr3]
           call set_cr3
 
           xor eax, eax
           mov    [application_table_status],eax ;unlock application_table_status mutex
           popfd
           mov    eax,[process_number]  ;set result
           ret
 
.failed:
           mov eax, [save_cr3]
           call set_cr3
.err:
 
           popfd
           xor eax, eax
           mov [application_table_status],eax
           ret
endp
 
align 4
proc add_app_parameters stdcall,slot:dword,img_base:dword,\
                        cmd_line:dword, app_path:dword, flags:dword
 
           mov eax,[slot]
           bt [cpu_caps], CAPS_SSE
           jnc .no_SSE
           shl eax, 8
           mov ebx, eax
           add eax, eax
           add eax, [fpu_data]
           mov [ebx+PROC_BASE+APPDATA.fpu_state], eax
           mov [ebx+PROC_BASE+APPDATA.fpu_handler], 0
           mov [ebx+PROC_BASE+APPDATA.sse_handler], 0
           jmp .m1
.no_SSE:
           mov ecx, eax
           mov ebx, eax
           shl eax, 7
           shl ebx, 4
           sub eax, ebx       ;eax*=112
           add eax, [fpu_data]
           shl ecx, 8
           mov [ecx+PROC_BASE+APPDATA.fpu_state], eax
           mov [ecx+PROC_BASE+APPDATA.fpu_handler], 0
           mov [ecx+PROC_BASE+APPDATA.sse_handler], 0
.m1:
           mov    ebx,[slot]
           cmp    ebx,[TASK_COUNT]
           jle    .noinc
           inc    dword [TASK_COUNT]       ;update number of processes
.noinc:
           shl    ebx,8
           mov    eax,[app_mem]
           mov    [PROC_BASE+0x8c+ebx],eax
 
           shr    ebx,3
           mov eax, new_app_base
           mov    dword [CURRENT_TASK+ebx+0x10],eax
 
.add_command_line:
           mov    edx,[app_i_param]
           test   edx,edx
           jz     .no_command_line      ;application don't need parameters
           mov    eax,[cmd_line]
           test   eax,eax
           jz     .no_command_line      ;no parameters specified
;calculate parameter length
           xor    ecx,ecx
.command_line_len:
           cmp    byte [eax],0
           jz     .command_line_len_end
           inc    eax
           inc    ecx
           cmp    ecx,255
           jl     .command_line_len
 
.command_line_len_end:
;ecx - parameter length
;edx - address of parameters in new process address space
           inc ecx
           mov edi, [img_base]
           add edi, edx
           mov esi, [cmd_line]
           rep movsb
 
.no_command_line:
 
            mov    edx,[app_i_icon]
            test   edx,edx
            jz     .no_command_line_1      ;application don't need path of file
            mov    esi,[app_path]
            test esi, esi
            jz     .no_command_line_1      ;application don't need path of file
            mov    ecx, 64
            mov    edi, [img_base]
            add edi, edx
            rep movsb
 
.no_command_line_1:
           mov    ebx,[slot]
           mov    eax,ebx
           shl    ebx,5
           add    ebx,CURRENT_TASK            ;ebx - pointer to information about process
           mov    [ebx+0xe],al          ;set window number on screen = process slot
 
           mov    [ebx],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
 
           mov    ecx,ebx
           add    ecx,(draw_data-CURRENT_TASK)  ;ecx - pointer to draw data
;set draw data to full screen
 
           mov    [ecx+0],dword 0
           mov    [ecx+4],dword 0
           mov    eax,[SCR_X_SIZE]
           mov    [ecx+8],eax
           mov    eax,[SCR_Y_SIZE]
           mov    [ecx+12],eax
;set window state to 'normal' (non-minimized/maximized/rolled-up) state
           mov    [ecx+WDATA.fl_wstate],WSTATE_NORMAL
;set cr3 register in TSS of application
 
           mov    ecx,[slot]
           shl    ecx,8
           mov    eax,[PROC_BASE+0xB8+ecx]
           ;or     eax,  PG_NOCACHE
           mov    [l.cr3],eax
 
           mov    eax,[app_start]
           mov    [l.eip],eax           ;set eip in TSS
           mov    eax,[app_esp]
           mov    [l.esp],eax           ;set stack in TSS
 
;gdt
           mov    ax,app_code           ;ax - selector of code segment
           mov    [l.cs],ax
           mov    ax,app_data
           mov    [l.ss],ax
           mov    [l.ds],ax
           mov    [l.es],ax
           mov    [l.fs],ax
           mov    ax,graph_data         ;ax - selector of graphic segment
           mov    [l.gs],ax
           mov    [l.io],word 128
           mov    [l.eflags],dword 0x1202
 
           mov    [l.ss0],os_data
           mov    ebx,[slot]
           shl    ebx,12
           add    ebx,sysint_stack_data+4096
           mov    [l.esp0],ebx
 
;copy tss to it place
           mov    eax,tss_sceleton
           mov    ebx,[slot]
           imul   ebx,tss_step
           add    ebx,tss_data          ;ebx - address of application TSS
           mov    ecx,120
           call   memmove
 
;Add IO access table - bit array of permitted ports
           or     eax,-1
           mov    edi,[slot]
           imul   edi,tss_step
           add    edi,tss_data+128
           mov    ecx,2048
           cld
           rep    stosd                 ;full access to 2048*8=16384 ports
 
           mov    ecx,ebx               ;ecx - address of application TSS
           mov    edi,[slot]
           shl    edi,3
;set TSS descriptor
           mov    [edi+gdts+tss0+0],word tss_step ;limit (size)
           mov    [edi+gdts+tss0+2],cx  ;part of offset
           mov    eax,ecx
           shr    eax,16
           mov    [edi+gdts+tss0+4],al  ;part of offset
           mov    [edi+gdts+tss0+7],ah  ;part of offset
           mov    [edi+gdts+tss0+5],word 01010000b*256+11101001b ;system flags
 
;flush keyboard and buttons queue
           mov    [KEY_COUNT],byte 0
           mov    [BTN_COUNT],byte 0
 
           mov    edi,[slot]
           shl    edi,5
           add    edi,window_data
           mov    ebx,[slot]
           movzx  esi,word [WIN_STACK+ebx*2]
           lea    esi,[WIN_POS+esi*2]
           call   windowactivate        ;gui initialization
 
           mov    ebx,[slot]
           shl    ebx,5
           mov    [CURRENT_TASK+ebx+0xa],byte 0 ;set process state - running
; set if debuggee
           mov eax, [flags]
           test   byte [flags], 1
           jz     .no_debug
           mov    [CURRENT_TASK+ebx+0xa],byte 1 ;set process state - suspended
           mov    eax,[CURRENT_TASK]
           mov    [PROC_BASE+ebx*8+0xac],eax ;set debugger PID - current
.no_debug:
 
           mov    esi,new_process_running
           call   sys_msg_board_str     ;output information about succefull startup
 
           ret
endp
 
pid_to_slot:
;Input:
;  eax - pid of process
;Output:
;  eax - slot of process or 0 if process don't exists
;Search process by PID.
    push   ebx
    push   ecx
    mov    ebx,[TASK_COUNT]
    shl    ebx,5
    mov    ecx,2*32
 
.loop:
;ecx=offset of current process info entry
;ebx=maximum permitted offset
    cmp    byte [CURRENT_TASK+ecx+0xa],9
    jz     .endloop              ;skip empty slots
    cmp    [CURRENT_TASK+ecx+0x4],eax ;check PID
    jz     .pid_found
.endloop:
    add    ecx,32
    cmp    ecx,ebx
    jle    .loop
 
    pop    ecx
    pop    ebx
    xor    eax,eax
    ret
 
.pid_found:
    shr    ecx,5
    mov    eax,ecx               ;convert offset to index of slot
    pop    ecx
    pop    ebx
    ret
 
check_region:
;input:
;  ebx - start of buffer
;  ecx - size of buffer
;result:
;  eax = 1 region lays in app memory
;  eax = 0 region don't lays in app memory
     mov  eax,[CURRENT_TASK]
     jmp  check_process_region
;-----------------------------------------------------------------------------
check_process_region:
;input:
;  eax - slot
;  ebx - start of buffer
;  ecx - size of buffer
;result:
;  eax = 1 region lays in app memory
;  eax = 0 region don't lays in app memory
 
     test ecx,ecx
     jle  .ok
     shl  eax,5
     cmp  word [CURRENT_TASK+eax+0xa],0
     jnz  .failed
     shl  eax,3
     mov  eax,[PROC_BASE+eax+0xb8]
     test eax,eax
     jz   .failed
 
     mov  eax,1
     ret
 
 
;    call MEM_Get_Linear_Address
;    push ebx
;    push ecx
;    push edx
;    mov  edx,ebx
;    and  edx,not (4096-1)
;    sub  ebx,edx
;    add  ecx,ebx
;    mov  ebx,edx
;    add  ecx,(4096-1)
;    and  ecx,not (4096-1)
;.loop:
;;eax - linear address of page directory
;;ebx - current page
;;ecx - current size
;    mov  edx,ebx
;    shr  edx,22
;    mov  edx,[eax+4*edx]
;    and  edx,not (4096-1)
;    test edx,edx
;    jz   .failed1
;    push eax
;    mov  eax,edx
;    call MEM_Get_Linear_Address
;    mov  edx,ebx
;    shr  edx,12
;    and  edx,(1024-1)
;    mov  eax,[eax+4*edx]
;    and  eax,not (4096-1)
;    test eax,eax
;    pop  eax
;    jz   .failed1
;    add  ebx,4096
;    sub  ecx,4096
;    jg   .loop
;    pop  edx
;    pop  ecx
;    pop  ebx
.ok:
    mov  eax,1
    ret
;
;.failed1:
;    pop  edx
;    pop  ecx
;    pop  ebx
.failed:
    xor  eax,eax
    ret
 
align 4
proc read_process_memory
;Input:
;  eax - process slot
;  ebx - buffer address
;  ecx - buffer size
;  edx - start address in other process
;Output:
;  eax - number of bytes read.
           locals
             slot       dd ?
             buff       dd ?
             r_count    dd ?
             offset     dd ?
             tmp_r_cnt  dd ?
           endl
 
           mov [slot], eax
           mov [buff], ebx
           mov [r_count], ecx
           mov [tmp_r_cnt], ecx
           mov [offset], edx
 
           pushad
.read_mem:
           mov edx, [offset]
           mov ebx, [tmp_r_cnt]
 
           mov ecx, 0x400000
           and edx, 0x3FFFFF
           sub ecx, edx
           cmp ecx, ebx
           jbe @f
           mov ecx, ebx
@@:
           cmp ecx, 0x8000
           jna @F
           mov ecx, 0x8000
@@:
           mov eax, [slot]
           shl  eax,8
           mov ebx, [offset]
           add ebx, new_app_base
           push ecx
           stdcall map_memEx, [proc_mem_map],\
                              [PROC_BASE+eax+0xB8],\
                              ebx, ecx
           pop ecx
 
           mov esi, [offset]
           and esi, 0xfff
           add esi, [proc_mem_map]
           mov edi, [buff]
           mov edx, ecx
           rep movsb
 
           add [offset], edx
           sub [tmp_r_cnt], edx
           jnz .read_mem
 
           popad
           mov eax, [r_count]
           ret
 
endp
 
align 4
proc write_process_memory
;Input:
;  eax - process slot
;  ebx - buffer address
;  ecx - buffer size
;  edx - start address in other process
;Output:
;  eax - number of bytes written
 
           locals
             slot       dd ?
             buff       dd ?
             w_count    dd ?
             offset     dd ?
             tmp_w_cnt  dd ?
           endl
 
           mov [slot], eax
           mov [buff], ebx
           mov [w_count], ecx
           mov [tmp_w_cnt], ecx
           mov [offset], edx
 
           pushad
.read_mem:
           mov edx, [offset]
           mov ebx, [tmp_w_cnt]
 
           mov ecx, 0x400000
           and edx, 0x3FFFFF
           sub ecx, edx
           cmp ecx, ebx
           jbe @f
           mov ecx, ebx
@@:
           cmp ecx, 0x8000
           jna @F
           mov ecx, 0x8000
@@:
           mov eax, [slot]
           shl  eax,8
           mov ebx, [offset]
           add ebx, new_app_base
           push ecx
           stdcall map_memEx, [proc_mem_map],\
                              [PROC_BASE+eax+0xB8],\
                              ebx, ecx
           pop ecx
 
           mov edi, [offset]
           and edi, 0xfff
           add edi, [proc_mem_map]
           mov esi, [buff]
           mov edx, ecx
           rep movsb
 
           add [offset], edx
           sub [tmp_w_cnt], edx
           jnz .read_mem
 
           popad
           mov eax, [w_count]
           ret
endp
 
 
align 4
proc new_sys_threads
           locals
             thread_start  dd ?
             thread_stack  dd ?
             params        dd ?
             slot          dd ?
           endl
 
           mov [thread_start], ebx
           mov [thread_stack], ecx
           mov [params], 0
 
           xor    edx,edx      ; flags=0
 
           cmp    eax,1
           jnz    .failed                  ;other subfunctions
           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
 
           xor    eax,eax
           mov    [app_i_param],eax
           mov    [app_i_icon],eax
 
           mov ebx, [thread_start]
           mov ecx, [thread_stack]
 
           mov    [app_start],ebx
           mov    [app_esp],ecx
 
           mov    esi,[CURRENT_TASK]
           shl    esi,8
           add    esi,PROC_BASE
           mov    ebx,esi               ;ebx=esi - pointer to extended information about current thread
 
           mov    edi,[slot]
           shl    edi,8
           add    edi,PROC_BASE
           mov    edx,edi               ;edx=edi - pointer to extended infomation about new thread
           mov    ecx,256/4
           rep    stosd                 ;clean extended information about new thread
           mov    edi,edx
           mov    ecx,11
           rep    movsb                 ;copy process name
           mov    eax,[ebx+0x8c]
           mov    [app_mem],eax         ;set memory size
           mov    eax,[ebx+0xb8]
           mov    [edx+0xb8],eax        ;copy page directory
 
           stdcall add_app_parameters, [slot], new_app_base,\
                                        [params], 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
 
align 4
proc wait_mutex stdcall, mutex:dword
           mov ebx, [mutex]
.wait_lock:
           cmp dword [ebx],0
           je .get_lock
           push ebx
           call change_task
           pop ebx
           jmp .wait_lock
 
.get_lock:
           mov eax, 1
           xchg eax, [ebx]
           test eax, eax
           jnz .wait_lock
           ret
endp
 
 
include "debug.inc"
 
iglobal
    new_process_loading db 'K : New Process - loading',13,10,0
    new_process_running db 'K : New Process - done',13,10,0
    start_not_enough_memory db 'K : New Process - not enough memory',13,10,0
endg
>

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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/taskman.inc – Rev 170 → 172