230 lines
7.9 KiB
PHP
230 lines
7.9 KiB
PHP
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ;;
|
|
;; Copyright (C) KolibriOS team 2012-2015. All rights reserved. ;;
|
|
;; Distributed under terms of the GNU General Public License ;;
|
|
;; ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
$Revision$
|
|
|
|
; Simple implementation of timers. All timers are organized in a double-linked
|
|
; list, and the OS loop after every timer tick processes the list.
|
|
|
|
; This structure describes a timer for the kernel.
|
|
struct TIMER
|
|
Next dd ?
|
|
Prev dd ?
|
|
; These fields organize a double-linked list of all timers.
|
|
TimerFunc dd ?
|
|
; Function to be called when the timer is activated.
|
|
UserData dd ?
|
|
; The value that is passed as is to .TimerFunc.
|
|
Time dd ?
|
|
; Time at which the timer should be activated.
|
|
Interval dd ?
|
|
; Interval between activations of the timer, in 0.01s.
|
|
ends
|
|
|
|
iglobal
|
|
align 4
|
|
; The head of timer list.
|
|
timer_list:
|
|
dd timer_list
|
|
dd timer_list
|
|
endg
|
|
uglobal
|
|
; These two variables are used to synchronize access to the global list.
|
|
; Logically, they form an recursive mutex. Physically, the first variable holds
|
|
; the slot number of the current owner or 0, the second variable holds the
|
|
; recursion count.
|
|
; The mutex should be recursive to allow a timer function to add/delete other
|
|
; timers or itself.
|
|
timer_list_owner dd 0
|
|
timer_list_numlocks dd 0
|
|
; A timer function can delete any timer, including itself and the next timer in
|
|
; the chain. To handle such situation correctly, we keep the next timer in a
|
|
; global variable, so the removing operation can update it.
|
|
timer_next dd 0
|
|
endg
|
|
|
|
; This internal function acquires the lock for the global list.
|
|
lock_timer_list:
|
|
mov edx, [current_slot_idx]
|
|
@@:
|
|
xor eax, eax
|
|
lock cmpxchg [timer_list_owner], edx
|
|
jz @f
|
|
cmp eax, edx
|
|
jz @f
|
|
call change_task
|
|
jmp @b
|
|
@@:
|
|
inc [timer_list_numlocks]
|
|
ret
|
|
|
|
; This internal function releases the lock for the global list.
|
|
unlock_timer_list:
|
|
dec [timer_list_numlocks]
|
|
jnz .nothing
|
|
mov [timer_list_owner], 0
|
|
.nothing:
|
|
ret
|
|
|
|
; This function adds a timer.
|
|
; If deltaStart is nonzero, the timer is activated after deltaStart hundredths
|
|
; of seconds starting from the current time. If interval is nonzero, the timer
|
|
; is activated every deltaWork hundredths of seconds starting from the first
|
|
; activation. The activated timer calls timerFunc as stdcall function with one
|
|
; argument userData.
|
|
; Return value is NULL if something has failed or some value which is opaque
|
|
; for the caller. Later this value can be used for cancel_timer_hs.
|
|
proc timer_hs stdcall uses ebx, deltaStart:dword, interval:dword, \
|
|
timerFunc:dword, userData:dword
|
|
; 1. Allocate memory for the TIMER structure.
|
|
; 1a. Call the allocator.
|
|
movi eax, sizeof.TIMER
|
|
call malloc
|
|
; 1b. If allocation failed, return (go to 5) with eax = 0.
|
|
test eax, eax
|
|
jz .nothing
|
|
; 2. Setup the TIMER structure.
|
|
xchg ebx, eax
|
|
; 2a. Copy values from the arguments.
|
|
mov ecx, [interval]
|
|
mov [ebx+TIMER.Interval], ecx
|
|
mov ecx, [timerFunc]
|
|
mov [ebx+TIMER.TimerFunc], ecx
|
|
mov ecx, [userData]
|
|
mov [ebx+TIMER.UserData], ecx
|
|
; 2b. Get time of the next activation.
|
|
mov ecx, [deltaStart]
|
|
test ecx, ecx
|
|
jnz @f
|
|
mov ecx, [interval]
|
|
@@:
|
|
add ecx, [timer_ticks]
|
|
mov [ebx+TIMER.Time], ecx
|
|
; 3. Insert the TIMER structure to the global list.
|
|
; 3a. Acquire the lock.
|
|
call lock_timer_list
|
|
; 3b. Insert an item at ebx to the tail of the timer_list.
|
|
mov eax, timer_list
|
|
mov ecx, [eax+TIMER.Prev]
|
|
mov [ebx+TIMER.Next], eax
|
|
mov [ebx+TIMER.Prev], ecx
|
|
mov [eax+TIMER.Prev], ebx
|
|
mov [ecx+TIMER.Next], ebx
|
|
; 3c. Release the lock.
|
|
call unlock_timer_list
|
|
; 4. Return with eax = pointer to TIMER structure.
|
|
xchg ebx, eax
|
|
.nothing:
|
|
; 5. Returning.
|
|
ret
|
|
endp
|
|
|
|
; This function removes a timer.
|
|
; The only argument is [esp+4] = the value which was returned from timer_hs.
|
|
cancel_timer_hs:
|
|
push ebx ; save used register to be stdcall
|
|
; 1. Remove the TIMER structure from the global list.
|
|
; 1a. Acquire the lock.
|
|
call lock_timer_list
|
|
mov ebx, [esp+4+4]
|
|
; 1b. Delete an item at ebx from the double-linked list.
|
|
mov eax, [ebx+TIMER.Next]
|
|
mov ecx, [ebx+TIMER.Prev]
|
|
mov [eax+TIMER.Prev], ecx
|
|
mov [ecx+TIMER.Next], eax
|
|
; 1c. If we are removing the next timer in currently processing chain,
|
|
; the next timer for this timer becomes new next timer.
|
|
cmp ebx, [timer_next]
|
|
jnz @f
|
|
mov [timer_next], eax
|
|
@@:
|
|
; 1d. Release the lock.
|
|
call unlock_timer_list
|
|
; 2. Free the TIMER structure.
|
|
xchg eax, ebx
|
|
call free
|
|
; 3. Return.
|
|
pop ebx ; restore used register to be stdcall
|
|
ret 4 ; purge one dword argument to be stdcall
|
|
|
|
; This function is regularly called from osloop. It processes the global list
|
|
; and activates the corresponding timers.
|
|
check_timers:
|
|
; 1. Acquire the lock.
|
|
call lock_timer_list
|
|
; 2. Loop over all registered timers, checking time.
|
|
; 2a. Get the first item.
|
|
mov eax, [timer_list+TIMER.Next]
|
|
mov [timer_next], eax
|
|
.loop:
|
|
; 2b. Check for end of list.
|
|
cmp eax, timer_list
|
|
jz .done
|
|
; 2c. Get and store the next timer.
|
|
mov edx, [eax+TIMER.Next]
|
|
mov [timer_next], edx
|
|
; 2d. Check time for timer activation.
|
|
; We can't just compare [timer_ticks] and [TIMER.Time], since overflows are
|
|
; possible: if the current time is 0FFFFFFFFh ticks and timer should be
|
|
; activated in 3 ticks, the simple comparison will produce incorrect result.
|
|
; So we calculate the difference [timer_ticks] - [TIMER.Time]; if it is
|
|
; non-negative, the time is over; if it is negative, then either the time is
|
|
; not over or we have not processed this timer for 2^31 ticks, what is very
|
|
; unlikely.
|
|
mov edx, [timer_ticks]
|
|
sub edx, [eax+TIMER.Time]
|
|
js .next
|
|
; The timer should be activated now.
|
|
; 2e. Store the timer data in the stack. This is required since 2f can delete
|
|
; the timer, invalidating the content.
|
|
push [eax+TIMER.UserData] ; parameter for TimerFunc
|
|
push [eax+TIMER.TimerFunc] ; to be restored in 2g
|
|
; 2f. Calculate time of next activation or delete the timer if it is one-shot.
|
|
mov ecx, [eax+TIMER.Interval]
|
|
add [eax+TIMER.Time], ecx
|
|
test ecx, ecx
|
|
jnz .nodelete
|
|
stdcall cancel_timer_hs, eax
|
|
.nodelete:
|
|
; 2g. Activate timer, using data from the stack.
|
|
pop eax
|
|
call eax
|
|
.next:
|
|
; 2h. Advance to the next timer and continue the loop.
|
|
mov eax, [timer_next]
|
|
jmp .loop
|
|
.done:
|
|
; 3. Release the lock.
|
|
call unlock_timer_list
|
|
; 4. Return.
|
|
ret
|
|
|
|
; This is a simplified version of check_timers that does not call anything,
|
|
; just checks whether check_timers should do something.
|
|
proc check_timers_has_work?
|
|
pushf
|
|
cli
|
|
mov eax, [timer_list+TIMER.Next]
|
|
.loop:
|
|
cmp eax, timer_list
|
|
jz .done_nowork
|
|
mov edx, [timer_ticks]
|
|
sub edx, [eax+TIMER.Time]
|
|
jns .done_haswork
|
|
mov eax, [eax+TIMER.Next]
|
|
jmp .loop
|
|
.done_nowork:
|
|
popf
|
|
xor eax, eax
|
|
ret
|
|
.done_haswork:
|
|
popf
|
|
xor eax, eax
|
|
inc eax
|
|
ret
|
|
endp
|