WebSVN – Kolibri OS – Diff – /kernel/branches/net/core/debug.inc


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2011. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision $
 
 
; diamond, 2006
sys_debug_services:
        cmp     ebx, 9
        ja      @f
        jmp     dword [sys_debug_services_table+ebx*4]
@@:
        ret
iglobal
align 4
sys_debug_services_table:
        dd      debug_set_event_data
        dd      debug_getcontext
        dd      debug_setcontext
        dd      debug_detach
        dd      debug_suspend
        dd      debug_resume
        dd      debug_read_process_memory
        dd      debug_write_process_memory
        dd      debug_terminate
        dd      debug_set_drx
endg
debug_set_event_data:
; in: ecx = pointer
; destroys eax
        mov     eax, [current_slot]
        mov     [eax+APPDATA.dbg_event_mem], ecx
        ret
 
get_debuggee_slot:
; in: ecx=PID
; out: CF=1 if error
;      CF=0 and eax=slot*0x20 if ok
; out: interrupts disabled
        cli
        mov     eax, ecx
        call    pid_to_slot
        test    eax, eax
        jz      .ret_bad
        shl     eax, 5
        push    ebx
        mov     ebx, [CURRENT_TASK]
        cmp     [SLOT_BASE+eax*8+APPDATA.debugger_slot], ebx
        pop     ebx
        jnz     .ret_bad
;       clc     ; automatically
        ret
.ret_bad:
        stc
        ret
 
debug_detach:
; in: ecx=pid
; destroys eax,ebx
        call    get_debuggee_slot
        jc      .ret
        and     dword [eax*8+SLOT_BASE+APPDATA.debugger_slot], 0
        call    do_resume
.ret:
        sti
        ret
 
debug_terminate:
; in: ecx=pid
        call    get_debuggee_slot
        jc      debug_detach.ret
        mov     ecx, eax
        shr     ecx, 5
;        push    2
;        pop     ebx
        mov     edx, esi
        jmp     sysfn_terminate
 
debug_suspend:
; in: ecx=pid
; destroys eax,ecx
        cli
        mov     eax, ecx
        call    pid_to_slot
        shl     eax, 5
        jz      .ret
        mov     cl, [CURRENT_TASK+eax+TASKDATA.state] ; process state
        test    cl, cl
        jz      .1
        cmp     cl, 5
        jnz     .ret
        mov     cl, 2
.2:
        mov     [CURRENT_TASK+eax+TASKDATA.state], cl
.ret:
        sti
        ret
.1:
        inc     ecx
        jmp     .2
 
do_resume:
        mov     cl, [CURRENT_TASK+eax+TASKDATA.state]
        cmp     cl, 1
        jz      .1
        cmp     cl, 2
        jnz     .ret
        mov     cl, 5
.2:
        mov     [CURRENT_TASK+eax+TASKDATA.state], cl
.ret:
        ret
.1:
        dec     ecx
        jmp     .2
 
debug_resume:
; in: ecx=pid
; destroys eax,ebx
        cli
        mov     eax, ecx
        call    pid_to_slot
        shl     eax, 5
        jz      .ret
        call    do_resume
.ret:
        sti
        ret
 
debug_getcontext:
; in:
; ecx=pid
; edx=sizeof(CONTEXT)
; esi->CONTEXT
; destroys eax,ecx,edx,esi,edi
        cmp     edx, 28h
        jnz     .ret
;        push    ecx
;        mov     ecx, esi
        call    check_region
;        pop     ecx
        dec     eax
        jnz     .ret
        call    get_debuggee_slot
        jc      .ret
        mov     edi, esi
        mov     eax, [eax*8+SLOT_BASE+APPDATA.pl0_stack]
        lea     esi, [eax+RING0_STACK_SIZE]
 
.ring0:
; note that following code assumes that all interrupt/exception handlers
; saves ring-3 context by pushad in this order
; top of ring0 stack: ring3 stack ptr (ss+esp), iret data (cs+eip+eflags), pushad
        sub     esi, 8+12+20h
        lodsd                     ;edi
        mov     [edi+24h], eax
        lodsd                     ;esi
        mov     [edi+20h], eax
        lodsd                     ; ebp
        mov     [edi+1Ch], eax
        lodsd                     ;esp
        lodsd                     ;ebx
        mov     [edi+14h], eax
        lodsd                     ;edx
        mov     [edi+10h], eax
        lodsd                     ;ecx
        mov     [edi+0Ch], eax
        lodsd                     ;eax
        mov     [edi+8], eax
        lodsd                     ;eip
        mov     [edi], eax
        lodsd                     ;cs
        lodsd                     ;eflags
        mov     [edi+4], eax
        lodsd                     ;esp
        mov     [edi+18h], eax
.ret:
        sti
        ret
 
debug_setcontext:
; in:
; ecx=pid
; edx=sizeof(CONTEXT)
; esi->CONTEXT
; destroys eax,ecx,edx,esi,edi
        cmp     edx, 28h
        jnz     .ret
;        push    ebx
;        mov     ebx, edx
        call    check_region
;        pop     ebx
        dec     eax
        jnz     .ret
        call    get_debuggee_slot
        jc      .stiret
;        mov     esi, edx
        mov     eax, [eax*8+SLOT_BASE+APPDATA.pl0_stack]
        lea     edi, [eax+RING0_STACK_SIZE]
 
.ring0:
        sub     edi, 8+12+20h
        mov     eax, [esi+24h]    ;edi
        stosd
        mov     eax, [esi+20h]    ;esi
        stosd
        mov     eax, [esi+1Ch]    ;ebp
        stosd
        scasd
        mov     eax, [esi+14h]    ;ebx
        stosd
        mov     eax, [esi+10h]    ;edx
        stosd
        mov     eax, [esi+0Ch]    ;ecx
        stosd
        mov     eax, [esi+8]      ;eax
        stosd
        mov     eax, [esi]        ;eip
        stosd
        scasd
        mov     eax, [esi+4]      ;eflags
        stosd
        mov     eax, [esi+18h]    ;esp
        stosd
.stiret:
        sti
.ret:
        ret
 
debug_set_drx:
        call    get_debuggee_slot
        jc      .errret
        mov     ebp, eax
        lea     eax, [eax*8+SLOT_BASE+APPDATA.dbg_regs]
; [eax]=dr0, [eax+4]=dr1, [eax+8]=dr2, [eax+C]=dr3
; [eax+10]=dr7
        cmp     esi, OS_BASE
        jae     .errret
        cmp     dl, 3
        ja      .errret
        mov     ecx, dr7
;fix me
        xchg    ecx, edx
        shr     edx, cl
        shr     edx, cl
        xchg    ecx, edx
 
        test    ecx, 2          ; bit 1+2*index = G0..G3, global break enable
        jnz     .errret2
        test    dh, dh
        jns     .new
; clear breakpoint
        movzx   edx, dl
        add     edx, edx
        and     dword [eax+edx*2], 0    ; clear DR
        btr     dword [eax+10h], edx    ; clear L bit
        test    byte [eax+10h], 55h
        jnz     .okret
;        imul    eax, ebp, tss_step/32
;        and     byte [eax + tss_data + TSS._trap], not 1
        and     [ebp*8 + SLOT_BASE+APPDATA.dbg_state], not 1
.okret:
        and     dword [esp+32], 0
        sti
        ret
.errret:
        sti
        mov     dword [esp+32], 1
        ret
.errret2:
        sti
        mov     dword [esp+32], 2
        ret
.new:
; add new breakpoint
; dl=index; dh=flags; esi=address
        test    dh, 0xF0
        jnz     .errret
        mov     cl, dh
        and     cl, 3
        cmp     cl, 2
        jz      .errret
        mov     cl, dh
        shr     cl, 2
        cmp     cl, 2
        jz      .errret
 
        mov     ebx, esi
        test    bl, dl
 
        jnz     .errret
        or      byte [eax+10h+1], 3     ; set GE and LE flags
 
        movzx   edx, dh
        movzx   ecx, dl
        add     ecx, ecx
        bts     dword [eax+10h], ecx    ; set L flag
        add     ecx, ecx
        mov     [eax+ecx], ebx;esi      ; set DR
        shl     edx, cl
        mov     ebx, 0xF
        shl     ebx, cl
        not     ebx
        and     [eax+10h+2], bx
        or      [eax+10h+2], dx         ; set R/W and LEN fields
;        imul    eax, ebp, tss_step/32
;        or      byte [eax + tss_data + TSS._trap], 1
        or      [ebp*8 + SLOT_BASE+APPDATA.dbg_state], 1
        jmp     .okret
 
debug_read_process_memory:
; in:
; ecx=pid
; edx=length
; edi->buffer in debugger
; esi=address in debuggee
; out: [esp+36]=sizeof(read)
; destroys all
;        push    ebx
;        mov     ebx, esi
        call    check_region
;        pop     ebx
        dec     eax
        jnz     .err
        call    get_debuggee_slot
        jc      .err
        shr     eax, 5
        mov     ecx, edi
        call    read_process_memory
        sti
        mov     dword [esp+32], eax
        ret
.err:
        or      dword [esp+32], -1
        ret
 
debug_write_process_memory:
; in:
; ecx=pid
; edx=length
; edi->buffer in debugger
; esi=address in debuggee
; out: [esp+36]=sizeof(write)
; destroys all
;        push    ebx
;        mov     ebx, esi
        call    check_region
;        pop     ebx
        dec     eax
        jnz     debug_read_process_memory.err
        call    get_debuggee_slot
        jc      debug_read_process_memory.err
        shr     eax, 5
        mov     ecx, edi
        call    write_process_memory
        sti
        mov     [esp+32], eax
        ret
 
debugger_notify:
; in: eax=debugger slot
;     ecx=size of debug message
;     [esp+4]..[esp+4+ecx]=message
; interrupts must be disabled!
; destroys all general registers
; interrupts remain disabled
        xchg    ebp, eax
        mov     edi, [timer_ticks]
        add     edi, 500        ; 5 sec timeout
.1:
        mov     eax, ebp
        shl     eax, 8
        mov     esi, [SLOT_BASE+eax+APPDATA.dbg_event_mem]
        test    esi, esi
        jz      .ret
; read buffer header
        push    ecx
        push    eax
        push    eax
        mov     eax, ebp
        mov     ecx, esp
        mov     edx, 8
        call    read_process_memory
        cmp     eax, edx
        jz      @f
        add     esp, 12
        jmp     .ret
@@:
        cmp     dword [ecx], 0
        jg      @f
.2:
        pop     ecx
        pop     ecx
        pop     ecx
        cmp     dword [CURRENT_TASK], 1
        jnz     .notos
        cmp     [timer_ticks], edi
        jae     .ret
.notos:
        sti
        call    change_task
        cli
        jmp     .1
@@:
        mov     edx, [ecx+8]
        add     edx, [ecx+4]
        cmp     edx, [ecx]
        ja      .2
; advance buffer position
        push    edx
        mov     edx, 4
        sub     ecx, edx
        mov     eax, ebp
        add     esi, edx
        call    write_process_memory
        pop     eax
; write message
        mov     eax, ebp
        add     esi, edx
        add     esi, [ecx+8]
        add     ecx, 20
        pop     edx
        pop     edx
        pop     edx
        call    write_process_memory
; new debug event
        mov     eax, ebp
        shl     eax, 8
        or      byte [SLOT_BASE+eax+APPDATA.event_mask+1], 1      ; set flag 100h
.ret:
        ret

Rev 2382	Rev 2540
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2011. All rights reserved. ;;
4	;; Distributed under terms of the GNU General Public License ;;	4	;; Distributed under terms of the GNU General Public License ;;
5	;; ;;	5	;; ;;
6	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	6	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
7		7
8	$Revision: 2382 $	8	$Revision $
9		9
10		10
11	; diamond, 2006	11	; diamond, 2006
12	sys_debug_services:	12	sys_debug_services:
13	cmp ebx, 9	13	cmp ebx, 9
14	ja @f	14	ja @f
15	jmp dword [sys_debug_services_table+ebx*4]	15	jmp dword [sys_debug_services_table+ebx*4]
16	@@:	16	@@:
17	ret	17	ret
18	iglobal	18	iglobal
19	align 4	19	align 4
20	sys_debug_services_table:	20	sys_debug_services_table:
21	dd debug_set_event_data	21	dd debug_set_event_data
22	dd debug_getcontext	22	dd debug_getcontext
23	dd debug_setcontext	23	dd debug_setcontext
24	dd debug_detach	24	dd debug_detach
25	dd debug_suspend	25	dd debug_suspend
26	dd debug_resume	26	dd debug_resume
27	dd debug_read_process_memory	27	dd debug_read_process_memory
28	dd debug_write_process_memory	28	dd debug_write_process_memory
29	dd debug_terminate	29	dd debug_terminate
30	dd debug_set_drx	30	dd debug_set_drx
31	endg	31	endg
32	debug_set_event_data:	32	debug_set_event_data:
33	; in: ecx = pointer	33	; in: ecx = pointer
34	; destroys eax	34	; destroys eax
35	mov eax, [current_slot]	35	mov eax, [current_slot]
36	mov [eax+APPDATA.dbg_event_mem], ecx	36	mov [eax+APPDATA.dbg_event_mem], ecx
37	ret	37	ret
38		38
39	get_debuggee_slot:	39	get_debuggee_slot:
40	; in: ecx=PID	40	; in: ecx=PID
41	; out: CF=1 if error	41	; out: CF=1 if error
42	; CF=0 and eax=slot*0x20 if ok	42	; CF=0 and eax=slot*0x20 if ok
43	; out: interrupts disabled	43	; out: interrupts disabled
44	cli	44	cli
45	mov eax, ecx	45	mov eax, ecx
46	call pid_to_slot	46	call pid_to_slot
47	test eax, eax	47	test eax, eax
48	jz .ret_bad	48	jz .ret_bad
49	shl eax, 5	49	shl eax, 5
50	push ebx	50	push ebx
51	mov ebx, [CURRENT_TASK]	51	mov ebx, [CURRENT_TASK]
52	cmp [SLOT_BASE+eax*8+APPDATA.debugger_slot], ebx	52	cmp [SLOT_BASE+eax*8+APPDATA.debugger_slot], ebx
53	pop ebx	53	pop ebx
54	jnz .ret_bad	54	jnz .ret_bad
55	; clc ; automatically	55	; clc ; automatically
56	ret	56	ret
57	.ret_bad:	57	.ret_bad:
58	stc	58	stc
59	ret	59	ret
60		60
61	debug_detach:	61	debug_detach:
62	; in: ecx=pid	62	; in: ecx=pid
63	; destroys eax,ebx	63	; destroys eax,ebx
64	call get_debuggee_slot	64	call get_debuggee_slot
65	jc .ret	65	jc .ret
66	and dword [eax*8+SLOT_BASE+APPDATA.debugger_slot], 0	66	and dword [eax*8+SLOT_BASE+APPDATA.debugger_slot], 0
67	call do_resume	67	call do_resume
68	.ret:	68	.ret:
69	sti	69	sti
70	ret	70	ret
71		71
72	debug_terminate:	72	debug_terminate:
73	; in: ecx=pid	73	; in: ecx=pid
74	call get_debuggee_slot	74	call get_debuggee_slot
75	jc debug_detach.ret	75	jc debug_detach.ret
76	mov ecx, eax	76	mov ecx, eax
77	shr ecx, 5	77	shr ecx, 5
78	; push 2	78	; push 2
79	; pop ebx	79	; pop ebx
80	mov edx, esi	80	mov edx, esi
81	jmp sysfn_terminate	81	jmp sysfn_terminate
82		82
83	debug_suspend:	83	debug_suspend:
84	; in: ecx=pid	84	; in: ecx=pid
85	; destroys eax,ecx	85	; destroys eax,ecx
86	cli	86	cli
87	mov eax, ecx	87	mov eax, ecx
88	call pid_to_slot	88	call pid_to_slot
89	shl eax, 5	89	shl eax, 5
90	jz .ret	90	jz .ret
91	mov cl, [CURRENT_TASK+eax+TASKDATA.state] ; process state	91	mov cl, [CURRENT_TASK+eax+TASKDATA.state] ; process state
92	test cl, cl	92	test cl, cl
93	jz .1	93	jz .1
94	cmp cl, 5	94	cmp cl, 5
95	jnz .ret	95	jnz .ret
96	mov cl, 2	96	mov cl, 2
97	.2:	97	.2:
98	mov [CURRENT_TASK+eax+TASKDATA.state], cl	98	mov [CURRENT_TASK+eax+TASKDATA.state], cl
99	.ret:	99	.ret:
100	sti	100	sti
101	ret	101	ret
102	.1:	102	.1:
103	inc ecx	103	inc ecx
104	jmp .2	104	jmp .2
105		105
106	do_resume:	106	do_resume:
107	mov cl, [CURRENT_TASK+eax+TASKDATA.state]	107	mov cl, [CURRENT_TASK+eax+TASKDATA.state]
108	cmp cl, 1	108	cmp cl, 1
109	jz .1	109	jz .1
110	cmp cl, 2	110	cmp cl, 2
111	jnz .ret	111	jnz .ret
112	mov cl, 5	112	mov cl, 5
113	.2:	113	.2:
114	mov [CURRENT_TASK+eax+TASKDATA.state], cl	114	mov [CURRENT_TASK+eax+TASKDATA.state], cl
115	.ret:	115	.ret:
116	ret	116	ret
117	.1:	117	.1:
118	dec ecx	118	dec ecx
119	jmp .2	119	jmp .2
120		120
121	debug_resume:	121	debug_resume:
122	; in: ecx=pid	122	; in: ecx=pid
123	; destroys eax,ebx	123	; destroys eax,ebx
124	cli	124	cli
125	mov eax, ecx	125	mov eax, ecx
126	call pid_to_slot	126	call pid_to_slot
127	shl eax, 5	127	shl eax, 5
128	jz .ret	128	jz .ret
129	call do_resume	129	call do_resume
130	.ret:	130	.ret:
131	sti	131	sti
132	ret	132	ret
133		133
134	debug_getcontext:	134	debug_getcontext:
135	; in:	135	; in:
136	; ecx=pid	136	; ecx=pid
137	; edx=sizeof(CONTEXT)	137	; edx=sizeof(CONTEXT)
138	; esi->CONTEXT	138	; esi->CONTEXT
139	; destroys eax,ecx,edx,esi,edi	139	; destroys eax,ecx,edx,esi,edi
140	cmp edx, 28h	140	cmp edx, 28h
141	jnz .ret	141	jnz .ret
142	; push ecx	142	; push ecx
143	; mov ecx, esi	143	; mov ecx, esi
144	call check_region	144	call check_region
145	; pop ecx	145	; pop ecx
146	dec eax	146	dec eax
147	jnz .ret	147	jnz .ret
148	call get_debuggee_slot	148	call get_debuggee_slot
149	jc .ret	149	jc .ret
150	mov edi, esi	150	mov edi, esi
151	mov eax, [eax*8+SLOT_BASE+APPDATA.pl0_stack]	151	mov eax, [eax*8+SLOT_BASE+APPDATA.pl0_stack]
152	lea esi, [eax+RING0_STACK_SIZE]	152	lea esi, [eax+RING0_STACK_SIZE]
153		153
154	.ring0:	154	.ring0:
155	; note that following code assumes that all interrupt/exception handlers	155	; note that following code assumes that all interrupt/exception handlers
156	; saves ring-3 context by pushad in this order	156	; saves ring-3 context by pushad in this order
157	; top of ring0 stack: ring3 stack ptr (ss+esp), iret data (cs+eip+eflags), pushad	157	; top of ring0 stack: ring3 stack ptr (ss+esp), iret data (cs+eip+eflags), pushad
158	sub esi, 8+12+20h	158	sub esi, 8+12+20h
159	lodsd ;edi	159	lodsd ;edi
160	mov [edi+24h], eax	160	mov [edi+24h], eax
161	lodsd ;esi	161	lodsd ;esi
162	mov [edi+20h], eax	162	mov [edi+20h], eax
163	lodsd ; ebp	163	lodsd ; ebp
164	mov [edi+1Ch], eax	164	mov [edi+1Ch], eax
165	lodsd ;esp	165	lodsd ;esp
166	lodsd ;ebx	166	lodsd ;ebx
167	mov [edi+14h], eax	167	mov [edi+14h], eax
168	lodsd ;edx	168	lodsd ;edx
169	mov [edi+10h], eax	169	mov [edi+10h], eax
170	lodsd ;ecx	170	lodsd ;ecx
171	mov [edi+0Ch], eax	171	mov [edi+0Ch], eax
172	lodsd ;eax	172	lodsd ;eax
173	mov [edi+8], eax	173	mov [edi+8], eax
174	lodsd ;eip	174	lodsd ;eip
175	mov [edi], eax	175	mov [edi], eax
176	lodsd ;cs	176	lodsd ;cs
177	lodsd ;eflags	177	lodsd ;eflags
178	mov [edi+4], eax	178	mov [edi+4], eax
179	lodsd ;esp	179	lodsd ;esp
180	mov [edi+18h], eax	180	mov [edi+18h], eax
181	.ret:	181	.ret:
182	sti	182	sti
183	ret	183	ret
184		184
185	debug_setcontext:	185	debug_setcontext:
186	; in:	186	; in:
187	; ecx=pid	187	; ecx=pid
188	; edx=sizeof(CONTEXT)	188	; edx=sizeof(CONTEXT)
189	; esi->CONTEXT	189	; esi->CONTEXT
190	; destroys eax,ecx,edx,esi,edi	190	; destroys eax,ecx,edx,esi,edi
191	cmp edx, 28h	191	cmp edx, 28h
192	jnz .ret	192	jnz .ret
193	; push ebx	193	; push ebx
194	; mov ebx, edx	194	; mov ebx, edx
195	call check_region	195	call check_region
196	; pop ebx	196	; pop ebx
197	dec eax	197	dec eax
198	jnz .ret	198	jnz .ret
199	call get_debuggee_slot	199	call get_debuggee_slot
200	jc .stiret	200	jc .stiret
201	; mov esi, edx	201	; mov esi, edx
202	mov eax, [eax*8+SLOT_BASE+APPDATA.pl0_stack]	202	mov eax, [eax*8+SLOT_BASE+APPDATA.pl0_stack]
203	lea edi, [eax+RING0_STACK_SIZE]	203	lea edi, [eax+RING0_STACK_SIZE]
204		204
205	.ring0:	205	.ring0:
206	sub edi, 8+12+20h	206	sub edi, 8+12+20h
207	mov eax, [esi+24h] ;edi	207	mov eax, [esi+24h] ;edi
208	stosd	208	stosd
209	mov eax, [esi+20h] ;esi	209	mov eax, [esi+20h] ;esi
210	stosd	210	stosd
211	mov eax, [esi+1Ch] ;ebp	211	mov eax, [esi+1Ch] ;ebp
212	stosd	212	stosd
213	scasd	213	scasd
214	mov eax, [esi+14h] ;ebx	214	mov eax, [esi+14h] ;ebx
215	stosd	215	stosd
216	mov eax, [esi+10h] ;edx	216	mov eax, [esi+10h] ;edx
217	stosd	217	stosd
218	mov eax, [esi+0Ch] ;ecx	218	mov eax, [esi+0Ch] ;ecx
219	stosd	219	stosd
220	mov eax, [esi+8] ;eax	220	mov eax, [esi+8] ;eax
221	stosd	221	stosd
222	mov eax, [esi] ;eip	222	mov eax, [esi] ;eip
223	stosd	223	stosd
224	scasd	224	scasd
225	mov eax, [esi+4] ;eflags	225	mov eax, [esi+4] ;eflags
226	stosd	226	stosd
227	mov eax, [esi+18h] ;esp	227	mov eax, [esi+18h] ;esp
228	stosd	228	stosd
229	.stiret:	229	.stiret:
230	sti	230	sti
231	.ret:	231	.ret:
232	ret	232	ret
233		233
234	debug_set_drx:	234	debug_set_drx:
235	call get_debuggee_slot	235	call get_debuggee_slot
236	jc .errret	236	jc .errret
237	mov ebp, eax	237	mov ebp, eax
238	lea eax, [eax*8+SLOT_BASE+APPDATA.dbg_regs]	238	lea eax, [eax*8+SLOT_BASE+APPDATA.dbg_regs]
239	; [eax]=dr0, [eax+4]=dr1, [eax+8]=dr2, [eax+C]=dr3	239	; [eax]=dr0, [eax+4]=dr1, [eax+8]=dr2, [eax+C]=dr3
240	; [eax+10]=dr7	240	; [eax+10]=dr7
241	cmp esi, OS_BASE	241	cmp esi, OS_BASE
242	jae .errret	242	jae .errret
243	cmp dl, 3	243	cmp dl, 3
244	ja .errret	244	ja .errret
245	mov ecx, dr7	245	mov ecx, dr7
246	;fix me	246	;fix me
247	xchg ecx, edx	247	xchg ecx, edx
248	shr edx, cl	248	shr edx, cl
249	shr edx, cl	249	shr edx, cl
250	xchg ecx, edx	250	xchg ecx, edx
251		251
252	test ecx, 2 ; bit 1+2*index = G0..G3, global break enable	252	test ecx, 2 ; bit 1+2*index = G0..G3, global break enable
253	jnz .errret2	253	jnz .errret2
254	test dh, dh	254	test dh, dh
255	jns .new	255	jns .new
256	; clear breakpoint	256	; clear breakpoint
257	movzx edx, dl	257	movzx edx, dl
258	add edx, edx	258	add edx, edx
259	and dword [eax+edx*2], 0 ; clear DR	259	and dword [eax+edx*2], 0 ; clear DR
260	btr dword [eax+10h], edx ; clear L bit	260	btr dword [eax+10h], edx ; clear L bit
261	test byte [eax+10h], 55h	261	test byte [eax+10h], 55h
262	jnz .okret	262	jnz .okret
263	; imul eax, ebp, tss_step/32	263	; imul eax, ebp, tss_step/32
264	; and byte [eax + tss_data + TSS._trap], not 1	264	; and byte [eax + tss_data + TSS._trap], not 1
265	and [ebp*8 + SLOT_BASE+APPDATA.dbg_state], not 1	265	and [ebp*8 + SLOT_BASE+APPDATA.dbg_state], not 1
266	.okret:	266	.okret:
267	and dword [esp+32], 0	267	and dword [esp+32], 0
268	sti	268	sti
269	ret	269	ret
270	.errret:	270	.errret:
271	sti	271	sti
272	mov dword [esp+32], 1	272	mov dword [esp+32], 1
273	ret	273	ret
274	.errret2:	274	.errret2:
275	sti	275	sti
276	mov dword [esp+32], 2	276	mov dword [esp+32], 2
277	ret	277	ret
278	.new:	278	.new:
279	; add new breakpoint	279	; add new breakpoint
280	; dl=index; dh=flags; esi=address	280	; dl=index; dh=flags; esi=address
281	test dh, 0xF0	281	test dh, 0xF0
282	jnz .errret	282	jnz .errret
283	mov cl, dh	283	mov cl, dh
284	and cl, 3	284	and cl, 3
285	cmp cl, 2	285	cmp cl, 2
286	jz .errret	286	jz .errret
287	mov cl, dh	287	mov cl, dh
288	shr cl, 2	288	shr cl, 2
289	cmp cl, 2	289	cmp cl, 2
290	jz .errret	290	jz .errret
291		291
292	mov ebx, esi	292	mov ebx, esi
293	test bl, dl	293	test bl, dl
294		294
295	jnz .errret	295	jnz .errret
296	or byte [eax+10h+1], 3 ; set GE and LE flags	296	or byte [eax+10h+1], 3 ; set GE and LE flags
297		297
298	movzx edx, dh	298	movzx edx, dh
299	movzx ecx, dl	299	movzx ecx, dl
300	add ecx, ecx	300	add ecx, ecx
301	bts dword [eax+10h], ecx ; set L flag	301	bts dword [eax+10h], ecx ; set L flag
302	add ecx, ecx	302	add ecx, ecx
303	mov [eax+ecx], ebx;esi ; set DR	303	mov [eax+ecx], ebx;esi ; set DR
304	shl edx, cl	304	shl edx, cl
305	mov ebx, 0xF	305	mov ebx, 0xF
306	shl ebx, cl	306	shl ebx, cl
307	not ebx	307	not ebx
308	and [eax+10h+2], bx	308	and [eax+10h+2], bx
309	or [eax+10h+2], dx ; set R/W and LEN fields	309	or [eax+10h+2], dx ; set R/W and LEN fields
310	; imul eax, ebp, tss_step/32	310	; imul eax, ebp, tss_step/32
311	; or byte [eax + tss_data + TSS._trap], 1	311	; or byte [eax + tss_data + TSS._trap], 1
312	or [ebp*8 + SLOT_BASE+APPDATA.dbg_state], 1	312	or [ebp*8 + SLOT_BASE+APPDATA.dbg_state], 1
313	jmp .okret	313	jmp .okret
314		314
315	debug_read_process_memory:	315	debug_read_process_memory:
316	; in:	316	; in:
317	; ecx=pid	317	; ecx=pid
318	; edx=length	318	; edx=length
319	; edi->buffer in debugger	319	; edi->buffer in debugger
320	; esi=address in debuggee	320	; esi=address in debuggee
321	; out: [esp+36]=sizeof(read)	321	; out: [esp+36]=sizeof(read)
322	; destroys all	322	; destroys all
323	; push ebx	323	; push ebx
324	; mov ebx, esi	324	; mov ebx, esi
325	call check_region	325	call check_region
326	; pop ebx	326	; pop ebx
327	dec eax	327	dec eax
328	jnz .err	328	jnz .err
329	call get_debuggee_slot	329	call get_debuggee_slot
330	jc .err	330	jc .err
331	shr eax, 5	331	shr eax, 5
332	mov ecx, edi	332	mov ecx, edi
333	call read_process_memory	333	call read_process_memory
334	sti	334	sti
335	mov dword [esp+32], eax	335	mov dword [esp+32], eax
336	ret	336	ret
337	.err:	337	.err:
338	or dword [esp+32], -1	338	or dword [esp+32], -1
339	ret	339	ret
340		340
341	debug_write_process_memory:	341	debug_write_process_memory:
342	; in:	342	; in:
343	; ecx=pid	343	; ecx=pid
344	; edx=length	344	; edx=length
345	; edi->buffer in debugger	345	; edi->buffer in debugger
346	; esi=address in debuggee	346	; esi=address in debuggee
347	; out: [esp+36]=sizeof(write)	347	; out: [esp+36]=sizeof(write)
348	; destroys all	348	; destroys all
349	; push ebx	349	; push ebx
350	; mov ebx, esi	350	; mov ebx, esi
351	call check_region	351	call check_region
352	; pop ebx	352	; pop ebx
353	dec eax	353	dec eax
354	jnz debug_read_process_memory.err	354	jnz debug_read_process_memory.err
355	call get_debuggee_slot	355	call get_debuggee_slot
356	jc debug_read_process_memory.err	356	jc debug_read_process_memory.err
357	shr eax, 5	357	shr eax, 5
358	mov ecx, edi	358	mov ecx, edi
359	call write_process_memory	359	call write_process_memory
360	sti	360	sti
361	mov [esp+32], eax	361	mov [esp+32], eax
362	ret	362	ret
363		363
364	debugger_notify:	364	debugger_notify:
365	; in: eax=debugger slot	365	; in: eax=debugger slot
366	; ecx=size of debug message	366	; ecx=size of debug message
367	; [esp+4]..[esp+4+ecx]=message	367	; [esp+4]..[esp+4+ecx]=message
368	; interrupts must be disabled!	368	; interrupts must be disabled!
369	; destroys all general registers	369	; destroys all general registers
370	; interrupts remain disabled	370	; interrupts remain disabled
371	xchg ebp, eax	371	xchg ebp, eax
372	mov edi, [timer_ticks]	372	mov edi, [timer_ticks]
373	add edi, 500 ; 5 sec timeout	373	add edi, 500 ; 5 sec timeout
374	.1:	374	.1:
375	mov eax, ebp	375	mov eax, ebp
376	shl eax, 8	376	shl eax, 8
377	mov esi, [SLOT_BASE+eax+APPDATA.dbg_event_mem]	377	mov esi, [SLOT_BASE+eax+APPDATA.dbg_event_mem]
378	test esi, esi	378	test esi, esi
379	jz .ret	379	jz .ret
380	; read buffer header	380	; read buffer header
381	push ecx	381	push ecx
382	push eax	382	push eax
383	push eax	383	push eax
384	mov eax, ebp	384	mov eax, ebp
385	mov ecx, esp	385	mov ecx, esp
386	mov edx, 8	386	mov edx, 8
387	call read_process_memory	387	call read_process_memory
388	cmp eax, edx	388	cmp eax, edx
389	jz @f	389	jz @f
390	add esp, 12	390	add esp, 12
391	jmp .ret	391	jmp .ret
392	@@:	392	@@:
393	cmp dword [ecx], 0	393	cmp dword [ecx], 0
394	jg @f	394	jg @f
395	.2:	395	.2:
396	pop ecx	396	pop ecx
397	pop ecx	397	pop ecx
398	pop ecx	398	pop ecx
399	cmp dword [CURRENT_TASK], 1	399	cmp dword [CURRENT_TASK], 1
400	jnz .notos	400	jnz .notos
401	cmp [timer_ticks], edi	401	cmp [timer_ticks], edi
402	jae .ret	402	jae .ret
403	.notos:	403	.notos:
404	sti	404	sti
405	call change_task	405	call change_task
406	cli	406	cli
407	jmp .1	407	jmp .1
408	@@:	408	@@:
409	mov edx, [ecx+8]	409	mov edx, [ecx+8]
410	add edx, [ecx+4]	410	add edx, [ecx+4]
411	cmp edx, [ecx]	411	cmp edx, [ecx]
412	ja .2	412	ja .2
413	; advance buffer position	413	; advance buffer position
414	push edx	414	push edx
415	mov edx, 4	415	mov edx, 4
416	sub ecx, edx	416	sub ecx, edx
417	mov eax, ebp	417	mov eax, ebp
418	add esi, edx	418	add esi, edx
419	call write_process_memory	419	call write_process_memory
420	pop eax	420	pop eax
421	; write message	421	; write message
422	mov eax, ebp	422	mov eax, ebp
423	add esi, edx	423	add esi, edx
424	add esi, [ecx+8]	424	add esi, [ecx+8]
425	add ecx, 20	425	add ecx, 20
426	pop edx	426	pop edx
427	pop edx	427	pop edx
428	pop edx	428	pop edx
429	call write_process_memory	429	call write_process_memory
430	; new debug event	430	; new debug event
431	mov eax, ebp	431	mov eax, ebp
432	shl eax, 8	432	shl eax, 8
433	or byte [SLOT_BASE+eax+APPDATA.event_mask+1], 1 ; set flag 100h	433	or byte [SLOT_BASE+eax+APPDATA.event_mask+1], 1 ; set flag 100h
434	.ret:	434	.ret:
435	ret	435	ret

Subversion Repositories Kolibri OS

(root)/kernel/branches/net/core/debug.inc – Rev 2382 → 2540