WebSVN – Kolibri OS – Diff – /kernel/branches/Kolibri-acpi/core/sched.inc


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;
;; Copyright (C) MenuetOS 2000-2004 Ville Mikael Turjanmaa      ;;
;; Distributed under terms of the GNU General Public License    ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 2150 $
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; IRQ0 HANDLER (TIMER INTERRUPT) ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 
align 32
irq0:
        pushad
        Mov     ds, ax, app_data
        mov     es, ax
        inc     [timer_ticks]
        mov     eax, [timer_ticks]
        call    playNote       ; <<<--- Speaker driver
        sub     eax,[next_usage_update]
        cmp     eax,100
        jb      .nocounter
        add     [next_usage_update],100
        call    updatecputimes
  .nocounter:
	mov	al, 0	; send End Of Interrupt signal
	call	IRQ_EOI
        btr     dword[DONT_SWITCH], 0
        jc      .return
        call    find_next_task
        jz      .return  ; if there is only one running process
        call    do_change_task
  .return:
        popad
        iretd
 
align 4
change_task:
        pushfd
        cli
        pushad
if 0
; \begin{Mario79} ; <- must be refractoried, if used...
        cmp     [dma_task_switched], 1
        jne     .find_next_task
        mov     [dma_task_switched], 0
        mov     ebx, [dma_process]
        cmp     [CURRENT_TASK], ebx
        je      .return
        mov     edi, [dma_slot_ptr]
        mov     [CURRENT_TASK], ebx
        mov     [TASK_BASE], edi
        jmp     @f
.find_next_task:
; \end{Mario79}
end if
        call    find_next_task
        jz      .return  ; the same task -> skip switch
  @@:   mov     byte[DONT_SWITCH], 1
        call    do_change_task
  .return:
        popad
        popfd
        ret
 
uglobal
align 4
;  far_jump:
;   .offs dd ?
;   .sel  dw ?
   context_counter     dd 0 ;noname & halyavin
   next_usage_update   dd 0
   timer_ticks         dd 0
;  prev_slot           dd ?
;  event_sched         dd ?
endg
 
align 4
update_counters:
        mov     edi, [TASK_BASE]
        rdtsc
        sub     eax, [edi+TASKDATA.counter_add] ; time stamp counter add
        add     [edi+TASKDATA.counter_sum], eax ; counter sum
        ret
align 4
updatecputimes:
        xor     eax,eax
        xchg    eax,[idleuse]
        mov     [idleusesec],eax
        mov     ecx, [TASK_COUNT]
        mov     edi, TASK_DATA
  .newupdate:
        xor     eax,eax
        xchg    eax,[edi+TASKDATA.counter_sum]
        mov     [edi+TASKDATA.cpu_usage],eax
        add     edi,0x20
        loop    .newupdate
        ret
 
align 4
find_next_task:
;info:
;   Find next task to execute
;retval:
;   ebx = address of the APPDATA for the selected task (slot-base)
;   esi = previous slot-base ([current_slot] at the begin)
;   edi = address of the TASKDATA for the selected task
;   ZF  = 1  if the task is the same
;warning:
;   [CURRENT_TASK] = bh , [TASK_BASE] = edi -- as result
;   [current_slot] is not set to new value (ebx)!!!
;scratched: eax,ecx
        call    update_counters ; edi := [TASK_BASE]
        Mov     esi, ebx, [current_slot]
  .loop:
        cmp     bh,[TASK_COUNT]
        jb      @f
        xor     bh, bh
        mov     edi,CURRENT_TASK
  @@:   inc     bh       ; ebx += APPDATA.size
        add     edi,0x20 ; edi += TASKDATA.size
        mov     al, [edi+TASKDATA.state]
        test    al, al
        jz      .found   ; state == 0
        cmp     al, 5
        jne     .loop    ; state == 1,2,3,4,9
      ; state == 5
        pushad  ; more freedom for [APPDATA.wait_test]
        call    [ebx+APPDATA.wait_test]
        mov     [esp+28],eax
        popad
        or      eax,eax
        jnz     @f
      ; testing for timeout
        mov     ecx, [timer_ticks]
        sub     ecx, [ebx+APPDATA.wait_begin]
        cmp     ecx, [ebx+APPDATA.wait_timeout]
        jb      .loop
  @@:   mov     [ebx+APPDATA.wait_param], eax  ; retval for wait
        mov     [edi+TASKDATA.state], 0
  .found:
        mov     [CURRENT_TASK],bh
        mov     [TASK_BASE],edi
        rdtsc   ;call  _rdtsc
        mov     [edi+TASKDATA.counter_add],eax ; for next using update_counters
        cmp     ebx, esi ;esi - previous slot-base
        ret
;TODO: Íàäî áû óáðàòü èñïîëüçîâàíèå do_change_task èç V86...
; è ïîñëå ýòîãî ïåðåíåñòè îáðàáîòêó TASKDATA.counter_add/sum â do_change_task
 
align 4
do_change_task:
;param:
;   ebx = address of the APPDATA for incoming task (new)
;warning:
;   [CURRENT_TASK] and [TASK_BASE] must be changed before (e.g. in find_next_task)
;   [current_slot] is the outcoming (old), and set here to a new value (ebx)
;scratched: eax,ecx,esi
        mov     esi,ebx
        xchg    esi,[current_slot]
; set new stack after saving old
        mov     [esi+APPDATA.saved_esp], esp
        mov     esp, [ebx+APPDATA.saved_esp]
; set new thread io-map
        Mov     dword [page_tabs+((tss._io_map_0 and -4096) shr 10)],eax,[ebx+APPDATA.io_map]
        Mov     dword [page_tabs+((tss._io_map_1 and -4096) shr 10)],eax,[ebx+APPDATA.io_map+4]
; set new thread memory-map
        mov     ecx, APPDATA.dir_table
        mov     eax, [ebx+ecx]      ;offset>0x7F
        cmp     eax, [esi+ecx]      ;offset>0x7F
        je      @f
        mov     cr3, eax
@@:
; set tss.esp0
 
        Mov     [tss._esp0],eax,[ebx+APPDATA.saved_esp0]
 
        mov edx, [ebx+APPDATA.tls_base]
        cmp edx, [esi+APPDATA.tls_base]
        je @f
 
        mov     [tls_data_l+2],dx
        shr     edx,16
        mov     [tls_data_l+4],dl
        mov     [tls_data_l+7],dh
 
        mov dx, app_tls
        mov fs, dx
@@:
; set gs selector unconditionally
        Mov     gs,ax,graph_data
      ; set CR0.TS
        cmp     bh, byte[fpu_owner] ;bh == incoming task (new)
        clts                        ;clear a task switch flag
        je      @f
        mov     eax, cr0            ;and set it again if the owner
        or      eax, CR0_TS         ;of a fpu has changed
        mov     cr0, eax
  @@: ; set context_counter (only for user pleasure ???)
        inc     [context_counter]   ;noname & halyavin
      ; set debug-registers, if it's necessary
        test    byte[ebx+APPDATA.dbg_state], 1
        jz      @f
        xor     eax, eax
        mov     dr6, eax
        lea     esi,[ebx+ecx+APPDATA.dbg_regs-APPDATA.dir_table] ;offset>0x7F
        cld
  macro lodsReg [reg] {
        lodsd
        mov     reg,eax
  }     lodsReg dr0, dr1, dr2, dr3, dr7
  purge lodsReg
  @@:   ret
;end.
 
 
 
struc MUTEX_WAITER
{
    .list   LHEAD
    .task   rd 1
    .sizeof:
};
 
virtual at 0
 MUTEX_WAITER MUTEX_WAITER
end virtual
 
;void  __fastcall mutex_init(struct mutex *lock)
 
align 4
mutex_init:
        mov [ecx+MUTEX.wait.next], ecx
        mov [ecx+MUTEX.wait.prev], ecx
        mov [ecx+MUTEX.count],1
        ret
 
 
;void  __fastcall mutex_lock(struct mutex *lock)
 
align 4
mutex_lock:
 
        dec [ecx+MUTEX.count]
        jns .done
 
        pushfd
        cli
 
        sub esp, MUTEX_WAITER.sizeof
 
        list_add_tail esp, ecx      ;esp= new waiter, ecx= list head
 
        mov edx, [TASK_BASE]
        mov [esp+MUTEX_WAITER.task], edx
 
.forever:
 
        mov eax, -1
        xchg eax, [ecx+MUTEX.count]
        dec eax
        jz @F
 
        mov [edx+TASKDATA.state], 1
        call change_task
        jmp .forever
@@:
        mov edx, [esp+MUTEX_WAITER.list.next]
        mov eax, [esp+MUTEX_WAITER.list.prev]
 
        mov [eax+MUTEX_WAITER.list.next], edx
        mov [edx+MUTEX_WAITER.list.prev], eax
        cmp [ecx+MUTEX.wait.next], ecx
        jne @F
 
        mov [ecx+MUTEX.count], 0
@@:
        add  esp, MUTEX_WAITER.sizeof
 
        popfd
.done:
        ret
 
;void  __fastcall mutex_unlock(struct mutex *lock)
 
align 4
mutex_unlock:
 
        pushfd
        cli
 
        mov eax, [ecx+MUTEX.wait.next]
        cmp eax, ecx
        mov [ecx+MUTEX.count], 1
        je @F
 
        mov eax, [eax+MUTEX_WAITER.task]
        mov [eax+TASKDATA.state], 0
@@:
        popfd
        ret
 
 
purge MUTEX_WAITER
 
if 0
 
struc TIMER
{
  .next      dd ?
  .exp_time  dd ?
  .func      dd ?
  .arg       dd ?
}
 
 
MAX_PROIRITY         0   ; highest, used for kernel tasks
MAX_USER_PRIORITY    0   ; highest priority for user processes
USER_PRIORITY        7   ; default (should correspond to nice 0)
MIN_USER_PRIORITY   14   ; minimum priority for user processes
IDLE_PRIORITY       15   ; lowest, only IDLE process goes here
NR_SCHED_QUEUES     16   ; MUST equal IDLE_PRIORYTY + 1
 
uglobal
rdy_head   rd 16
endg
 
align 4
pick_task:
 
       xor eax, eax
  .pick:
       mov ebx, [rdy_head+eax*4]
       test ebx, ebx
       jz .next
 
       mov [next_task], ebx
       test [ebx+flags.billable]
       jz @F
       mov [bill_task], ebx
  @@:
       ret
  .next:
       inc eax
       jmp .pick
 
; param
;  eax= task
;
; retval
;  eax= task
;  ebx= queue
;  ecx= front if 1 or back if 0
align 4
shed:
       cmp [eax+.tics_left], 0 ;signed compare
       mov ebx, [eax+.priority]
       setg ecx
       jg @F
 
       mov edx, [eax+.tics_quantum]
       mov [eax+.ticks_left], edx
       cmp ebx, (IDLE_PRIORITY-1)
       je @F
       inc ebx
  @@:
       ret
 
; param
;  eax= task
align 4
enqueue:
      call shed  ;eax
      cmp [rdy_head+ebx*4],0
      jnz @F
 
      mov [rdy_head+ebx*4], eax
      mov [rdy_tail+ebx*4], eax
      mov [eax+.next_ready], 0
      jmp .pick
  @@:
      test ecx, ecx
      jz .back
 
      mov ecx, [rdy_head+ebx*4]
      mov [eax+.next_ready], ecx
      mov [rdy_head+ebx*4], eax
      jmp .pick
  .back:
      mov ecx, [rdy_tail+ebx*4]
      mov [ecx+.next_ready], eax
      mov [rdy_tail+ebx*4], eax
      mov [eax+.next_ready], 0
  .pick:
      call pick_proc     ;select next task
      ret
 
end if

Rev 2143	Rev 2150
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;
4	;; Copyright (C) MenuetOS 2000-2004 Ville Mikael Turjanmaa ;;	4	;; Copyright (C) MenuetOS 2000-2004 Ville Mikael Turjanmaa ;;
5	;; Distributed under terms of the GNU General Public License ;;	5	;; Distributed under terms of the GNU General Public License ;;
6	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	6	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
7		7
8	$Revision: 2143 $	8	$Revision: 2150 $
9		9
10		10
11	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	11	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
12	;; IRQ0 HANDLER (TIMER INTERRUPT) ;;	12	;; IRQ0 HANDLER (TIMER INTERRUPT) ;;
13	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	13	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
14		14
15		15
16	align 32	16	align 32
17	irq0:	17	irq0:
18	pushad	18	pushad
19	Mov ds, ax, app_data	19	Mov ds, ax, app_data
20	mov es, ax	20	mov es, ax
21	inc [timer_ticks]	21	inc [timer_ticks]
22	mov eax, [timer_ticks]	22	mov eax, [timer_ticks]
23	call playNote ; <<<--- Speaker driver	23	call playNote ; <<<--- Speaker driver
24	sub eax,[next_usage_update]	24	sub eax,[next_usage_update]
25	cmp eax,100	25	cmp eax,100
26	jb .nocounter	26	jb .nocounter
27	add [next_usage_update],100	27	add [next_usage_update],100
28	call updatecputimes	28	call updatecputimes
29	.nocounter:	29	.nocounter:
30	mov al, 0 ; send End Of Interrupt signal	30	mov al, 0 ; send End Of Interrupt signal
31	call IRQ_EOI	31	call IRQ_EOI
32	btr dword[DONT_SWITCH], 0	32	btr dword[DONT_SWITCH], 0
33	jc .return	33	jc .return
34	call find_next_task	34	call find_next_task
35	jz .return ; if there is only one running process	35	jz .return ; if there is only one running process
36	call do_change_task	36	call do_change_task
37	.return:	37	.return:
38	popad	38	popad
39	iretd	39	iretd
40		40
41	align 4	41	align 4
42	change_task:	42	change_task:
43	pushfd	43	pushfd
44	cli	44	cli
45	pushad	45	pushad
46	if 0	46	if 0
47	; \begin{Mario79} ; <- must be refractoried, if used...	47	; \begin{Mario79} ; <- must be refractoried, if used...
48	cmp [dma_task_switched], 1	48	cmp [dma_task_switched], 1
49	jne .find_next_task	49	jne .find_next_task
50	mov [dma_task_switched], 0	50	mov [dma_task_switched], 0
51	mov ebx, [dma_process]	51	mov ebx, [dma_process]
52	cmp [CURRENT_TASK], ebx	52	cmp [CURRENT_TASK], ebx
53	je .return	53	je .return
54	mov edi, [dma_slot_ptr]	54	mov edi, [dma_slot_ptr]
55	mov [CURRENT_TASK], ebx	55	mov [CURRENT_TASK], ebx
56	mov [TASK_BASE], edi	56	mov [TASK_BASE], edi
57	jmp @f	57	jmp @f
58	.find_next_task:	58	.find_next_task:
59	; \end{Mario79}	59	; \end{Mario79}
60	end if	60	end if
61	call find_next_task	61	call find_next_task
62	jz .return ; the same task -> skip switch	62	jz .return ; the same task -> skip switch
63	@@: mov byte[DONT_SWITCH], 1	63	@@: mov byte[DONT_SWITCH], 1
64	call do_change_task	64	call do_change_task
65	.return:	65	.return:
66	popad	66	popad
67	popfd	67	popfd
68	ret	68	ret
69		69
70	uglobal	70	uglobal
71	align 4	71	align 4
72	; far_jump:	72	; far_jump:
73	; .offs dd ?	73	; .offs dd ?
74	; .sel dw ?	74	; .sel dw ?
75	context_counter dd 0 ;noname & halyavin	75	context_counter dd 0 ;noname & halyavin
76	next_usage_update dd 0	76	next_usage_update dd 0
77	timer_ticks dd 0	77	timer_ticks dd 0
78	; prev_slot dd ?	78	; prev_slot dd ?
79	; event_sched dd ?	79	; event_sched dd ?
80	endg	80	endg
81		81
82	align 4	82	align 4
83	update_counters:	83	update_counters:
84	mov edi, [TASK_BASE]	84	mov edi, [TASK_BASE]
85	rdtsc	85	rdtsc
86	sub eax, [edi+TASKDATA.counter_add] ; time stamp counter add	86	sub eax, [edi+TASKDATA.counter_add] ; time stamp counter add
87	add [edi+TASKDATA.counter_sum], eax ; counter sum	87	add [edi+TASKDATA.counter_sum], eax ; counter sum
88	ret	88	ret
89	align 4	89	align 4
90	updatecputimes:	90	updatecputimes:
91	xor eax,eax	91	xor eax,eax
92	xchg eax,[idleuse]	92	xchg eax,[idleuse]
93	mov [idleusesec],eax	93	mov [idleusesec],eax
94	mov ecx, [TASK_COUNT]	94	mov ecx, [TASK_COUNT]
95	mov edi, TASK_DATA	95	mov edi, TASK_DATA
96	.newupdate:	96	.newupdate:
97	xor eax,eax	97	xor eax,eax
98	xchg eax,[edi+TASKDATA.counter_sum]	98	xchg eax,[edi+TASKDATA.counter_sum]
99	mov [edi+TASKDATA.cpu_usage],eax	99	mov [edi+TASKDATA.cpu_usage],eax
100	add edi,0x20	100	add edi,0x20
101	loop .newupdate	101	loop .newupdate
102	ret	102	ret
103		103
104	align 4	104	align 4
105	find_next_task:	105	find_next_task:
106	;info:	106	;info:
107	; Find next task to execute	107	; Find next task to execute
108	;retval:	108	;retval:
109	; ebx = address of the APPDATA for the selected task (slot-base)	109	; ebx = address of the APPDATA for the selected task (slot-base)
110	; esi = previous slot-base ([current_slot] at the begin)	110	; esi = previous slot-base ([current_slot] at the begin)
111	; edi = address of the TASKDATA for the selected task	111	; edi = address of the TASKDATA for the selected task
112	; ZF = 1 if the task is the same	112	; ZF = 1 if the task is the same
113	;warning:	113	;warning:
114	; [CURRENT_TASK] = bh , [TASK_BASE] = edi -- as result	114	; [CURRENT_TASK] = bh , [TASK_BASE] = edi -- as result
115	; [current_slot] is not set to new value (ebx)!!!	115	; [current_slot] is not set to new value (ebx)!!!
116	;scratched: eax,ecx	116	;scratched: eax,ecx
117	call update_counters ; edi := [TASK_BASE]	117	call update_counters ; edi := [TASK_BASE]
118	Mov esi, ebx, [current_slot]	118	Mov esi, ebx, [current_slot]
119	.loop:	119	.loop:
120	cmp bh,[TASK_COUNT]	120	cmp bh,[TASK_COUNT]
121	jb @f	121	jb @f
122	xor bh, bh	122	xor bh, bh
123	mov edi,CURRENT_TASK	123	mov edi,CURRENT_TASK
124	@@: inc bh ; ebx += APPDATA.size	124	@@: inc bh ; ebx += APPDATA.size
125	add edi,0x20 ; edi += TASKDATA.size	125	add edi,0x20 ; edi += TASKDATA.size
126	mov al, [edi+TASKDATA.state]	126	mov al, [edi+TASKDATA.state]
127	test al, al	127	test al, al
128	jz .found ; state == 0	128	jz .found ; state == 0
129	cmp al, 5	129	cmp al, 5
130	jne .loop ; state == 1,2,3,4,9	130	jne .loop ; state == 1,2,3,4,9
131	; state == 5	131	; state == 5
132	pushad ; more freedom for [APPDATA.wait_test]	132	pushad ; more freedom for [APPDATA.wait_test]
133	call [ebx+APPDATA.wait_test]	133	call [ebx+APPDATA.wait_test]
134	mov [esp+28],eax	134	mov [esp+28],eax
135	popad	135	popad
136	or eax,eax	136	or eax,eax
137	jnz @f	137	jnz @f
138	; testing for timeout	138	; testing for timeout
139	mov ecx, [timer_ticks]	139	mov ecx, [timer_ticks]
140	sub ecx, [ebx+APPDATA.wait_begin]	140	sub ecx, [ebx+APPDATA.wait_begin]
141	cmp ecx, [ebx+APPDATA.wait_timeout]	141	cmp ecx, [ebx+APPDATA.wait_timeout]
142	jb .loop	142	jb .loop
143	@@: mov [ebx+APPDATA.wait_param], eax ; retval for wait	143	@@: mov [ebx+APPDATA.wait_param], eax ; retval for wait
144	mov [edi+TASKDATA.state], 0	144	mov [edi+TASKDATA.state], 0
145	.found:	145	.found:
146	mov [CURRENT_TASK],bh	146	mov [CURRENT_TASK],bh
147	mov [TASK_BASE],edi	147	mov [TASK_BASE],edi
148	rdtsc ;call _rdtsc	148	rdtsc ;call _rdtsc
149	mov [edi+TASKDATA.counter_add],eax ; for next using update_counters	149	mov [edi+TASKDATA.counter_add],eax ; for next using update_counters
150	cmp ebx, esi ;esi - previous slot-base	150	cmp ebx, esi ;esi - previous slot-base
151	ret	151	ret
152	;TODO: Íàäî áû óáðàòü èñïîëüçîâàíèå do_change_task èç V86...	152	;TODO: Íàäî áû óáðàòü èñïîëüçîâàíèå do_change_task èç V86...
153	; è ïîñëå ýòîãî ïåðåíåñòè îáðàáîòêó TASKDATA.counter_add/sum â do_change_task	153	; è ïîñëå ýòîãî ïåðåíåñòè îáðàáîòêó TASKDATA.counter_add/sum â do_change_task
154		154
155	align 4	155	align 4
156	do_change_task:	156	do_change_task:
157	;param:	157	;param:
158	; ebx = address of the APPDATA for incoming task (new)	158	; ebx = address of the APPDATA for incoming task (new)
159	;warning:	159	;warning:
160	; [CURRENT_TASK] and [TASK_BASE] must be changed before (e.g. in find_next_task)	160	; [CURRENT_TASK] and [TASK_BASE] must be changed before (e.g. in find_next_task)
161	; [current_slot] is the outcoming (old), and set here to a new value (ebx)	161	; [current_slot] is the outcoming (old), and set here to a new value (ebx)
162	;scratched: eax,ecx,esi	162	;scratched: eax,ecx,esi
163	mov esi,ebx	163	mov esi,ebx
164	xchg esi,[current_slot]	164	xchg esi,[current_slot]
165	; set new stack after saving old	165	; set new stack after saving old
166	mov [esi+APPDATA.saved_esp], esp	166	mov [esi+APPDATA.saved_esp], esp
167	mov esp, [ebx+APPDATA.saved_esp]	167	mov esp, [ebx+APPDATA.saved_esp]
168	; set new thread io-map	168	; set new thread io-map
169	Mov dword [page_tabs+((tss._io_map_0 and -4096) shr 10)],eax,[ebx+APPDATA.io_map]	169	Mov dword [page_tabs+((tss._io_map_0 and -4096) shr 10)],eax,[ebx+APPDATA.io_map]
170	Mov dword [page_tabs+((tss._io_map_1 and -4096) shr 10)],eax,[ebx+APPDATA.io_map+4]	170	Mov dword [page_tabs+((tss._io_map_1 and -4096) shr 10)],eax,[ebx+APPDATA.io_map+4]
171	; set new thread memory-map	171	; set new thread memory-map
172	mov ecx, APPDATA.dir_table	172	mov ecx, APPDATA.dir_table
173	mov eax, [ebx+ecx] ;offset>0x7F	173	mov eax, [ebx+ecx] ;offset>0x7F
174	cmp eax, [esi+ecx] ;offset>0x7F	174	cmp eax, [esi+ecx] ;offset>0x7F
175	je @f	175	je @f
176	mov cr3, eax	176	mov cr3, eax
177	@@:	177	@@:
178	; set tss.esp0	178	; set tss.esp0
179		179
180	Mov [tss._esp0],eax,[ebx+APPDATA.saved_esp0]	180	Mov [tss._esp0],eax,[ebx+APPDATA.saved_esp0]
181		181
182	mov edx, [ebx+APPDATA.tls_base]	182	mov edx, [ebx+APPDATA.tls_base]
183	cmp edx, [esi+APPDATA.tls_base]	183	cmp edx, [esi+APPDATA.tls_base]
184	je @f	184	je @f
185		185
186	mov [tls_data_l+2],dx	186	mov [tls_data_l+2],dx
187	shr edx,16	187	shr edx,16
188	mov [tls_data_l+4],dl	188	mov [tls_data_l+4],dl
189	mov [tls_data_l+7],dh	189	mov [tls_data_l+7],dh
190		190
191	mov dx, app_tls	191	mov dx, app_tls
192	mov fs, dx	192	mov fs, dx
193	@@:	193	@@:
194	; set gs selector unconditionally	194	; set gs selector unconditionally
195	Mov gs,ax,graph_data	195	Mov gs,ax,graph_data
196	; set CR0.TS	196	; set CR0.TS
197	cmp bh, byte[fpu_owner] ;bh == incoming task (new)	197	cmp bh, byte[fpu_owner] ;bh == incoming task (new)
198	clts ;clear a task switch flag	198	clts ;clear a task switch flag
199	je @f	199	je @f
200	mov eax, cr0 ;and set it again if the owner	200	mov eax, cr0 ;and set it again if the owner
201	or eax, CR0_TS ;of a fpu has changed	201	or eax, CR0_TS ;of a fpu has changed
202	mov cr0, eax	202	mov cr0, eax
203	@@: ; set context_counter (only for user pleasure ???)	203	@@: ; set context_counter (only for user pleasure ???)
204	inc [context_counter] ;noname & halyavin	204	inc [context_counter] ;noname & halyavin
205	; set debug-registers, if it's necessary	205	; set debug-registers, if it's necessary
206	test byte[ebx+APPDATA.dbg_state], 1	206	test byte[ebx+APPDATA.dbg_state], 1
207	jz @f	207	jz @f
208	xor eax, eax	208	xor eax, eax
209	mov dr6, eax	209	mov dr6, eax
210	lea esi,[ebx+ecx+APPDATA.dbg_regs-APPDATA.dir_table] ;offset>0x7F	210	lea esi,[ebx+ecx+APPDATA.dbg_regs-APPDATA.dir_table] ;offset>0x7F
211	cld	211	cld
212	macro lodsReg [reg] {	212	macro lodsReg [reg] {
213	lodsd	213	lodsd
214	mov reg,eax	214	mov reg,eax
215	} lodsReg dr0, dr1, dr2, dr3, dr7	215	} lodsReg dr0, dr1, dr2, dr3, dr7
216	purge lodsReg	216	purge lodsReg
217	@@: ret	217	@@: ret
218	;end.	218	;end.
219		219
220		220
221		221
222	struc MUTEX_WAITER	222	struc MUTEX_WAITER
223	{	223	{
224	.list LHEAD	224	.list LHEAD
225	.task rd 1	225	.task rd 1
226	.sizeof:	226	.sizeof:
227	};	227	};
228		228
229	virtual at 0	229	virtual at 0
230	MUTEX_WAITER MUTEX_WAITER	230	MUTEX_WAITER MUTEX_WAITER
231	end virtual	231	end virtual
232		232
233	;void __fastcall mutex_init(struct mutex *lock)	233	;void __fastcall mutex_init(struct mutex *lock)
234		234
235	align 4	235	align 4
236	mutex_init:	236	mutex_init:
237	mov [ecx+MUTEX.wait.next], ecx	237	mov [ecx+MUTEX.wait.next], ecx
238	mov [ecx+MUTEX.wait.prev], ecx	238	mov [ecx+MUTEX.wait.prev], ecx
239	mov [ecx+MUTEX.count],1	239	mov [ecx+MUTEX.count],1
240	ret	240	ret
241		241
242		242
243	;void __fastcall mutex_lock(struct mutex *lock)	243	;void __fastcall mutex_lock(struct mutex *lock)
244		244
245	align 4	245	align 4
246	mutex_lock:	246	mutex_lock:
247		247
248	dec [ecx+MUTEX.count]	248	dec [ecx+MUTEX.count]
249	jns .done	249	jns .done
250		250
251	pushfd	251	pushfd
252	cli	252	cli
253		253
254	sub esp, MUTEX_WAITER.sizeof	254	sub esp, MUTEX_WAITER.sizeof
255		255
256	list_add_tail esp, ecx ;esp= new waiter, ecx= list head	256	list_add_tail esp, ecx ;esp= new waiter, ecx= list head
257		257
258	mov edx, [TASK_BASE]	258	mov edx, [TASK_BASE]
259	mov [esp+MUTEX_WAITER.task], edx	259	mov [esp+MUTEX_WAITER.task], edx
260		260
261	.forever:	261	.forever:
262		262
263	mov eax, -1	263	mov eax, -1
264	xchg eax, [ecx+MUTEX.count]	264	xchg eax, [ecx+MUTEX.count]
265	dec eax	265	dec eax
266	jz @F	266	jz @F
267		267
268	mov [edx+TASKDATA.state], 1	268	mov [edx+TASKDATA.state], 1
269	call change_task	269	call change_task
270	jmp .forever	270	jmp .forever
271	@@:	271	@@:
272	mov edx, [esp+MUTEX_WAITER.list.next]	272	mov edx, [esp+MUTEX_WAITER.list.next]
273	mov eax, [esp+MUTEX_WAITER.list.prev]	273	mov eax, [esp+MUTEX_WAITER.list.prev]
274		274
275	mov [eax+MUTEX_WAITER.list.next], edx	275	mov [eax+MUTEX_WAITER.list.next], edx
276	mov [edx+MUTEX_WAITER.list.prev], eax	276	mov [edx+MUTEX_WAITER.list.prev], eax
277	cmp [ecx+MUTEX.wait.next], ecx	277	cmp [ecx+MUTEX.wait.next], ecx
278	jne @F	278	jne @F
279		279
280	mov [ecx+MUTEX.count], 0	280	mov [ecx+MUTEX.count], 0
281	@@:	281	@@:
282	add esp, MUTEX_WAITER.sizeof	282	add esp, MUTEX_WAITER.sizeof
283		283
284	popfd	284	popfd
285	.done:	285	.done:
286	ret	286	ret
287		287
288	;void __fastcall mutex_unlock(struct mutex *lock)	288	;void __fastcall mutex_unlock(struct mutex *lock)
289		289
290	align 4	290	align 4
291	mutex_unlock:	291	mutex_unlock:
292		292
293	pushfd	293	pushfd
294	cli	294	cli
295		295
296	mov eax, [ecx+MUTEX.wait.next]	296	mov eax, [ecx+MUTEX.wait.next]
297	cmp eax, [ecx]	297	cmp eax, ecx
298	mov [ecx+MUTEX.count], 1	298	mov [ecx+MUTEX.count], 1
299	je @F	299	je @F
300		300
301	mov eax, [eax+MUTEX_WAITER.task]	301	mov eax, [eax+MUTEX_WAITER.task]
302	mov [eax+TASKDATA.state], 0	302	mov [eax+TASKDATA.state], 0
303	@@:	303	@@:
304	popfd	304	popfd
305	ret	305	ret
306		306
307		307
308	purge MUTEX_WAITER	308	purge MUTEX_WAITER
309		309
310	if 0	310	if 0
311		311
312	struc TIMER	312	struc TIMER
313	{	313	{
314	.next dd ?	314	.next dd ?
315	.exp_time dd ?	315	.exp_time dd ?
316	.func dd ?	316	.func dd ?
317	.arg dd ?	317	.arg dd ?
318	}	318	}
319		319
320		320
321	MAX_PROIRITY 0 ; highest, used for kernel tasks	321	MAX_PROIRITY 0 ; highest, used for kernel tasks
322	MAX_USER_PRIORITY 0 ; highest priority for user processes	322	MAX_USER_PRIORITY 0 ; highest priority for user processes
323	USER_PRIORITY 7 ; default (should correspond to nice 0)	323	USER_PRIORITY 7 ; default (should correspond to nice 0)
324	MIN_USER_PRIORITY 14 ; minimum priority for user processes	324	MIN_USER_PRIORITY 14 ; minimum priority for user processes
325	IDLE_PRIORITY 15 ; lowest, only IDLE process goes here	325	IDLE_PRIORITY 15 ; lowest, only IDLE process goes here
326	NR_SCHED_QUEUES 16 ; MUST equal IDLE_PRIORYTY + 1	326	NR_SCHED_QUEUES 16 ; MUST equal IDLE_PRIORYTY + 1
327		327
328	uglobal	328	uglobal
329	rdy_head rd 16	329	rdy_head rd 16
330	endg	330	endg
331		331
332	align 4	332	align 4
333	pick_task:	333	pick_task:
334		334
335	xor eax, eax	335	xor eax, eax
336	.pick:	336	.pick:
337	mov ebx, [rdy_head+eax*4]	337	mov ebx, [rdy_head+eax*4]
338	test ebx, ebx	338	test ebx, ebx
339	jz .next	339	jz .next
340		340
341	mov [next_task], ebx	341	mov [next_task], ebx
342	test [ebx+flags.billable]	342	test [ebx+flags.billable]
343	jz @F	343	jz @F
344	mov [bill_task], ebx	344	mov [bill_task], ebx
345	@@:	345	@@:
346	ret	346	ret
347	.next:	347	.next:
348	inc eax	348	inc eax
349	jmp .pick	349	jmp .pick
350		350
351	; param	351	; param
352	; eax= task	352	; eax= task
353	;	353	;
354	; retval	354	; retval
355	; eax= task	355	; eax= task
356	; ebx= queue	356	; ebx= queue
357	; ecx= front if 1 or back if 0	357	; ecx= front if 1 or back if 0
358	align 4	358	align 4
359	shed:	359	shed:
360	cmp [eax+.tics_left], 0 ;signed compare	360	cmp [eax+.tics_left], 0 ;signed compare
361	mov ebx, [eax+.priority]	361	mov ebx, [eax+.priority]
362	setg ecx	362	setg ecx
363	jg @F	363	jg @F
364		364
365	mov edx, [eax+.tics_quantum]	365	mov edx, [eax+.tics_quantum]
366	mov [eax+.ticks_left], edx	366	mov [eax+.ticks_left], edx
367	cmp ebx, (IDLE_PRIORITY-1)	367	cmp ebx, (IDLE_PRIORITY-1)
368	je @F	368	je @F
369	inc ebx	369	inc ebx
370	@@:	370	@@:
371	ret	371	ret
372		372
373	; param	373	; param
374	; eax= task	374	; eax= task
375	align 4	375	align 4
376	enqueue:	376	enqueue:
377	call shed ;eax	377	call shed ;eax
378	cmp [rdy_head+ebx*4],0	378	cmp [rdy_head+ebx*4],0
379	jnz @F	379	jnz @F
380		380
381	mov [rdy_head+ebx*4], eax	381	mov [rdy_head+ebx*4], eax
382	mov [rdy_tail+ebx*4], eax	382	mov [rdy_tail+ebx*4], eax
383	mov [eax+.next_ready], 0	383	mov [eax+.next_ready], 0
384	jmp .pick	384	jmp .pick
385	@@:	385	@@:
386	test ecx, ecx	386	test ecx, ecx
387	jz .back	387	jz .back
388		388
389	mov ecx, [rdy_head+ebx*4]	389	mov ecx, [rdy_head+ebx*4]
390	mov [eax+.next_ready], ecx	390	mov [eax+.next_ready], ecx
391	mov [rdy_head+ebx*4], eax	391	mov [rdy_head+ebx*4], eax
392	jmp .pick	392	jmp .pick
393	.back:	393	.back:
394	mov ecx, [rdy_tail+ebx*4]	394	mov ecx, [rdy_tail+ebx*4]
395	mov [ecx+.next_ready], eax	395	mov [ecx+.next_ready], eax
396	mov [rdy_tail+ebx*4], eax	396	mov [rdy_tail+ebx*4], eax
397	mov [eax+.next_ready], 0	397	mov [eax+.next_ready], 0
398	.pick:	398	.pick:
399	call pick_proc ;select next task	399	call pick_proc ;select next task
400	ret	400	ret
401		401
402	end if	402	end if

Subversion Repositories Kolibri OS

(root)/kernel/branches/Kolibri-acpi/core/sched.inc – Rev 2143 → 2150