Subversion Repositories Kolibri OS

{ .banner      dq ?

  .version     dd ?    ;+8

  .start       dd ?    ;+12

  .i_end       dd ?    ;+16

  .mem_size    dd ?    ;+20

  .i_param     dd ?    ;+24

}

{ .banner      dq ?

  .version     dd ?    ;+8

  .start       dd ?    ;+12

  .i_end       dd ?    ;+16

  .mem_size    dd ?    ;+20

  .stack_top   dd ?    ;+24

  .i_param     dd ?    ;+28

  .i_icon      dd ?    ;+32

}

proc test_app_header stdcall, header:dword

           virtual at ebx

             APP_HEADER_00 APP_HEADER_00

           end virtual

           cmp [ebx+6], word '00'

           jne  .check_01_header

           mov  [app_start],eax

           mov  eax,[APP_HEADER_00.i_end]

           mov  [app_i_end],eax

           mov  eax,[APP_HEADER_00.mem_size]

           mov  [app_mem],eax

           shr  eax,1

           sub  eax,0x10

           mov  [app_esp],eax

           mov  eax,[APP_HEADER_00.i_param]

           mov  [app_i_param],eax

           mov  [app_i_icon],dword 0

           ret

           virtual at ebx

             APP_HEADER_01 APP_HEADER_01

           end virtual

           jne  .no_01_header

           mov  [app_start],eax

           mov  eax,[APP_HEADER_01.i_end]

           mov  [app_i_end],eax

           mov  eax,[APP_HEADER_01.mem_size]

           mov  [app_mem],eax

           mov  eax,[APP_HEADER_01.stack_top]

           mov  [app_esp],eax

           mov  eax,[APP_HEADER_01.i_param]

           mov  [app_i_param],eax

           mov  eax,[APP_HEADER_01.i_icon]

           mov  [app_i_icon],eax

           ret

           ret

endp

proc get_new_process_place

;input:

;  none

;result:

;  eax=[new_process_place]<>0 - ok

;      0 - failed.

;This function find least empty slot.

;It doesn't increase [TASK_COUNT]!

           mov    eax,CURRENT_TASK

           mov    ebx,[TASK_COUNT]

           inc    ebx

           shl    ebx,5

           add    ebx,eax               ;ebx - address of process information for (last+1) slot

.newprocessplace:

;eax = address of process information for current slot

           cmp    eax,ebx

           jz     .endnewprocessplace   ;empty slot after high boundary

           add    eax,0x20

           cmp    word [eax+0xa],9      ;check process state, 9 means that process slot is empty

           jnz    .newprocessplace

.endnewprocessplace:

           mov    ebx,eax

           sub    eax,CURRENT_TASK

           shr    eax,5                 ;calculate slot index

           cmp    eax,256

           jge    .failed               ;it should be <256

           mov    word [ebx+0xa],9      ;set process state to 9 (for slot after hight boundary)

        ;   mov [new_process_place], eax

           ret

           xor    eax,eax

           ret

endp

proc create_app_space stdcall, app_size:dword,img_size:dword

           locals

             app_pages   dd ?

             img_pages   dd ?

             dir_addr    dd ?

             master_addr dd ?

             app_tabs    dd ?

           endl

           mov [dir_addr], eax

           mov [master_addr], eax

           add eax, 4095+4096

           and eax, NOT(4095)

           mov [app_size], eax

           mov ebx, eax

           shr eax, 12

           mov [app_pages], eax

           add ebx, 0x3FFFFF

           and ebx, NOT(0x3FFFFF)

           shr ebx, 22

           mov [app_tabs], ebx

           add eax, 4095

           and eax, NOT(4095)

           shr eax, 12

           mov [img_pages], eax

           test eax, eax

           jz .fail

           mov [dir_addr], eax

           stdcall map_page,[tmp_task_pdir],eax,dword PG_SW

           mov edi, [tmp_task_pdir]

           mov ecx, 384

           cld

           rep movsd

           xor eax, eax

           cld

           rep stosd

           mov esi, sys_pgdir+0xc00

           rep movsd

           test eax, eax

           jz .fail

           mov [master_addr], eax

           stdcall map_page,[tmp_task_ptab],eax,dword PG_SW

           mov edi, [tmp_task_ptab]

           mov esi, master_tab

           cld

           rep movsd

           xor eax, eax

           rep stosd

           mov esi, master_tab+0xc00

           rep movsd

           or eax, PG_SW

           mov ebx, [tmp_task_pdir]

           mov [ebx+0x600], eax

           mov ecx, [tmp_task_ptab]

           mov [ecx+0x600],eax

           call set_cr3

           mov edi, new_app_base

@@:

           call alloc_page

           test eax, eax

           jz .fail

           add edi, 0x00400000

           dec edx

           jnz @B

           shr edi, 10

           add edi, pages_tab

           mov ecx, [app_tabs]

           shl ecx, 10

           xor eax, eax

           rep stosd

           call alloc_page

           test eax, eax

           jz .fail

           add edx, 0x1000

           sub [app_pages], 1

           sub [img_pages], 1

           jnz .alloc

           and ecx, ecx

           jz .next

           shr edx, 12

.reserve:

           mov dword [pages_tab+edx*4], 0x02

           invlpg [ebx]

           inc edx

           dec ecx

           jnz .reserve

.next:

           mov edi, new_app_base

           mov ecx, [img_size]

           shr ecx, 2

           xor eax, eax

           cld

           rep stosd

           stdcall map_page,[tmp_task_pdir],dword 0,dword PG_UNMAP

           mov eax, [dir_addr]

           ret

.fail:

           dec [pg_data.pg_mutex]

           cmp [dir_addr], 0

           jz @f

           stdcall destroy_app_space, [dir_addr]

@@:

           xor eax, eax

           ret

endp

set_cr3:

           mov esi, [CURRENT_TASK]

           mov ebx, esi

           shl esi,8

           mov [PROC_BASE+esi+0xB8],eax

           imul   ebx,tss_step

           add    ebx,tss_data

           mov [ebx+28], eax

           mov cr3, eax

           ret

proc destroy_page_table stdcall, pg_tab:dword

           mov ecx, 1024

.free:

           mov eax, [esi]

           test eax, 1

           jz .next

           call free_page

.next:

           add esi, 4

           dec ecx

           jnz .free

           pop esi

           ret

endp

proc destroy_app_space stdcall, pg_dir:dword

           mov   eax,0x2

           mov ebx, [pg_dir]

;eax = current slot of process

           mov   ecx,eax

           shl   ecx,5

           cmp   byte [CURRENT_TASK+ecx+0xa],9  ;if process running?

           jz    @f                              ;skip empty slots

           shl   ecx,3

           cmp   [PROC_BASE+ecx+0xB8],ebx       ;compare page directory addresses

           jnz   @f

           inc   edx                            ;thread found

@@:

           inc   eax

           cmp   eax,[TASK_COUNT]               ;exit loop if we look through all processes

           jle   .loop

;our process is zombi so it isn't counted

           cmp   edx,1

           jg    .exit

;if there isn't threads then clear memory.

           and eax, not 0xFFF

           stdcall map_page,[tmp_task_pdir],eax,dword PG_SW

           mov esi, [tmp_task_pdir]

           add esi, 0x600

           mov eax, [esi]

           call free_page   ;destroy master table

           add esi, 4

           mov edi, 383

.destroy:

           mov eax, [esi]

           test eax, 1

           jz .next

           and eax, not 0xFFF

           stdcall map_page,[tmp_task_ptab],eax,dword PG_SW

           stdcall destroy_page_table, [tmp_task_ptab]

           mov eax, [esi]

           call free_page

.next:

           add esi, 4

           dec edi

           jnz .destroy

           call free_page

.exit:

           stdcall map_page,[tmp_task_ptab],dword 0,dword PG_UNMAP

           stdcall map_page,[tmp_task_pdir],dword 0,dword PG_UNMAP

           dec [pg_data.pg_mutex]

           ret

endp

proc fs_execute

; edx - flags

; ebp - full filename

; [esp+4] = procedure DoRead, [esp+8] = filesize & [esp+12]... - arguments for it

             cmdline    dd ?

             flags      dd ?

             filename   dd ?

             retval     dd ?

           endl

           mov [flags], edx

           mov eax, [ebp]

           mov [filename], eax

           mov ecx, (2048+256)/4

           xor eax, eax

           rep stosd

           mov edi, [tmp_task_data]

           add edi, TMP_FILE_NAME

           mov ecx, 1024

           rep movsb

           mov edi, [tmp_task_data]

           add edi, TMP_ICON_OFFS

           mov ecx, 1024

           rep movsb

           test esi, esi

           jz @f

           mov edi, [tmp_task_data]

           add edi, TMP_CMD_LINE

           mov ecx, 256

           rep movsb

@@:

           mov eax, TMP_FILE_NAME

           add eax, [tmp_task_data]

           mov ebx, [tmp_task_data]    ;cmd line

           add ebx, TMP_CMD_LINE

                            [ebp+12], [ebp+16],[ebp+20]

           mov [retval], eax

           popad

           mov [pg_data.tmp_task_mutex], 0

           mov eax, [retval]

           ret

proc fs_exec stdcall file_name:dword, cmd_line:dword, flags:dword,\

                       fn_read:dword, file_size:dword,\

                       cluster:dword, some_data:dword

             slot          dd ?

             app_path_size dd ?

             save_cr3      dd ?

             img_size      dd ?

           endl

           mov ecx, 1024

           xor eax, eax

           repnz scasb

           jz @f

           mov     eax, -ERROR_FILE_NOT_FOUND

           ret

@@:

           sub edi, [file_name]

           mov [app_path_size], edi

           call sys_msg_board_str       ; write message to message board

           cli

           cmp [application_table_status],0

           je .get_lock

           call   change_task

           jmp .wait_lock

           mov eax, 1

           xchg eax, [application_table_status]

           cmp eax, 0

           jne .wait_lock

           test eax, eax

           mov ecx, -0x20      ; too many processes

           jz .err

           mov [slot], eax

           shl    edi,8

           add    edi,PROC_BASE

           mov    ecx,256/4

           xor    eax,eax

           cld

           rep    stosd              ;clean extended information about process

           mov ecx, [app_path_size]

           add edi, ecx

           dec edi

           std

           mov al, '/'

           repnz scasb

           cld

           jnz @f

           inc edi

@@:

           inc edi

; now edi points to name without path

           mov ecx, 8  ; 8 chars for name

           mov edi, [slot]

           shl edi, cl

           add edi, PROC_BASE

.copy_process_name_loop:

           lodsb

           cmp al, '.'

           jz .copy_process_name_done

           test al, al

           jz .copy_process_name_done

           stosb

           loop .copy_process_name_loop

.copy_process_name_done:

           mov al, ' '

           rep stosb

           pop eax

           mov cl, 3   ; 3 chars for extension

           dec esi

@@:

           dec eax

           cmp eax, esi

           jbe .copy_process_ext_done

           cmp byte [eax], '.'

           jnz @b

           lea esi, [eax+1]

.copy_process_ext_loop:

           lodsb

           test al, al

           jz  .copy_process_ext_done

           stosb

           loop .copy_process_ext_loop

.copy_process_ext_done:

           mov al, ' '

           rep stosb

           mov  edi, TMP_BUFF

           call [fn_read]

           test eax, eax

           jnz .err

;check MENUET signature

           cmp    [TMP_BUFF],dword 'MENU'

           jnz    .err

           cmp    [TMP_BUFF+4],word 'ET'

           jnz    .err

           test eax, eax

           jz .err

           mov [save_cr3], eax

           stdcall create_app_space,[app_mem], [app_mem];[file_size]

           test eax, eax

           jz .failed

           shl   ebx,8

           mov   [PROC_BASE+ebx+0xB8],eax

           mov edi, new_app_base

           mov ecx, 512/4

           cld

           rep movsd

@@:

           lea  eax, [file_size]

           cmp dword [eax], 0

           jz .done

           push edi

           call [fn_read]

           pop edi

           add edi, 512

           test eax, eax

           jz  @b

           cmp ebx, 6

           jne .failed

.done:

           stdcall add_app_parameters, [slot], new_app_base,\

                                       [cmd_line],[file_name],[flags]

           call set_cr3

           mov    [application_table_status],eax ;unlock application_table_status mutex

           popfd

           mov    eax,[process_number]  ;set result

           ret

           mov eax, [save_cr3]

           call set_cr3

.err:

           xor eax, eax

           mov [application_table_status],eax

           ret

endp

proc add_app_parameters stdcall,slot:dword,img_base:dword,\

                        cmd_line:dword, app_path:dword, flags:dword

           bt [cpu_caps], CAPS_SSE

           jnc .no_SSE

           shl eax, 8

           mov ebx, eax

           add eax, eax

           add eax, [fpu_data]

           mov [ebx+PROC_BASE+APPDATA.fpu_state], eax

           mov [ebx+PROC_BASE+APPDATA.fpu_handler], 0

           mov [ebx+PROC_BASE+APPDATA.sse_handler], 0

           jmp .m1

.no_SSE:

           mov ecx, eax

           mov ebx, eax

           shl eax, 7

           shl ebx, 4

           sub eax, ebx       ;eax*=112

           add eax, [fpu_data]

           shl ecx, 8

           mov [ecx+PROC_BASE+APPDATA.fpu_state], eax

           mov [ecx+PROC_BASE+APPDATA.fpu_handler], 0

           mov [ecx+PROC_BASE+APPDATA.sse_handler], 0

.m1:

           mov    ebx,[slot]

           cmp    ebx,[TASK_COUNT]

           jle    .noinc

           inc    dword [TASK_COUNT]       ;update number of processes

.noinc:

           shl    ebx,8

           mov    eax,[app_mem]

           mov    [PROC_BASE+0x8c+ebx],eax

           mov eax, new_app_base

           mov    dword [CURRENT_TASK+ebx+0x10],eax

           mov    edx,[app_i_param]

           test   edx,edx

           jz     .no_command_line      ;application don't need parameters

           mov    eax,[cmd_line]

           test   eax,eax

           jz     .no_command_line      ;no parameters specified

;calculate parameter length

           xor    ecx,ecx

.command_line_len:

           cmp    byte [eax],0

           jz     .command_line_len_end

           inc    eax

           inc    ecx

           cmp    ecx,255

           jl     .command_line_len

;ecx - parameter length

;edx - address of parameters in new process address space

           inc ecx

           mov edi, [img_base]

           add edi, edx

           mov esi, [cmd_line]

           rep movsb

            test   edx,edx

            jz     .no_command_line_1      ;application don't need path of file

            mov    esi,[app_path]

            test esi, esi

            jz     .no_command_line_1      ;application don't need path of file

            mov    ecx, 64

            mov    edi, [img_base]

            add edi, edx

            rep movsb

           mov    ebx,[slot]

           mov    eax,ebx

           shl    ebx,5

           add    ebx,CURRENT_TASK            ;ebx - pointer to information about process

           mov    [ebx+0xe],al          ;set window number on screen = process slot

           mov    eax,[process_number]

           mov    [ebx+4],eax           ;set PID

           add    ecx,(draw_data-CURRENT_TASK)  ;ecx - pointer to draw data

;set draw data to full screen

           mov    [ecx+4],dword 0

           mov    eax,[SCR_X_SIZE]

           mov    [ecx+8],eax

           mov    eax,[SCR_Y_SIZE]

           mov    [ecx+12],eax

;set window state to 'normal' (non-minimized/maximized/rolled-up) state

           mov    [ecx+WDATA.fl_wstate],WSTATE_NORMAL

;set cr3 register in TSS of application

           shl    ecx,8

           mov    eax,[PROC_BASE+0xB8+ecx]

           ;or     eax,  PG_NOCACHE

           mov    [l.cr3],eax

           mov    [l.eip],eax           ;set eip in TSS

           mov    eax,[app_esp]

           mov    [l.esp],eax           ;set stack in TSS

           mov    ax,app_code           ;ax - selector of code segment

           mov    [l.cs],ax

           mov    ax,app_data

           mov    [l.ss],ax

           mov    [l.ds],ax

           mov    [l.es],ax

           mov    [l.fs],ax

           mov    ax,graph_data         ;ax - selector of graphic segment

           mov    [l.gs],ax

           mov    [l.io],word 128

           mov    [l.eflags],dword 0x3202

           mov    ebx,[slot]

           shl    ebx,12

           add    ebx,sysint_stack_data+4096

           mov    [l.esp0],ebx

           mov    eax,tss_sceleton

           mov    ebx,[slot]

           imul   ebx,tss_step

           add    ebx,tss_data          ;ebx - address of application TSS

           mov    ecx,120

           call   memmove

           or     eax,-1

           mov    edi,[slot]

           imul   edi,tss_step

           add    edi,tss_data+128

           mov    ecx,2048

           cld

           rep    stosd                 ;full access to 2048*8=16384 ports

           mov    edi,[slot]

           shl    edi,3

;set TSS descriptor

           mov    [edi+gdts+tss0+0],word tss_step ;limit (size)

           mov    [edi+gdts+tss0+2],cx  ;part of offset

           mov    eax,ecx

           shr    eax,16

           mov    [edi+gdts+tss0+4],al  ;part of offset

           mov    [edi+gdts+tss0+7],ah  ;part of offset

           mov    [edi+gdts+tss0+5],word 01010000b*256+11101001b ;system flags

           mov    [KEY_COUNT],byte 0

           mov    [BTN_COUNT],byte 0

           shl    edi,5

           add    edi,window_data

           mov    ebx,[slot]

           movzx  esi,word [WIN_STACK+ebx*2]

           lea    esi,[WIN_POS+esi*2]

           call   windowactivate        ;gui initialization

           shl    ebx,5

           mov    [CURRENT_TASK+ebx+0xa],byte 0 ;set process state - running

; set if debuggee

           mov eax, [flags]

           test   byte [flags], 1

           jz     .no_debug

           mov    [CURRENT_TASK+ebx+0xa],byte 1 ;set process state - suspended

           mov    eax,[CURRENT_TASK]

           mov    [PROC_BASE+ebx*8+0xac],eax ;set debugger PID - current

.no_debug:

           call   sys_msg_board_str     ;output information about succefull startup

endp

;Input:

;  eax - pid of process

;Output:

;  eax - slot of process or 0 if process don't exists

;Search process by PID.

    push   ebx

    push   ecx

    mov    ebx,[TASK_COUNT]

    shl    ebx,5

    mov    ecx,2*32

;ecx=offset of current process info entry

;ebx=maximum permitted offset

    cmp    byte [CURRENT_TASK+ecx+0xa],9

    jz     .endloop              ;skip empty slots

    cmp    [CURRENT_TASK+ecx+0x4],eax ;check PID

    jz     .pid_found

.endloop:

    add    ecx,32

    cmp    ecx,ebx

    jle    .loop

    pop    ebx

    xor    eax,eax

    ret

    shr    ecx,5

    mov    eax,ecx               ;convert offset to index of slot

    pop    ecx

    pop    ebx

    ret

;input:

;  ebx - start of buffer

;  ecx - size of buffer

;result:

;  eax = 1 region lays in app memory

;  eax = 0 region don't lays in app memory

     mov  eax,[CURRENT_TASK]

     jmp  check_process_region

;-----------------------------------------------------------------------------

check_process_region:

;input:

;  eax - slot

;  ebx - start of buffer

;  ecx - size of buffer

;result:

;  eax = 1 region lays in app memory

;  eax = 0 region don't lays in app memory

     jle  .ok

     shl  eax,5

     cmp  word [CURRENT_TASK+eax+0xa],0

     jnz  .failed

     shl  eax,3

     mov  eax,[PROC_BASE+eax+0xb8]

     test eax,eax

     jz   .failed

     ret

;    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

proc read_process_memory

;Input:

;  eax - process slot

;  ebx - buffer address

;  ecx - buffer size

;  edx - start address in other process

;Output:

;  eax - number of bytes read.

           locals

             slot       dd ?

             buff       dd ?

             r_count    dd ?

             offset     dd ?

             tmp_r_cnt  dd ?

           endl

           mov [buff], ebx

           mov [r_count], ecx

           mov [tmp_r_cnt], ecx

           mov [offset], edx

.read_mem:

           mov edx, [offset]

           mov ebx, [tmp_r_cnt]

           and edx, 0x3FFFFF

           sub ecx, edx

           cmp ecx, ebx

           jbe @f

           mov ecx, ebx

@@:

           cmp ecx, 0x8000

           jna @F

           mov ecx, 0x8000

@@:

           mov eax, [slot]

           shl  eax,8

           mov ebx, [offset]

           add ebx, new_app_base

           push ecx

           stdcall map_memEx, [proc_mem_map],\

                              [PROC_BASE+eax+0xB8],\

                              ebx, ecx

           pop ecx

           and esi, 0xfff

           add esi, [proc_mem_map]

           mov edi, [buff]

           mov edx, ecx

           rep movsb

           sub [tmp_r_cnt], edx

           jnz .read_mem

           mov eax, [r_count]

           ret

proc write_process_memory

;Input:

;  eax - process slot

;  ebx - buffer address

;  ecx - buffer size

;  edx - start address in other process

;Output:

;  eax - number of bytes written

             slot       dd ?

             buff       dd ?

             w_count    dd ?

             offset     dd ?

             tmp_w_cnt  dd ?

           endl

           mov [buff], ebx

           mov [w_count], ecx

           mov [tmp_w_cnt], ecx

           mov [offset], edx

.read_mem:

           mov edx, [offset]

           mov ebx, [tmp_w_cnt]

           and edx, 0x3FFFFF

           sub ecx, edx

           cmp ecx, ebx

           jbe @f

           mov ecx, ebx

@@:

           cmp ecx, 0x8000

           jna @F

           mov ecx, 0x8000

@@:

           mov eax, [slot]

           shl  eax,8

           mov ebx, [offset]

           add ebx, new_app_base

           push ecx

           stdcall map_memEx, [proc_mem_map],\

                              [PROC_BASE+eax+0xB8],\

                              ebx, ecx

           pop ecx

           and edi, 0xfff

           add edi, [proc_mem_map]

           mov esi, [buff]

           mov edx, ecx

           rep movsb

           sub [tmp_w_cnt], edx

           jnz .read_mem

           mov eax, [w_count]

           ret

endp

proc new_sys_threads

           locals

             thread_start  dd ?

             thread_stack  dd ?

             params        dd ?

             slot          dd ?

           endl

           mov [thread_stack], ecx

           mov [params], 0

           jnz    .failed                  ;other subfunctions

           mov    esi,new_process_loading

           call   sys_msg_board_str

           cmp [application_table_status],0

           je .get_lock

           call   change_task

           jmp .wait_lock

           mov eax, 1

           xchg eax, [application_table_status]

           cmp eax, 0

           jne .wait_lock

           test eax, eax

           jz .failed

           mov    [app_i_param],eax

           mov    [app_i_icon],eax

           mov ecx, [thread_stack]

           mov    [app_esp],ecx

           shl    esi,8

           add    esi,PROC_BASE

           mov    ebx,esi               ;ebx=esi - pointer to extended information about current thread

           shl    edi,8

           add    edi,PROC_BASE

           mov    edx,edi               ;edx=edi - pointer to extended infomation about new thread

           mov    ecx,256/4

           rep    stosd                 ;clean extended information about new thread

           mov    edi,edx

           mov    ecx,11

           rep    movsb                 ;copy process name

           mov    eax,[ebx+0x8c]

           mov    [app_mem],eax         ;set memory size

           mov    eax,[ebx+0xb8]

           mov    [edx+0xb8],eax        ;copy page directory