Subversion Repositories Kolibri OS

Rev

Rev 7124 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

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