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


; diamond, 2006
sys_debug_services:
	cmp	eax, 9
	ja	@f
	jmp	dword [sys_debug_services_table+eax*4]
@@:	ret
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
 
debug_set_event_data:
; in: ebx = pointer
; destroys eax
        mov     eax, [current_slot]
 
        mov     [eax+APPDATA.dbg_event_mem], ebx
	ret
 
get_debuggee_slot:
; in: ebx=PID
; out: CF=1 if error
;      CF=0 and eax=slot*0x20 if ok
; out: interrupts disabled
	cli
	mov	eax, ebx
	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: ebx=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: ebx=pid
	call	get_debuggee_slot
	jc	debug_detach.ret
	mov	ebx, eax
	shr	ebx, 5
	push	2
	pop	eax
	jmp	sys_system
 
debug_suspend:
; in: ebx=pid
; destroys eax,ebx
	call	get_debuggee_slot
	jc	.ret
        mov     bl, [CURRENT_TASK+eax+TASKDATA.state] ; process state
	test	bl, bl
	jz	.1
	cmp	bl, 5
	jnz	.ret
	mov	bl, 2
.2:     mov     [CURRENT_TASK+eax+TASKDATA.state], bl
.ret:
	sti
	ret
.1:
	inc	ebx
	jmp	.2
 
do_resume:
        mov     bl, [CURRENT_TASK+eax+TASKDATA.state]
	cmp	bl, 1
	jz	.1
	cmp	bl, 2
	jnz	.ret
	mov	bl, 5
.2:     mov     [CURRENT_TASK+eax+TASKDATA.state], bl
.ret:	ret
.1:	dec	ebx
	jmp	.2
 
debug_resume:
; in: ebx=pid
; destroys eax,ebx
	call	get_debuggee_slot
	jc	.ret
	call	do_resume
.ret:	sti
	ret
 
debug_getcontext:
; in:
; ebx=pid
; ecx=sizeof(CONTEXT)
; edx->CONTEXT
; destroys eax,ecx,edx,esi,edi
	cmp	ecx, 28h
	jnz	.ret
    ;    add     edx, std_application_base_address
	push	ebx
	mov	ebx, edx
	call	check_region
	pop	ebx
	dec	eax
	jnz	.ret
	call	get_debuggee_slot
	jc	.ret
	imul	eax, tss_step/32
	add	eax, tss_data
	mov	edi, edx
        cmp     [eax+TSS._cs], app_code
	jnz	.ring0
        lea     esi, [eax+TSS._eip]
	shr	ecx, 2
	rep	movsd
	jmp	.ret
.ring0:
; note that following code assumes that all interrupt/exception handlers
; saves ring-3 context by pushad in this order
        mov     esi, [eax+TSS._esp0]
; 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
;;;        add     esi, 8         ;ds es
        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:
; ebx=pid
; ecx=sizeof(CONTEXT)
; edx->CONTEXT
; destroys eax,ecx,edx,esi,edi
	cmp	ecx, 28h
	jnz	.ret
    ;    add     edx, std_application_base_address
	push	ebx
	mov	ebx, edx
	call	check_region
	pop	ebx
	dec	eax
	jnz	.ret
	call	get_debuggee_slot
	jc	.stiret
	imul	eax, tss_step/32
	add	eax, tss_data
	mov	esi, edx
        cmp     [eax+TSS._cs], app_code
	jnz	.ring0
        lea     edi, [eax+TSS._eip]
	shr	ecx, 2
	rep	movsd
	jmp	.stiret
.ring0:
        mov     edi, [eax+TSS._esp0]
        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
;;;        add     edi, 8         ;ds es
        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
    ;    add     edx, std_application_base_address
	jc	.errret
	cmp	cl, 3
	ja	.errret
	mov	ebx, dr7
	shr	ebx, cl
	shr	ebx, cl
	test	ebx, 2		; bit 1+2*index = G0..G3, global break enable
	jnz	.errret2
	test	ch, ch
	jns	.new
; clear breakpoint
	movzx	ecx, cl
	add	ecx, ecx
	and	dword [eax+ecx*2], 0	; clear DR
	btr	dword [eax+10h], ecx	; 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
.okret:
	and	dword [esp+36], 0
	sti
	ret
.errret:
	sti
	mov	dword [esp+36], 1
	ret
.errret2:
	sti
	mov	dword [esp+36], 2
	ret
.new:
; add new breakpoint
; cl=index; ch=flags; edx=address
	test	ch, 0xF0
	jnz	.errret
	mov	bl, ch
	and	bl, 3
	cmp	bl, 2
	jz	.errret
	mov	bl, ch
	shr	bl, 2
	cmp	bl, 2
	jz	.errret
	test	dl, bl
	jnz	.errret
	or	byte [eax+10h+1], 3	; set GE and LE flags
	movzx	ebx, ch
	movzx	ecx, cl
	add	ecx, ecx
	bts	dword [eax+10h], ecx	; set L flag
	add	ecx, ecx
	mov	[eax+ecx], edx		; set DR
	shl	ebx, cl
	mov	edx, 0xF
	shl	edx, cl
	not	edx
	and	[eax+10h+2], dx
	or	[eax+10h+2], bx		; set R/W and LEN fields
	imul	eax, ebp, tss_step/32
        or      byte [eax + tss_data + TSS._trap], 1
	jmp	.okret
 
debug_read_process_memory:
; in:
; ebx=pid
; ecx=length
; esi->buffer in debugger
; edx=address in debuggee
; out: [esp+36]=sizeof(read)
; destroys all
    ;    add     esi, std_application_base_address
	push	ebx
	mov	ebx, esi
	call	check_region
	pop	ebx
	dec	eax
	jnz	.err
	call	get_debuggee_slot
	jc	.err
	shr	eax, 5
	mov	ebx, esi
	call	read_process_memory
	sti
	mov	dword [esp+36], eax
	ret
.err:
	or	dword [esp+36], -1
	ret
 
debug_write_process_memory:
; in:
; ebx=pid
; ecx=length
; esi->buffer in debugger
; edx=address in debuggee
; out: [esp+36]=sizeof(write)
; destroys all
    ;    add     esi, std_application_base_address
	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	ebx, esi
	call	write_process_memory
	sti
	mov	[esp+36], 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     edx, [SLOT_BASE+eax+APPDATA.dbg_event_mem]
	test	edx, edx
	jz	.ret
; read buffer header
	push	ecx
	push	eax
	push	eax
	mov	eax, ebp
	mov	ebx, esp
	mov	ecx, 8
	call	read_process_memory
	cmp	eax, ecx
	jz	@f
	add	esp, 12
	jmp	.ret
@@:
	cmp	dword [ebx], 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	ecx, [ebx+8]
	add	ecx, [ebx+4]
	cmp	ecx, [ebx]
	ja	.2
; advance buffer position
	push	ecx
	mov	ecx, 4
	sub	ebx, ecx
	mov	eax, ebp
	add	edx, ecx
	call	write_process_memory
	pop	eax
; write message
	mov	eax, ebp
	add	edx, ecx
	add	edx, [ebx+8]
	add	ebx, 20
	pop	ecx
	pop	ecx
	pop	ecx
	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
 
debug_exc:
; int 1 = #DB
	save_ring3_context
	cld
        mov     ax, app_data ;os_data
	mov	ds, ax
	mov	es, ax
	mov	eax, dr6
	test	ax, ax
	jns	@f
; this is exception from task switch
; set DRx registers for task and continue
        mov     eax, [CURRENT_TASK]
	shl	eax, 8
        add     eax, SLOT_BASE+APPDATA.dbg_regs
	mov	ecx, [eax+0]
	mov	dr0, ecx
	mov	ecx, [eax+4]
	mov	dr1, ecx
	mov	ecx, [eax+8]
	mov	dr2, ecx
	mov	ecx, [eax+0Ch]
	mov	dr3, ecx
	xor	ecx, ecx
	mov	dr6, ecx
	mov	ecx, [eax+10h]
	mov	dr7, ecx
	restore_ring3_context
	iretd
@@:
	push	eax
	xor	eax, eax
	mov	dr6, eax
; test if debugging
	cli
        mov     eax, [current_slot]
 
        mov     eax, [eax+APPDATA.debugger_slot]
	test	eax, eax
	jnz	.debug
	sti
; not debuggee => say error and terminate
        add     esp, 0x20+4
	mov	[error_interrupt], 1
	call	show_error_parameters
        mov     edx, [TASK_BASE]
	mov	byte [edx+TASKDATA.state], 4
	jmp	change_task
.debug:
; we are debugged process, notify debugger and suspend ourself
; eax=debugger PID
	pop	edx
	mov	ebx, dr7
	mov	cl, not 1
.l1:
	test	bl, 1
	jnz	@f
	and	dl, cl
@@:
	shr	ebx, 2
	add	cl, cl
	inc	ecx
	cmp	cl, not 10h
	jnz	.l1
	push	edx	; DR6 image
        mov     ecx, [TASK_BASE]
	push	dword [ecx+TASKDATA.pid]	; PID
	push	12
	pop	ecx
	push	3	; 3 = debug exception
	call	debugger_notify
	pop	ecx
	pop	ecx
	pop	ecx
        mov     edx, [TASK_BASE]
	mov	byte [edx+TASKDATA.state], 1	; suspended
	call	change_task
	restore_ring3_context
	iretd

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

Subversion Repositories Kolibri OS

(root)/kernel/branches/flat_kernel/core/debug.inc – Rev 420 → 427