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


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

Subversion Repositories Kolibri OS

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