WebSVN – Kolibri OS – Diff – /kernel/trunk/core/debug.inc


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2011. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 4893 $
 
 
; 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,ebx,ecx,edx,esi,edi
 
        xor     ebx, ebx            ; 0 - get only gp regs
        cmp     edx, 40
        je      .std_ctx
 
        cmp     edx, 48+288
        jne     .ret
 
        inc     ebx                 ; 1 - get sse context
                                  ; TODO legacy 32-bit FPU/MMX context
.std_ctx:
;        push    ecx
;        mov     ecx, esi
        call    check_region
;        pop     ecx
        dec     eax
        jnz     .ret
        call    get_debuggee_slot
        jc      .ret
 
        shr     eax, 5
        cmp     eax, [fpu_owner]
        jne     @f
        inc     bh                ; set swap context flag
@@:
        shl     eax, 8
        mov     edi, esi
        mov     eax, [eax+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
 
        dec     bl
        js      .ret
        dec     bl
        jns     .ret
 
        test    bh, bh            ; check swap flag
        jz      @F
 
        ffree   st0               ; swap context
@@:
 
        add     esi, 4            ;top of ring0 stack
                                  ;fpu/sse context saved here
        add     edi, 40
        mov     eax, 1            ;sse context
        stosd
        xor     eax, eax          ;reserved dword
        stosd
 
        mov     ecx, 288/4
        rep movsd                 ;copy sse context
 
.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 2455	Rev 4893
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2011. 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: 2455 $	8	$Revision: 4893 $
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,ebx,ecx,edx,esi,edi
-		140
-		141	xor ebx, ebx ; 0 - get only gp regs
140	cmp edx, 28h	142	cmp edx, 40
-		143	je .std_ctx
-		144
-		145	cmp edx, 48+288
141	jnz .ret	146	jne .ret
-		147
-		148	inc ebx ; 1 - get sse context
-		149	; TODO legacy 32-bit FPU/MMX context
-		150	.std_ctx:
142	; push ecx	151	; push ecx
143	; mov ecx, esi	152	; mov ecx, esi
144	call check_region	153	call check_region
145	; pop ecx	154	; pop ecx
146	dec eax	155	dec eax
147	jnz .ret	156	jnz .ret
148	call get_debuggee_slot	157	call get_debuggee_slot
149	jc .ret	158	jc .ret
-		159
-		160	shr eax, 5
-		161	cmp eax, [fpu_owner]
-		162	jne @f
-		163	inc bh ; set swap context flag
-		164	@@:
-		165	shl eax, 8
150	mov edi, esi	166	mov edi, esi
151	mov eax, [eax*8+SLOT_BASE+APPDATA.pl0_stack]	167	mov eax, [eax+SLOT_BASE+APPDATA.pl0_stack]
152	lea esi, [eax+RING0_STACK_SIZE]	168	lea esi, [eax+RING0_STACK_SIZE]
153		169
154	.ring0:	170	.ring0:
155	; note that following code assumes that all interrupt/exception handlers	171	; note that following code assumes that all interrupt/exception handlers
156	; saves ring-3 context by pushad in this order	172	; 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	173	; top of ring0 stack: ring3 stack ptr (ss+esp), iret data (cs+eip+eflags), pushad
158	sub esi, 8+12+20h	174	sub esi, 8+12+20h
159	lodsd ;edi	175	lodsd ;edi
160	mov [edi+24h], eax	176	mov [edi+24h], eax
161	lodsd ;esi	177	lodsd ;esi
162	mov [edi+20h], eax	178	mov [edi+20h], eax
163	lodsd ; ebp	179	lodsd ; ebp
164	mov [edi+1Ch], eax	180	mov [edi+1Ch], eax
165	lodsd ;esp	181	lodsd ;esp
166	lodsd ;ebx	182	lodsd ;ebx
167	mov [edi+14h], eax	183	mov [edi+14h], eax
168	lodsd ;edx	184	lodsd ;edx
169	mov [edi+10h], eax	185	mov [edi+10h], eax
170	lodsd ;ecx	186	lodsd ;ecx
171	mov [edi+0Ch], eax	187	mov [edi+0Ch], eax
172	lodsd ;eax	188	lodsd ;eax
173	mov [edi+8], eax	189	mov [edi+8], eax
174	lodsd ;eip	190	lodsd ;eip
175	mov [edi], eax	191	mov [edi], eax
176	lodsd ;cs	192	lodsd ;cs
177	lodsd ;eflags	193	lodsd ;eflags
178	mov [edi+4], eax	194	mov [edi+4], eax
179	lodsd ;esp	195	lodsd ;esp
180	mov [edi+18h], eax	196	mov [edi+18h], eax
-		197
-		198	dec bl
-		199	js .ret
-		200	dec bl
-		201	jns .ret
-		202
-		203	test bh, bh ; check swap flag
-		204	jz @F
-		205
-		206	ffree st0 ; swap context
-		207	@@:
-		208
-		209	add esi, 4 ;top of ring0 stack
-		210	;fpu/sse context saved here
-		211	add edi, 40
-		212	mov eax, 1 ;sse context
-		213	stosd
-		214	xor eax, eax ;reserved dword
-		215	stosd
-		216
-		217	mov ecx, 288/4
-		218	rep movsd ;copy sse context
-		219
181	.ret:	220	.ret:
182	sti	221	sti
183	ret	222	ret
184		223
185	debug_setcontext:	224	debug_setcontext:
186	; in:	225	; in:
187	; ecx=pid	226	; ecx=pid
188	; edx=sizeof(CONTEXT)	227	; edx=sizeof(CONTEXT)
189	; esi->CONTEXT	228	; esi->CONTEXT
190	; destroys eax,ecx,edx,esi,edi	229	; destroys eax,ecx,edx,esi,edi
191	cmp edx, 28h	230	cmp edx, 28h
192	jnz .ret	231	jnz .ret
193	; push ebx	232	; push ebx
194	; mov ebx, edx	233	; mov ebx, edx
195	call check_region	234	call check_region
196	; pop ebx	235	; pop ebx
197	dec eax	236	dec eax
198	jnz .ret	237	jnz .ret
199	call get_debuggee_slot	238	call get_debuggee_slot
200	jc .stiret	239	jc .stiret
201	; mov esi, edx	240	; mov esi, edx
202	mov eax, [eax*8+SLOT_BASE+APPDATA.pl0_stack]	241	mov eax, [eax*8+SLOT_BASE+APPDATA.pl0_stack]
203	lea edi, [eax+RING0_STACK_SIZE]	242	lea edi, [eax+RING0_STACK_SIZE]
204		243
205	.ring0:	244	.ring0:
206	sub edi, 8+12+20h	245	sub edi, 8+12+20h
207	mov eax, [esi+24h] ;edi	246	mov eax, [esi+24h] ;edi
208	stosd	247	stosd
209	mov eax, [esi+20h] ;esi	248	mov eax, [esi+20h] ;esi
210	stosd	249	stosd
211	mov eax, [esi+1Ch] ;ebp	250	mov eax, [esi+1Ch] ;ebp
212	stosd	251	stosd
213	scasd	252	scasd
214	mov eax, [esi+14h] ;ebx	253	mov eax, [esi+14h] ;ebx
215	stosd	254	stosd
216	mov eax, [esi+10h] ;edx	255	mov eax, [esi+10h] ;edx
217	stosd	256	stosd
218	mov eax, [esi+0Ch] ;ecx	257	mov eax, [esi+0Ch] ;ecx
219	stosd	258	stosd
220	mov eax, [esi+8] ;eax	259	mov eax, [esi+8] ;eax
221	stosd	260	stosd
222	mov eax, [esi] ;eip	261	mov eax, [esi] ;eip
223	stosd	262	stosd
224	scasd	263	scasd
225	mov eax, [esi+4] ;eflags	264	mov eax, [esi+4] ;eflags
226	stosd	265	stosd
227	mov eax, [esi+18h] ;esp	266	mov eax, [esi+18h] ;esp
228	stosd	267	stosd
229	.stiret:	268	.stiret:
230	sti	269	sti
231	.ret:	270	.ret:
232	ret	271	ret
233		272
234	debug_set_drx:	273	debug_set_drx:
235	call get_debuggee_slot	274	call get_debuggee_slot
236	jc .errret	275	jc .errret
237	mov ebp, eax	276	mov ebp, eax
238	lea eax, [eax*8+SLOT_BASE+APPDATA.dbg_regs]	277	lea eax, [eax*8+SLOT_BASE+APPDATA.dbg_regs]
239	; [eax]=dr0, [eax+4]=dr1, [eax+8]=dr2, [eax+C]=dr3	278	; [eax]=dr0, [eax+4]=dr1, [eax+8]=dr2, [eax+C]=dr3
240	; [eax+10]=dr7	279	; [eax+10]=dr7
241	cmp esi, OS_BASE	280	cmp esi, OS_BASE
242	jae .errret	281	jae .errret
243	cmp dl, 3	282	cmp dl, 3
244	ja .errret	283	ja .errret
245	mov ecx, dr7	284	mov ecx, dr7
246	;fix me	285	;fix me
247	xchg ecx, edx	286	xchg ecx, edx
248	shr edx, cl	287	shr edx, cl
249	shr edx, cl	288	shr edx, cl
250	xchg ecx, edx	289	xchg ecx, edx
251		290
252	test ecx, 2 ; bit 1+2*index = G0..G3, global break enable	291	test ecx, 2 ; bit 1+2*index = G0..G3, global break enable
253	jnz .errret2	292	jnz .errret2
254	test dh, dh	293	test dh, dh
255	jns .new	294	jns .new
256	; clear breakpoint	295	; clear breakpoint
257	movzx edx, dl	296	movzx edx, dl
258	add edx, edx	297	add edx, edx
259	and dword [eax+edx*2], 0 ; clear DR	298	and dword [eax+edx*2], 0 ; clear DR
260	btr dword [eax+10h], edx ; clear L bit	299	btr dword [eax+10h], edx ; clear L bit
261	test byte [eax+10h], 55h	300	test byte [eax+10h], 55h
262	jnz .okret	301	jnz .okret
263	; imul eax, ebp, tss_step/32	302	; imul eax, ebp, tss_step/32
264	; and byte [eax + tss_data + TSS._trap], not 1	303	; and byte [eax + tss_data + TSS._trap], not 1
265	and [ebp*8 + SLOT_BASE+APPDATA.dbg_state], not 1	304	and [ebp*8 + SLOT_BASE+APPDATA.dbg_state], not 1
266	.okret:	305	.okret:
267	and dword [esp+32], 0	306	and dword [esp+32], 0
268	sti	307	sti
269	ret	308	ret
270	.errret:	309	.errret:
271	sti	310	sti
272	mov dword [esp+32], 1	311	mov dword [esp+32], 1
273	ret	312	ret
274	.errret2:	313	.errret2:
275	sti	314	sti
276	mov dword [esp+32], 2	315	mov dword [esp+32], 2
277	ret	316	ret
278	.new:	317	.new:
279	; add new breakpoint	318	; add new breakpoint
280	; dl=index; dh=flags; esi=address	319	; dl=index; dh=flags; esi=address
281	test dh, 0xF0	320	test dh, 0xF0
282	jnz .errret	321	jnz .errret
283	mov cl, dh	322	mov cl, dh
284	and cl, 3	323	and cl, 3
285	cmp cl, 2	324	cmp cl, 2
286	jz .errret	325	jz .errret
287	mov cl, dh	326	mov cl, dh
288	shr cl, 2	327	shr cl, 2
289	cmp cl, 2	328	cmp cl, 2
290	jz .errret	329	jz .errret
291		330
292	mov ebx, esi	331	mov ebx, esi
293	test bl, dl	332	test bl, dl
294		333
295	jnz .errret	334	jnz .errret
296	or byte [eax+10h+1], 3 ; set GE and LE flags	335	or byte [eax+10h+1], 3 ; set GE and LE flags
297		336
298	movzx edx, dh	337	movzx edx, dh
299	movzx ecx, dl	338	movzx ecx, dl
300	add ecx, ecx	339	add ecx, ecx
301	bts dword [eax+10h], ecx ; set L flag	340	bts dword [eax+10h], ecx ; set L flag
302	add ecx, ecx	341	add ecx, ecx
303	mov [eax+ecx], ebx;esi ; set DR	342	mov [eax+ecx], ebx;esi ; set DR
304	shl edx, cl	343	shl edx, cl
305	mov ebx, 0xF	344	mov ebx, 0xF
306	shl ebx, cl	345	shl ebx, cl
307	not ebx	346	not ebx
308	and [eax+10h+2], bx	347	and [eax+10h+2], bx
309	or [eax+10h+2], dx ; set R/W and LEN fields	348	or [eax+10h+2], dx ; set R/W and LEN fields
310	; imul eax, ebp, tss_step/32	349	; imul eax, ebp, tss_step/32
311	; or byte [eax + tss_data + TSS._trap], 1	350	; or byte [eax + tss_data + TSS._trap], 1
312	or [ebp*8 + SLOT_BASE+APPDATA.dbg_state], 1	351	or [ebp*8 + SLOT_BASE+APPDATA.dbg_state], 1
313	jmp .okret	352	jmp .okret
314		353
315	debug_read_process_memory:	354	debug_read_process_memory:
316	; in:	355	; in:
317	; ecx=pid	356	; ecx=pid
318	; edx=length	357	; edx=length
319	; edi->buffer in debugger	358	; edi->buffer in debugger
320	; esi=address in debuggee	359	; esi=address in debuggee
321	; out: [esp+36]=sizeof(read)	360	; out: [esp+36]=sizeof(read)
322	; destroys all	361	; destroys all
323	; push ebx	362	; push ebx
324	; mov ebx, esi	363	; mov ebx, esi
325	call check_region	364	call check_region
326	; pop ebx	365	; pop ebx
327	dec eax	366	dec eax
328	jnz .err	367	jnz .err
329	call get_debuggee_slot	368	call get_debuggee_slot
330	jc .err	369	jc .err
331	shr eax, 5	370	shr eax, 5
332	mov ecx, edi	371	mov ecx, edi
333	call read_process_memory	372	call read_process_memory
334	sti	373	sti
335	mov dword [esp+32], eax	374	mov dword [esp+32], eax
336	ret	375	ret
337	.err:	376	.err:
338	or dword [esp+32], -1	377	or dword [esp+32], -1
339	ret	378	ret
340		379
341	debug_write_process_memory:	380	debug_write_process_memory:
342	; in:	381	; in:
343	; ecx=pid	382	; ecx=pid
344	; edx=length	383	; edx=length
345	; edi->buffer in debugger	384	; edi->buffer in debugger
346	; esi=address in debuggee	385	; esi=address in debuggee
347	; out: [esp+36]=sizeof(write)	386	; out: [esp+36]=sizeof(write)
348	; destroys all	387	; destroys all
349	; push ebx	388	; push ebx
350	; mov ebx, esi	389	; mov ebx, esi
351	call check_region	390	call check_region
352	; pop ebx	391	; pop ebx
353	dec eax	392	dec eax
354	jnz debug_read_process_memory.err	393	jnz debug_read_process_memory.err
355	call get_debuggee_slot	394	call get_debuggee_slot
356	jc debug_read_process_memory.err	395	jc debug_read_process_memory.err
357	shr eax, 5	396	shr eax, 5
358	mov ecx, edi	397	mov ecx, edi
359	call write_process_memory	398	call write_process_memory
360	sti	399	sti
361	mov [esp+32], eax	400	mov [esp+32], eax
362	ret	401	ret
363		402
364	debugger_notify:	403	debugger_notify:
365	; in: eax=debugger slot	404	; in: eax=debugger slot
366	; ecx=size of debug message	405	; ecx=size of debug message
367	; [esp+4]..[esp+4+ecx]=message	406	; [esp+4]..[esp+4+ecx]=message
368	; interrupts must be disabled!	407	; interrupts must be disabled!
369	; destroys all general registers	408	; destroys all general registers
370	; interrupts remain disabled	409	; interrupts remain disabled
371	xchg ebp, eax	410	xchg ebp, eax
372	mov edi, [timer_ticks]	411	mov edi, [timer_ticks]
373	add edi, 500 ; 5 sec timeout	412	add edi, 500 ; 5 sec timeout
374	.1:	413	.1:
375	mov eax, ebp	414	mov eax, ebp
376	shl eax, 8	415	shl eax, 8
377	mov esi, [SLOT_BASE+eax+APPDATA.dbg_event_mem]	416	mov esi, [SLOT_BASE+eax+APPDATA.dbg_event_mem]
378	test esi, esi	417	test esi, esi
379	jz .ret	418	jz .ret
380	; read buffer header	419	; read buffer header
381	push ecx	420	push ecx
382	push eax	421	push eax
383	push eax	422	push eax
384	mov eax, ebp	423	mov eax, ebp
385	mov ecx, esp	424	mov ecx, esp
386	mov edx, 8	425	mov edx, 8
387	call read_process_memory	426	call read_process_memory
388	cmp eax, edx	427	cmp eax, edx
389	jz @f	428	jz @f
390	add esp, 12	429	add esp, 12
391	jmp .ret	430	jmp .ret
392	@@:	431	@@:
393	cmp dword [ecx], 0	432	cmp dword [ecx], 0
394	jg @f	433	jg @f
395	.2:	434	.2:
396	pop ecx	435	pop ecx
397	pop ecx	436	pop ecx
398	pop ecx	437	pop ecx
399	cmp dword [CURRENT_TASK], 1	438	cmp dword [CURRENT_TASK], 1
400	jnz .notos	439	jnz .notos
401	cmp [timer_ticks], edi	440	cmp [timer_ticks], edi
402	jae .ret	441	jae .ret
403	.notos:	442	.notos:
404	sti	443	sti
405	call change_task	444	call change_task
406	cli	445	cli
407	jmp .1	446	jmp .1
408	@@:	447	@@:
409	mov edx, [ecx+8]	448	mov edx, [ecx+8]
410	add edx, [ecx+4]	449	add edx, [ecx+4]
411	cmp edx, [ecx]	450	cmp edx, [ecx]
412	ja .2	451	ja .2
413	; advance buffer position	452	; advance buffer position
414	push edx	453	push edx
415	mov edx, 4	454	mov edx, 4
416	sub ecx, edx	455	sub ecx, edx
417	mov eax, ebp	456	mov eax, ebp
418	add esi, edx	457	add esi, edx
419	call write_process_memory	458	call write_process_memory
420	pop eax	459	pop eax
421	; write message	460	; write message
422	mov eax, ebp	461	mov eax, ebp
423	add esi, edx	462	add esi, edx
424	add esi, [ecx+8]	463	add esi, [ecx+8]
425	add ecx, 20	464	add ecx, 20
426	pop edx	465	pop edx
427	pop edx	466	pop edx
428	pop edx	467	pop edx
429	call write_process_memory	468	call write_process_memory
430	; new debug event	469	; new debug event
431	mov eax, ebp	470	mov eax, ebp
432	shl eax, 8	471	shl eax, 8
433	or byte [SLOT_BASE+eax+APPDATA.event_mask+1], 1 ; set flag 100h	472	or byte [SLOT_BASE+eax+APPDATA.event_mask+1], 1 ; set flag 100h
434	.ret:	473	.ret:
435	ret	474	ret

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/debug.inc – Rev 2455 → 4893