📄 utils.cod

📁 怎样在win2000下构造驱动程序znsoft_Serial2000_demo.ZIP
💻 COD
📖 第 1 页 / 共 5 页
字号:
12 3 4 5 下一页
; Listing generated by Microsoft (R) Optimizing Compiler Version 12.00.9044.0 

	TITLE	F:\W2DDK\src\kernel\serial\utils.c
	.386P
include listing.inc
if @Version gt 510
.model FLAT
else
_TEXT	SEGMENT PARA USE32 PUBLIC 'CODE'
_TEXT	ENDS
_DATA	SEGMENT DWORD USE32 PUBLIC 'DATA'
_DATA	ENDS
CONST	SEGMENT DWORD USE32 PUBLIC 'CONST'
CONST	ENDS
_BSS	SEGMENT DWORD USE32 PUBLIC 'BSS'
_BSS	ENDS
$$SYMBOLS	SEGMENT BYTE USE32 'DEBSYM'
$$SYMBOLS	ENDS
$$TYPES	SEGMENT BYTE USE32 'DEBTYP'
$$TYPES	ENDS
_TLS	SEGMENT DWORD USE32 PUBLIC 'TLS'
_TLS	ENDS
PAGESRP0	SEGMENT PARA USE32 PUBLIC ''
PAGESRP0	ENDS
PAGESER	SEGMENT PARA USE32 PUBLIC ''
PAGESER	ENDS
;	COMDAT _RtlConvertLongToLargeInteger@4
_TEXT	SEGMENT PARA USE32 PUBLIC 'CODE'
_TEXT	ENDS
;	COMDAT _SerialKillAllReadsOrWrites@12
_TEXT	SEGMENT PARA USE32 PUBLIC 'CODE'
_TEXT	ENDS
;	COMDAT _SerialGetNextIrp@20
PAGESER	SEGMENT PARA USE32 PUBLIC ''
PAGESER	ENDS
;	COMDAT _SerialGetNextIrpLocked@24
PAGESER	SEGMENT PARA USE32 PUBLIC ''
PAGESER	ENDS
;	COMDAT _SerialTryToCompleteCurrent@44
PAGESER	SEGMENT PARA USE32 PUBLIC ''
PAGESER	ENDS
;	COMDAT _SerialRundownIrpRefs@16
PAGESER	SEGMENT PARA USE32 PUBLIC ''
PAGESER	ENDS
;	COMDAT _SerialStartOrQueue@20
PAGESER	SEGMENT PARA USE32 PUBLIC ''
PAGESER	ENDS
;	COMDAT _SerialCancelQueued@8
PAGESER	SEGMENT PARA USE32 PUBLIC ''
PAGESER	ENDS
;	COMDAT _SerialCompleteIfError@8
PAGESER	SEGMENT PARA USE32 PUBLIC ''
PAGESER	ENDS
;	COMDAT _SerialFilterCancelQueued@8
_TEXT	SEGMENT PARA USE32 PUBLIC 'CODE'
_TEXT	ENDS
;	COMDAT _SerialKillAllStalled@4
_TEXT	SEGMENT PARA USE32 PUBLIC 'CODE'
_TEXT	ENDS
;	COMDAT _SerialFilterIrps@8
_TEXT	SEGMENT PARA USE32 PUBLIC 'CODE'
_TEXT	ENDS
;	COMDAT _SerialUnstallIrps@4
_TEXT	SEGMENT PARA USE32 PUBLIC 'CODE'
_TEXT	ENDS
;	COMDAT _SerialIRPPrologue@8
_TEXT	SEGMENT PARA USE32 PUBLIC 'CODE'
_TEXT	ENDS
;	COMDAT _SerialIRPEpilogue@4
_TEXT	SEGMENT PARA USE32 PUBLIC 'CODE'
_TEXT	ENDS
;	COMDAT _SerialInsertQueueDpc@16
_TEXT	SEGMENT PARA USE32 PUBLIC 'CODE'
_TEXT	ENDS
;	COMDAT _SerialSetTimer@20
_TEXT	SEGMENT PARA USE32 PUBLIC 'CODE'
_TEXT	ENDS
;	COMDAT _SerialCancelTimer@8
_TEXT	SEGMENT PARA USE32 PUBLIC 'CODE'
_TEXT	ENDS
;	COMDAT _SerialDpcEpilogue@8
_TEXT	SEGMENT PARA USE32 PUBLIC 'CODE'
_TEXT	ENDS
;	COMDAT _SerialUnlockPages@16
_TEXT	SEGMENT PARA USE32 PUBLIC 'CODE'
_TEXT	ENDS
;	COMDAT _SerialIoCallDriver@12
_TEXT	SEGMENT PARA USE32 PUBLIC 'CODE'
_TEXT	ENDS
;	COMDAT _SerialPoCallDriver@12
_TEXT	SEGMENT PARA USE32 PUBLIC 'CODE'
_TEXT	ENDS
;	COMDAT _SerialLogError@64
PAGESRP0	SEGMENT PARA USE32 PUBLIC ''
PAGESRP0	ENDS
;	COMDAT _SerialMarkHardwareBroken@4
PAGESRP0	SEGMENT PARA USE32 PUBLIC ''
PAGESRP0	ENDS
;	COMDAT _SerialSetDeviceFlags@16
_TEXT	SEGMENT PARA USE32 PUBLIC 'CODE'
_TEXT	ENDS
FLAT	GROUP _DATA, CONST, _BSS
	ASSUME	CS: FLAT, DS: FLAT, SS: FLAT
endif

INCLUDELIB LIBC
INCLUDELIB OLDNAMES

CONST	SEGMENT
_SerialPhysicalZero DD 00H
	ORG $+4
CONST	ENDS
PUBLIC	_SerialKillAllReadsOrWrites@12
EXTRN	__imp__IoAcquireCancelSpinLock@4:NEAR
EXTRN	__imp__IoReleaseCancelSpinLock@4:NEAR
; Function compile flags: /Ogs
; File f:\w2ddk\src\kernel\serial\utils.c
;	COMDAT _SerialKillAllReadsOrWrites@12
_TEXT	SEGMENT
_DeviceObject$ = 8
_QueueToClean$ = 12
_CurrentOpIrp$ = 16
_cancelIrql$ = -4
_SerialKillAllReadsOrWrites@12 PROC NEAR		; COMDAT

; 79   : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	51		 push	 ecx
  00004	56		 push	 esi

; 80   : 
; 81   :     KIRQL cancelIrql;
; 82   :     PDRIVER_CANCEL cancelRoutine;
; 83   : 
; 84   :     //
; 85   :     // We acquire the cancel spin lock.  This will prevent the
; 86   :     // irps from moving around.
; 87   :     //
; 88   : 
; 89   :     IoAcquireCancelSpinLock(&cancelIrql);

  00005	8d 45 fc	 lea	 eax, DWORD PTR _cancelIrql$[ebp]
  00008	57		 push	 edi
  00009	8b 3d 00 00 00
	00		 mov	 edi, DWORD PTR __imp__IoAcquireCancelSpinLock@4
  0000f	50		 push	 eax
  00010	ff d7		 call	 edi

; 90   : 
; 91   :     //
; 92   :     // Clean the list from back to front.
; 93   :     //
; 94   : 
; 95   :     while (!IsListEmpty(QueueToClean)) {

  00012	8b 75 0c	 mov	 esi, DWORD PTR _QueueToClean$[ebp]
  00015	eb 2d		 jmp	 SHORT $L15553
$L14824:

; 96   : 
; 97   :         PIRP currentLastIrp = CONTAINING_RECORD(
; 98   :                                   QueueToClean->Blink,
; 99   :                                   IRP,
; 100  :                                   Tail.Overlay.ListEntry
; 101  :                                   );

  00017	8b 4e 04	 mov	 ecx, DWORD PTR [esi+4]

; 102  : 
; 103  :         RemoveEntryList(QueueToClean->Blink);

  0001a	8b 11		 mov	 edx, DWORD PTR [ecx]
  0001c	8d 41 a8	 lea	 eax, DWORD PTR [ecx-88]
  0001f	8b 49 04	 mov	 ecx, DWORD PTR [ecx+4]

; 104  : 
; 105  :         cancelRoutine = currentLastIrp->CancelRoutine;
; 106  :         currentLastIrp->CancelIrql = cancelIrql;
; 107  :         currentLastIrp->CancelRoutine = NULL;
; 108  :         currentLastIrp->Cancel = TRUE;
; 109  : 
; 110  :         cancelRoutine(
; 111  :             DeviceObject,
; 112  :             currentLastIrp
; 113  :             );

  00022	50		 push	 eax
  00023	ff 75 08	 push	 DWORD PTR _DeviceObject$[ebp]
  00026	89 11		 mov	 DWORD PTR [ecx], edx
  00028	89 4a 04	 mov	 DWORD PTR [edx+4], ecx
  0002b	8a 55 fc	 mov	 dl, BYTE PTR _cancelIrql$[ebp]
  0002e	8b 48 38	 mov	 ecx, DWORD PTR [eax+56]
  00031	83 60 38 00	 and	 DWORD PTR [eax+56], 0
  00035	88 50 25	 mov	 BYTE PTR [eax+37], dl
  00038	c6 40 24 01	 mov	 BYTE PTR [eax+36], 1
  0003c	ff d1		 call	 ecx

; 114  : 
; 115  :         IoAcquireCancelSpinLock(&cancelIrql);

  0003e	8d 45 fc	 lea	 eax, DWORD PTR _cancelIrql$[ebp]
  00041	50		 push	 eax
  00042	ff d7		 call	 edi
$L15553:

; 90   : 
; 91   :     //
; 92   :     // Clean the list from back to front.
; 93   :     //
; 94   : 
; 95   :     while (!IsListEmpty(QueueToClean)) {

  00044	39 36		 cmp	 DWORD PTR [esi], esi
  00046	75 cf		 jne	 SHORT $L14824

; 116  : 
; 117  :     }
; 118  : 
; 119  :     //
; 120  :     // The queue is clean.  Now go after the current if
; 121  :     // it's there.
; 122  :     //
; 123  : 
; 124  :     if (*CurrentOpIrp) {

  00048	8b 45 10	 mov	 eax, DWORD PTR _CurrentOpIrp$[ebp]
  0004b	5f		 pop	 edi
  0004c	5e		 pop	 esi
  0004d	8b 08		 mov	 ecx, DWORD PTR [eax]
  0004f	85 c9		 test	 ecx, ecx
  00051	74 24		 je	 SHORT $L14834

; 125  : 
; 126  : 
; 127  :         cancelRoutine = (*CurrentOpIrp)->CancelRoutine;

  00053	8b 51 38	 mov	 edx, DWORD PTR [ecx+56]

; 128  :         (*CurrentOpIrp)->Cancel = TRUE;

  00056	c6 41 24 01	 mov	 BYTE PTR [ecx+36], 1

; 129  : 
; 130  :         //
; 131  :         // If the current irp is not in a cancelable state
; 132  :         // then it *will* try to enter one and the above
; 133  :         // assignment will kill it.  If it already is in
; 134  :         // a cancelable state then the following will kill it.
; 135  :         //
; 136  : 
; 137  :         if (cancelRoutine) {

  0005a	85 d2		 test	 edx, edx
  0005c	74 19		 je	 SHORT $L14834

; 138  : 
; 139  :             (*CurrentOpIrp)->CancelRoutine = NULL;

  0005e	8b 08		 mov	 ecx, DWORD PTR [eax]
  00060	53		 push	 ebx
  00061	83 61 38 00	 and	 DWORD PTR [ecx+56], 0

; 140  :             (*CurrentOpIrp)->CancelIrql = cancelIrql;

  00065	8b 08		 mov	 ecx, DWORD PTR [eax]
  00067	8a 5d fc	 mov	 bl, BYTE PTR _cancelIrql$[ebp]
  0006a	88 59 25	 mov	 BYTE PTR [ecx+37], bl

; 141  : 
; 142  :             //
; 143  :             // This irp is already in a cancelable state.  We simply
; 144  :             // mark it as canceled and call the cancel routine for
; 145  :             // it.
; 146  :             //
; 147  : 
; 148  :             cancelRoutine(
; 149  :                 DeviceObject,
; 150  :                 *CurrentOpIrp
; 151  :                 );

  0006d	ff 30		 push	 DWORD PTR [eax]
  0006f	ff 75 08	 push	 DWORD PTR _DeviceObject$[ebp]
  00072	ff d2		 call	 edx
  00074	5b		 pop	 ebx

; 152  : 
; 153  :         } else {

  00075	eb 09		 jmp	 SHORT $L14838
$L14834:

; 154  : 
; 155  :             IoReleaseCancelSpinLock(cancelIrql);
; 156  : 
; 157  :         }
; 158  : 
; 159  :     } else {
; 160  : 
; 161  :         IoReleaseCancelSpinLock(cancelIrql);

  00077	ff 75 fc	 push	 DWORD PTR _cancelIrql$[ebp]
  0007a	ff 15 00 00 00
	00		 call	 DWORD PTR __imp__IoReleaseCancelSpinLock@4
$L14838:

; 162  : 
; 163  :     }
; 164  : 
; 165  : }

  00080	c9		 leave
  00081	c2 0c 00	 ret	 12			; 0000000cH
_SerialKillAllReadsOrWrites@12 ENDP
_TEXT	ENDS
PUBLIC	_SerialGetNextIrp@20
PUBLIC	_SerialGetNextIrpLocked@24
EXTRN	__imp__KeGetCurrentIrql@0:NEAR
EXTRN	__imp__RtlAssert@16:NEAR
EXTRN	_DbgPrint:NEAR
EXTRN	_SerialGlobals:BYTE
;	COMDAT _SerialGetNextIrp@20
PAGESER	SEGMENT
$SG14852 DB	'SERIAL: Pageable code called at IRQL %d without lock ', 0aH
	DB	00H
	ORG $+1
$SG14855 DB	'f:\w2ddk\src\kernel\serial\utils.c', 00H
	ORG $+1
$SG14856 DB	'FALSE', 00H
; Function compile flags: /Ogs
_CurrentOpIrp$ = 8
_QueueToProcess$ = 12
_NextIrp$ = 16
_CompleteCurrent$ = 20
_extension$ = 24
_oldIrql$ = -4
_SerialGetNextIrp@20 PROC NEAR				; COMDAT

; 211  : {

  00062	55		 push	 ebp
  00063	8b ec		 mov	 ebp, esp
  00065	51		 push	 ecx
  00066	56		 push	 esi

; 212  : 
; 213  :     KIRQL oldIrql;
; 214  :     SERIAL_LOCKED_PAGED_CODE();

  00067	8b 35 00 00 00
	00		 mov	 esi, DWORD PTR __imp__KeGetCurrentIrql@0
  0006d	ff d6		 call	 esi
  0006f	3c 01		 cmp	 al, 1
  00071	76 32		 jbe	 SHORT $L14853
  00073	83 3d 14 00 00
	00 00		 cmp	 DWORD PTR _SerialGlobals+20, 0
  0007a	75 29		 jne	 SHORT $L14853
  0007c	ff d6		 call	 esi
  0007e	0f b6 c0	 movzx	 eax, al
  00081	50		 push	 eax
  00082	68 00 00 00 00	 push	 OFFSET FLAT:$SG14852
  00087	e8 00 00 00 00	 call	 _DbgPrint
  0008c	59		 pop	 ecx
  0008d	59		 pop	 ecx
  0008e	6a 00		 push	 0
  00090	68 d6 00 00 00	 push	 214			; 000000d6H
  00095	68 00 00 00 00	 push	 OFFSET FLAT:$SG14855
  0009a	68 00 00 00 00	 push	 OFFSET FLAT:$SG14856
  0009f	ff 15 00 00 00
	00		 call	 DWORD PTR __imp__RtlAssert@16
$L14853:

; 215  : 
; 216  : 
; 217  :     IoAcquireCancelSpinLock(&oldIrql);

  000a5	8d 45 fc	 lea	 eax, DWORD PTR _oldIrql$[ebp]
  000a8	50		 push	 eax
  000a9	ff 15 00 00 00
	00		 call	 DWORD PTR __imp__IoAcquireCancelSpinLock@4

; 218  :     SerialGetNextIrpLocked(CurrentOpIrp, QueueToProcess, NextIrp,
; 219  :                            CompleteCurrent, extension, oldIrql);

  000af	ff 75 fc	 push	 DWORD PTR _oldIrql$[ebp]
  000b2	ff 75 18	 push	 DWORD PTR _extension$[ebp]
  000b5	ff 75 14	 push	 DWORD PTR _CompleteCurrent$[ebp]
  000b8	ff 75 10	 push	 DWORD PTR _NextIrp$[ebp]
  000bb	ff 75 0c	 push	 DWORD PTR _QueueToProcess$[ebp]
  000be	ff 75 08	 push	 DWORD PTR _CurrentOpIrp$[ebp]
  000c1	e8 00 00 00 00	 call	 _SerialGetNextIrpLocked@24
  000c6	5e		 pop	 esi

; 220  : }

  000c7	c9		 leave
  000c8	c2 14 00	 ret	 20			; 00000014H
_SerialGetNextIrp@20 ENDP
PAGESER	ENDS
PUBLIC	_SerialIRPEpilogue@4
EXTRN	_SerialDebugLevel:DWORD
EXTRN	__imp_@InterlockedExchange@8:NEAR
EXTRN	__imp_@IofCompleteRequest@8:NEAR
;	COMDAT _SerialGetNextIrpLocked@24
PAGESER	SEGMENT
$SG14872 DB	'SERIAL: Pageable code called at IRQL %d without lock ', 0aH
	DB	00H
	ORG $+1
$SG14875 DB	'f:\w2ddk\src\kernel\serial\utils.c', 00H
	ORG $+1
$SG14876 DB	'FALSE', 00H
	ORG $+2
$SG14881 DB	'f:\w2ddk\src\kernel\serial\utils.c', 00H
	ORG $+1
$SG14882 DB	'!oldIrp->CancelRoutine', 00H
	ORG $+1
$SG14908 DB	'SERIAL: Complete Irp: %x', 0aH, 00H
; Function compile flags: /Ogs
_CurrentOpIrp$ = 8
_QueueToProcess$ = 12
_NextIrp$ = 16
_CompleteCurrent$ = 20
_extension$ = 24
_OldIrql$ = 28
_SerialGetNextIrpLocked@24 PROC NEAR			; COMDAT

; 272  : {

  000ba	55		 push	 ebp
  000bb	8b ec		 mov	 ebp, esp
  000bd	53		 push	 ebx
  000be	56		 push	 esi

; 273  : 
; 274  :     PIRP oldIrp;
; 275  : 
; 276  :     SERIAL_LOCKED_PAGED_CODE();

  000bf	8b 35 00 00 00
	00		 mov	 esi, DWORD PTR __imp__KeGetCurrentIrql@0
  000c5	57		 push	 edi
  000c6	ff d6		 call	 esi
  000c8	8b 3d 00 00 00
	00		 mov	 edi, DWORD PTR __imp__RtlAssert@16
  000ce	3c 01		 cmp	 al, 1
  000d0	76 2e		 jbe	 SHORT $L14873
  000d2	83 3d 14 00 00
	00 00		 cmp	 DWORD PTR _SerialGlobals+20, 0
12 3 4 5 下一页
💿 文件大小 2408 K
👤 上传用户 ddddong
📂 所属分类驱动编程
🏷️ 相关标签

#2000 #znsoft_Serial #demo #win
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -