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
 
    jc     .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
    mov    ebp,edx               ;save buffer address for .endofimage
    push   ebx
    mov    edi,[esp+16]    
;    cli
    call   floppy_fileread
;ebx=file size    
;    sti
    pop    ecx
    add    ecx,8
    test   eax,eax
    jnz    .endloop1             ;check io errors
    mov    eax,[app_i_end]
    add    eax,511
    shr    eax,9
    cmp    ecx,eax
    jg     .endofimage           ;we have loaded whole program
    add    ebx,511
    shr    ebx,9
    cmp    ecx,ebx
    jg     .endloop1             ;if end of file?
    mov    ebx,ecx
    pop    edx
    add    edx,4
    jmp    .loop1
    
.endofimage:                     ;set to zero memory at end of page
    mov    ecx,[app_i_end]
    and    ecx,4096-1
    jz     .endloop1
    lea    edi,[ebp+ecx]
    neg    ecx
    add    ecx,4096
    xor    eax,eax
    cld
    rep    stosb
.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
 
    jc     .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
    mov    ebp,edx               ;save buffer address for .endofimage
    push   ebx
    cli
    call   fileread
;ebx=file size    
    call   safe_sti
    pop    ecx
    add    ecx,8
    test   eax,eax
    jnz    .endloop1             ;check io errors
    mov    eax,[app_i_end]
    add    eax,511
    shr    eax,9
    cmp    ecx,eax
    jg     .endofimage           ;we have loaded whole program
    add    ebx,511
    shr    ebx,9
    cmp    ecx,ebx
    jg     .endloop1             ;if end of file?
    mov    ebx,ecx
    pop    edx
    add    edx,4
    jmp    .loop1
    
.endofimage:                     ;set to zero memory at end of page
    mov    ecx,[app_i_end]
    and    ecx,4096-1
    jz     .endloop1
    lea    edi,[ebp+ecx]
    neg    ecx
    add    ecx,4096
    xor    eax,eax
    cld
    rep    stosb
.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
 
    jc     .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
        jc      .cleanfailed
; sanity check - because we will load all file,
; file size must be not greater than memory size
        mov     eax, [esp+8+36]
        cmp     [app_mem], eax
        jb      .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 130	Rev 133
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+TASKDATA.state],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+TASKDATA.state],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 + APPDATA.app_name	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	-
142	jz .cleanfailed	141	jc .cleanfailed
143		142
144	mov eax,[new_process_place]	143	mov eax,[new_process_place]
145	inc ecx ; -0x1E = no memory	144	inc ecx ; -0x1E = no memory
146	call create_app_cr3_table ;create page directory for new process	145	call create_app_cr3_table ;create page directory for new process
147	test eax,eax	146	test eax,eax
148	jz .cleanfailed_mem	147	jz .cleanfailed_mem
149		148
150	call MEM_Get_Linear_Address ;calculate linear address of it	149	call MEM_Get_Linear_Address ;calculate linear address of it
151		150
152	mov ebx,std_application_base_address	151	mov ebx,std_application_base_address
153	mov ecx,[app_mem]	152	mov ecx,[app_mem]
154	add ecx,4095	153	add ecx,4095
155	shr ecx,12	154	shr ecx,12
156	mov edx,eax	155	mov edx,eax
157	call mem_alloc_specified_region ;allocate memory for application	156	call mem_alloc_specified_region ;allocate memory for application
158	test eax,eax	157	test eax,eax
159	mov ecx, -0x1E	158	mov ecx, -0x1E
160	jz .cleanfailed_mem1	159	jz .cleanfailed_mem1
161		160
162	mov eax,[edx+(std_application_base_address shr 20)]	161	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	162	and eax,not (4096-1) ;eax - physical address of first (for application memory) page table
164	call MEM_Get_Linear_Address	163	call MEM_Get_Linear_Address
165	mov edx,eax	164	mov edx,eax
166		165
167	;read file	166	;read file
168	mov ebx,1	167	mov ebx,1
169	mov esi,12 ;length of file name	168	mov esi,12 ;length of file name
170	.loop1:	169	.loop1:
171	;edx = linear address of current page table entry	170	;edx = linear address of current page table entry
172	;ebx = index of current block in file	171	;ebx = index of current block in file
173	push edx	172	push edx
174	mov eax,[edx]	173	mov eax,[edx]
175	and eax,not (4096-1)	174	and eax,not (4096-1)
176	call MEM_Get_Linear_Address	175	call MEM_Get_Linear_Address
177	mov edx,eax ;read file block to current page	176	mov edx,eax ;read file block to current page
178	mov eax,[esp+4] ;restore pointer to file name	177	mov eax,[esp+4] ;restore pointer to file name
179	mov ecx,8 ;number of blocks read	178	mov ecx,8 ;number of blocks read
180	mov ebp,edx ;save buffer address for .endofimage	179	mov ebp,edx ;save buffer address for .endofimage
181	push ebx	180	push ebx
182	mov edi,[esp+16]	181	mov edi,[esp+16]
183	; cli	182	; cli
184	call floppy_fileread	183	call floppy_fileread
185	;ebx=file size	184	;ebx=file size
186	; sti	185	; sti
187	pop ecx	186	pop ecx
188	add ecx,8	187	add ecx,8
189	test eax,eax	188	test eax,eax
190	jnz .endloop1 ;check io errors	189	jnz .endloop1 ;check io errors
191	mov eax,[app_i_end]	190	mov eax,[app_i_end]
192	add eax,511	191	add eax,511
193	shr eax,9	192	shr eax,9
194	cmp ecx,eax	193	cmp ecx,eax
195	jg .endofimage ;we have loaded whole program	194	jg .endofimage ;we have loaded whole program
196	add ebx,511	195	add ebx,511
197	shr ebx,9	196	shr ebx,9
198	cmp ecx,ebx	197	cmp ecx,ebx
199	jg .endloop1 ;if end of file?	198	jg .endloop1 ;if end of file?
200	mov ebx,ecx	199	mov ebx,ecx
201	pop edx	200	pop edx
202	add edx,4	201	add edx,4
203	jmp .loop1	202	jmp .loop1
204		203
205	.endofimage: ;set to zero memory at end of page	204	.endofimage: ;set to zero memory at end of page
206	mov ecx,[app_i_end]	205	mov ecx,[app_i_end]
207	and ecx,4096-1	206	and ecx,4096-1
208	jz .endloop1	207	jz .endloop1
209	lea edi,[ebp+ecx]	208	lea edi,[ebp+ecx]
210	neg ecx	209	neg ecx
211	add ecx,4096	210	add ecx,4096
212	xor eax,eax	211	xor eax,eax
213	cld	212	cld
214	rep stosb	213	rep stosb
215	.endloop1:	214	.endloop1:
216	add esp,8+4 ;pop linear address of page table entry and pointer to file name	215	add esp,8+4 ;pop linear address of page table entry and pointer to file name
217	call new_start_application_fl.add_app_parameters	216	call new_start_application_fl.add_app_parameters
218	mov [esp+28],eax	217	mov [esp+28],eax
219	popad	218	popad
220	ret	219	ret
221		220
222	.cleanfailed_mem1:	221	.cleanfailed_mem1:
223	;there is mem for directory entry, but there is no mem for pages	222	;there is mem for directory entry, but there is no mem for pages
224	;so free directory entry	223	;so free directory entry
225	mov eax,[new_process_place]	224	mov eax,[new_process_place]
226	shl eax,8	225	shl eax,8
227	mov eax,[0x80000+eax+APPDATA.dir_table]	226	mov eax,[0x80000+eax+APPDATA.dir_table]
228	call MEM_Free_Page	227	call MEM_Free_Page
229	.cleanfailed_mem:	228	.cleanfailed_mem:
230	;there is no mem for directory entry, display message.	229	;there is no mem for directory entry, display message.
231	mov esi,start_not_enough_memory	230	mov esi,start_not_enough_memory
232	call sys_msg_board_str	231	call sys_msg_board_str
233	.cleanfailed: ;clean process name	232	.cleanfailed: ;clean process name
234	push ecx ; save error code	233	push ecx ; save error code
235	;can't read file, clean process name.	234	;can't read file, clean process name.
236	;this avoid problems with panel application.	235	;this avoid problems with panel application.
237	mov edi,[new_process_place]	236	mov edi,[new_process_place]
238	shl edi,8	237	shl edi,8
239	add edi,0x80000 + APPDATA.app_name	238	add edi,0x80000 + APPDATA.app_name
240	mov ecx,11	239	mov ecx,11
241	mov eax,' '	240	mov eax,' '
242	cld	241	cld
243	rep stosb	242	rep stosb
244	pop eax	243	pop eax
245	.failed:	244	.failed:
246	;no more slots	245	;no more slots
247	add esp,8+4	246	add esp,8+4
248	mov [application_table_status],0	247	mov [application_table_status],0
249	mov [esp+1Ch], eax	248	mov [esp+1Ch], eax
250	popad	249	popad
251	sti	250	sti
252	ret	251	ret
253		252
254	;-----------------------------------------------------------------------------	253	;-----------------------------------------------------------------------------
255	new_start_application_fl:	254	new_start_application_fl:
256	;input:	255	;input:
257	; eax - pointer to filename	256	; eax - pointer to filename
258	; ebx - parameters to pass	257	; ebx - parameters to pass
259	; edx - flags	258	; edx - flags
260	;result:	259	;result:
261	; eax - pid of new process	260	; eax - pid of new process
262	; or 0 if call fails.	261	; or 0 if call fails.
263	mov [appl_path],edi	262	mov [appl_path],edi
264	mov [appl_path_size],36	263	mov [appl_path_size],36
265	pushad	264	pushad
266	mov esi,new_process_loading	265	mov esi,new_process_loading
267	call sys_msg_board_str ;write to debug board	266	call sys_msg_board_str ;write to debug board
268		267
269	;wait application_table_status mutex	268	;wait application_table_status mutex
270	.table_status:	269	.table_status:
271	cli	270	cli
272	cmp [application_table_status],0	271	cmp [application_table_status],0
273	jz .stf	272	jz .stf
274	sti	273	sti
275	call change_task	274	call change_task
276	jmp .table_status	275	jmp .table_status
277	.stf:	276	.stf:
278	call set_application_table_status	277	call set_application_table_status
279	;we can change system tables now	278	;we can change system tables now
280	push ebx	279	push ebx
281	push eax	280	push eax
282	call find_new_process_place ;find empty process slot	281	call find_new_process_place ;find empty process slot
283	call safe_sti	282	call safe_sti
284	test eax,eax	283	test eax,eax
285	mov ecx, -0x20 ; too many processes	284	mov ecx, -0x20 ; too many processes
286	jz .failed	285	jz .failed
287		286
288	mov edi,eax	287	mov edi,eax
289	shl edi,8	288	shl edi,8
290	add edi,0x80000	289	add edi,0x80000
291	mov ecx,256/4	290	mov ecx,256/4
292	xor eax,eax	291	xor eax,eax
293	cld	292	cld
294	rep stosd ;clean extended information about process	293	rep stosd ;clean extended information about process
295		294
296	;set new process name	295	;set new process name
297	mov eax,[esp] ;eax - pointer to file name	296	mov eax,[esp] ;eax - pointer to file name
298	mov ebx,[new_process_place]	297	mov ebx,[new_process_place]
299	shl ebx,8	298	shl ebx,8
300	add ebx,0x80000 + APPDATA.app_name	299	add ebx,0x80000 + APPDATA.app_name
301	mov ecx,11	300	mov ecx,11
302	call memmove	301	call memmove
303		302
304	;read header of file	303	;read header of file
305	mov ebx,1 ;index of first block	304	mov ebx,1 ;index of first block
306	mov ecx,2 ;number of blocks	305	mov ecx,2 ;number of blocks
307	mov edx,0x90000 ;temp area	306	mov edx,0x90000 ;temp area
308	mov esi,12 ;file name length	307	mov esi,12 ;file name length
309	cli	308	cli
310	call fileread ;read file from RD	309	call fileread ;read file from RD
311	call safe_sti	310	call safe_sti
312	mov ecx, eax	311	mov ecx, eax
313	neg ecx	312	neg ecx
314	jnz .cleanfailed	313	jnz .cleanfailed
315	;check MENUET signature	314	;check MENUET signature
316	mov ecx, -0x1F ; not Menuet/Kolibri executable	315	mov ecx, -0x1F ; not Menuet/Kolibri executable
317	cmp [0x90000],dword 'MENU'	316	cmp [0x90000],dword 'MENU'
318	jnz .cleanfailed	317	jnz .cleanfailed
319	cmp [0x90004],word 'ET'	318	cmp [0x90004],word 'ET'
320	jnz .cleanfailed	319	jnz .cleanfailed
321		320
322	call get_app_params ;parse header fields	321	call get_app_params ;parse header fields
323	test esi,esi	-
324	jz .cleanfailed	322	jc .cleanfailed
325		323
326	mov eax,[new_process_place]	324	mov eax,[new_process_place]
327	inc ecx ; -0x1E = no memory	325	inc ecx ; -0x1E = no memory
328	call create_app_cr3_table ;create page directory for new process	326	call create_app_cr3_table ;create page directory for new process
329	test eax,eax	327	test eax,eax
330	jz .cleanfailed_mem	328	jz .cleanfailed_mem
331		329
332	call MEM_Get_Linear_Address ;calculate linear address of it	330	call MEM_Get_Linear_Address ;calculate linear address of it
333		331
334	mov ebx,std_application_base_address	332	mov ebx,std_application_base_address
335	mov ecx,[app_mem]	333	mov ecx,[app_mem]
336	add ecx,4095	334	add ecx,4095
337	shr ecx,12	335	shr ecx,12
338	mov edx,eax	336	mov edx,eax
339	call mem_alloc_specified_region ;allocate memory for application	337	call mem_alloc_specified_region ;allocate memory for application
340	test eax,eax	338	test eax,eax
341	mov ecx, -0x1E	339	mov ecx, -0x1E
342	jz .cleanfailed_mem1	340	jz .cleanfailed_mem1
343		341
344	mov eax,[edx+(std_application_base_address shr 20)]	342	mov eax,[edx+(std_application_base_address shr 20)]
345	and eax,not (4096-1) ;eax - physical address of first (for application memory) page table	343	and eax,not (4096-1) ;eax - physical address of first (for application memory) page table
346	call MEM_Get_Linear_Address	344	call MEM_Get_Linear_Address
347	mov edx,eax	345	mov edx,eax
348		346
349	;read file	347	;read file
350	mov ebx,1	348	mov ebx,1
351	mov esi,12 ;length of file name	349	mov esi,12 ;length of file name
352	.loop1:	350	.loop1:
353	;edx = linear address of current page table entry	351	;edx = linear address of current page table entry
354	;ebx = index of current block in file	352	;ebx = index of current block in file
355	push edx	353	push edx
356	mov eax,[edx]	354	mov eax,[edx]
357	and eax,not (4096-1)	355	and eax,not (4096-1)
358	call MEM_Get_Linear_Address	356	call MEM_Get_Linear_Address
359	mov edx,eax ;read file block to current page	357	mov edx,eax ;read file block to current page
360	mov eax,[esp+4] ;restore pointer to file name	358	mov eax,[esp+4] ;restore pointer to file name
361	mov ecx,8 ;number of blocks read	359	mov ecx,8 ;number of blocks read
362	mov ebp,edx ;save buffer address for .endofimage	360	mov ebp,edx ;save buffer address for .endofimage
363	push ebx	361	push ebx
364	cli	362	cli
365	call fileread	363	call fileread
366	;ebx=file size	364	;ebx=file size
367	call safe_sti	365	call safe_sti
368	pop ecx	366	pop ecx
369	add ecx,8	367	add ecx,8
370	test eax,eax	368	test eax,eax
371	jnz .endloop1 ;check io errors	369	jnz .endloop1 ;check io errors
372	mov eax,[app_i_end]	370	mov eax,[app_i_end]
373	add eax,511	371	add eax,511
374	shr eax,9	372	shr eax,9
375	cmp ecx,eax	373	cmp ecx,eax
376	jg .endofimage ;we have loaded whole program	374	jg .endofimage ;we have loaded whole program
377	add ebx,511	375	add ebx,511
378	shr ebx,9	376	shr ebx,9
379	cmp ecx,ebx	377	cmp ecx,ebx
380	jg .endloop1 ;if end of file?	378	jg .endloop1 ;if end of file?
381	mov ebx,ecx	379	mov ebx,ecx
382	pop edx	380	pop edx
383	add edx,4	381	add edx,4
384	jmp .loop1	382	jmp .loop1
385		383
386	.endofimage: ;set to zero memory at end of page	384	.endofimage: ;set to zero memory at end of page
387	mov ecx,[app_i_end]	385	mov ecx,[app_i_end]
388	and ecx,4096-1	386	and ecx,4096-1
389	jz .endloop1	387	jz .endloop1
390	lea edi,[ebp+ecx]	388	lea edi,[ebp+ecx]
391	neg ecx	389	neg ecx
392	add ecx,4096	390	add ecx,4096
393	xor eax,eax	391	xor eax,eax
394	cld	392	cld
395	rep stosb	393	rep stosb
396	.endloop1:	394	.endloop1:
397	add esp,8 ;pop linear address of page table entry and pointer to file name	395	add esp,8 ;pop linear address of page table entry and pointer to file name
398	call .add_app_parameters	396	call .add_app_parameters
399	mov [esp+28],eax	397	mov [esp+28],eax
400	popad	398	popad
401	ret	399	ret
402		400
403	.cleanfailed_mem1:	401	.cleanfailed_mem1:
404	;there is mem for directory entry, but there is no mem for pages	402	;there is mem for directory entry, but there is no mem for pages
405	;so free directory entry	403	;so free directory entry
406	mov eax,[new_process_place]	404	mov eax,[new_process_place]
407	shl eax,8	405	shl eax,8
408	mov eax,[0x80000+eax+APPDATA.dir_table]	406	mov eax,[0x80000+eax+APPDATA.dir_table]
409	call MEM_Free_Page	407	call MEM_Free_Page
410	.cleanfailed_mem:	408	.cleanfailed_mem:
411	;there is no mem for directory entry, display message.	409	;there is no mem for directory entry, display message.
412	mov esi,start_not_enough_memory	410	mov esi,start_not_enough_memory
413	call sys_msg_board_str	411	call sys_msg_board_str
414	.cleanfailed: ;clean process name	412	.cleanfailed: ;clean process name
415	push ecx ; save error code	413	push ecx ; save error code
416	;can't read file, clean process name.	414	;can't read file, clean process name.
417	;this avoid problems with panel application.	415	;this avoid problems with panel application.
418	mov edi,[new_process_place]	416	mov edi,[new_process_place]
419	shl edi,8	417	shl edi,8
420	add edi,0x80000+APPDATA.app_name	418	add edi,0x80000+APPDATA.app_name
421	mov ecx,11	419	mov ecx,11
422	mov eax,' '	420	mov eax,' '
423	cld	421	cld
424	rep stosb	422	rep stosb
425	pop eax	423	pop eax
426	.failed:	424	.failed:
427	;no more slots	425	;no more slots
428	add esp,8	426	add esp,8
429	mov [application_table_status],0	427	mov [application_table_status],0
430	mov [esp+1Ch], eax	428	mov [esp+1Ch], eax
431	popad	429	popad
432	call safe_sti	430	call safe_sti
433	ret	431	ret
434		432
435	.add_app_parameters:	433	.add_app_parameters:
436	;input:	434	;input:
437	; [esp] - pointer to parameters	435	; [esp] - pointer to parameters
438	; [esp+4]-[esp+36] pushad registers.	436	; [esp+4]-[esp+36] pushad registers.
439	;result	437	;result
440	; eax - pid of new process	438	; eax - pid of new process
441	; or zero if failed	439	; or zero if failed
442	cli	440	cli
443	mov ebx,[new_process_place]	441	mov ebx,[new_process_place]
444	cmp ebx,[0x3004]	442	cmp ebx,[0x3004]
445	jle .noinc	443	jle .noinc
446	inc dword [0x3004] ;update number of processes	444	inc dword [0x3004] ;update number of processes
447	.noinc:	445	.noinc:
448		446
449	; mov ebx,[new_process_place]	447	; mov ebx,[new_process_place]
450	;set 0x8c field of extended information about process	448	;set 0x8c field of extended information about process
451	;(size of application memory)	449	;(size of application memory)
452	shl ebx,8	450	shl ebx,8
453	mov eax,[app_mem]	451	mov eax,[app_mem]
454	mov [second_base_address+0x80000+APPDATA.mem_size+ebx],eax	452	mov [second_base_address+0x80000+APPDATA.mem_size+ebx],eax
455	;set 0x10 field of information about process	453	;set 0x10 field of information about process
456	;(application base address)	454	;(application base address)
457	; mov ebx,[new_process_place]	455	; mov ebx,[new_process_place]
458	; shl ebx,5	456	; shl ebx,5
459	shr ebx,3	457	shr ebx,3
460	mov dword [second_base_address+0x3000+ebx+TASKDATA.mem_start],std_application_base_address	458	mov dword [second_base_address+0x3000+ebx+TASKDATA.mem_start],std_application_base_address
461		459
462	;add command line parameters	460	;add command line parameters
463	.add_command_line:	461	.add_command_line:
464	mov edx,[app_i_param]	462	mov edx,[app_i_param]
465	test edx,edx	463	test edx,edx
466	jz .no_command_line ;application don't need parameters	464	jz .no_command_line ;application don't need parameters
467	mov eax,[esp+4]	465	mov eax,[esp+4]
468	test eax,eax	466	test eax,eax
469	jz .no_command_line ;no parameters specified	467	jz .no_command_line ;no parameters specified
470	;calculate parameter length	468	;calculate parameter length
471	mov esi,eax	469	mov esi,eax
472	xor ecx,ecx	470	xor ecx,ecx
473	.command_line_len:	471	.command_line_len:
474	cmp byte [esi],0	472	cmp byte [esi],0
475	jz .command_line_len_end	473	jz .command_line_len_end
476	inc esi	474	inc esi
477	inc ecx	475	inc ecx
478	cmp ecx,256	476	cmp ecx,256
479	jl .command_line_len	477	jl .command_line_len
480		478
481	.command_line_len_end:	479	.command_line_len_end:
482	;ecx - parameter length	480	;ecx - parameter length
483	;edx - address of parameters in new process address space	481	;edx - address of parameters in new process address space
484	mov ebx,eax ;ebx - address of parameters in our address space	482	mov ebx,eax ;ebx - address of parameters in our address space
485	mov eax,[new_process_place]	483	mov eax,[new_process_place]
486	call write_process_memory ;copy parameters to new process address space	484	call write_process_memory ;copy parameters to new process address space
487		485
488	.no_command_line:	486	.no_command_line:
489	;******************************************************************	487	;******************************************************************
490	mov edx,[app_i_icon]	488	mov edx,[app_i_icon]
491	test edx,edx	489	test edx,edx
492	jz .no_command_line_1 ;application don't need path of file	490	jz .no_command_line_1 ;application don't need path of file
493	mov ebx,[appl_path]	491	mov ebx,[appl_path]
494	mov ecx,[appl_path_size]	492	mov ecx,[appl_path_size]
495	mov eax,[new_process_place]	493	mov eax,[new_process_place]
496	call write_process_memory ;copy path of file to new process address space	494	call write_process_memory ;copy path of file to new process address space
497	.no_command_line_1:	495	.no_command_line_1:
498	;******************************************************************	496	;******************************************************************
499	mov ebx,[new_process_place]	497	mov ebx,[new_process_place]
500	mov eax,ebx	498	mov eax,ebx

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/newproce.inc – Rev 130 → 133