Subversion Repositories Kolibri OS

proc alloc_page

           cli

           mov ebx, [page_start]

           mov ecx, [page_end]

.l1:

           bsf eax,[ebx];

           jnz .found

           add ebx,4

           cmp ebx, ecx

           jb .l1

           popfd

           xor eax,eax

           ret

.found:

           btr [ebx], eax

           mov [page_start],ebx

           sub ebx, sys_pgmap

           lea eax, [eax+ebx*8]

           shl eax, 12

           dec [pg_data.pages_free]

           popfd

           ret

endp

proc alloc_pages stdcall, count:dword

           pushfd

           cli

           mov eax, [count]

           add eax, 7

           shr eax, 3

           mov [count], eax

           cmp eax, [pg_data.pages_free]

           ja .fail

           mov ebx, [page_end]

.find:

           mov edx, [count]

           mov edi, ecx

.match:

           cmp byte [ecx], 0xFF

           jne .next

           dec edx

           jz .ok

           inc ecx

           cmp ecx,ebx

           jb .match

.fail:     xor eax, eax

           popfd

           ret

.next:

           inc ecx

           cmp ecx, ebx

           jb .find

           popfd

           xor eax, eax

           ret

.ok:

           sub ecx, edi

           inc ecx

           mov esi, edi

           xor eax, eax

           rep stosb

           sub esi, sys_pgmap

           shl esi, 3+12

           mov eax, esi

           mov ebx, [count]

           shl ebx, 3

           sub [pg_data.pages_free], ebx

           popfd

           ret

endp

proc map_page stdcall,lin_addr:dword,phis_addr:dword,flags:dword

           push ebx

           mov eax, [phis_addr]

           and eax, not 0xFFF

           or eax, [flags]

           mov ebx, [lin_addr]

           shr ebx, 12

           mov [page_tabs+ebx*4], eax

           mov eax, [lin_addr]

           invlpg [eax]

           pop ebx

           ret

endp

map_space:    ;not implemented

proc free_page

;arg:  eax  page address

           pushfd

           cli

           shr eax, 12              ;page index

           mov ebx, sys_pgmap

           bts [ebx], eax           ;that's all!

           cmc

           adc [pg_data.pages_free], 0

           shr eax, 3

           and eax, not 3           ;dword offset from page_map

           add eax, ebx

           cmp [page_start], eax

           ja @f

           popfd

           ret

@@:

           mov [page_start], eax

           popfd

           ret

endp

;  eax= page base + page flags

;  ebx= liear address

;  ecx= count

commit_pages:

           jz .fail

           mov ebx, pg_data.pg_mutex

           call wait_mutex      ;ebx

           mov ebx, edi

           shr ebx, 12

@@:

           mov [page_tabs+ebx*4], eax

           invlpg [edi]

           add edi, edx

           add eax, edx

           inc ebx

           dec ecx

           jnz @B

           mov [pg_data.pg_mutex],ecx

.fail:

           ret

;  eax= base

;  ecx= count

release_pages:

           mov ebx, pg_data.pg_mutex

           call wait_mutex      ;ebx

           mov edi, eax

           add esi, page_tabs

           mov ebx, [page_start]

           mov edx, sys_pgmap

@@:

           xor eax, eax

           xchg eax, [esi]

           invlpg [edi]

           jz .next

           bts [edx], eax

           cmc

           adc ebp, 0

           shr eax, 3

           and eax, -4

           add eax, edx

           cmp eax, ebx

           jae .next

.next:

           add edi, 0x1000

           add esi, 4

           dec ecx

           jnz @B

           mov [pg_data.pages_free], ebp

           and [pg_data.pg_mutex],0

           popad

           ret

proc map_page_table stdcall, lin_addr:dword, phis_addr:dword

           push ebx

           mov ebx, [lin_addr]

           shr ebx, 22

           mov eax, [phis_addr]

           and eax, not 0xFFF

           or eax, PG_UW          ;+PG_NOCACHE

           mov dword [master_tab+ebx*4], eax

           mov eax, [lin_addr]

           shr eax, 10

           add eax, page_tabs

           invlpg [eax]

           pop ebx

           ret

endp

proc init_LFB

           locals

             pg_count dd ?

           endl

           jne @f

           mov [BOOT_VAR+0x901c],byte 2

           stdcall kernel_alloc, 0x280000

           mov [LFBAddress], eax

           ret

@@:

           test [SCR_MODE],word 0100000000000000b

           jnz @f

           mov [BOOT_VAR+0x901c],byte 2

           ret

@@:

           mov edx, LFB_BASE

           mov esi, [LFBAddress]

           mov edi, 0x00800000

           mov dword [exp_lfb+4], edx

           mov [pg_count], edi

           shr edi, 10

           jnc .map_page_tables

           or esi, PG_LARGE+PG_UW

           mov edx, sys_pgdir+(LFB_BASE shr 20)

@@:

           mov [edx], esi

           add edx, 4

           add esi, 0x00400000

           dec edi

           jnz @B

           jnc @F

           or dword [sys_pgdir+(LFB_BASE shr 20)], PG_GLOBAL

@@:

           mov dword [LFBAddress], LFB_BASE

           mov eax, cr3       ;flush TLB

           mov cr3, eax

           ret

           call alloc_page

           stdcall map_page_table, edx, eax

           add edx, 0x00400000

           dec edi

           jnz @B

           mov edi, page_tabs + (LFB_BASE shr 10)

           or eax, PG_UW

           mov ecx, [pg_count]

           cld

@@:

           stosd

           add eax, 0x1000

           dec ecx

           jnz @B

           mov eax, cr3       ;flush TLB

           mov cr3, eax

endp

proc new_mem_resize stdcall, new_size:dword

           call wait_mutex    ;ebx

           add edi,4095

           and edi,not 4095

           mov [new_size], edi

           cmp [edx+APPDATA.heap_base],0

           jne .exit

           add esi, 4095

           and esi, not 4095

           jae .expand

           shr esi, 12

@@:

           mov eax, [app_page_tabs+edi*4]

           test eax, 1

           jz .next

           mov dword [app_page_tabs+edi*4], 2

           mov ebx, edi

           shl ebx, 12

           invlpg [ebx+std_application_base_address]

           call free_page

           cmp edi, esi

           jb @B

           mov     ebx, [new_size]

           call    update_mem_size

           dec [pg_data.pg_mutex]

           ret

.expand:

           push edi

           and edi, not(0x3FFFFF)

           add esi, 0x3FFFFF

           and esi, not(0x3FFFFF)

           jae .grow

           call alloc_page

           test eax, eax

           jz .exit

           shr edi, 10

           add edi, page_tabs

           mov ecx, 1024

           xor eax, eax

           cld

           rep stosd

           pop edi

           cmp edi, esi

           jb @B

.grow:

           pop edi

           pop esi

@@:

           call alloc_page

           test eax, eax

           jz .exit

           stdcall map_page,esi,eax,dword PG_UW

           mov edi, esi

           xor eax, eax

           mov ecx, 1024

           cld

           rep stosd

           pop edi

           cmp esi, edi

           jb  @B

.exit:

           xor eax, eax

           inc eax

           dec [pg_data.pg_mutex]

           ret

endp

; in: edx = slot base

;     ebx = new memory size

; destroys eax,ecx,edx

;search threads and update

;application memory size infomation

           mov    ecx,[APPDATA.dir_table+edx]

           mov    eax,2

;eax = current slot

;ebx = new memory size

;ecx = page directory

           cmp    eax,[TASK_COUNT]

           jg     .search_threads_end

           mov    edx,eax

           shl    edx,5

           cmp    word [CURRENT_TASK+edx+TASKDATA.state],9 ;if slot empty?

           jz     .search_threads_next

           shl    edx,3

           cmp    [SLOT_BASE+edx+APPDATA.dir_table],ecx     ;if it is our thread?

           jnz    .search_threads_next

           mov    [SLOT_BASE+edx+APPDATA.mem_size],ebx     ;update memory size

.search_threads_next:

           inc    eax

           jmp    .search_threads

.search_threads_end:

           ret

;  eax= linear address

;

; retval

;  eax= phisical page address

get_pg_addr:

           shr eax, 12

           mov eax, [page_tabs+eax*4]

           and eax, 0xFFFFF000

           ret

proc page_fault_handler

        .err_addr equ ebp-4

           mov ebp, esp

           mov eax, cr2

           push eax

           mov ds, ax

           mov es, ax

     push edx

     mov edx, 0x400   ;bochs

     mov al,0xff      ;bochs

     out dx, al       ;bochs

     pop edx

     pop eax

           mov eax, [.err_code]

           jb .user_space      ;ñòðàíèöà â ïàìÿòè ïðèëîæåíèÿ ;

           jb .kernel_space    ;ñòðàíèöà â ïàìÿòè ÿäðà

           jb .alloc;.app_tabs ;òàáëèöû ñòðàíèö ïðèëîæåíèÿ ;

                               ;ïðîñòî ñîçäàäèì îäíó

           jb .core_tabs       ;òàáëèöû ñòðàíèö ÿäðà

                               ;Îøèáêà

.lfb:

                               ;îáëàñòü LFB

                               ;Îøèáêà

           jmp .fail

.user_space:

           test eax, PG_MAP

           jnz .err_access     ;Ñòðàíèöà ïðèñóòñòâóåò

                               ;Îøèáêà äîñòóïà ?

           mov ecx, ebx

           shr ecx, 10

           mov edx, [master_tab+ecx*4]

           test edx, PG_MAP

           jz .fail            ;òàáëèöà ñòðàíèö íå ñîçäàíà

                               ;íåâåðíûé àäðåñ â ïðîãðàììå

           test eax, 2

           jz .fail            ;àäðåñ íå çàðåçåðâèðîâàí äëÿ ;

                               ;èñïîëüçîâàíèÿ. Îøèáêà

.alloc:

           call alloc_page

           and eax, eax

           jz .fail

           and edi, 0xFFFFF000

           mov ecx, 1024

           xor eax, eax

           cld

           rep stosd

.exit:

           mov esp, ebp

           popad

           add esp, 4

           iretd

;íèêîãäà íå ïðîèñõîäèò

           jmp .fail

           test eax, PG_MAP

           jz .fail        ;ñòðàíèöà íå ïðèñóòñòâóåò

           jnz .fail       ;ïðèëîæåíèå îáðàòèëîñü ê ïàìÿòè

                           ;ÿäðà

           test eax, 8

           jnz .fail       ;óñòàíîâëåí çàðåçåðâèðîâàííûé áèò

                           ;â òàáëèöàõ ñòðàíèö. äîáàâëåíî â P4/Xeon

;íå îáðàáàòûâàåì. Îøèáêà

.fail:

           mov esp, ebp

           popad

           add esp, 4

           iretd

           jmp exc_c

           iretd

;           shr ebx, 12

;           mov eax, [page_tabs+ebx*4]

;           shr ebx, 10

;           mov eax, [master_tab+ebx*4]

           jmp .exit

;.old_addr:

;           shr ebx, 12

;           mov eax, [page_tabs+ebx*4]

;           shr ebx, 10

;           mov eax, [master_tab+ebx*4]

           jmp .exit

;.lfb_addr:

;           shr ebx, 22

;           ;mov ecx, [sys_page_dir]

;           mov eax, [master_tab+ebx*4]

           jmp .exit

;.tab_space:

;           shr ebx, 12

;           mov eax, [page_tabs+ebx*4]

;           shr ebx, 10

;           ;mov ecx, [sys_page_dir]

;           mov eax, [master_tab+ebx*4]

;           jmp .exit

endp

proc map_mem stdcall, lin_addr:dword,pdir:dword,\

                      ofs:dword,buf_size:dword

           mov eax, [buf_size]

           test eax, eax

           jz .exit

           and eax, 0xFFFFF000

           mov ebx, [ofs]

           shr ebx, 22

           mov esi, [ipc_pdir]

           mov edi, [ipc_ptab]

           mov eax, [esi+ebx*4]

           and eax, 0xFFFFF000

           test eax, eax

           jz .exit

           stdcall map_page,edi,eax,dword PG_UW

;           inc ebx

;           add edi, 0x1000

;           mov eax, [esi+ebx*4]

;           test eax, eax

;           jz @f

;          and eax, 0xFFFFF000

;           stdcall map_page, edi, eax

           and edi, 0xFFFFF000

           mov ecx, [buf_size]

           add ecx, 4095

           shr ecx, 12

           inc ecx

           shr edx, 12

           and edx, 0x3FF

           mov esi, [ipc_ptab]

           and eax, 0xFFFFF000

           test eax, eax

           jz .exit

           stdcall map_page,edi,eax,dword PG_UW

           add edi, 0x1000

           inc edx

           dec ecx

           jnz .map

           ret

endp

proc map_memEx stdcall, lin_addr:dword,pdir:dword,\

                        ofs:dword,buf_size:dword

           mov eax, [buf_size]

           test eax, eax

           jz .exit

           and eax, 0xFFFFF000

           mov ebx, [ofs]

           shr ebx, 22

           mov esi, [proc_mem_pdir]

           mov edi, [proc_mem_tab]

           mov eax, [esi+ebx*4]

           and eax, 0xFFFFF000

           test eax, eax

           jz .exit

           stdcall map_page,edi,eax,dword PG_UW

           and edi, 0xFFFFF000

           mov ecx, [buf_size]

           add ecx, 4095

           shr ecx, 12

           inc ecx

           shr edx, 12

           and edx, 0x3FF

           mov esi, [proc_mem_tab]

;           and eax, 0xFFFFF000

;           test eax, eax

;           jz .exit

           stdcall map_page,edi,eax,dword PG_UW

           add edi, 0x1000

           inc edx

           dec ecx

           jnz .map

.exit:

           ret

endp

;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

           jne @f

           call set_ipc_buff

           mov [esp+36], eax

           ret

@@:

           cmp eax, 2

           jne @f

           stdcall sys_ipc_send, ebx, ecx, edx

           mov [esp+36], eax

           ret

@@:

           xor eax, eax

           not eax

           mov [esp+36], eax

           ret

proc set_ipc_buff

           pushf

           cli

           mov  [eax+APPDATA.ipc_start],ebx     ;set fields in extended information area

           mov  [eax+APPDATA.ipc_size],ecx

           add ecx, 4095

           and ecx, not 4095

           add ebx, 0x1000

           cmp ebx, ecx

           jna .touch

           xor eax, eax

           ret

endp

           locals

             dst_slot   dd ?

             dst_offset dd ?

             buf_size   dd ?

           endl

           cli

           call pid_to_slot

           test eax,eax

           jz   .no_pid

           shl  eax,8

           mov  edi,[eax+SLOT_BASE+0xa0]  ;is ipc area defined?

           test edi,edi

           jz   .no_ipc_area

       ;    add edi, new_app_base

           and ebx, 0xFFF

           mov [dst_offset], ebx

           mov [buf_size], esi

                             edi, esi

           add edi, [ipc_tmp]

           cmp dword [edi], 0

           jnz  .ipc_blocked          ;if dword [buffer]<>0 - ipc blocked now

           mov edx, ebx

           add ebx, 8

           add ebx, [msg_size]

           cmp ebx, [buf_size]

           ja .buffer_overflow         ;esi<0 - not enough memory in buffer

           mov eax,[TASK_BASE]

           mov eax, [eax+0x04]         ;eax - our PID

           mov edi, [dst_offset]

           add edi, [ipc_tmp]

           add edi, edx

           mov [edi], eax

           mov ecx, [msg_size]

           add edi, 8

           mov esi, [msg_addr]

       ;    add esi, new_app_base

           cld

           rep movsb

           mov edx, ebx

           shr ebx, 12

           xor eax, eax

           mov [page_tabs+ebx*4], eax

           invlpg [edx]

           mov edx, ebx

           shr ebx, 12

           xor eax, eax

           mov [page_tabs+ebx*4], eax

           invlpg [edx]

           mov edx, ebx

           shr ebx, 12

           xor eax, eax

           mov [page_tabs+ebx*4], eax

           invlpg [edx]

           shl eax, 8

           or   [eax+SLOT_BASE+0xA8],dword 0x40

           cmp  dword [check_idle_semaphore],20

           jge  .ipc_no_cis

.ipc_no_cis:

           popf

           xor eax, eax

           ret

.no_pid:

           popf

           mov  eax, 4

           ret

.no_ipc_area:

           popf

           xor eax, eax

           inc eax

           ret

.ipc_blocked:

           popf

           mov  eax, 2

           ret

.buffer_overflow:

           popf

           mov  eax, 3

           ret

endp

sysfn_meminfo:

           cmp ebx, OS_BASE

           jae .fail

           mov [ebx], eax

           shl eax, 12

           mov [esp+36], eax

           mov ecx, [pg_data.pages_free]

           mov [ebx+4], ecx

           mov edx, [pg_data.pages_faults]

           mov [ebx+8], edx

           mov esi, [heap_size]

           mov [ebx+12], esi

           mov edi, [heap_free]

           mov [ebx+16], edi

           mov eax, [heap_blocks]

           mov [ebx+20], eax

           mov ecx, [free_blocks]

           mov [ebx+24], ecx

           ret

.fail:

           mov dword [esp+36], -1

           ret

new_services:

           jle  sys_sheduler

           jb .fail

           ja @f

           mov [esp+36], eax

           ret

@@:

           cmp eax, 12

           ja @f

           mov [esp+36], eax

           ret

@@:

           cmp eax, 13

           ja @f

           stdcall user_free, ebx

           mov [esp+36], eax

           ret

@@:

           cmp eax, 14

           ja @f

           cmp ebx, OS_BASE

           jae .fail

           stdcall get_event_ex, ebx, ecx

           mov [esp+36], eax

           ret

@@:

           cmp eax, 15

           ja @f

           mov ecx, [current_slot]

           mov eax, [ecx+APPDATA.fpu_handler]

           mov [ecx+APPDATA.fpu_handler], ebx

           mov [esp+36], eax

           ret

@@:

           cmp eax, 16

           ja @f

           jz .fail

           cmp ebx, OS_BASE

           jae .fail

           stdcall get_service, ebx

           mov [esp+36], eax

           ret

@@:

           cmp eax, 17

           ja @f

           call srv_handlerEx   ;ebx

           mov [esp+36], eax

           ret

@@:

           cmp eax, 18

           ja @f

           mov ecx, [current_slot]

           mov eax, [ecx+APPDATA.sse_handler]

           mov [ecx+APPDATA.sse_handler], ebx

           mov [esp+36], eax

           ret

@@:

           cmp eax, 19

           ja .fail

      ;     add ebx, new_app_base

           cmp ebx, OS_BASE

           jae .fail

           stdcall load_library, ebx

           mov [esp+36], eax

           ret

           xor eax, eax

           mov [esp+36], eax

           ret

proc init_mtrr

           je  .exit

           jnc .exit

           or eax, 0x60000000   ;disable caching

           mov cr0, eax

           wbinvd               ;invalidate cache

           rdmsr                ;

           push eax

           xor eax, eax

           mov ecx, 0x2FF

           wrmsr                ;disable all MTRR

           stdcall set_mtrr, dword 1,[LFBAddress],[LFBSize],MEM_WC

           xor edx, edx

           xor eax, eax

           mov ecx, 0x204

           mov ebx, 6

@@:

           wrmsr                ;disable unused MTRR

           inc ecx

           wrmsr

           inc ecx

           dec ebx

           jnz @b

           or eax, 0x800        ;set default memtype to UC

           and al, 0xF0

           mov ecx, 0x2FF

           wrmsr                ;and enable MTRR

           and eax, not 0x60000000

           mov cr0, eax         ; enable caching

.exit:

           ret

endp

proc set_mtrr stdcall, reg:dword,base:dword,size:dword,mem_type:dword

           mov eax, [base]

           or eax, [mem_type]

           mov ecx, [reg]

           lea ecx, [0x200+ecx*2]

           wrmsr

           dec ebx

           mov eax, 0xFFFFFFFF

           mov edx, 0x0000000F

           sub eax, ebx

           sbb edx, 0

           or eax, 0x800

           inc ecx

           wrmsr

           ret

endp

proc strncmp stdcall, str1:dword, str2:dword, count:dword

          jecxz .end

          mov esi,edi

          xor eax,eax

          repne scasb

          neg ecx             ; cx = count - strlen

          add ecx,ebx         ; strlen + count - strlen

          mov edi,esi

          mov esi,[str2]

          repe cmpsb

          mov al,[esi-1]

          xor ecx,ecx

          ja .str2_big

          je .end

          sub ecx,2

          not ecx

.end:

          mov eax,ecx

          ret

endp

proc stall stdcall, delay:dword

           push ecx

           push edx

           push ebx

           push eax

           mul [stall_mcs]

           mov ebx, eax       ;low

           mov ecx, edx       ;high

           rdtsc

           add ebx, eax

           adc ecx,edx

@@:

           rdtsc

           sub eax, ebx

           sbb edx, ecx

           jb @B

           pop ebx