Subversion Repositories Kolibri OS

Rev

Rev 1394 | Rev 2465 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

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