0,0 → 1,1321 |
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 |
;----------------------------------------------------------------------------- |
|
new_start_application_floppy: |
;input: |
; eax - pointer to filename |
; ebx - parameters to pass |
;result: |
; eax - pid of new process |
; or 0 if call fails. |
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 |
mov eax,[esp+8] |
.find_last_byte: |
cmp byte [eax],0 |
jz .find_last_byte_end |
inc eax |
jmp .find_last_byte |
.find_last_byte_end: |
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_mem |
|
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_mem: |
mov esi,start_not_enough_memory |
call sys_msg_board_str |
.cleanfailed: ;clean process name |
mov edi,[new_process_place] |
shl edi,8 |
add edi,0x80000 |
mov ecx,11 |
mov eax,' ' |
cld |
rep stosb |
.failed: |
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. |
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 |
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 |
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_mem |
|
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 |
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_mem: |
mov esi,start_not_enough_memory |
call sys_msg_board_str |
.cleanfailed: ;clean process name |
mov edi,[new_process_place] |
shl edi,8 |
add edi,0x80000 |
mov ecx,11 |
mov eax,' ' |
cld |
rep stosb |
.failed: |
add esp,8 |
mov [application_table_status],0 |
popad |
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 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 |
;write cr3 in TSS of System Call Handler |
mov ecx,[new_process_place] |
shl ecx,7 |
mov [0x298000+ecx+l.cr3-tss_sceleton],eax ;write directy to TSS |
|
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 [l.esp0],0x55000 |
; mov [l.esp1],0x56000 |
; mov [l.esp2],0x57000 |
|
;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 |
|
;set code and data segments |
mov eax,[new_process_place] |
shl eax,3 |
;set base address of code segment |
mov word [eax+gdts+app_code-3+2],0 |
mov byte [eax+gdts+app_code-3+4],0 |
mov byte [eax+gdts+app_code-3+7],std_application_base_address shr 24 |
;set limit of code segment |
; mov ebx,[app_mem] |
; add ebx,4095 |
; shr ebx,12 |
mov ebx,(0x80000000-std_application_base_address) shr 12 |
mov [eax+gdts+app_code-3+0],bx |
mov [eax+gdts+app_code-3+5],word 11010000b*256+11111010b+256*((0x80000000-std_application_base_address) shr 28) |
;set base address of data segment |
mov word [eax+gdts+app_data-3+2],0 |
mov byte [eax+gdts+app_data-3+4],0 |
mov byte [eax+gdts+app_data-3+7],std_application_base_address shr 24 |
;set limit of data segment |
mov [eax+gdts+app_data-3+0],bx |
mov [eax+gdts+app_data-3+5],word 11010000b*256+11110010b+256*((0x80000000-std_application_base_address) shr 28) |
|
|
;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 |
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 |
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 |
mov eax,[esp+4] |
.find_last_byte: |
cmp byte [eax],0 |
jz .find_last_byte_end |
inc eax |
jmp .find_last_byte |
.find_last_byte_end: |
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_mem |
|
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_mem: |
mov esi,start_not_enough_memory |
call sys_msg_board_str |
.cleanfailed: ;clean process name |
mov edi,[new_process_place] |
shl edi,8 |
add edi,0x80000 |
mov ecx,11 |
mov eax,' ' |
cld |
rep stosb |
.failed: |
add esp,16 |
popad |
mov eax,-1 |
mov [application_table_status],0 |
sti |
ret |
end if |