forked from KolibriOS/kolibrios
287 lines
6.4 KiB
PHP
287 lines
6.4 KiB
PHP
label next_usage_update dword at 0xB008
|
|
label timer_ticks dword at 0xFDF0
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; IRQ0 HANDLER (TIMER INTERRUPT) ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
align 32
|
|
irq0:
|
|
|
|
cmp [error_interrupt],-1
|
|
je no_error_in_previous_process
|
|
|
|
mov edi,[error_interrupt]
|
|
shl edi, 3
|
|
mov [edi+tss0i_l +5], word 01010000b *256 +11101001b
|
|
|
|
mov edi,[error_interrupt]
|
|
shl edi,7
|
|
add edi,0x290000
|
|
mov esi,[error_interrupt_entry]
|
|
mov [edi+l.eip-tss_sceleton],esi
|
|
mov [edi+l.eflags-tss_sceleton],dword 0x11002
|
|
|
|
mov [0xffff],byte 0
|
|
|
|
mov [error_interrupt],-1
|
|
|
|
no_error_in_previous_process:
|
|
|
|
mov edi,[0x3000]
|
|
shl edi, 3
|
|
; fields of TSS descriptor:
|
|
mov [edi+gdts+ tss0 +5], word 01010000b *256 +11101001b
|
|
|
|
inc dword [timer_ticks]
|
|
|
|
mov eax, [timer_ticks]
|
|
;!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
|
call playNote ; <<<--- INSERT THIS LINE !!!!!!!!!!
|
|
;!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
|
|
|
cmp eax,[next_usage_update]
|
|
jb .nocounter
|
|
add eax,100
|
|
mov [next_usage_update],eax
|
|
call updatecputimes
|
|
.nocounter:
|
|
|
|
mov edi, [0x3010]
|
|
|
|
mov ebx, [edi+0x18] ; time stamp counter add
|
|
call _rdtsc
|
|
sub eax, ebx
|
|
add eax, [edi+0x14] ; counter sum
|
|
mov [edi+0x14], eax
|
|
|
|
mov ebx,[0x3000]
|
|
|
|
cmp [0xffff], byte 1 ;1
|
|
je do_not_change_task ;je
|
|
|
|
.waiting_for_termination:
|
|
.waiting_for_reuse:
|
|
.waiting_on_queue:
|
|
add edi,0x20
|
|
inc ebx
|
|
|
|
mov al, byte [edi+0xA]
|
|
cmp al, 3
|
|
je .waiting_for_termination
|
|
cmp al, 4
|
|
je .waiting_for_termination
|
|
cmp al, 9
|
|
je .waiting_for_reuse
|
|
cmp al, 16
|
|
je .waiting_on_queue
|
|
cmp al, 17
|
|
je .waiting_on_queue
|
|
|
|
cmp ebx,[0x3004]
|
|
jbe nsched0
|
|
mov ebx,1
|
|
mov edi,0x3020
|
|
|
|
nsched0:
|
|
|
|
mov [0x3000],ebx
|
|
mov [0x3010],edi
|
|
|
|
do_not_change_task:
|
|
|
|
mov edx,[0x3000]
|
|
lea edx,[tss0sys+8*edx]
|
|
;mov [8*0x40+idts+8+0], word 0
|
|
mov [8*0x40+idts+8+2],dx
|
|
;mov [8*0x40+idts+8+4],word 11100101b*256
|
|
;mov [8*0x40+idts+8+6], word 0
|
|
|
|
call _rdtsc
|
|
mov [edi+0x18],eax
|
|
|
|
cmp [0xffff],byte 0
|
|
je nodecffff
|
|
dec byte [0xffff]
|
|
nodecffff:
|
|
|
|
|
|
shl ebx, 3
|
|
xor eax, eax
|
|
add ebx, tss0
|
|
mov word [0xB004], bx ; selector ;mov [tss_s],bx
|
|
mov dword [0xB000], eax ; offset
|
|
|
|
mov al,0x20 ; send End Of Interrupt signal
|
|
mov dx,0x20
|
|
out dx,al
|
|
.switch:
|
|
jmp pword [0xB000]
|
|
inc [context_counter] ;noname & halyavin
|
|
jmp irq0
|
|
|
|
iglobal
|
|
context_counter dd 0 ;noname & halyavin
|
|
endg
|
|
|
|
|
|
align 4
|
|
change_task:
|
|
|
|
mov [0xffff],byte 2
|
|
|
|
dec dword [timer_ticks] ; because irq0 will increase it
|
|
|
|
int 0x20 ; irq0 handler
|
|
|
|
ret
|
|
|
|
|
|
|
|
align 4
|
|
updatecputimes:
|
|
|
|
mov eax,[idleuse]
|
|
mov [idleusesec],eax
|
|
mov [idleuse],dword 0
|
|
mov ecx, [0x3004]
|
|
mov edi, 0x3020
|
|
.newupdate:
|
|
mov ebx,[edi+0x14]
|
|
mov [edi+0x1c],ebx
|
|
mov [edi+0x14],dword 0
|
|
add edi,0x20
|
|
dec ecx
|
|
jnz .newupdate
|
|
|
|
ret
|
|
|
|
|
|
|
|
;
|
|
; Wait queue is 16 bytes
|
|
; dd return code +12
|
|
; dd pointer to process +8
|
|
; dd prev +4
|
|
; dd next +0
|
|
;
|
|
; eax - pointer to pointer to the wait queue
|
|
; return:
|
|
; ecx - return code
|
|
sleep_on_queue:
|
|
sub esp,16 ; reserve space for wait node
|
|
mov ecx,esp ; ecx=this_node, [eax]=queue
|
|
|
|
pusha
|
|
|
|
mov ebx,[0x3010] ; get pointer to the current process
|
|
mov [ecx+8],ebx
|
|
|
|
pushf
|
|
cli ; adding element to the wait queue must be atomic
|
|
|
|
mov edi,[eax] ; edi=queue
|
|
and edi,edi ; check if queue is empty
|
|
jz .is_empty
|
|
|
|
; add element at the end of wait queue
|
|
|
|
mov edx,[edi+4] ; get pointer to prev edx=queue->prev
|
|
mov [ecx+4],edx ; this_node->prev=queue->prev
|
|
mov [ecx+0],edi ; this_node->next=queue
|
|
mov [edx+0],ecx ; this_node->prev->next=this_node
|
|
mov [edi+4],ecx ; queue->prev=this_node
|
|
jmp .added_ok
|
|
.is_empty:
|
|
; set this element as first in the queue
|
|
mov [ecx+0],ecx ; this_node->next=this_node
|
|
mov [ecx+4],ecx ; this_node->prev=this_node
|
|
mov [eax],ecx ; [queue]=this_node
|
|
.added_ok:
|
|
|
|
popf ; we can safely restore interrupts
|
|
|
|
mov [ebx+0xa],byte 17 ; set current task state as sleeping
|
|
call change_task ; schedule new thread
|
|
|
|
; someone has called wake_up_queue
|
|
|
|
pushf ; disable interrupts
|
|
cli
|
|
|
|
mov edx,[ecx+0] ; edx=this_node->next
|
|
mov esi,[ecx+4] ; esi=this_node->prev
|
|
|
|
; check if we need to remove this node from head
|
|
cmp [eax],ecx
|
|
jne .no_head
|
|
|
|
cmp [ecx+0],ecx ; check if queue is empty
|
|
jne .not_empty
|
|
|
|
mov [eax],dword 0
|
|
jmp .no_head
|
|
|
|
.not_empty:
|
|
mov [eax],edx
|
|
|
|
; remove our node from the queue (this must be atomic)
|
|
.no_head:
|
|
mov [edx+4],esi ; this_node->next->prev=this_node->prev
|
|
mov [esi+0],edx ; this_node->prev->next=this_node->next
|
|
|
|
popf
|
|
popa
|
|
add esp,12
|
|
pop ecx
|
|
ret
|
|
|
|
; eax - pointer to the wait queue
|
|
; ebx - wake up all (1=yes, 0=no)
|
|
; ecx - return code
|
|
; return:
|
|
; ebx - number of processes woken
|
|
wake_up_queue:
|
|
and eax,eax
|
|
jnz .nz
|
|
ret
|
|
.nz:
|
|
push eax
|
|
push ebx
|
|
push ecx
|
|
push edx
|
|
push esi
|
|
|
|
pushf
|
|
cli
|
|
|
|
xor ebx,ebx
|
|
mov edx,eax
|
|
.wake_loop:
|
|
|
|
mov [edx+12],ecx
|
|
mov esi,[edx+8]
|
|
mov byte [esi+0xa],0
|
|
inc ebx
|
|
|
|
mov edx,[edx+0]
|
|
cmp edx,eax
|
|
jne .wake_loop
|
|
|
|
and ebx,ebx
|
|
jz .wake_up_1
|
|
|
|
.return_it:
|
|
popf
|
|
pop esi
|
|
pop edx
|
|
pop ecx
|
|
add esp,4
|
|
pop eax
|
|
ret
|
|
.wake_up_1:
|
|
mov [eax+12],ecx
|
|
mov ecx,[eax+8]
|
|
mov byte [ecx+0xa],0
|
|
jmp .return_it
|