Subversion Repositories Kolibri OS

Rev

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

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