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+0xa],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+0xa],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
;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
    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
    xor    eax,eax
    mov    [appl_path_size],eax
    mov    eax,[esp]  ;+8]
.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
    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
    cmp    eax,0
    jne    .cleanfailed
;check MENUET signature    
    cmp    [0x90000],dword 'MENU'
    jnz    .cleanfailed
    cmp    [0x90004],word 'ET'
    jnz    .cleanfailed
    
    call   get_app_params        ;parse header fields
    cmp    esi,0
    jz     .cleanfailed
    
    mov    eax,[new_process_place]
    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
    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+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:                    ;clean process name
;can't read file, clean process name. 
;this avoid problems with panel application.
    mov    edi,[new_process_place]
    shl    edi,8
    add    edi,0x80000
    mov    ecx,11
    mov    eax,' '
    cld
    rep    stosb
.failed:
;no more slots
    add    esp,8+4
    mov    [application_table_status],0
    popad
    sti
    mov    eax,-1
    ret  
 
;-----------------------------------------------------------------------------    
new_start_application_fl:
;input:
;  eax - pointer to filename
;  ebx - parameters to pass
;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
    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
    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
    cmp    eax,0
    jne    .cleanfailed
;check MENUET signature    
    cmp    [0x90000],dword 'MENU'
    jnz    .cleanfailed
    cmp    [0x90004],word 'ET'
    jnz    .cleanfailed
    
    call   get_app_params        ;parse header fields
    cmp    esi,0
    jz     .failed
    
    mov    eax,[new_process_place]
    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
    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+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:                    ;clean process name
;can't read file, clean process name. 
;this avoid problems with panel application.
    mov    edi,[new_process_place]
    shl    edi,8
    add    edi,0x80000
    mov    ecx,11
    mov    eax,' '
    cld
    rep    stosb
.failed:
;no more slots
    add    esp,8
    mov    [application_table_status],0
    popad
    call   safe_sti
    mov    eax,-1
    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+0x8c+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+0x10],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+0xe],al          ;set window number on screen = process slot
    
    mov    [ebx],dword 1+2+4     ;set default event flags (see 40 function)
    
    inc    dword [process_number]
    mov    eax,[process_number]
    mov    [ebx+4],eax           ;set PID
    
    mov    ecx,ebx
    add    ecx,draw_data-0x3000  ;ecx - pointer to draw data
;set draw data to full screen    
    mov    [ecx+0],dword 0       
    mov    [ecx+4],dword 0
    mov    eax,[0xfe00]
    mov    [ecx+8],eax
    mov    eax,[0xfe04]
    mov    [ecx+12],eax
;set cr3 register in TSS of application    
    mov    ecx,[new_process_place]     
    shl    ecx,8
    mov    eax,[0x800B8+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
    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
    mov    [0x3000+ebx+0xa],byte 0 ;set process state - running
    
    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
    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
    mov    ebx,esi               ;ebx=esi - pointer to extended information about current thread
    
    mov    edi,[new_process_place]
    shl    edi,8
    add    edi,0x80000
    mov    edx,edi               ;edx=edi - pointer to extended infomation about new thread
    mov    ecx,256/4
    rep    stosd                 ;clean extended information about new thread
    mov    edi,edx
    mov    ecx,11
    rep    movsb                 ;copy process name
    mov    eax,[ebx+0x8c]
    mov    [app_mem],eax         ;set memory size
    mov    eax,[ebx+0xb8]
    mov    [edx+0xb8],eax        ;copy page directory
;    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,[0x8008C+ecx]     
    add    edx,4095
    and    edx,not (4096-1)      ;old size
    mov    eax,[0x800B8+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+0x8008c],ebx     ;write new memory size
;search threads and update 
;application memory size infomation    
    mov    ecx,[eax+0x800b8] 
    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+0xa],9 ;if slot empty?
    jz     .search_threads_next
    shl    edx,3
    cmp    [edx+0x800b8],ecx     ;if it is our thread?
    jnz    .search_threads_next
    mov    [edx+0x8008c],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+0xa],9
    jz     .endloop              ;skip empty slots
    cmp    [second_base_address+0x3000+ecx+0x4],eax ;check PID
    jz     .pid_found
.endloop:
    add    ecx,32
    cmp    ecx,ebx
    jle    .loop
    
    pop    ecx
    pop    ebx
    xor    eax,eax
    ret
    
.pid_found:
    shr    ecx,5
    mov    eax,ecx               ;convert offset to index of slot
    pop    ecx
    pop    ebx
    ret
;-----------------------------------------------------------------------------    
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+0xB8]
    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+0xB8]
    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+0xa],0
    jnz  .failed
    shl  eax,3
    mov  eax,[0x80000+eax+0xb8]
    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+0xA0],ebx          ;set fields in extended information area
    mov  [edi+0xA4],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+0xa0]  ;is ipc area defined?
    test edi,edi
    jz   .no_ipc_area
    mov  esi,[eax+0x80000+0xa4]  ;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+0x4]           ;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+0x800A8],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)
;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
    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
    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
    test   eax,eax
    jnz    .cleanfailed
 
    mov    esi,[esp]
;check menuet signature    
    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
    test   esi,esi
    jz     .cleanfailed
    
    mov    eax,[new_process_place]
    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
    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+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:                    ;clean process name
;can't read file, clean process name. 
;this avoid problems with panel application.
    mov    edi,[new_process_place]
    shl    edi,8
    add    edi,0x80000
    mov    ecx,11
    mov    eax,' '
    cld
    rep    stosb    
.failed:
;no more slots
    add    esp,16
    popad   
    mov    eax,-1
    mov    [application_table_status],0
    sti
    ret
end if
>

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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/newproce.inc – Rev 5 → 9