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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/debug.inc – Rev 7124 → 8534