home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 35 Internet / 35-Internet.zip / dyndd.zip / dyndd.asm next >
Assembly Source File  |  1997-12-01  |  19KB  |  527 lines
  1. ; Dynamic Trace Exit - sample device driver           
  2. ; Author: Richard Moore
  3. ; Date:    1st December 1997
  4. ; Version: 1.0
  5. ;
  6. ; This device drive implements a number of functions that are 
  7. ; invoked using RPN commands as follows:
  8. ;
  9. ;
  10. ;   push parm1
  11. ;   ....
  12. ;   push parmn
  13. ;   push function
  14. ;   call dd
  15. ;
  16. ; The functions implemented are:
  17. ;
  18. ; 0 - log the buffer contents and reset the buffer
  19. ; 1 - compare two ASCIIZ strings from flat addresses
  20. ;     The addresses are popped from the RPN stack and
  21. ;     the result of the compare is pushed. If the
  22. ;     addresses are equal then the result is 0, if not
  23. ;     then the result is -1. If an exception occurs then
  24. ;     a error message is logged and no result is pushed.
  25. ; 2 - compare two ASCIIZ strings from segmented addresses.
  26. ;     An offset, then segment of the first comparand is 
  27. ;     popped from the RPN stack, followed by the offset
  28. ;     and segment of the 2nd comparand. This functions 
  29. ;     then proceeds as for function 1.
  30. ; 3/4 Test device driver fault handler behaviour.
  31. ; 5 - Get a DWORD global variable. An index (0-15) is popped
  32. ;     from the RPN stack and the value of the corresponding
  33. ;     global variable is pushed onto the stack.
  34. ; 6 - Put a DWORD value into a global variable. An index (0-15) is 
  35. ;     popped followed by the variable value.
  36. ;     The corresponding global variable is updated.
  37. ;     Global variable may be shared across dynamic trace objects,
  38. ;     unlike local variables, which are local to a DTO.
  39. ;
  40. ; 7 - log the buffer contents skipping the initial 3-byte prefix 
  41. ;     and reset the buffer. If the buffer contains less than 3 bytes
  42. ;     then a null record is logged.
  43. ;
  44. ;     See DYNDD.RPN for example of these functions being used.
  45. ;
  46. ; 
  47. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  48.  
  49.         PAGE    255,133
  50.         .386p   
  51.         .SALL
  52. include devhlp.inc
  53. include dynapi.inc
  54. include basemaca.inc
  55.         PUBLIC  Strat,DynExit,DynFault
  56. ; RPN stack manipulation macros
  57.  
  58. ; RPNPush - increment top of RPN stack pointer.
  59. ;
  60. ;    RPNPush increments the top of stack pointer held in EDX.
  61. ;    No data transfer to the RPN stack occurs.
  62.  
  63. RPNPush macro
  64.     inc    edx
  65.     and    edx,15    ; assumes RPN stack size is 16 DWORDS
  66. endm
  67.  
  68.  
  69. ; RPNPop - decrement top of RPN stack pointer.
  70. ;
  71. ;    RPNPop decrement the top of stack pointer held in EDX.
  72. ;    No data transfer to the RPN stack occurs.
  73.  
  74. RPNPop    macro
  75.     dec    edx
  76.     and    edx,15    ; assumes RPN stack size is 16 DWORDS 
  77. endm
  78.  
  79.  
  80. ; RPNGetTOS - Move top element of RPN stack to a register
  81. ;
  82. ;    RPNGetTOS <reg>
  83. ;
  84. ;    RPNGetTOS moves the top element of the RPN stack into a register.
  85. ;    No motion of the RPN stack occurs.
  86.  
  87. RPNGetTOS macro reg
  88.    mov   reg,edx
  89.    shl   reg,2
  90.    add   reg,esi
  91.    mov    reg,es:[reg]
  92. endm
  93.  
  94.  
  95. ; RPNPutTOS - Move register to top element of RPN stack 
  96. ;
  97. ;    RPNPutTOS <reg>
  98. ;
  99. ;    RPNPutTOS moves a register to the top element of the RPN stack.
  100. ;    No motion of the RPN stack occurs.
  101.  
  102. RPNPutTOS macro reg
  103.    push  reg
  104.    mov   reg,edx
  105.    shl   reg,2
  106.    add   reg,esi
  107.     pop   DWORD PTR es:[reg]
  108.    mov   reg,es:[reg]
  109. endm
  110.  
  111.  
  112. ;   Standard Request Packet Header definition
  113. RP              equ     es:[bx]                 ;use mnemonic
  114. RPP             equ     [bp-4]                  ;saved address of RP
  115. RP_COMMAND      equ     byte ptr es:[bx+2]      ;location of command byte
  116. RPCmdInit       equ     0                       ;Initialize
  117. RPInitDevHlp    equ    dword ptr es:[bx+14]     ;Offset&Segment of DevHlp
  118. RPInitEndCode   equ     word ptr es:[bx+14]     ;end of code segment
  119. RPInitEndData   equ     word ptr es:[bx+16]     ;end of data segment
  120. RPInitParmPtr   equ    dword ptr es:[bx+18]     ;address of parameters
  121. RPCmdRead       equ     4                       ;device read 
  122. RPCmdWrite      equ     8                       ;device write
  123. RPCmdWriteV     equ     9                       ;device write with verify
  124. RPRWPhysAdrL    equ     word ptr es:[bx+14]     ;low half of phys addr
  125. RPRWPhysAdrH    equ     word ptr es:[bx+16]     ;high half of phys addr
  126. RPRWLen         equ     word ptr es:[bx+18]     ;length of read/write
  127. RPCmdOpen       equ     13                      ;device open
  128. RPCmdClose      equ     14                      ;device close
  129. RP_STATUS       equ     word ptr es:[bx+3]
  130. DONEAOK         equ     0100H
  131. DONENOK         equ     8100H           ;use one of the below with DONENOK 
  132. CMDBAD          equ     3
  133. GENFAIL         equ     12
  134. INVPARM         equ     19
  135. DEVBUSY         equ     20
  136. ;
  137. ;**     Device Driver Type definitions 
  138. Dev_Char_Dev    equ 1000000000000000B ;Device is a character device
  139. Dev_30          equ 0000100000000000B ;Accepts Open/Close/Rem. Media
  140. DevLev_1        equ 0000000110000000B ;OS/2 Device Driver+bitstrip
  141. DDattr          equ Dev_Char_Dev+Dev_30+DevLev_1
  142. ;
  143.         PUBLIC DevHdr
  144.         PUBLIC DevHlp
  145.         PUBLIC Iflag 
  146.         PUBLIC trbuffer
  147.         PUBLIC dynreq
  148.         PUBLIC fltmsg
  149.         PUBLIC FlatSel
  150.         PUBLIC dynddx
  151.         PUBLIC EntrySP
  152.         PUBLIC sel1
  153.         PUBLIC sel2
  154.         PUBLIC off1
  155.         PUBLIC off2
  156.         PUBLIC GlobalV
  157. _DATA   segment para public use16 'DATA'
  158. DevHdr  dd      -1              ;+00  chain pointer
  159.         dw      DDattr          ;+04  device attributes  
  160.         dw      Strat           ;+06  strategy routine
  161.         dw      0               ;+08  inter dd comm entry
  162.         db      'DYNDD   '      ;+0A  device name
  163.         db      8 dup (0)       ;+12  reserved
  164.         dd      00000001H       ;+1A  capability bitstrip, >16Mb support
  165. DevHlp  dd      0               ;+1C  address of device help entry point
  166. Iflag   db      0               ;+20  operational flags
  167. Inited  =       128
  168. trbuffer db     'DynExit - invalid request'   ;Static trace buffer
  169.         db      0
  170. dynreq  dd      0
  171. trsize  equ     $-trbuffer
  172. fltmsg   db     'DynExit - encountered a GP Fault'
  173.         db      0
  174. fltsize equ     $-fltmsg
  175. FlatSel dw      0
  176. dynddx  dd      0
  177. ;
  178. EntrySP dw      0               ; Entry SP 
  179. off1    dw      ?
  180. sel1    dw      ?
  181. off2    dw      ?
  182. sel2    dw      ?
  183. ;
  184. GlobalV dd      16 dup(0)       ; array of 16 global variables
  185. ;
  186. DATASIZ equ     $-Devhdr        ;size of resident data
  187. _DATA   ends
  188. ;
  189. _TEXT   segment para public use16 'CODE'
  190. CSBeg   equ     $
  191.         assume  CS:_TEXT, DS:_DATA
  192.  
  193. ; Dynamic Trace exit routine
  194. DynExit proc far
  195.         push ds               ; save the flat data sel
  196.         mov  ds,ax            ; restore the data segment
  197.         pop  [FlatSel]
  198.         mov  [EntrySP],sp             ; save entry sp for use by the fault handler
  199.         mov  WORD PTR [dynddx],di     ; save ddx address for realoding after a fault
  200.         mov  WORD PTR [dynddx+2],fs
  201.         mov  edx,fs:[di].ddx_StackIndex
  202.         xor  esi,esi
  203.         les  si,fs:[di].ddx_StackStart
  204.         RPNGetTOS eax         ; get function request from TOS
  205.         RPNPop                         ; Pop the function code from TOS
  206.         cmp  eax,0            ; log buffer function?
  207.         jz   LogBuffer
  208.         cmp  eax,1            ; Compare strings from Flat addresses
  209.         jz   CompStrF
  210.         cmp  eax,2            ; Compare strings from Segmented addresses
  211.         jz   CompStrS
  212.         cmp  eax,3            ; Test fault handler
  213.         jz   TestFault
  214.         cmp  eax,4            ; Test fault without a local handler
  215.         jz   TestFaultNH
  216.         cmp  eax,5            ; Get Global Var
  217.         jz   GetGlobalVar
  218.         cmp  eax,6            ; Put Global Var
  219.         jz   PutGlobalVar
  220.         cmp  eax,7            ; log buffer without prefix function?
  221.         jz   LogBufferNP
  222.         RPNPush               ; Restore the stack pointer - we don't regognise
  223.                               ; the request, it could be for another exit
  224.  
  225. ; write out an error message via a static trace record
  226.         mov  [dynreq],eax     ; log the function
  227.         mov  eax,fs:[di].ddx_Major     ; original major code
  228.         mov  ecx,fs:[di].ddx_Minor     ; original minor code
  229.         mov  bx,trsize        ; size of trace data
  230.         mov  si,Offset trbuffer      ; ds:si->trbuffer
  231.         mov  dl,DevHlp_RAS    ; SysTrace DevHlp
  232.         call    [DevHlp]      ; call SysTrace
  233.         jmp  DynEnd
  234.  
  235.  
  236. ; log out the existing buffer using static trace and reset the log buffer
  237.         PUBLIC LogBuffer
  238. LogBuffer:
  239.         mov  eax,fs:[di].ddx_Major     ; original major code
  240.         mov  ebx,fs:[di].ddx_LogIndex  ; size of log data
  241.         mov  ecx,fs:[di].ddx_Minor     ; original minor code
  242.         push ds                        ; save ds
  243.         pop  es                        ; as es
  244.         push si                        ; save si
  245.         lds  si,fs:[di].ddx_LogStart   ; ds:si->log buffer
  246.         mov  dl,DevHlp_RAS             ; SysTrace DevHlp
  247.         call es:[DevHlp]               ; write out the log
  248.         pop  si                        ; restore our si
  249.         push es
  250.         pop  ds                        ; restore our ds
  251.         xor  eax,eax
  252.         mov  fs:[di].ddx_LogIndex,eax  ; reset log index
  253.         jmp  DynEnd
  254.  
  255. ; log out the existing buffer without the initial prefix using static trace 
  256. ; and reset the log buffer
  257.         PUBLIC LogBufferNP
  258. LogBufferNP:
  259.         mov  eax,fs:[di].ddx_Major     ; original major code
  260.         mov  ebx,fs:[di].ddx_LogIndex  ; size of log data
  261.         mov  ecx,fs:[di].ddx_Minor     ; original minor code
  262.         push ds                        ; save ds
  263.         pop  es                        ; as es
  264.         push si                        ; save si
  265.         lds  si,fs:[di].ddx_LogStart   ; ds:si->log buffer
  266.         add  si,3                      ; bypass prefix
  267.         or   bx,bx                     ; if 0, 1 or 2 bytes in log then
  268.         jz   @F                        ; leave length zero
  269.         dec  bx                        ; (don't bother adjusting si - it's not used).
  270.         jz   @F                        ;
  271.         dec  bx                        ;
  272.         jz   @F                        ;
  273.         dec  bx                        ;
  274. @@:     mov  dl,DevHlp_RAS             ; SysTrace DevHlp
  275.         call es:[DevHlp]               ; write out the log
  276.         pop  si                        ; restore our si
  277.         push es
  278.         pop  ds                        ; restore our ds
  279.         xor  eax,eax
  280.         mov  fs:[di].ddx_LogIndex,eax  ; reset log index
  281.         jmp  DynEnd
  282.  
  283. ; Compare two zero terminated strings pointed to by the flat address on the RPN stack
  284. ; push 0 if equal, -1 if not
  285.         PUBLIC CompStrF
  286. CompStrF:  
  287.         RPNGetTOS eax                  ; get addess of 1st string address
  288.         RPNPop
  289.         RPNGetTOS ebx                  ; get addess of 2st string address
  290.                                        ; don't pop here - we'll replace TOS
  291.                                        ; with the result
  292.  
  293.         push cs                        ; set up a fault handler 
  294.         pop  cx
  295.         shl  cx,16
  296.         mov  cx,offset DynFault        
  297.         mov  fs:[di].ddx_pfnFault,ecx
  298. ; note use fs instead of ds in string instructions - this makes fault recovery
  299. ; easier. The system will pass the fault handler the value of ds in use at the
  300. ; time the trap occurred in ax. If we re-use ds - life gets difficult.
  301.         SaveReg    <edi,esi,es,fs>
  302.         mov  fs,[FlatSel]
  303.         push fs
  304.         pop  es
  305.         mov  esi,eax
  306.         mov  edi,ebx
  307.         xor  eax,eax
  308. CFloop: cmp  BYTE PTR fs:[esi],0
  309.         jne  CF1
  310.         cmp  BYTE PTR es:[edi],0
  311.         je   CFeq
  312.         jmp  CF2    
  313. CF1:    cmp  BYTE PTR es:[edi],0
  314.         jne  CF2     
  315.         je   CFne
  316.  
  317. CF2:    cmps  BYTE PTR fs:[esi], BYTE PTR es:[edi]
  318.         jnz   CFne
  319.         jmp   CFloop
  320.  
  321.  
  322. CFeq:
  323.         RestoreReg <fs,es,esi,edi>
  324.         RPNPutTOS <eax>
  325.         jmp  DynEnd
  326.  
  327. CFne:
  328.         RestoreReg <fs,es,esi,edi>
  329.         dec  eax
  330.         RPNPutTOS <eax>
  331.         jmp  DynEnd
  332.  
  333. ; Compare two zero terminated strings pointed to by 16:16 addresses on the RPN stack
  334. ; push 0 if equal, -1 if not
  335.         PUBLIC CompStrS
  336. CompStrS:  
  337.         push cs                        ; set up a fault handler 
  338.         pop  cx
  339.         shl  cx,16
  340.         mov  cx,offset DynFault        
  341.         mov  fs:[di].ddx_pfnFault,ecx
  342.         RPNGetTOS eax                  ; get offset of  1st string
  343.         RPNPop
  344.         mov  ds:[off1],ax 
  345.         RPNGetTOS eax                  ; get segment of 1st string 
  346.         RPNPop
  347.         mov  ds:[sel1],ax 
  348.         RPNGetTOS eax                  ; get offset of 2st string 
  349.         RPNPop
  350.         mov  ds:[off2],ax 
  351.         RPNGetTOS eax                  ; get segment of 2st string 
  352.                                        ; don't pop here - we'll replace TOS
  353.                                        ; with the result
  354.         mov  ds:[sel2],ax 
  355.  
  356. ; note use fs instead of ds in string instructions - this makes fault recovery
  357. ; easier. The system will pass the fault handler the value of ds in use at the
  358. ; time the trap occurred in ax. If we re-use ds - life gets difficult.
  359.         SaveReg    <di,si,es,fs>
  360.         mov  di,ds:[off2]
  361.         push ds:[sel2]
  362.         pop  es
  363.         mov  si,ds:[off1]
  364.         push ds:[sel1]
  365.         pop  fs
  366.         xor  eax,eax
  367. CSloop: cmp  BYTE PTR fs:[si],0
  368.         jne  CS1
  369.         cmp  BYTE PTR es:[di],0
  370.         je   CSeq
  371.         jmp  CS2    
  372. CS1:    cmp  BYTE PTR es:[di],0
  373.         jne  CS2     
  374.         je   CSne
  375.  
  376. CS2:    cmps  BYTE PTR fs:[si], BYTE PTR es:[di]
  377.         jnz   CSne
  378.         jmp   CSloop
  379.  
  380.  
  381. CSeq:
  382.         RestoreReg <fs,es,si,di>
  383.         RPNPutTOS <eax>
  384.         jmp  DynEnd
  385.  
  386. CSne:
  387.         RestoreReg <fs,es,si,di>
  388.         dec  eax
  389.         RPNPutTOS <eax>
  390.         jmp  DynEnd
  391.  
  392. ;Test Fault handling - register a fault handler and cause a fault
  393.         PUBLIC TestFault
  394. TestFault:
  395.         push cs                        ; set up a fault handler 
  396.         pop  cx
  397.         shl  cx,16
  398.         mov  cx,offset DynFault        
  399.         mov  fs:[di].ddx_pfnFault,ecx
  400.         mov  ax,fs:[0ffffh]            ; cause a fault
  401.         int  2                         ; should not execute
  402.  
  403. ;Test Fault handling - no fault handler registered 
  404.         PUBLIC TestFaultNH
  405. TestFaultNH:
  406.         mov  ax,fs:[0ffffh]            ; cause a fault
  407.         int  2                         ; should not execute
  408.  
  409. ;Get a Global Variable 
  410. ;Pop GVAR index from TOS adjust modulo 16, index GlobalV, Push DWORD
  411.         PUBLIC GetGlobalVar
  412. GetGlobalVar:
  413.         RPNGetTOS ebx
  414.         and  ebx,15
  415.         mov  eax,[GlobalV].[ebx*4]
  416.         RPNPutTOS eax
  417.         jmp  DynEnd                    
  418.  
  419. ;Put a Global Variable 
  420. ;Pop a GVAR value then a GVAR index from TOS adjust modulo 16, store value in GVAR
  421.         PUBLIC PutGlobalVar
  422. PutGlobalVar:
  423.         RPNGetTOS eax
  424.         RPNPop        
  425.         RPNGetTOS ebx
  426.         and  ebx,15
  427.         mov  [GlobalV].[ebx*4],eax
  428. ;fall through to DynEnd
  429. ;       jmp  DynEnd                        
  430.  
  431.  
  432. DynEnd: xor  ax,ax                         ; allow other registered dyn exits to be called
  433.         mov  fs:[di].ddx_StackIndex,edx    ; reset the RPN TOS   
  434.         mov  fs:[di].ddx_pfnFault,eax      ; cancel fault handler
  435.         push ds:[FlatSel]
  436.         pop  ds                            ; restore ds
  437.         retf
  438. DynExit endp
  439.  
  440. DynFault proc far
  441.           push ds               ; save system's ds
  442.           mov  ds,ax            ; restore our data segment
  443.           assume ds:_DATA
  444.           lfs  di,dynddx        ; reload the ddx ptr
  445. ; write out an error message via a static trace record
  446.           mov  eax,fs:[di].ddx_Major     ; original major code
  447.           mov  ecx,fs:[di].ddx_Minor     ; original minor code
  448.           mov  bx,fltsize       ; size of trace data
  449.           mov  si,Offset fltmsg ; ds:si->fltmsg
  450.           mov  dl,DevHlp_RAS    ; SysTrace DevHlp
  451.           call    [DevHlp]      ; call SysTrace
  452.           mov  ax,[EntrySP]     ; prepare to restore stack
  453.           pop  ds               ; restore system's ds
  454.           mov  sp,ax            ; Stack now as on entry
  455.           retf               
  456. DynFault  endp
  457.  
  458. ;Device Driver strategy entry point. Request Packet is at es:[bx]
  459. Strat   proc    far
  460. ;       int 3
  461.         push    bp                      ;standard
  462.         mov     bp,sp                   ;linkage
  463.         SaveReg <es,bx,cx,dx,si,di>     ;save es,bx,cx,dx,si,di
  464.         pushf                           ;save flags @ [bp-e] 
  465.         cld                             ;insure up for string ops
  466.         mov     al,RP_COMMAND           ;get command
  467.         cmp     al,RPCmdInit            ;is it Init?
  468.         jne     short DoneOK            ;no, go get PID
  469.         test    Iflag,Inited            ;already initialized?
  470.         jz      Init                    ;no, go initialize
  471.         jmp     short DoneOK            ;yes, do not initialize twice
  472.  
  473. BadCmd: mov     ax,DONENOK+CMDBAD       ;bad command
  474.         jmp     short Done              ;exit
  475.  
  476. GenErr: mov     ax,DONENOK+GENFAIL      ;general failure
  477.         jmp     short Done              ;exit
  478.  
  479. InUse:  mov     ax,DONENOK+DEVBUSY      ;device in use
  480.         jmp      short Done             ;exit
  481.  
  482. InvPrm: mov     ax,DONENOK+INVPARM      ;invalid parm
  483.         jmp     short Done              ;exit
  484.  
  485. DoneOK: mov     ax,DONEAOK              ;result status
  486. ;       jmp     short Done              ;exit
  487.  
  488. Done:   popf                            ;restore flags
  489.         RestoreReg <di,si,dx,cx,bx,es>  ;restore di,si,dx,cx,bx,es
  490.         mov     RP_STATUS,ax            ;set request packet status
  491.         pop     bp                      ;restore bp
  492. ;       int     3
  493.         ret                             ;back to caller
  494.  
  495. CODESIZ equ     $-CSBeg
  496. ;end of resident code
  497. ;
  498. ;init    runs at pl=3, discarded after use.
  499.  
  500. InitOK: les     bx,RPP                  ;refresh RP pointer
  501.         mov     RPInitParmPtr,0         ;set to zero
  502.         or      Iflag,Inited            ;set initialized flag
  503.         jmp     DoneOK                  ;Initialize complete
  504. InitNo: les     bx,RPP                  ;refresh RP address
  505.         mov     RPInitEndCode,0         ;no code
  506.         mov     RPInitEndData,0         ;no data
  507.         mov     RPInitParmPtr,0         ;set to zero
  508.         jmp     GenErr                  ;decline installation
  509. Init:   mov     eax,RPInitDevHlp        ;get DevHlp offset:segment
  510.         mov     DevHlp,eax              ;save it
  511.         mov     RPInitEndData,DATASIZ   ;set resident data size
  512.         mov     RPInitEndCode,CODESIZ   ;set resident code size
  513. ; now register for Dynamic Trace
  514.         mov     bx,cs                   ; same CS
  515.         and     bl,0f8h                 ; make sure will be CPL=0
  516.         mov     esi,OFFSET _TEXT:DynExit  ; offset myapi
  517.         mov     ax,1000h                ; add exit
  518.         mov     cx,3                    ; DYN_Exit
  519.         mov     dl,DevHlp_RegisterKrnlExit ; register exit
  520. ;       int 3
  521.         call    [DevHlp]                ; do it.
  522. ;       int 3
  523.         jmp     InitOK
  524. Strat   endp
  525. _TEXT   ends
  526.         end     Strat
  527.