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


if ~defined newprocess_inc
newprocess_inc_fix:
newprocess_inc fix newprocess_inc_fix
include "mem.inc"
include "memmanag.inc"
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;Working with new types of processes.
;;Author: Khalyavin Andrey halyavin@land.ru
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
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
;-----------------------------------------------------------------------------
 
find_new_process_place:
;input:
;  none
;result:
;  eax=[new_process_place]<>0 - ok
;      0 - failed.
;This function find least empty slot.
;It doesn't increase [0x3004]!
    mov    eax,0x3000+second_base_address
    push   ebx
    mov    ebx,[0x3004]
    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+TASKDATA.state],9      ;check process state, 9 means that process slot is empty
    jnz    .newprocessplace
.endnewprocessplace:
    mov    ebx,eax
    sub    eax,0x3000+second_base_address
    shr    eax,5                 ;calculate slot index
    cmp    eax,256
    jge    .failed               ;it should be <256
    mov    word [ebx+TASKDATA.state],9      ;set process state to 9 (for slot after hight boundary)
    mov    [new_process_place],eax ;save process slot
    pop    ebx
    ret    
.failed:
    xor    eax,eax
    pop    ebx
    ret
;-----------------------------------------------------------------------------
safe_sti:
    cmp    byte [0xe000], 1
    jne    @f
    sti
 @@:ret
 
new_start_application_floppy:
;input:
;  eax - pointer to filename
;  ebx - parameters to pass
;  edx - flags
;result:
;  eax - pid of new process
;        or 0 if call fails.
    mov    [appl_path],edi
    pushad
    mov    esi,new_process_loading
    call   sys_msg_board_str     ;write to debug board
    
;wait application_table_status mutex
.table_status:    
    cli
    cmp    [application_table_status],0
    jz     .stf
    sti
    call   change_task
    jmp    .table_status
.stf:
    call   set_application_table_status
;we can change system tables now
    push   edi
    push   ebx
    push   eax
    call   find_new_process_place ;find empty process slot 
    sti
    test   eax,eax
	mov	ecx, -0x20	; too many processes
    jz     .failed
 
    mov    edi,eax
    shl    edi,8
    add    edi,0x80000
    mov    ecx,256/4
    xor    eax,eax
    cld
    rep    stosd                 ;clean extended information about process
    
;set new process name
    mov    [appl_path_size],eax
    pop    eax
    push   eax
.find_last_byte:
    cmp    byte [eax],0    
    jz     .find_last_byte_end
    inc    eax
    inc    [appl_path_size]
    jmp    .find_last_byte
.find_last_byte_end:
    add    [appl_path_size],24    
    sub    eax,11                ;last 11 bytes = application name
;    mov    eax,[esp]             ;eax - pointer to file name
    mov    ebx,[new_process_place]
    shl    ebx,8
    add    ebx,0x80000 + APPDATA.app_name
    mov    ecx,11
    call   memmove
      
;read header of file
    mov    eax,[esp]
    mov    ebx,1                 ;index of first block
    mov    ecx,2                 ;number of blocks
    mov    edx,0x90000           ;temp area
    mov    esi,12                ;file name length
    mov    edi,[esp+8]
;    cli
    call   floppy_fileread       ;read file from FD
;    sti
	mov	ecx, eax
	neg	ecx
	jnz	.cleanfailed
;check MENUET signature
	mov	ecx, -0x1F	; not Menuet/Kolibri executable
    cmp    [0x90000],dword 'MENU'
    jnz    .cleanfailed
    cmp    [0x90004],word 'ET'
    jnz    .cleanfailed
    
    call   get_app_params        ;parse header fields
    test   esi, esi
    jz     .cleanfailed
    
    mov    eax,[new_process_place]
    	inc	ecx		; -0x1E = no memory
    call   create_app_cr3_table   ;create page directory for new process
    test   eax,eax
    jz     .cleanfailed_mem
    
    call   MEM_Get_Linear_Address ;calculate linear address of it
    
    mov    ebx,std_application_base_address
    mov    ecx,[app_mem]
    add    ecx,4095
    shr    ecx,12
    mov    edx,eax
    call   mem_alloc_specified_region ;allocate memory for application
    test   eax,eax
	mov	ecx, -0x1E
    jz     .cleanfailed_mem1
    
    mov    eax,[edx+(std_application_base_address shr 20)]
    and    eax,not (4096-1)      ;eax - physical address of first (for application memory) page table
    call   MEM_Get_Linear_Address
    mov    edx,eax
 
;read file
    mov    ebx,1
    mov    esi,12                ;length of file name
.loop1:
;edx = linear address of current page table entry
;ebx = index of current block in file
    push   edx
    mov    eax,[edx]
    and    eax,not (4096-1)
    call   MEM_Get_Linear_Address
    mov    edx,eax               ;read file block to current page
    mov    eax,[esp+4]           ;restore pointer to file name
    mov    ecx,8                 ;number of blocks read
    push   ebx
    mov    edi,[esp+16]    
;    cli
    call   floppy_fileread
;ebx=file size    
;    sti
    pop    ecx
    shr    ebx,9
    cmp    ecx,ebx
    jg     .endloop1             ;if end of file?
    mov    ebx,ecx
    test   eax,eax               
    jnz    .endloop1             ;check io errors
    pop    edx
    add    ebx,8                 ;go to next page
    add    edx,4
    jmp    .loop1
    
.endloop1:
    add    esp,8+4                 ;pop linear address of page table entry and pointer to file name
    call   new_start_application_fl.add_app_parameters
    mov    [esp+28],eax
    popad
    ret
    
.cleanfailed_mem1:
;there is mem for directory entry, but there is no mem for pages
;so free directory entry
    mov    eax,[new_process_place]    
    shl    eax,8
    mov    eax,[0x80000+eax+APPDATA.dir_table]
    call   MEM_Free_Page    
.cleanfailed_mem:
;there is no mem for directory entry, display message.
    mov    esi,start_not_enough_memory
    call   sys_msg_board_str
.cleanfailed:                    ;clean process name
	push	ecx	; save error code
;can't read file, clean process name. 
;this avoid problems with panel application.
    mov    edi,[new_process_place]
    shl    edi,8
    add    edi,0x80000 + APPDATA.app_name
    mov    ecx,11
    mov    eax,' '
    cld
    rep    stosb
	pop	eax
.failed:
;no more slots
    add    esp,8+4
    mov    [application_table_status],0
    mov    [esp+1Ch], eax
    popad
    sti
    ret  
 
;-----------------------------------------------------------------------------    
new_start_application_fl:
;input:
;  eax - pointer to filename
;  ebx - parameters to pass
;  edx - flags
;result:
;  eax - pid of new process
;        or 0 if call fails.
    mov    [appl_path],edi
    mov    [appl_path_size],36
    pushad
    mov    esi,new_process_loading
    call   sys_msg_board_str     ;write to debug board
    
;wait application_table_status mutex
.table_status:    
    cli
    cmp    [application_table_status],0
    jz     .stf
    sti
    call   change_task
    jmp    .table_status
.stf:
    call   set_application_table_status
;we can change system tables now    
    push   ebx
    push   eax
    call   find_new_process_place ;find empty process slot 
    call   safe_sti
    test   eax,eax
	mov	ecx, -0x20	; too many processes
    jz     .failed
 
    mov    edi,eax
    shl    edi,8
    add    edi,0x80000
    mov    ecx,256/4
    xor    eax,eax
    cld
    rep    stosd                 ;clean extended information about process
    
;set new process name
    mov    eax,[esp]             ;eax - pointer to file name
    mov    ebx,[new_process_place]
    shl    ebx,8
    add    ebx,0x80000 + APPDATA.app_name
    mov    ecx,11
    call   memmove
      
;read header of file
    mov    ebx,1                 ;index of first block
    mov    ecx,2                 ;number of blocks
    mov    edx,0x90000           ;temp area
    mov    esi,12                ;file name length
    cli
    call   fileread              ;read file from RD
    call   safe_sti
	mov	ecx, eax
	neg	ecx
	jnz	.cleanfailed
;check MENUET signature
	mov	ecx, -0x1F	; not Menuet/Kolibri executable
    cmp    [0x90000],dword 'MENU'
    jnz    .cleanfailed
    cmp    [0x90004],word 'ET'
    jnz    .cleanfailed
    
    call   get_app_params        ;parse header fields
    test   esi,esi
    jz     .cleanfailed
    
    mov    eax,[new_process_place]
    inc    ecx		; -0x1E = no memory
    call   create_app_cr3_table   ;create page directory for new process
    test   eax,eax
    jz     .cleanfailed_mem
    
    call   MEM_Get_Linear_Address ;calculate linear address of it
    
    mov    ebx,std_application_base_address
    mov    ecx,[app_mem]
    add    ecx,4095
    shr    ecx,12
    mov    edx,eax
    call   mem_alloc_specified_region ;allocate memory for application
    test   eax,eax
	mov	ecx, -0x1E
    jz     .cleanfailed_mem1
    
    mov    eax,[edx+(std_application_base_address shr 20)]
    and    eax,not (4096-1)      ;eax - physical address of first (for application memory) page table
    call   MEM_Get_Linear_Address
    mov    edx,eax
 
;read file
    mov    ebx,1
    mov    esi,12                ;length of file name
.loop1:
;edx = linear address of current page table entry
;ebx = index of current block in file
    push   edx
    mov    eax,[edx]
    and    eax,not (4096-1)
    call   MEM_Get_Linear_Address
    mov    edx,eax               ;read file block to current page
    mov    eax,[esp+4]           ;restore pointer to file name
    mov    ecx,8                 ;number of blocks read
    push   ebx
    cli
    call   fileread
;ebx=file size    
    call   safe_sti
    pop    ecx
    shr    ebx,9
    cmp    ecx,ebx
    jg     .endloop1             ;if end of file?
    mov    ebx,ecx
    test   eax,eax               
    jnz    .endloop1             ;check io errors
    pop    edx
    add    ebx,8                 ;go to next page
    add    edx,4
    jmp    .loop1
    
.endloop1:
    add    esp,8                 ;pop linear address of page table entry and pointer to file name
    call   .add_app_parameters
    mov    [esp+28],eax
    popad
    ret
    
.cleanfailed_mem1:
;there is mem for directory entry, but there is no mem for pages
;so free directory entry
    mov    eax,[new_process_place]    
    shl    eax,8
    mov    eax,[0x80000+eax+APPDATA.dir_table]
    call   MEM_Free_Page
.cleanfailed_mem:
;there is no mem for directory entry, display message.
    mov    esi,start_not_enough_memory
    call   sys_msg_board_str
.cleanfailed:                    ;clean process name
	push	ecx	; save error code
;can't read file, clean process name. 
;this avoid problems with panel application.
    mov    edi,[new_process_place]
    shl    edi,8
    add    edi,0x80000+APPDATA.app_name
    mov    ecx,11
    mov    eax,' '
    cld
    rep    stosb
	pop	eax
.failed:
;no more slots
    add    esp,8
    mov    [application_table_status],0
    mov    [esp+1Ch], eax
    popad
    call   safe_sti
    ret
        
.add_app_parameters:
;input:
;  [esp] - pointer to parameters
;  [esp+4]-[esp+36] pushad registers.
;result
;  eax - pid of new process
;        or zero if failed
    cli
    mov    ebx,[new_process_place]
    cmp    ebx,[0x3004]
    jle    .noinc
    inc    dword [0x3004]        ;update number of processes
.noinc:
 
;   mov    ebx,[new_process_place]
;set 0x8c field of extended information about process
;(size of application memory)
    shl    ebx,8
    mov    eax,[app_mem]
    mov    [second_base_address+0x80000+APPDATA.mem_size+ebx],eax             
;set 0x10 field of information about process
;(application base address)     
;    mov    ebx,[new_process_place]
;    shl    ebx,5
    shr    ebx,3
    mov    dword [second_base_address+0x3000+ebx+TASKDATA.mem_start],std_application_base_address
 
;add command line parameters
.add_command_line:
    mov    edx,[app_i_param]
    test   edx,edx
    jz     .no_command_line      ;application don't need parameters
    mov    eax,[esp+4]
    test   eax,eax
    jz     .no_command_line      ;no parameters specified
;calculate parameter length    
    mov    esi,eax
    xor    ecx,ecx
.command_line_len:
    cmp    byte [esi],0
    jz     .command_line_len_end
    inc    esi
    inc    ecx
    cmp    ecx,256
    jl     .command_line_len
    
.command_line_len_end:
;ecx - parameter length
;edx - address of parameters in new process address space
    mov    ebx,eax               ;ebx - address of parameters in our address space
    mov    eax,[new_process_place]
    call   write_process_memory  ;copy parameters to new process address space
    
.no_command_line:
;******************************************************************
    mov    edx,[app_i_icon]
    test   edx,edx
    jz     .no_command_line_1      ;application don't need path of file
    mov    ebx,[appl_path]
    mov    ecx,[appl_path_size]
    mov    eax,[new_process_place]
    call   write_process_memory  ;copy path of file to new process address space
.no_command_line_1:
;******************************************************************
    mov    ebx,[new_process_place]
    mov    eax,ebx
    shl    ebx,5
    add    ebx,0x3000            ;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+TASKDATA.pid],eax           ;set PID
    
    mov    ecx,ebx
    add    ecx,draw_data-0x3000  ;ecx - pointer to draw data
;set draw data to full screen    
    mov    [ecx+RECT.left],dword 0       
    mov    [ecx+RECT.top],dword 0
    mov    eax,[0xfe00]
    mov    [ecx+RECT.right],eax
    mov    eax,[0xfe04]
    mov    [ecx+RECT.bottom],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,[new_process_place]     
    shl    ecx,8
    mov    eax,[0x80000+APPDATA.dir_table+ecx]
    add    eax,8+16              ;add flags
    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    ebx,[new_process_place]
    ;shl    ebx,3
    mov    ax,app_code           ;ax - selector of code segment
    ;add    ax,bx
    mov    [l.cs],ax
    mov    ax,app_data
    ;add    ax,bx                 ;ax - selector of data segment
    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 0x11202
    mov    [l.ss0],os_data
    mov    ebx,[new_process_place]
    shl    ebx,12
    add    ebx,sysint_stack_data+4096
    mov    [l.esp0],ebx
 
;copy tss to it place
    mov    eax,tss_sceleton
    mov    ebx,[new_process_place]
    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,[new_process_place]
    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,[new_process_place]
    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    [0xf400],byte 0
    mov    [0xf500],byte 0
 
    mov    edi,[new_process_place]
    shl    edi,5
    add    edi,window_data
    mov    ebx,[new_process_place]
    movzx  esi,word [0xC000+ebx*2]
    lea    esi,[0xC400+esi*2]
    call   windowactivate        ;gui initialization
 
    mov    ebx,[new_process_place]
    shl    ebx,5
; set if debuggee
        test    byte [esp+28], 1
        jz      .no_debug
        mov     [0x3000+ebx+TASKDATA.state], 1        ; set process state - suspended
        mov     eax, [0x3000]
        mov     [0x80000+ebx*8+APPDATA.debugger_slot], eax ;set debugger PID - current
        jmp     .debug
.no_debug:
        mov     [0x3000+ebx+TASKDATA.state], 0        ; set process state - running
.debug:
    
    mov    esi,new_process_running
    call   sys_msg_board_str     ;output information about succefull startup
    
;    add    esp,4                 ;pop pointer to parameters 
;    popad
    mov    eax,[process_number]  ;set result
    mov    [application_table_status],0 ;unlock application_table_status mutex
    call   safe_sti
    ret    4
;-----------------------------------------------------------------------------    
new_sys_threads:
;eax=1 - create thread
;   ebx=thread start
;   ecx=thread stack value
;result:
;   eax=pid
    xor    edx,edx	; flags=0
    pushad
   
    cmp    eax,1
    jnz    .ret                  ;other subfunctions
    mov    esi,new_process_loading
    call   sys_msg_board_str
;lock application_table_status mutex
.table_status:    
    cli
    cmp    [application_table_status],0
    je     .stf
    sti
    call   change_task
    jmp    .table_status
.stf:
    call   set_application_table_status
;find free process slot
 
    call   find_new_process_place
    test   eax,eax
    jz     .failed
    
;set parameters for thread
    xor    eax,eax
    mov    [app_i_param],eax
    mov    [app_i_icon],eax
    mov    [app_start],ebx
    mov    [app_esp],ecx
 
    mov    esi,[0x3000]
    shl    esi,8
    add    esi,0x80000+APPDATA.app_name
    mov    ebx,esi               ;ebx=esi - pointer to extended information about current thread
    
    mov    edi,[new_process_place]
    shl    edi,8
    add    edi,0x80000
    lea    edx, [edi+APPDATA.app_name] ;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+APPDATA.mem_size]
    mov    [app_mem],eax         ;set memory size
    mov    eax,[ebx+APPDATA.dir_table]
    mov    dword [edx-APPDATA.app_name+APPDATA.dir_table],eax        ;copy page directory
;    mov    eax,[new_process_place]
;    mov    ebx,[0x3000]
;    call   addreference_app_cr3_table
 
    push   0                     ;no parameters
    call    new_start_application_fl.add_app_parameters ;start thread 
    mov    [esp+28],eax
    popad
    ret
   
.failed:
    sti
    popad
    mov    eax,-1
    ret    
.ret:
    popad
    ret
;-----------------------------------------------------------------------------    
new_mem_resize:
;input:
;  ebx - new size
;result:
;  [esp+36]:=0 - normal
;  [esp+36]:=1 - error
;This function set new application memory size.
    mov    esi,ebx               ;save new size
    add    ebx,4095
    and    ebx,not (4096-1)      ;round up size
    mov    ecx,[0x3000]
    shl    ecx,8
    mov    edx,[0x80000 + APPDATA.mem_size +ecx]     
    add    edx,4095
    and    edx,not (4096-1)      ;old size
    mov    eax,[0x80000 + APPDATA.dir_table+ecx]
    call   MEM_Get_Linear_Address
;eax - linear address of page directory    
    call   MEM_Heap_Lock         ;guarantee that two threads willn't 
                                 ;change memory size simultaneously
    cmp    ebx,edx
;    mov    esi,ebx               ;save new size
    jg     .expand
    
.free:
    sub    edx,ebx
    jz     .unlock               ;do nothing
    mov    ecx,edx
    shr    ecx,12
    add    ebx,std_application_base_address 
    call   mem_free_specified_region  ;free unnecessary pages
    jmp    .unlock
 
.expand:
    sub    ebx,edx
    mov    ecx,ebx
    shr    ecx,12
    mov    ebx,edx
    add    ebx,std_application_base_address
    call   mem_alloc_specified_region ;alloc necessary pages
    test   eax,eax
    jz     .failed               ;not enough memory
    
.unlock:
    mov    ebx,esi
    mov    eax,[0x3000]
    shl    eax,8
    mov    [eax+0x80000 + APPDATA.mem_size],ebx     ;write new memory size
;search threads and update 
;application memory size infomation    
    mov    ecx,[eax+0x80000 + APPDATA.dir_table] 
    mov    eax,2
    
.search_threads:
;eax = current slot
;ebx = new memory size
;ecx = page directory
    cmp    eax,[0x3004]
    jg     .search_threads_end
    mov    edx,eax
    shl    edx,5
    cmp    word [0x3000+edx+TASKDATA.state],9 ;if slot empty?
    jz     .search_threads_next
    shl    edx,3
    cmp    [edx+0x80000+APPDATA.dir_table],ecx     ;if it is our thread?
    jnz    .search_threads_next
    mov    [edx+0x80000+APPDATA.mem_size],ebx     ;update memory size
.search_threads_next:
    inc    eax
    jmp    .search_threads
.search_threads_end:
 
    call   MEM_Heap_UnLock
    mov    dword [esp+36],0
    ret
   
.failed:
    call   MEM_Heap_UnLock
    mov    dword [esp+36],1
    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,[0x3004]
    shl    ebx,5
    mov    ecx,2*32
    
.loop:
;ecx=offset of current process info entry
;ebx=maximum permitted offset
    cmp    byte [second_base_address+0x3000+ecx+TASKDATA.state],9
    jz     .endloop              ;skip empty slots
    cmp    [second_base_address+0x3000+ecx+TASKDATA.pid],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
;-----------------------------------------------------------------------------    
is_new_process:
;Input:
;  eax - process slot
;Output:
;  eax=1 - it is new process
;  eax=0 - it is old process
;    shl   eax,5
;    mov   eax,[second_base_address+0x3000+eax+0x10]
;    cmp   eax,std_application_base_address  ;check base address of application
;    jz    .new_process
;    xor   eax,eax
;    ret
    
;.new_process:
    mov   eax,1
    ret
;-----------------------------------------------------------------------------    
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
    pushad
    shl  eax,8
    mov  eax,[0x80000+eax+APPDATA.dir_table]
    call MEM_Get_Linear_Address
    mov  ebp,eax
;ebp=linear address of page directory of other process.    
    add  edx,std_application_base_address  ;convert to linear address
    test ecx,ecx
    jle  .ret
    
.write_loop:
;ebx = current buffer address
;ecx>0 = current size
;edx = current address in other process
;ebp = linear address of page directory
 
    call MEM_Heap_Lock           ;cli
    mov  esi,edx
    shr  esi,22
    mov  eax,[ebp+4*esi]         ;find page directory entry
    and  eax,not (4096-1)        ;clear flags
    test eax,eax
    jz   .page_not_found
    call MEM_Get_Linear_Address  ;calculate linear address of page table
    test eax,eax
    jz   .page_not_found
    mov  esi,edx
    shr  esi,12
    and  esi,1023                
    mov  eax,[eax+4*esi]         ;find page table entry
    and  eax,not (4096-1)
    test eax,eax
    jz   .page_not_found
    call MEM_Get_Linear_Address  ;calculate linear address of page
    test eax,eax
    jz   .page_not_found
    mov  edi,eax
    call MEM_Add_Reference_Linear;guarantee that page willn't disappear
    call MEM_Heap_UnLock         ;sti
    
    mov  esi,edx
    and  esi,4095
    add  edi,esi                 ;add offset in page
;edi = linear address corresponding edx in other process
    sub  esi,4096
    neg  esi                     ;esi - number of remaining bytes in page
    cmp  esi,ecx
    jl   .min_ecx
    mov  esi,ecx
.min_ecx:                        ;esi=min(ecx,esi) - number of bytes to write
    sub  ecx,esi
    push ecx
    mov  ecx,esi                 ;ecx - number of bytes to write
    mov  esi,ebx                 ;esi - source, edi - destination
    add  edx,ecx                 ;move pointer in address space of other process
    push edi
    
;move ecx bytes    
    test ecx,3
    jnz  .not_aligned
    shr  ecx,2
    rep  movsd
    jmp  .next_iter
.not_aligned:
    rep  movsb
.next_iter:
 
    pop  eax                     
    and  eax,not (4096-1)        ;eax - linear address of current page
    call MEM_Free_Page_Linear    ;free reference
    mov  ebx,esi                 ;new pointer to buffer - movsb automaticaly advance it.
    pop  ecx                     ;restore number of remaining bytes
    test ecx,ecx
    jnz  .write_loop
.ret:    
    popad
    mov  eax,ecx
    ret
    
.page_not_found:
    call MEM_Heap_UnLock         ;error has appeared in critical region
    sub  ecx,[esp+24]            ;[esp+24]<-->ecx
    neg  ecx                     ;ecx=number_of_written_bytes
    mov  [esp+28],ecx            ;[esp+28]<-->eax
    popad
    ret    
;-----------------------------------------------------------------------------    
syscall_test:
;for testing memory manager from applications.
    mov  edx,ecx
    mov  ecx,ebx
    call trans_address
    mov  ebx,eax
    mov  eax,[0x3000]
    call read_process_memory
    ret
;-----------------------------------------------------------------------------    
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.
    pushad
    shl  eax,8
    mov  eax,[0x80000+eax+APPDATA.dir_table]
    call MEM_Get_Linear_Address
    mov  ebp,eax
    add  edx,std_application_base_address
.read_loop:
;ebx = current buffer address
;ecx>0 = current size
;edx = current address in other process
;ebp = linear address of page directory
 
    call MEM_Heap_Lock           ;cli
    mov  esi,edx
    shr  esi,22
    mov  eax,[ebp+4*esi]         ;find page directory entry
    and  eax,not (4096-1)
    test eax,eax
    jz   .page_not_found
    call MEM_Get_Linear_Address
    test eax,eax
    jz   .page_not_found
    mov  esi,edx
    shr  esi,12
    and  esi,1023
    mov  eax,[eax+4*esi]         ;find page table entry
    and  eax,not (4096-1)
    test eax,eax
    jz   .page_not_found
    call MEM_Get_Linear_Address  ;calculate linear address of page
    test eax,eax
    jz   .page_not_found
    mov  esi,eax
    call MEM_Add_Reference_Linear;guarantee that page willn't disappear
    call MEM_Heap_UnLock         ;sti
    
    mov  edi,edx
    and  edi,4095                
    add  esi,edi                 ;add offset in page
;esi = linear address corresponding edx in other process
    sub  edi,4096
    neg  edi
    
;edi=min(edi,ecx) - number of bytes to copy  
    cmp  edi,ecx
    jl   .min_ecx
    mov  edi,ecx
.min_ecx:
 
    sub  ecx,edi                 ;update size of remaining bytes
    add  edx,edi                 ;update current pointer in other address space.
    push ecx
    mov  ecx,edi                 ;ecx - number of bytes to read
    mov  edi,ebx                 ;esi - source, edi - destination
    push esi
;move ecx bytes    
    test ecx,3
    jnz  .not_aligned
    shr  ecx,2
    rep  movsd
    jmp  .next_iter
.not_aligned:
    rep  movsb
.next_iter:
    pop  eax
    and  eax,not (4096-1)        ;eax - linear address of current page
    call MEM_Free_Page_Linear    ;free reference
    mov  ebx,edi                 ;new pointer to buffer - movsb automaticaly advance it.
    pop  ecx                     ;restore number of remaining bytes
    test ecx,ecx
    jnz  .read_loop
    
    popad
    mov  eax,ecx
    ret
    
.page_not_found:
    call MEM_Heap_UnLock         ;error has appeared in critical region
    sub  ecx,[esp+24]            ;[esp+24]<-->ecx
    neg  ecx                     ;ecx=number_of_read_bytes
    mov  [esp+28],ecx            ;[esp+28]<-->eax
    popad
    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,[0x3000]
    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 [0x3000+eax+TASKDATA.state],0
    jnz  .failed
    shl  eax,3
    mov  eax,[0x80000+eax+APPDATA.dir_table]
    test eax,eax
    jz   .failed
    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
;-----------------------------------------------------------------------------
new_sys_ipc:
;input:
;  eax=1 - set ipc buffer area
;    ebx=address of buffer
;    ecx=size of buffer
;  eax=2 - send message
;    ebx=PID
;    ecx=address of message
;    edx=size of message
    cmp  eax,1
    jnz  .no_ipc_def
;set ipc buffer area    
    mov  edi,[0x3000]
    shl  edi,8
    add  edi,0x80000 
    cli
    mov  [edi+APPDATA.ipc_start],ebx          ;set fields in extended information area
    mov  [edi+APPDATA.ipc_size],ecx
    sti
    mov  [esp+36],dword 0        ;success
    ret
       
.no_ipc_def:
    cmp  eax,2
    jnz  .no_ipc_send
;send message    
    cli
;obtain slot from PID    
    mov  eax,ebx
    call pid_to_slot
    test eax,eax
    jz   .no_pid
    mov  ebp,eax
;ebp = slot of other process    
    shl  eax,8
    mov  edi,[eax+0x80000+APPDATA.ipc_start]  ;is ipc area defined?
    test edi,edi
    jz   .no_ipc_area
    mov  esi,[eax+0x80000+APPDATA.ipc_size]  ;esi - size of buffer
    push dword -1                ;temp variable for read_process_memory
    mov  ebx,esp
    push ecx
    push edx
    mov  ecx,4                   ;read 4 bytes
    mov  eax,ebp
    mov  edx,edi                 ;from beginning of buffer.
    call read_process_memory
    mov  eax,[esp+8]
    test eax,eax
    jnz  .ipc_blocked            ;if dword [buffer]<>0 - ipc blocked now
    add  edx,4                   ;move to next 4 bytes
    mov  eax,ebp
    call read_process_memory     ;read size of occupied space in buffer
    sub  esi,8
    sub  esi,[esp]
    sub  esi,[esp+8]             ;esi=(buffer size)-(occupied size)-(message size)-(header of message size)
    js   .buffer_overflow        ;esi<0 - not enough memory in buffer
    mov  esi,[esp+8]             ;previous offset
    add  dword [esp+8],8
    mov  edi,[esp]
    add  [esp+8],edi             ;add (size of message)+(size of header of message) to [buffer+4]
    mov  eax,ebp
    call write_process_memory
    add  edx,esi                 
    sub  edx,4                   ;move to beginning of place for our message
    mov  eax,[second_base_address+0x3010]
    mov  eax,[eax+TASKDATA.pid]           ;eax - our PID
    mov  [esp+8],eax
    mov  eax,ebp
    call write_process_memory    ;write PID
    mov  ebx,esp                 ;address of size of message
    mov  eax,ebp
    add  edx,4
    call write_process_memory    ;write size of message
    add  edx,4
    pop  ecx                     ;ecx - size of message
    pop  eax
    call trans_address
    mov  ebx,eax                 ;ebx - linear address of message
    add  esp,4                   ;pop temporary variable
    mov  eax,ebp
    call write_process_memory    ;write message
    sti
;awake other process    
    shl  ebp,8
    mov  eax,ebp
    or   [eax+0x80000+APPDATA.event_mask],dword 0x40
    
    cmp  dword [check_idle_semaphore],20
    jge  .ipc_no_cis
    mov  dword [check_idle_semaphore],5
.ipc_no_cis:
    mov  dword [esp+36],0
    ret
.no_ipc_send:
    mov  dword [esp+36],-1
    ret
.no_pid:
    sti
    mov  dword [esp+36],4
    ret
.no_ipc_area:
    sti
    mov  dword [esp+36],1
    ret
.ipc_blocked:
    sti
    add  esp,12
    mov  dword [esp+36],2
    ret
.buffer_overflow:
    sti
    add  esp,12
    mov  dword [esp+36],3
    ret
;-----------------------------------------------------------------------------    
trans_address:
;Input
;  eax - application address
;Output
;  eax - linear address for kernel      
    add   eax,std_application_base_address
    ret
;-----------------------------------------------------------------------------    
new_start_application_hd:
;eax - file name (kernel address)
;ebx - file name length
;ecx - work area (kernel address)
;edx - flags
;ebp - parameters
    mov    [appl_path],edi
    pushad
    
    mov    esi,new_process_loading
    call   sys_msg_board_str     ;write message to message board
    
;lock application_table_status mutex
.table_status:
    cli
    cmp    [application_table_status],0
    jz     .stf
    sti
    call   change_task
    jmp    .table_status
.stf:
    call   set_application_table_status
    
    push   ebp
    push   ebx
    push   eax
    push   ecx
    call   find_new_process_place ;find new process slot
    sti
    test   eax,eax
	mov	ecx, -0x20	; too many processes
    jz     .failed
    
;write application name
    xor    eax,eax
    mov    [appl_path_size],eax    
    mov    eax,[esp+4]
.find_last_byte:
    cmp    byte [eax],0    
    jz     .find_last_byte_end
    inc    eax
    inc    [appl_path_size]
    jmp    .find_last_byte
.find_last_byte_end:
    add    [appl_path_size],24    
    lea    esi,[eax-11]          ;last 11 bytes = application name
    mov    edi,[new_process_place]
    shl    edi,8
    add    edi,0x80000+APPDATA.app_name
    mov    ecx,11
    cld
    rep    movsb                 ;copy name to extended information about process
    
;read header    
    mov    eax,[esp+4]           ;file name
    mov    esi,[esp]             ;work area
    mov    ecx,1                 ;read from first block
    mov    edx,1                 ;read 1 block
    call   read_hd_file
	mov	ecx, eax
	neg	ecx
	jnz	.cleanfailed
 
    pop    esi
    push   esi
;check menuet signature
	mov	ecx, -0x1F	; not Menuet/Kolibri executable
    cmp    [esi+1024+0],dword 'MENU'  ;read_hd_file function write file to +1024 offset
    jnz    .cleanfailed
    cmp    [esi+1024+4],word 'ET'
    jnz    .cleanfailed
    add    esi,1024
    mov    edi,0x90000
    mov    ecx,512/4
    cld
    rep    movsd                 ;copy first block to 0x90000 address for get_app_params function
    call   get_app_params
	mov	ecx, -0x1F	; not Menuet/Kolibri executable
    test   esi,esi
    jz     .cleanfailed
    
    mov    eax,[new_process_place]
	inc	ecx		; -0x1E = no memory
    call   create_app_cr3_table  ;create page directory
    test   eax,eax
    jz     .cleanfailed_mem
    
    call   MEM_Get_Linear_Address
    
    mov    ebx,std_application_base_address
    mov    ecx,[app_mem]
    add    ecx,4096-1
    shr    ecx,12
    mov    edx,eax               ;edx - linear address of page directory
    call   mem_alloc_specified_region ;allocate memory for application
	mov	ecx, -0x1E	; no memory
    test   eax,eax
    jz     .cleanfailed_mem1
    
    add    edx,(std_application_base_address shr 20)
    mov    eax,[edx]
    and    eax,not (4096-1)
    call   MEM_Get_Linear_Address
    push   edx                   ;save pointer to first page table
    mov    edx,eax
;read file
    mov    ecx,1
    xor    ebp,ebp
.loop1:
;[esp] - pointer to current page directory entry
;edx - pointer to current page table
;ebp - offset in page
;ecx - current cluster
    push   edx
    mov    eax,[esp+12]          ;file name
    mov    ebx,[esp+16]          ;file name length
    mov    esi,[esp+8]           ;work area
    mov    edx,1                 ;number of blocks to read
    push   ecx
    push   ebp
    cli
    call   read_hd_file
    sti
    pop    ebp
    test   eax,eax
    jnz    .endloop1             ;check io errors
    
    mov    esi,[esp+8+4]         ;work area
    add    esi,1024
    mov    eax,[esp+4]           ;current page table 
    mov    eax,[eax]
    and    eax,not (4096-1)        
    call   MEM_Get_Linear_Address;calculate linear page address
    lea    edi,[eax+ebp]         ;add page offset
    mov    ecx,512/4
    cld
    rep    movsd                 ;copy data
    
    pop    ecx
    inc    ecx                   ;next block
    mov    eax,[app_i_end] ;todo: precalculate ([app_i_end]+4095)/4096
    add    eax,512-1
    shr    eax,9                 ;calculate application image size
    cmp    ecx,eax
    jg     .endloop11
    pop    edx
    add    ebp,512               ;new offset
    test   ebp,4096
    jz     .loop1
    xor    ebp,ebp
    add    edx,4                 ;go to next page
    test   edx,(4096-1)
    jnz    .loop1
    add    dword [esp],4         ;go to next directory entry
    mov    eax,[esp]
    mov    eax,[eax]
    and    eax,not (4096-1)
    call   MEM_Get_Linear_Address
    mov    edx,eax
    jmp    .loop1
.endloop1:
    add    esp,4                 ;pop ecx
.endloop11: 
    add    esp,4+4               ;pop edx, pop edx
    
;add_app_parameters
    add    esp,12                ;now pointer to parameters is on the top of the stack
    call   new_start_application_fl.add_app_parameters ;start process
    mov    [esp+28],eax
    popad
    ret
    
.cleanfailed_mem1:
;there is mem for directory entry, but there is no mem for pages
;so free directory entry
    mov    eax,[new_process_place]
    shl    eax,8
    mov    eax,[0x80000+eax+APPDATA.dir_table]
    call   MEM_Free_Page
.cleanfailed_mem:
;there is no mem for directory entry, display message.
    mov    esi,start_not_enough_memory
    call   sys_msg_board_str    
.cleanfailed:                    ;clean process name
	push	ecx
;can't read file, clean process name. 
;this avoid problems with panel application.
    mov    edi,[new_process_place]
    shl    edi,8
    add    edi,0x80000+APPDATA.app_name
    mov    ecx,11
    mov    eax,' '
    cld
    rep    stosb
	pop	eax
.failed:
;no more slots
    add    esp,16
    mov    [esp+1Ch], eax
    popad
    mov    [application_table_status],0
    sti
    ret
end if
 
; \begin{diamond}
        include 'debug.inc'
 
fs_execute:
; ebx - cmdline
; edx - flags
; ebp - full filename
; [esp+4] = procedure DoRead, [esp+8] = filesize & [esp+12]... - arguments for it
        pushad
; check filename length - with terminating NULL must be no more than 1024 symbols
        mov     edi, ebp
        mov     ecx, 1024
        xor     eax, eax
        repnz   scasb
        jz      @f
        popad
        mov     eax, -ERROR_FILE_NOT_FOUND
        ret
@@:
 
        mov     esi, new_process_loading
        call    sys_msg_board_str       ; write message to message board
 
; lock application_table_status mutex
.table_status:
        cli
        cmp     [application_table_status], 0
        jz      .stf
        sti
        call    change_task
        jmp     .table_status
.stf:
        call    set_application_table_status
        push    ebx     ; save command line pointer for add_app_parameters
 
        call    find_new_process_place  ; find new process slot
        call    safe_sti
        test    eax, eax
        mov     ecx, -0x20      ; too many processes
        jz      .failed
 
; write application name
        push    edi
        mov     ecx, edi
        sub     ecx, ebp
        mov     [appl_path], ebp
        mov     [appl_path_size], 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, [new_process_place]
        shl     edi, cl
        add     edi, 0x80000+APPDATA.app_name
.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, [esp+8+36]
        mov     edi, 0x90000
        call    dword [eax-4]
        mov     ecx, eax
        neg     ecx
        jnz     .cleanfailed
; check menuet signature
        mov     ecx, -0x1F
        cmp     dword [0x90000], 'MENU'
        jnz     .cleanfailed
        cmp     word [0x90004], 'ET'
        jnz     .cleanfailed
        call    get_app_params
        mov     ecx, -0x1F
        test    esi, esi
        jz      .cleanfailed
 
        mov     eax, [new_process_place]
        inc     ecx     ; -0x1E = no memory
        call    create_app_cr3_table
        test    eax, eax
        jz      .cleanfailed_mem
 
        call    MEM_Get_Linear_Address
 
        mov     ebx, std_application_base_address
        mov     ecx, [app_mem]
        add     ecx, 4095
        shr     ecx, 12
        mov     edx, eax        ; edx - linear address of page directory
        call    mem_alloc_specified_region
        mov     ecx, -0x1E      ; no memory
        test    eax, eax
        jz      .cleanfailed_mem1
 
        add     edx, std_application_base_address shr 20
        mov     eax, [edx]
        and     eax, not 4095
        call    MEM_Get_Linear_Address
        push    edx             ; save pointer to first page table
        mov     edx, eax
; read file
; first block is already read to 0x90000
        mov     eax, [edx]
        and     eax, not 0xFFF
        call    MEM_Get_Linear_Address
        mov     esi, 0x90000
        mov     edi, eax
        mov     ecx, 512/4
        rep     movsd
        sub     edi, eax
.loop1:
; [esp] = pointer to current page directory entry
; edx = pointer to current page table
; edi = offset in page
        mov     eax, [edx]
        and     eax, not 0xFFF
        call    MEM_Get_Linear_Address
        push    edi
        add     edi, eax
        lea     eax, [esp+8+36+8]
        call    dword [eax-4]
        pop     edi
        test    eax, eax
        jnz     .endloop1
        add     edi, 512        ; new offset
        cmp     edi, 4096
        jb      .loop1
        xor     edi, edi
        add     edx, 4          ; go to next page
        test    edx, 4096-1
        jnz     .loop1
        pop     eax
        add     eax, 4          ; go to next directory entry
        push    eax
        mov     eax, [eax]
        and     eax, not 0xFFF
        call    MEM_Get_Linear_Address
        mov     edx, eax
        jmp     .loop1
.endloop1:
        pop     edx
        cmp     eax, 6
        jnz     .cleanfailed_mem2
        call    new_start_application_fl.add_app_parameters
        mov     [esp+28], eax
        popad
        ret
 
.cleanfailed_mem2:
; file read error; free all allocated mem
        mov     ecx, eax
        neg     ecx
        mov     eax, [new_process_place]
        call    dispose_app_cr3_table
        jmp     .cleanfailed
.cleanfailed_mem1:
; there is mem for directory entry, but there is no mem for pages
; so free directory entry
        mov     eax, [new_process_place]
        shl     eax, 8
        mov     eax, [0x80000+eax+0xB8]
        call    MEM_Free_Page
.cleanfailed_mem:
; there is no mem for directory entry, display message
        mov     esi, start_not_enough_memory
        call    sys_msg_board_str
.cleanfailed:
        push    ecx
; clean process name, this avoid problems with @panel
        mov     edi, [new_process_place]
        shl     edi, 8
        add     edi, 0x80000+APPDATA.app_name
        mov     ecx, 11
        mov     al, ' '
        rep     stosb
        pop     eax
.failed:
        pop     ebx
        mov     [esp+28], eax
        popad
        mov     [application_table_status], 0
        call    safe_sti
        ret
; \end{diamond}
>

Rev 91	Rev 115
1	if ~defined newprocess_inc	1	if ~defined newprocess_inc
2	newprocess_inc_fix:	2	newprocess_inc_fix:
3	newprocess_inc fix newprocess_inc_fix	3	newprocess_inc fix newprocess_inc_fix
4	include "mem.inc"	4	include "mem.inc"
5	include "memmanag.inc"	5	include "memmanag.inc"
6	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	6	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
7	;;Working with new types of processes.	7	;;Working with new types of processes.
8	;;Author: Khalyavin Andrey halyavin@land.ru	8	;;Author: Khalyavin Andrey halyavin@land.ru
9	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	9	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
10	iglobal	10	iglobal
11	new_process_loading db 'K : New Process - loading',13,10,0	11	new_process_loading db 'K : New Process - loading',13,10,0
12	new_process_running db 'K : New Process - done',13,10,0	12	new_process_running db 'K : New Process - done',13,10,0
13	start_not_enough_memory db 'K : New Process - not enough memory',13,10,0	13	start_not_enough_memory db 'K : New Process - not enough memory',13,10,0
14	endg	14	endg
15	;-----------------------------------------------------------------------------	15	;-----------------------------------------------------------------------------
16		16
17	find_new_process_place:	17	find_new_process_place:
18	;input:	18	;input:
19	; none	19	; none
20	;result:	20	;result:
21	; eax=[new_process_place]<>0 - ok	21	; eax=[new_process_place]<>0 - ok
22	; 0 - failed.	22	; 0 - failed.
23	;This function find least empty slot.	23	;This function find least empty slot.
24	;It doesn't increase [0x3004]!	24	;It doesn't increase [0x3004]!
25	mov eax,0x3000+second_base_address	25	mov eax,0x3000+second_base_address
26	push ebx	26	push ebx
27	mov ebx,[0x3004]	27	mov ebx,[0x3004]
28	inc ebx	28	inc ebx
29	shl ebx,5	29	shl ebx,5
30	add ebx,eax ;ebx - address of process information for (last+1) slot	30	add ebx,eax ;ebx - address of process information for (last+1) slot
31	.newprocessplace:	31	.newprocessplace:
32	;eax = address of process information for current slot	32	;eax = address of process information for current slot
33	cmp eax,ebx	33	cmp eax,ebx
34	jz .endnewprocessplace ;empty slot after high boundary	34	jz .endnewprocessplace ;empty slot after high boundary
35	add eax,0x20	35	add eax,0x20
36	cmp word [eax+0xa],9 ;check process state, 9 means that process slot is empty	36	cmp word [eax+TASKDATA.state],9 ;check process state, 9 means that process slot is empty
37	jnz .newprocessplace	37	jnz .newprocessplace
38	.endnewprocessplace:	38	.endnewprocessplace:
39	mov ebx,eax	39	mov ebx,eax
40	sub eax,0x3000+second_base_address	40	sub eax,0x3000+second_base_address
41	shr eax,5 ;calculate slot index	41	shr eax,5 ;calculate slot index
42	cmp eax,256	42	cmp eax,256
43	jge .failed ;it should be <256	43	jge .failed ;it should be <256
44	mov word [ebx+0xa],9 ;set process state to 9 (for slot after hight boundary)	44	mov word [ebx+TASKDATA.state],9 ;set process state to 9 (for slot after hight boundary)
45	mov [new_process_place],eax ;save process slot	45	mov [new_process_place],eax ;save process slot
46	pop ebx	46	pop ebx
47	ret	47	ret
48	.failed:	48	.failed:
49	xor eax,eax	49	xor eax,eax
50	pop ebx	50	pop ebx
51	ret	51	ret
52	;-----------------------------------------------------------------------------	52	;-----------------------------------------------------------------------------
53	safe_sti:	53	safe_sti:
54	cmp byte [0xe000], 1	54	cmp byte [0xe000], 1
55	jne @f	55	jne @f
56	sti	56	sti
57	@@:ret	57	@@:ret
58		58
59	new_start_application_floppy:	59	new_start_application_floppy:
60	;input:	60	;input:
61	; eax - pointer to filename	61	; eax - pointer to filename
62	; ebx - parameters to pass	62	; ebx - parameters to pass
63	; edx - flags	63	; edx - flags
64	;result:	64	;result:
65	; eax - pid of new process	65	; eax - pid of new process
66	; or 0 if call fails.	66	; or 0 if call fails.
67	mov [appl_path],edi	67	mov [appl_path],edi
68	pushad	68	pushad
69	mov esi,new_process_loading	69	mov esi,new_process_loading
70	call sys_msg_board_str ;write to debug board	70	call sys_msg_board_str ;write to debug board
71		71
72	;wait application_table_status mutex	72	;wait application_table_status mutex
73	.table_status:	73	.table_status:
74	cli	74	cli
75	cmp [application_table_status],0	75	cmp [application_table_status],0
76	jz .stf	76	jz .stf
77	sti	77	sti
78	call change_task	78	call change_task
79	jmp .table_status	79	jmp .table_status
80	.stf:	80	.stf:
81	call set_application_table_status	81	call set_application_table_status
82	;we can change system tables now	82	;we can change system tables now
83	push edi	83	push edi
84	push ebx	84	push ebx
85	push eax	85	push eax
86	call find_new_process_place ;find empty process slot	86	call find_new_process_place ;find empty process slot
87	sti	87	sti
88	test eax,eax	88	test eax,eax
89	mov ecx, -0x20 ; too many processes	89	mov ecx, -0x20 ; too many processes
90	jz .failed	90	jz .failed
91		91
92	mov edi,eax	92	mov edi,eax
93	shl edi,8	93	shl edi,8
94	add edi,0x80000	94	add edi,0x80000
95	mov ecx,256/4	95	mov ecx,256/4
96	xor eax,eax	96	xor eax,eax
97	cld	97	cld
98	rep stosd ;clean extended information about process	98	rep stosd ;clean extended information about process
99		99
100	;set new process name	100	;set new process name
101	mov [appl_path_size],eax	101	mov [appl_path_size],eax
102	pop eax	102	pop eax
103	push eax	103	push eax
104	.find_last_byte:	104	.find_last_byte:
105	cmp byte [eax],0	105	cmp byte [eax],0
106	jz .find_last_byte_end	106	jz .find_last_byte_end
107	inc eax	107	inc eax
108	inc [appl_path_size]	108	inc [appl_path_size]
109	jmp .find_last_byte	109	jmp .find_last_byte
110	.find_last_byte_end:	110	.find_last_byte_end:
111	add [appl_path_size],24	111	add [appl_path_size],24
112	sub eax,11 ;last 11 bytes = application name	112	sub eax,11 ;last 11 bytes = application name
113	; mov eax,[esp] ;eax - pointer to file name	113	; mov eax,[esp] ;eax - pointer to file name
114	mov ebx,[new_process_place]	114	mov ebx,[new_process_place]
115	shl ebx,8	115	shl ebx,8
116	add ebx,0x80000	116	add ebx,0x80000 + APPDATA.app_name
117	mov ecx,11	117	mov ecx,11
118	call memmove	118	call memmove
119		119
120	;read header of file	120	;read header of file
121	mov eax,[esp]	121	mov eax,[esp]
122	mov ebx,1 ;index of first block	122	mov ebx,1 ;index of first block
123	mov ecx,2 ;number of blocks	123	mov ecx,2 ;number of blocks
124	mov edx,0x90000 ;temp area	124	mov edx,0x90000 ;temp area
125	mov esi,12 ;file name length	125	mov esi,12 ;file name length
126	mov edi,[esp+8]	126	mov edi,[esp+8]
127	; cli	127	; cli
128	call floppy_fileread ;read file from FD	128	call floppy_fileread ;read file from FD
129	; sti	129	; sti
130	mov ecx, eax	130	mov ecx, eax
131	neg ecx	131	neg ecx
132	jnz .cleanfailed	132	jnz .cleanfailed
133	;check MENUET signature	133	;check MENUET signature
134	mov ecx, -0x1F ; not Menuet/Kolibri executable	134	mov ecx, -0x1F ; not Menuet/Kolibri executable
135	cmp [0x90000],dword 'MENU'	135	cmp [0x90000],dword 'MENU'
136	jnz .cleanfailed	136	jnz .cleanfailed
137	cmp [0x90004],word 'ET'	137	cmp [0x90004],word 'ET'
138	jnz .cleanfailed	138	jnz .cleanfailed
139		139
140	call get_app_params ;parse header fields	140	call get_app_params ;parse header fields
141	test esi, esi	141	test esi, esi
142	jz .cleanfailed	142	jz .cleanfailed
143		143
144	mov eax,[new_process_place]	144	mov eax,[new_process_place]
145	inc ecx ; -0x1E = no memory	145	inc ecx ; -0x1E = no memory
146	call create_app_cr3_table ;create page directory for new process	146	call create_app_cr3_table ;create page directory for new process
147	test eax,eax	147	test eax,eax
148	jz .cleanfailed_mem	148	jz .cleanfailed_mem
149		149
150	call MEM_Get_Linear_Address ;calculate linear address of it	150	call MEM_Get_Linear_Address ;calculate linear address of it
151		151
152	mov ebx,std_application_base_address	152	mov ebx,std_application_base_address
153	mov ecx,[app_mem]	153	mov ecx,[app_mem]
154	add ecx,4095	154	add ecx,4095
155	shr ecx,12	155	shr ecx,12
156	mov edx,eax	156	mov edx,eax
157	call mem_alloc_specified_region ;allocate memory for application	157	call mem_alloc_specified_region ;allocate memory for application
158	test eax,eax	158	test eax,eax
159	mov ecx, -0x1E	159	mov ecx, -0x1E
160	jz .cleanfailed_mem1	160	jz .cleanfailed_mem1
161		161
162	mov eax,[edx+(std_application_base_address shr 20)]	162	mov eax,[edx+(std_application_base_address shr 20)]
163	and eax,not (4096-1) ;eax - physical address of first (for application memory) page table	163	and eax,not (4096-1) ;eax - physical address of first (for application memory) page table
164	call MEM_Get_Linear_Address	164	call MEM_Get_Linear_Address
165	mov edx,eax	165	mov edx,eax
166		166
167	;read file	167	;read file
168	mov ebx,1	168	mov ebx,1
169	mov esi,12 ;length of file name	169	mov esi,12 ;length of file name
170	.loop1:	170	.loop1:
171	;edx = linear address of current page table entry	171	;edx = linear address of current page table entry
172	;ebx = index of current block in file	172	;ebx = index of current block in file
173	push edx	173	push edx
174	mov eax,[edx]	174	mov eax,[edx]
175	and eax,not (4096-1)	175	and eax,not (4096-1)
176	call MEM_Get_Linear_Address	176	call MEM_Get_Linear_Address
177	mov edx,eax ;read file block to current page	177	mov edx,eax ;read file block to current page
178	mov eax,[esp+4] ;restore pointer to file name	178	mov eax,[esp+4] ;restore pointer to file name
179	mov ecx,8 ;number of blocks read	179	mov ecx,8 ;number of blocks read
180	push ebx	180	push ebx
181	mov edi,[esp+16]	181	mov edi,[esp+16]
182	; cli	182	; cli
183	call floppy_fileread	183	call floppy_fileread
184	;ebx=file size	184	;ebx=file size
185	; sti	185	; sti
186	pop ecx	186	pop ecx
187	shr ebx,9	187	shr ebx,9
188	cmp ecx,ebx	188	cmp ecx,ebx
189	jg .endloop1 ;if end of file?	189	jg .endloop1 ;if end of file?
190	mov ebx,ecx	190	mov ebx,ecx
191	test eax,eax	191	test eax,eax
192	jnz .endloop1 ;check io errors	192	jnz .endloop1 ;check io errors
193	pop edx	193	pop edx
194	add ebx,8 ;go to next page	194	add ebx,8 ;go to next page
195	add edx,4	195	add edx,4
196	jmp .loop1	196	jmp .loop1
197		197
198	.endloop1:	198	.endloop1:
199	add esp,8+4 ;pop linear address of page table entry and pointer to file name	199	add esp,8+4 ;pop linear address of page table entry and pointer to file name
200	call new_start_application_fl.add_app_parameters	200	call new_start_application_fl.add_app_parameters
201	mov [esp+28],eax	201	mov [esp+28],eax
202	popad	202	popad
203	ret	203	ret
204		204
205	.cleanfailed_mem1:	205	.cleanfailed_mem1:
206	;there is mem for directory entry, but there is no mem for pages	206	;there is mem for directory entry, but there is no mem for pages
207	;so free directory entry	207	;so free directory entry
208	mov eax,[new_process_place]	208	mov eax,[new_process_place]
209	shl eax,8	209	shl eax,8
210	mov eax,[0x80000+eax+0xB8]	210	mov eax,[0x80000+eax+APPDATA.dir_table]
211	call MEM_Free_Page	211	call MEM_Free_Page
212	.cleanfailed_mem:	212	.cleanfailed_mem:
213	;there is no mem for directory entry, display message.	213	;there is no mem for directory entry, display message.
214	mov esi,start_not_enough_memory	214	mov esi,start_not_enough_memory
215	call sys_msg_board_str	215	call sys_msg_board_str
216	.cleanfailed: ;clean process name	216	.cleanfailed: ;clean process name
217	push ecx ; save error code	217	push ecx ; save error code
218	;can't read file, clean process name.	218	;can't read file, clean process name.
219	;this avoid problems with panel application.	219	;this avoid problems with panel application.
220	mov edi,[new_process_place]	220	mov edi,[new_process_place]
221	shl edi,8	221	shl edi,8
222	add edi,0x80000	222	add edi,0x80000 + APPDATA.app_name
223	mov ecx,11	223	mov ecx,11
224	mov eax,' '	224	mov eax,' '
225	cld	225	cld
226	rep stosb	226	rep stosb
227	pop eax	227	pop eax
228	.failed:	228	.failed:
229	;no more slots	229	;no more slots
230	add esp,8+4	230	add esp,8+4
231	mov [application_table_status],0	231	mov [application_table_status],0
232	mov [esp+1Ch], eax	232	mov [esp+1Ch], eax
233	popad	233	popad
234	sti	234	sti
235	ret	235	ret
236		236
237	;-----------------------------------------------------------------------------	237	;-----------------------------------------------------------------------------
238	new_start_application_fl:	238	new_start_application_fl:
239	;input:	239	;input:
240	; eax - pointer to filename	240	; eax - pointer to filename
241	; ebx - parameters to pass	241	; ebx - parameters to pass
242	; edx - flags	242	; edx - flags
243	;result:	243	;result:
244	; eax - pid of new process	244	; eax - pid of new process
245	; or 0 if call fails.	245	; or 0 if call fails.
246	mov [appl_path],edi	246	mov [appl_path],edi
247	mov [appl_path_size],36	247	mov [appl_path_size],36
248	pushad	248	pushad
249	mov esi,new_process_loading	249	mov esi,new_process_loading
250	call sys_msg_board_str ;write to debug board	250	call sys_msg_board_str ;write to debug board
251		251
252	;wait application_table_status mutex	252	;wait application_table_status mutex
253	.table_status:	253	.table_status:
254	cli	254	cli
255	cmp [application_table_status],0	255	cmp [application_table_status],0
256	jz .stf	256	jz .stf
257	sti	257	sti
258	call change_task	258	call change_task
259	jmp .table_status	259	jmp .table_status
260	.stf:	260	.stf:
261	call set_application_table_status	261	call set_application_table_status
262	;we can change system tables now	262	;we can change system tables now
263	push ebx	263	push ebx
264	push eax	264	push eax
265	call find_new_process_place ;find empty process slot	265	call find_new_process_place ;find empty process slot
266	call safe_sti	266	call safe_sti
267	test eax,eax	267	test eax,eax
268	mov ecx, -0x20 ; too many processes	268	mov ecx, -0x20 ; too many processes
269	jz .failed	269	jz .failed
270		270
271	mov edi,eax	271	mov edi,eax
272	shl edi,8	272	shl edi,8
273	add edi,0x80000	273	add edi,0x80000
274	mov ecx,256/4	274	mov ecx,256/4
275	xor eax,eax	275	xor eax,eax
276	cld	276	cld
277	rep stosd ;clean extended information about process	277	rep stosd ;clean extended information about process
278		278
279	;set new process name	279	;set new process name
280	mov eax,[esp] ;eax - pointer to file name	280	mov eax,[esp] ;eax - pointer to file name
281	mov ebx,[new_process_place]	281	mov ebx,[new_process_place]
282	shl ebx,8	282	shl ebx,8
283	add ebx,0x80000	283	add ebx,0x80000 + APPDATA.app_name
284	mov ecx,11	284	mov ecx,11
285	call memmove	285	call memmove
286		286
287	;read header of file	287	;read header of file
288	mov ebx,1 ;index of first block	288	mov ebx,1 ;index of first block
289	mov ecx,2 ;number of blocks	289	mov ecx,2 ;number of blocks
290	mov edx,0x90000 ;temp area	290	mov edx,0x90000 ;temp area
291	mov esi,12 ;file name length	291	mov esi,12 ;file name length
292	cli	292	cli
293	call fileread ;read file from RD	293	call fileread ;read file from RD
294	call safe_sti	294	call safe_sti
295	mov ecx, eax	295	mov ecx, eax
296	neg ecx	296	neg ecx
297	jnz .cleanfailed	297	jnz .cleanfailed
298	;check MENUET signature	298	;check MENUET signature
299	mov ecx, -0x1F ; not Menuet/Kolibri executable	299	mov ecx, -0x1F ; not Menuet/Kolibri executable
300	cmp [0x90000],dword 'MENU'	300	cmp [0x90000],dword 'MENU'
301	jnz .cleanfailed	301	jnz .cleanfailed
302	cmp [0x90004],word 'ET'	302	cmp [0x90004],word 'ET'
303	jnz .cleanfailed	303	jnz .cleanfailed
304		304
305	call get_app_params ;parse header fields	305	call get_app_params ;parse header fields
306	test esi,esi	306	test esi,esi
307	jz .cleanfailed	307	jz .cleanfailed
308		308
309	mov eax,[new_process_place]	309	mov eax,[new_process_place]
310	inc ecx ; -0x1E = no memory	310	inc ecx ; -0x1E = no memory
311	call create_app_cr3_table ;create page directory for new process	311	call create_app_cr3_table ;create page directory for new process
312	test eax,eax	312	test eax,eax
313	jz .cleanfailed_mem	313	jz .cleanfailed_mem
314		314
315	call MEM_Get_Linear_Address ;calculate linear address of it	315	call MEM_Get_Linear_Address ;calculate linear address of it
316		316
317	mov ebx,std_application_base_address	317	mov ebx,std_application_base_address
318	mov ecx,[app_mem]	318	mov ecx,[app_mem]
319	add ecx,4095	319	add ecx,4095
320	shr ecx,12	320	shr ecx,12
321	mov edx,eax	321	mov edx,eax
322	call mem_alloc_specified_region ;allocate memory for application	322	call mem_alloc_specified_region ;allocate memory for application
323	test eax,eax	323	test eax,eax
324	mov ecx, -0x1E	324	mov ecx, -0x1E
325	jz .cleanfailed_mem1	325	jz .cleanfailed_mem1
326		326
327	mov eax,[edx+(std_application_base_address shr 20)]	327	mov eax,[edx+(std_application_base_address shr 20)]
328	and eax,not (4096-1) ;eax - physical address of first (for application memory) page table	328	and eax,not (4096-1) ;eax - physical address of first (for application memory) page table
329	call MEM_Get_Linear_Address	329	call MEM_Get_Linear_Address
330	mov edx,eax	330	mov edx,eax
331		331
332	;read file	332	;read file
333	mov ebx,1	333	mov ebx,1
334	mov esi,12 ;length of file name	334	mov esi,12 ;length of file name
335	.loop1:	335	.loop1:
336	;edx = linear address of current page table entry	336	;edx = linear address of current page table entry
337	;ebx = index of current block in file	337	;ebx = index of current block in file
338	push edx	338	push edx
339	mov eax,[edx]	339	mov eax,[edx]
340	and eax,not (4096-1)	340	and eax,not (4096-1)
341	call MEM_Get_Linear_Address	341	call MEM_Get_Linear_Address
342	mov edx,eax ;read file block to current page	342	mov edx,eax ;read file block to current page
343	mov eax,[esp+4] ;restore pointer to file name	343	mov eax,[esp+4] ;restore pointer to file name
344	mov ecx,8 ;number of blocks read	344	mov ecx,8 ;number of blocks read
345	push ebx	345	push ebx
346	cli	346	cli
347	call fileread	347	call fileread
348	;ebx=file size	348	;ebx=file size
349	call safe_sti	349	call safe_sti
350	pop ecx	350	pop ecx
351	shr ebx,9	351	shr ebx,9
352	cmp ecx,ebx	352	cmp ecx,ebx
353	jg .endloop1 ;if end of file?	353	jg .endloop1 ;if end of file?
354	mov ebx,ecx	354	mov ebx,ecx
355	test eax,eax	355	test eax,eax
356	jnz .endloop1 ;check io errors	356	jnz .endloop1 ;check io errors
357	pop edx	357	pop edx
358	add ebx,8 ;go to next page	358	add ebx,8 ;go to next page
359	add edx,4	359	add edx,4
360	jmp .loop1	360	jmp .loop1
361		361
362	.endloop1:	362	.endloop1:
363	add esp,8 ;pop linear address of page table entry and pointer to file name	363	add esp,8 ;pop linear address of page table entry and pointer to file name
364	call .add_app_parameters	364	call .add_app_parameters
365	mov [esp+28],eax	365	mov [esp+28],eax
366	popad	366	popad
367	ret	367	ret
368		368
369	.cleanfailed_mem1:	369	.cleanfailed_mem1:
370	;there is mem for directory entry, but there is no mem for pages	370	;there is mem for directory entry, but there is no mem for pages
371	;so free directory entry	371	;so free directory entry
372	mov eax,[new_process_place]	372	mov eax,[new_process_place]
373	shl eax,8	373	shl eax,8
374	mov eax,[0x80000+eax+0xB8]	374	mov eax,[0x80000+eax+APPDATA.dir_table]
375	call MEM_Free_Page	375	call MEM_Free_Page
376	.cleanfailed_mem:	376	.cleanfailed_mem:
377	;there is no mem for directory entry, display message.	377	;there is no mem for directory entry, display message.
378	mov esi,start_not_enough_memory	378	mov esi,start_not_enough_memory
379	call sys_msg_board_str	379	call sys_msg_board_str
380	.cleanfailed: ;clean process name	380	.cleanfailed: ;clean process name
381	push ecx ; save error code	381	push ecx ; save error code
382	;can't read file, clean process name.	382	;can't read file, clean process name.
383	;this avoid problems with panel application.	383	;this avoid problems with panel application.
384	mov edi,[new_process_place]	384	mov edi,[new_process_place]
385	shl edi,8	385	shl edi,8
386	add edi,0x80000	386	add edi,0x80000+APPDATA.app_name
387	mov ecx,11	387	mov ecx,11
388	mov eax,' '	388	mov eax,' '
389	cld	389	cld
390	rep stosb	390	rep stosb
391	pop eax	391	pop eax
392	.failed:	392	.failed:
393	;no more slots	393	;no more slots
394	add esp,8	394	add esp,8
395	mov [application_table_status],0	395	mov [application_table_status],0
396	mov [esp+1Ch], eax	396	mov [esp+1Ch], eax
397	popad	397	popad
398	call safe_sti	398	call safe_sti
399	ret	399	ret
400		400
401	.add_app_parameters:	401	.add_app_parameters:
402	;input:	402	;input:
403	; [esp] - pointer to parameters	403	; [esp] - pointer to parameters
404	; [esp+4]-[esp+36] pushad registers.	404	; [esp+4]-[esp+36] pushad registers.
405	;result	405	;result
406	; eax - pid of new process	406	; eax - pid of new process
407	; or zero if failed	407	; or zero if failed
408	cli	408	cli
409	mov ebx,[new_process_place]	409	mov ebx,[new_process_place]
410	cmp ebx,[0x3004]	410	cmp ebx,[0x3004]
411	jle .noinc	411	jle .noinc
412	inc dword [0x3004] ;update number of processes	412	inc dword [0x3004] ;update number of processes
413	.noinc:	413	.noinc:
414		414
415	; mov ebx,[new_process_place]	415	; mov ebx,[new_process_place]
416	;set 0x8c field of extended information about process	416	;set 0x8c field of extended information about process
417	;(size of application memory)	417	;(size of application memory)
418	shl ebx,8	418	shl ebx,8
419	mov eax,[app_mem]	419	mov eax,[app_mem]
420	mov [second_base_address+0x80000+0x8c+ebx],eax	420	mov [second_base_address+0x80000+APPDATA.mem_size+ebx],eax
421	;set 0x10 field of information about process	421	;set 0x10 field of information about process
422	;(application base address)	422	;(application base address)
423	; mov ebx,[new_process_place]	423	; mov ebx,[new_process_place]
424	; shl ebx,5	424	; shl ebx,5
425	shr ebx,3	425	shr ebx,3
426	mov dword [second_base_address+0x3000+ebx+0x10],std_application_base_address	426	mov dword [second_base_address+0x3000+ebx+TASKDATA.mem_start],std_application_base_address
427		427
428	;add command line parameters	428	;add command line parameters
429	.add_command_line:	429	.add_command_line:
430	mov edx,[app_i_param]	430	mov edx,[app_i_param]
431	test edx,edx	431	test edx,edx
432	jz .no_command_line ;application don't need parameters	432	jz .no_command_line ;application don't need parameters
433	mov eax,[esp+4]	433	mov eax,[esp+4]
434	test eax,eax	434	test eax,eax
435	jz .no_command_line ;no parameters specified	435	jz .no_command_line ;no parameters specified
436	;calculate parameter length	436	;calculate parameter length
437	mov esi,eax	437	mov esi,eax
438	xor ecx,ecx	438	xor ecx,ecx
439	.command_line_len:	439	.command_line_len:
440	cmp byte [esi],0	440	cmp byte [esi],0
441	jz .command_line_len_end	441	jz .command_line_len_end
442	inc esi	442	inc esi
443	inc ecx	443	inc ecx
444	cmp ecx,256	444	cmp ecx,256
445	jl .command_line_len	445	jl .command_line_len
446		446
447	.command_line_len_end:	447	.command_line_len_end:
448	;ecx - parameter length	448	;ecx - parameter length
449	;edx - address of parameters in new process address space	449	;edx - address of parameters in new process address space
450	mov ebx,eax ;ebx - address of parameters in our address space	450	mov ebx,eax ;ebx - address of parameters in our address space
451	mov eax,[new_process_place]	451	mov eax,[new_process_place]
452	call write_process_memory ;copy parameters to new process address space	452	call write_process_memory ;copy parameters to new process address space
453		453
454	.no_command_line:	454	.no_command_line:
455	;******************************************************************	455	;******************************************************************
456	mov edx,[app_i_icon]	456	mov edx,[app_i_icon]
457	test edx,edx	457	test edx,edx
458	jz .no_command_line_1 ;application don't need path of file	458	jz .no_command_line_1 ;application don't need path of file
459	mov ebx,[appl_path]	459	mov ebx,[appl_path]
460	mov ecx,[appl_path_size]	460	mov ecx,[appl_path_size]
461	mov eax,[new_process_place]	461	mov eax,[new_process_place]
462	call write_process_memory ;copy path of file to new process address space	462	call write_process_memory ;copy path of file to new process address space
463	.no_command_line_1:	463	.no_command_line_1:
464	;******************************************************************	464	;******************************************************************
465	mov ebx,[new_process_place]	465	mov ebx,[new_process_place]
466	mov eax,ebx	466	mov eax,ebx
467	shl ebx,5	467	shl ebx,5
468	add ebx,0x3000 ;ebx - pointer to information about process	468	add ebx,0x3000 ;ebx - pointer to information about process
469	mov [ebx+0xe],al ;set window number on screen = process slot	469	mov [ebx+TASKDATA.wnd_number],al ;set window number on screen = process slot
470		470
471	mov [ebx],dword 1+2+4 ;set default event flags (see 40 function)	471	mov [ebx+TASKDATA.event_mask],dword 1+2+4 ;set default event flags (see 40 function)
472		472
473	inc dword [process_number]	473	inc dword [process_number]
474	mov eax,[process_number]	474	mov eax,[process_number]
475	mov [ebx+4],eax ;set PID	475	mov [ebx+TASKDATA.pid],eax ;set PID
476		476
477	mov ecx,ebx	477	mov ecx,ebx
478	add ecx,draw_data-0x3000 ;ecx - pointer to draw data	478	add ecx,draw_data-0x3000 ;ecx - pointer to draw data
479	;set draw data to full screen	479	;set draw data to full screen
480	mov [ecx+0],dword 0	480	mov [ecx+RECT.left],dword 0
481	mov [ecx+4],dword 0	481	mov [ecx+RECT.top],dword 0
482	mov eax,[0xfe00]	482	mov eax,[0xfe00]
483	mov [ecx+8],eax	483	mov [ecx+RECT.right],eax
484	mov eax,[0xfe04]	484	mov eax,[0xfe04]
485	mov [ecx+12],eax	485	mov [ecx+RECT.bottom],eax
486	;set window state to 'normal' (non-minimized/maximized/rolled-up) state	486	;set window state to 'normal' (non-minimized/maximized/rolled-up) state
487	mov [ecx+WDATA.fl_wstate],WSTATE_NORMAL	487	mov [ecx+WDATA.fl_wstate],WSTATE_NORMAL
488	;set cr3 register in TSS of application	488	;set cr3 register in TSS of application
489	mov ecx,[new_process_place]	489	mov ecx,[new_process_place]
490	shl ecx,8	490	shl ecx,8
491	mov eax,[0x800B8+ecx]	491	mov eax,[0x80000+APPDATA.dir_table+ecx]
492	add eax,8+16 ;add flags	492	add eax,8+16 ;add flags
493	mov [l.cr3],eax	493	mov [l.cr3],eax
494		494
495	mov eax,[app_start]	495	mov eax,[app_start]
496	mov [l.eip],eax ;set eip in TSS	496	mov [l.eip],eax ;set eip in TSS
497	mov eax,[app_esp]	497	mov eax,[app_esp]
498	mov [l.esp],eax ;set stack in TSS	498	mov [l.esp],eax ;set stack in TSS
499		499
500	;gdt	500	;gdt

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/newproce.inc @ 147 – Rev 91 → 115